fix: make compression timing robust

Author: spoons-and-mirrors

lib/commands/stats.ts

@@ -50,14 +50,20 @@ function formatStatsMessage(
 }
 
 function formatCompressionTime(ms: number): string {
-    const totalSeconds = Math.max(0, Math.round(ms / 1000))
+    const safeMs = Math.max(0, Math.round(ms))
+    if (safeMs < 1000) {
+        return `${safeMs} ms`
+    }
+
+    const totalSeconds = safeMs / 1000
     if (totalSeconds < 60) {
-        return `${totalSeconds} s`
+        return `${totalSeconds.toFixed(1)} s`
     }
 
-    const hours = Math.floor(totalSeconds / 3600)
-    const minutes = Math.floor((totalSeconds % 3600) / 60)
-    const seconds = totalSeconds % 60
+    const wholeSeconds = Math.floor(totalSeconds)
+    const hours = Math.floor(wholeSeconds / 3600)
+    const minutes = Math.floor((wholeSeconds % 3600) / 60)
+    const seconds = wholeSeconds % 60
 
     if (hours > 0) {
         return `${hours}h ${minutes}m ${seconds}s`

lib/hooks.ts

@@ -269,6 +269,14 @@ export function createTextCompleteHandler() {
 
 export function createEventHandler(state: SessionState, logger: Logger) {
     return async (input: { event: any }) => {
+        const eventTime =
+            typeof input.event?.time === "number" && Number.isFinite(input.event.time)
+                ? input.event.time
+                : typeof input.event?.properties?.time === "number" &&
+                    Number.isFinite(input.event.properties.time)
+                  ? input.event.properties.time
+                  : undefined
+
         if (input.event.type !== "message.part.updated") {
             return
         }
@@ -287,7 +295,7 @@ export function createEventHandler(state: SessionState, logger: Logger) {
                 return
             }
 
-            const startedAt = Date.now()
+            const startedAt = eventTime ?? Date.now()
             state.compressionStarts.set(part.callID, {
                 messageId: part.messageID,
                 startedAt,
@@ -310,8 +318,11 @@ export function createEventHandler(state: SessionState, logger: Logger) {
                 return
             }
 
-            const runningAt = part.state.time?.start
-            if (typeof runningAt !== "number" || !Number.isFinite(runningAt)) {
+            const runningAt =
+                typeof part.state.time?.start === "number" && Number.isFinite(part.state.time.start)
+                    ? part.state.time.start
+                    : eventTime
+            if (typeof runningAt !== "number") {
                 return
             }
 
@@ -332,6 +343,33 @@ export function createEventHandler(state: SessionState, logger: Logger) {
                 return
             }
 
+            if (!state.compressionDurations.has(part.callID)) {
+                const start = state.compressionStarts.get(part.callID)
+                const runningAt =
+                    typeof part.state.time?.start === "number" &&
+                    Number.isFinite(part.state.time.start)
+                        ? part.state.time.start
+                        : eventTime
+
+                if (start && typeof runningAt === "number") {
+                    state.compressionStarts.delete(part.callID)
+                    const durationMs = Math.max(0, runningAt - start.startedAt)
+                    recordCompressionDuration(state, part.callID, durationMs)
+                } else {
+                    const toolStart = part.state.time?.start
+                    const toolEnd = part.state.time?.end
+                    if (
+                        typeof toolStart === "number" &&
+                        Number.isFinite(toolStart) &&
+                        typeof toolEnd === "number" &&
+                        Number.isFinite(toolEnd)
+                    ) {
+                        const durationMs = Math.max(0, toolEnd - toolStart)
+                        recordCompressionDuration(state, part.callID, durationMs)
+                    }
+                }
+            }
+
             const updates = attachCompressionDuration(state, part.callID, part.messageID)
             if (updates === 0) {
                 return

tests/hooks-permission.test.ts

@@ -403,6 +403,65 @@ test("event hook attaches durations to matching blocks by call id", async () =>
     assert.equal(state.compressionDurations.size, 0)
 })
 
+test("event hook falls back to completed runtime when running duration missing", async () => {
+    const state = createSessionState()
+    state.sessionId = "session-1"
+    const handler = createEventHandler(state, new Logger(false))
+
+    state.prune.messages.blocksById.set(1, {
+        blockId: 1,
+        runId: 1,
+        active: true,
+        deactivatedByUser: false,
+        compressedTokens: 0,
+        summaryTokens: 0,
+        durationMs: 0,
+        mode: "message",
+        topic: "one",
+        batchTopic: "one",
+        startId: "m0001",
+        endId: "m0001",
+        anchorMessageId: "msg-a",
+        compressMessageId: "message-1",
+        compressCallId: undefined,
+        includedBlockIds: [],
+        consumedBlockIds: [],
+        parentBlockIds: [],
+        directMessageIds: [],
+        directToolIds: [],
+        effectiveMessageIds: ["msg-a"],
+        effectiveToolIds: [],
+        createdAt: 1,
+        summary: "a",
+    })
+
+    await handler({
+        event: {
+            type: "message.part.updated",
+            properties: {
+                part: {
+                    type: "tool",
+                    tool: "compress",
+                    callID: "call-3",
+                    messageID: "message-1",
+                    sessionID: "session-1",
+                    state: {
+                        status: "completed",
+                        input: {},
+                        output: "done",
+                        title: "",
+                        metadata: {},
+                        time: { start: 500, end: 940 },
+                    },
+                },
+            },
+        },
+    })
+
+    assert.equal(state.prune.messages.blocksById.get(1)?.durationMs, 440)
+    assert.equal(state.compressionDurations.size, 0)
+})
+
 test("event hook ignores non-compress tool parts", async () => {
     const state = createSessionState()
     state.sessionId = "session-1"