opensquid 0.5.395

package/dist/hooks/session-end.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-end.d.ts","sourceRoot":"","sources":["../../src.legacy/hooks/session-end.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAaH,wBAAsB,iBAAiB,IAAI,OAAO,CAAC,IAAI,CAAC,CA+CvD"}

package/dist/hooks/session-end.js

@@ -0,0 +1,60 @@
+/**
+ * `opensquid hook session-end` — Claude Code SessionEnd hook handler.
+ *
+ * Fires when a Claude Code session terminates. Wipes the session's
+ * honesty-ledger state (turn-ledger.jsonl + broken-promises.jsonl) so
+ * the ledger doesn't grow unbounded across all-time sessions.
+ *
+ * Without this hook, every Claude Code session creates a
+ * <data-root>/sessions/<id>/ directory with two JSONL files that
+ * never get cleaned up. Disk usage grows linearly with session count.
+ *
+ * Exit 0 always — SessionEnd is cleanup, not blocking.
+ */
+import { runDriftCatalogScan } from "./drift-catalog.js";
+import { clearSession } from "./honesty-ledger.js";
+export async function runSessionEndHook() {
+    let raw = "";
+    for await (const chunk of process.stdin) {
+        raw += chunk;
+    }
+    if (!raw.trim())
+        process.exit(0);
+    let payload;
+    try {
+        payload = JSON.parse(raw);
+    }
+    catch {
+        process.exit(0);
+    }
+    const sessionId = payload.session_id;
+    if (!sessionId)
+        process.exit(0);
+    // 0.7.22 / D10 — automated drift catalog. Scan the transcript for
+    // drift markers (user corrections, locked-rule citations, agent
+    // mea-culpas) and append to the project's drift-catalog.jsonl. Runs
+    // BEFORE clearSession so any session-scoped state used for context
+    // is still available.
+    try {
+        const count = await runDriftCatalogScan({
+            sessionId,
+            transcriptPath: payload.transcript_path,
+            cwd: payload.cwd,
+        });
+        if (count > 0) {
+            process.stderr.write(`🦑 [opensquid drift-catalog] recorded ${count} drift marker(s)\n`);
+        }
+    }
+    catch (err) {
+        process.stderr.write(`[opensquid hook session-end] drift-catalog scan failed (non-fatal): ${err instanceof Error ? err.message : err}\n`);
+    }
+    try {
+        await clearSession(sessionId);
+    }
+    catch (err) {
+        // Cleanup failure is non-fatal — disk-space leak, not a correctness bug.
+        process.stderr.write(`[opensquid hook session-end] clearSession failed: ${err instanceof Error ? err.message : err}\n`);
+    }
+    process.exit(0);
+}
+//# sourceMappingURL=session-end.js.map

package/dist/hooks/session-end.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-end.js","sourceRoot":"","sources":["../../src.legacy/hooks/session-end.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AACzD,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAUnD,MAAM,CAAC,KAAK,UAAU,iBAAiB;IACrC,IAAI,GAAG,GAAG,EAAE,CAAC;IACb,IAAI,KAAK,EAAE,MAAM,KAAK,IAAI,OAAO,CAAC,KAAK,EAAE,CAAC;QACxC,GAAG,IAAI,KAAK,CAAC;IACf,CAAC;IACD,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE;QAAE,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IAEjC,IAAI,OAAwB,CAAC;IAC7B,IAAI,CAAC;QACH,OAAO,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IAC5B,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IAClB,CAAC;IAED,MAAM,SAAS,GAAG,OAAO,CAAC,UAAU,CAAC;IACrC,IAAI,CAAC,SAAS;QAAE,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IAEhC,kEAAkE;IAClE,gEAAgE;IAChE,oEAAoE;IACpE,mEAAmE;IACnE,sBAAsB;IACtB,IAAI,CAAC;QACH,MAAM,KAAK,GAAG,MAAM,mBAAmB,CAAC;YACtC,SAAS;YACT,cAAc,EAAE,OAAO,CAAC,eAAe;YACvC,GAAG,EAAE,OAAO,CAAC,GAAG;SACjB,CAAC,CAAC;QACH,IAAI,KAAK,GAAG,CAAC,EAAE,CAAC;YACd,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,yCAAyC,KAAK,oBAAoB,CAAC,CAAC;QAC3F,CAAC;IACH,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,OAAO,CAAC,MAAM,CAAC,KAAK,CAClB,uEAAuE,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,IAAI,CACpH,CAAC;IACJ,CAAC;IAED,IAAI,CAAC;QACH,MAAM,YAAY,CAAC,SAAS,CAAC,CAAC;IAChC,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,yEAAyE;QACzE,OAAO,CAAC,MAAM,CAAC,KAAK,CAClB,qDAAqD,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,IAAI,CAClG,CAAC;IACJ,CAAC;IAED,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;AAClB,CAAC"}

package/dist/hooks/session-end.test.js

@@ -0,0 +1,52 @@
+import * as crypto from "node:crypto";
+import { promises as fs } from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { clearSession, readBrokenPromises, readTurnLedger, recordBrokenPromise, recordToolCall, } from "./honesty-ledger.js";
+let tmpRoot;
+const SESSION = "session-end-test";
+beforeEach(async () => {
+    tmpRoot = path.join(os.tmpdir(), `oscli-session-end-${crypto.randomUUID()}`);
+    await fs.mkdir(tmpRoot, { recursive: true });
+});
+afterEach(async () => {
+    await fs.rm(tmpRoot, { recursive: true, force: true });
+});
+describe("SessionEnd cleanup (clearSession via the hook)", () => {
+    it("wipes both ledger and broken-promises after population", async () => {
+        await recordToolCall(SESSION, "Bash", "npm test", { dataRoot: tmpRoot });
+        await recordToolCall(SESSION, "Bash", "git commit -m foo", { dataRoot: tmpRoot });
+        await recordBrokenPromise(SESSION, {
+            ts: "2026-05-15T00:00:00Z",
+            claim_id: "fake",
+            claim_label: "x",
+            matched_text: "y",
+            reason: "z",
+        }, { dataRoot: tmpRoot });
+        // Sanity-check the precondition.
+        expect((await readTurnLedger(SESSION, { dataRoot: tmpRoot })).length).toBe(2);
+        expect((await readBrokenPromises(SESSION, { dataRoot: tmpRoot })).length).toBe(1);
+        // SessionEnd action.
+        await clearSession(SESSION, { dataRoot: tmpRoot });
+        expect(await readTurnLedger(SESSION, { dataRoot: tmpRoot })).toEqual([]);
+        expect(await readBrokenPromises(SESSION, { dataRoot: tmpRoot })).toEqual([]);
+    });
+    it("session directory remains, just empty of ledger files", async () => {
+        await recordToolCall(SESSION, "Bash", "ls", { dataRoot: tmpRoot });
+        await clearSession(SESSION, { dataRoot: tmpRoot });
+        // The sessions/<id>/ directory itself is preserved (cheap),
+        // only the JSONL files inside are removed.
+        const dir = path.join(tmpRoot, "sessions", SESSION);
+        await expect(fs.access(dir)).resolves.toBeUndefined();
+        const entries = await fs.readdir(dir);
+        expect(entries).toEqual([]);
+    });
+    it("does NOT touch other sessions' ledgers", async () => {
+        await recordToolCall(SESSION, "Bash", "ls", { dataRoot: tmpRoot });
+        await recordToolCall("other-session", "Bash", "ls", { dataRoot: tmpRoot });
+        await clearSession(SESSION, { dataRoot: tmpRoot });
+        expect((await readTurnLedger(SESSION, { dataRoot: tmpRoot })).length).toBe(0);
+        expect((await readTurnLedger("other-session", { dataRoot: tmpRoot })).length).toBe(1);
+    });
+});

package/dist/hooks/stop.d.ts

@@ -0,0 +1,35 @@
+/**
+ * `opensquid hook stop` — Claude Code Stop hook handler.
+ *
+ * Fires at the end of every assistant turn. Two responsibilities:
+ *
+ *   1. Honesty ledger reconciliation: cross-reference the assistant's
+ *      final message against the session's accumulated tool-call ledger.
+ *      Any unfulfilled claim is recorded as a broken promise that the
+ *      next turn's UserPromptSubmit hook surfaces back to the agent.
+ *
+ *   2. Token-threshold heartbeat: estimate transcript token count, and
+ *      if the conversation has grown past the configured threshold
+ *      since the last checkpoint, arm a pending heartbeat marker so
+ *      the next UserPromptSubmit hook injects a re-anchor nudge into
+ *      the agent's context. The agent (already authenticated and in
+ *      the loop) does the actual recall + classify work inline.
+ *
+ * Exit 0 always — Stop hook is observational, not blocking.
+ *
+ * Wired in ~/.claude/settings.json:
+ *
+ *   "Stop": [
+ *     { "hooks": [{
+ *       "type": "command",
+ *       "command": "node /path/to/opensquid/dist/index.js hook stop"
+ *     }] }
+ *   ]
+ *
+ * Pre-#124: this hook also spawned a detached LLM-classifier subprocess.
+ * Removed in favor of the heartbeat path — opensquid stays in-MCP-ecosystem
+ * (no external LLM dependency, no subprocess), and the agent does the
+ * classification work inline per CLAUDE.md classify-and-act rules.
+ */
+export declare function runStopHook(): Promise<void>;
+//# sourceMappingURL=stop.d.ts.map

package/dist/hooks/stop.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stop.d.ts","sourceRoot":"","sources":["../../src.legacy/hooks/stop.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAmBH,wBAAsB,WAAW,IAAI,OAAO,CAAC,IAAI,CAAC,CA4GjD"}

package/dist/hooks/stop.js

@@ -0,0 +1,136 @@
+/**
+ * `opensquid hook stop` — Claude Code Stop hook handler.
+ *
+ * Fires at the end of every assistant turn. Two responsibilities:
+ *
+ *   1. Honesty ledger reconciliation: cross-reference the assistant's
+ *      final message against the session's accumulated tool-call ledger.
+ *      Any unfulfilled claim is recorded as a broken promise that the
+ *      next turn's UserPromptSubmit hook surfaces back to the agent.
+ *
+ *   2. Token-threshold heartbeat: estimate transcript token count, and
+ *      if the conversation has grown past the configured threshold
+ *      since the last checkpoint, arm a pending heartbeat marker so
+ *      the next UserPromptSubmit hook injects a re-anchor nudge into
+ *      the agent's context. The agent (already authenticated and in
+ *      the loop) does the actual recall + classify work inline.
+ *
+ * Exit 0 always — Stop hook is observational, not blocking.
+ *
+ * Wired in ~/.claude/settings.json:
+ *
+ *   "Stop": [
+ *     { "hooks": [{
+ *       "type": "command",
+ *       "command": "node /path/to/opensquid/dist/index.js hook stop"
+ *     }] }
+ *   ]
+ *
+ * Pre-#124: this hook also spawned a detached LLM-classifier subprocess.
+ * Removed in favor of the heartbeat path — opensquid stays in-MCP-ecosystem
+ * (no external LLM dependency, no subprocess), and the agent does the
+ * classification work inline per CLAUDE.md classify-and-act rules.
+ */
+import { clearTurnLedger, reconcile, readBrokenPromises, readTurnLedger, recordBrokenPromise, } from "./honesty-ledger.js";
+import { checkAndMaybeArm } from "./heartbeat.js";
+import { checkInlineReportFormat } from "./inline-report-check.js";
+import { readLastAssistantText } from "./transcript.js";
+export async function runStopHook() {
+    let raw = "";
+    for await (const chunk of process.stdin) {
+        raw += chunk;
+    }
+    if (!raw.trim()) {
+        process.exit(0);
+    }
+    let payload;
+    try {
+        payload = JSON.parse(raw);
+    }
+    catch {
+        process.stderr.write("[opensquid hook stop] malformed input — proceeding\n");
+        process.exit(0);
+    }
+    const sessionId = payload.session_id;
+    if (!sessionId)
+        process.exit(0);
+    // -- (1) Honesty-ledger reconcile ----------------------------------
+    const assistantText = payload.transcript_path
+        ? await readLastAssistantText(payload.transcript_path)
+        : "";
+    const ledger = await readTurnLedger(sessionId);
+    const broken = reconcile(assistantText, ledger);
+    const existing = await readBrokenPromises(sessionId);
+    const existingKeys = new Set(existing.map((p) => `${p.claim_id}|${p.matched_text}`));
+    const fresh = [];
+    for (const promise of broken) {
+        const key = `${promise.claim_id}|${promise.matched_text}`;
+        if (existingKeys.has(key))
+            continue;
+        fresh.push(promise);
+        try {
+            await recordBrokenPromise(sessionId, promise);
+        }
+        catch (err) {
+            process.stderr.write(`[opensquid hook stop] failed to record promise: ${err instanceof Error ? err.message : err}\n`);
+        }
+    }
+    if (fresh.length > 0) {
+        for (const p of fresh) {
+            process.stderr.write(`🦑 [opensquid honesty] ${p.claim_id}: ${p.reason}\n`);
+        }
+    }
+    // 0.7.30 / D3 follow-up — when the agent writes a completion-report-
+    // shaped status update inline (vs. via mcp__opensquid__chat_send),
+    // D3's chat_send check doesn't fire. Catch the inline case here at
+    // Stop time and surface as a broken-promise next turn.
+    if (assistantText) {
+        const inlineViolation = checkInlineReportFormat(assistantText);
+        if (inlineViolation) {
+            const broken = {
+                ts: new Date().toISOString(),
+                claim_id: "inline-report-missing-phases",
+                claim_label: "PHASES block per [[feedback_telegram_reports]]",
+                matched_text: inlineViolation.matched_text,
+                reason: `inline message shape suggests a completion report ` +
+                    `(version_refs=${inlineViolation.signals.version_refs}, ` +
+                    `commit_hashes=${inlineViolation.signals.hash_refs}) but the ` +
+                    `PHASES heading is missing. Catches D3 inline variant.`,
+            };
+            try {
+                await recordBrokenPromise(sessionId, broken);
+                process.stderr.write(`🦑 [opensquid honesty] ${broken.claim_id}: ${broken.reason}\n`);
+            }
+            catch (err) {
+                process.stderr.write(`[opensquid hook stop] inline-report check write failed: ${err instanceof Error ? err.message : err}\n`);
+            }
+        }
+    }
+    // 0.7.8 (#162): clear the turn-ledger AFTER reconciliation so the
+    // next turn's claims reconcile against ONLY that turn's tool calls.
+    // Previously the ledger only cleared at SessionEnd, which meant
+    // yesterday's git push satisfied today's "I'll push" claim on long
+    // resumed sessions — the load-bearing #160 finding for ledger drift.
+    try {
+        await clearTurnLedger(sessionId);
+    }
+    catch (err) {
+        process.stderr.write(`[opensquid hook stop] turn-ledger clear failed (non-fatal): ${err instanceof Error ? err.message : err}\n`);
+    }
+    // -- (2) Token-threshold heartbeat ---------------------------------
+    if (payload.transcript_path) {
+        try {
+            const armed = await checkAndMaybeArm(sessionId, payload.transcript_path);
+            if (armed) {
+                // Surface to stderr too so the user sees that opensquid noticed
+                // drift (in addition to the agent seeing it next turn via UPS).
+                process.stderr.write(`🦑 [opensquid heartbeat-armed] ${armed}\n`);
+            }
+        }
+        catch (err) {
+            process.stderr.write(`[opensquid hook stop] heartbeat check failed (non-fatal): ${err instanceof Error ? err.message : err}\n`);
+        }
+    }
+    process.exit(0);
+}
+//# sourceMappingURL=stop.js.map

package/dist/hooks/stop.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stop.js","sourceRoot":"","sources":["../../src.legacy/hooks/stop.ts"],"names":[],"mappings":"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"}

package/dist/hooks/transcript-active-task.test.js

@@ -0,0 +1,342 @@
+/**
+ * Tests for `readActiveTaskId` — the transcript-walking helper that
+ * finds the most-recent TodoWrite in_progress task id. Used by the
+ * workflow gate to figure out which task's phase ledger to query.
+ */
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import * as crypto from "node:crypto";
+import { promises as fs } from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import { readActiveTaskId } from "./transcript.js";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+let tmpDir;
+let transcriptPath;
+beforeEach(async () => {
+    tmpDir = path.join(os.tmpdir(), `opensquid-tx-${crypto.randomUUID()}`);
+    await fs.mkdir(tmpDir, { recursive: true });
+    transcriptPath = path.join(tmpDir, "transcript.jsonl");
+});
+afterEach(async () => {
+    await fs.rm(tmpDir, { recursive: true, force: true });
+});
+async function writeEvents(events) {
+    const lines = events.map((e) => JSON.stringify(e)).join("\n") + "\n";
+    await fs.writeFile(transcriptPath, lines, "utf8");
+}
+function todoWriteEvent(todos) {
+    return {
+        type: "assistant",
+        message: {
+            role: "assistant",
+            content: [
+                {
+                    type: "tool_use",
+                    name: "TodoWrite",
+                    input: { todos },
+                },
+            ],
+        },
+    };
+}
+describe("readActiveTaskId", () => {
+    it("returns null when transcript doesn't exist", async () => {
+        expect(await readActiveTaskId(path.join(tmpDir, "missing.jsonl"))).toBeNull();
+    });
+    it("returns null when transcript is empty", async () => {
+        await fs.writeFile(transcriptPath, "", "utf8");
+        expect(await readActiveTaskId(transcriptPath)).toBeNull();
+    });
+    it("returns null when no TodoWrite block exists", async () => {
+        await writeEvents([
+            { type: "user", message: { role: "user", content: "hi" } },
+            { type: "assistant", message: { role: "assistant", content: "hello" } },
+        ]);
+        expect(await readActiveTaskId(transcriptPath)).toBeNull();
+    });
+    it("returns null when TodoWrite has no in_progress items", async () => {
+        await writeEvents([
+            todoWriteEvent([
+                { id: "1", status: "completed" },
+                { id: "2", status: "pending" },
+            ]),
+        ]);
+        expect(await readActiveTaskId(transcriptPath)).toBeNull();
+    });
+    it("returns the in_progress task id from a single TodoWrite", async () => {
+        await writeEvents([
+            todoWriteEvent([
+                { id: "1", status: "completed" },
+                { id: "2", status: "in_progress" },
+                { id: "3", status: "pending" },
+            ]),
+        ]);
+        expect(await readActiveTaskId(transcriptPath)).toBe("2");
+    });
+    it("prefers the MOST RECENT TodoWrite when multiple exist", async () => {
+        await writeEvents([
+            todoWriteEvent([{ id: "old-task", status: "in_progress" }]),
+            todoWriteEvent([{ id: "newer-task", status: "in_progress" }]),
+        ]);
+        expect(await readActiveTaskId(transcriptPath)).toBe("newer-task");
+    });
+    it("stops at the most-recent TodoWrite even if its in_progress is null", async () => {
+        // The MOST RECENT TodoWrite has no in_progress (all completed).
+        // We must NOT fall back to an OLDER TodoWrite's in_progress that
+        // may have been overwritten. Returns null.
+        await writeEvents([
+            todoWriteEvent([{ id: "stale-task", status: "in_progress" }]),
+            todoWriteEvent([
+                { id: "stale-task", status: "completed" },
+                { id: "all-done", status: "completed" },
+            ]),
+        ]);
+        expect(await readActiveTaskId(transcriptPath)).toBeNull();
+    });
+    it("ignores non-assistant events between TodoWrites", async () => {
+        await writeEvents([
+            { type: "user", message: { role: "user", content: "do thing" } },
+            todoWriteEvent([{ id: "active", status: "in_progress" }]),
+            { type: "user", message: { role: "user", content: "now go" } },
+        ]);
+        expect(await readActiveTaskId(transcriptPath)).toBe("active");
+    });
+    it("ignores assistant text events without tool_use blocks", async () => {
+        await writeEvents([
+            todoWriteEvent([{ id: "real-active", status: "in_progress" }]),
+            {
+                type: "assistant",
+                message: {
+                    role: "assistant",
+                    content: [{ type: "text", text: "thinking..." }],
+                },
+            },
+        ]);
+        expect(await readActiveTaskId(transcriptPath)).toBe("real-active");
+    });
+    it("ignores other tool_use events (Bash, Edit, etc.)", async () => {
+        await writeEvents([
+            todoWriteEvent([{ id: "active", status: "in_progress" }]),
+            {
+                type: "assistant",
+                message: {
+                    role: "assistant",
+                    content: [{ type: "tool_use", name: "Bash", input: { command: "ls" } }],
+                },
+            },
+        ]);
+        expect(await readActiveTaskId(transcriptPath)).toBe("active");
+    });
+    it("coerces numeric ids to strings", async () => {
+        await writeEvents([
+            todoWriteEvent([
+                // Some serializations encode id as number.
+                { id: 127, status: "in_progress" },
+            ]),
+        ]);
+        expect(await readActiveTaskId(transcriptPath)).toBe("127");
+    });
+    it("handles malformed JSON lines gracefully", async () => {
+        await fs.writeFile(transcriptPath, [
+            "{ malformed",
+            JSON.stringify(todoWriteEvent([{ id: "active", status: "in_progress" }])),
+            "still bad json",
+        ].join("\n"), "utf8");
+        expect(await readActiveTaskId(transcriptPath)).toBe("active");
+    });
+});
+// =====================================================================
+// v0.6.2 — TaskCreate + TaskUpdate recognition (the real-world Claude
+// Code shape; TodoWrite was the v0.6.1 shape). My own dogfood session
+// today used TaskCreate/TaskUpdate exclusively → workflow gate silent-
+// allowed every commit because readActiveTaskId only recognized
+// TodoWrite. This block is the regression coverage for the fix.
+// =====================================================================
+function assistantToolUse(name, blockId, input) {
+    return {
+        type: "assistant",
+        message: {
+            role: "assistant",
+            content: [
+                {
+                    type: "tool_use",
+                    id: blockId,
+                    name,
+                    input,
+                    caller: { type: "direct" },
+                },
+            ],
+        },
+    };
+}
+function toolResult(toolUseId, content) {
+    return {
+        type: "user",
+        message: {
+            role: "user",
+            content: [
+                {
+                    type: "tool_result",
+                    tool_use_id: toolUseId,
+                    content,
+                },
+            ],
+        },
+    };
+}
+describe("readActiveTaskId — TaskUpdate (v0.6.2 fix)", () => {
+    it("returns the taskId from TaskUpdate(status=in_progress)", async () => {
+        await writeEvents([
+            assistantToolUse("TaskUpdate", "tu-1", { taskId: "131", status: "in_progress" }),
+        ]);
+        expect(await readActiveTaskId(transcriptPath)).toBe("131");
+    });
+    it("does not return tasks marked completed by a later TaskUpdate", async () => {
+        await writeEvents([
+            assistantToolUse("TaskUpdate", "tu-1", { taskId: "131", status: "in_progress" }),
+            assistantToolUse("TaskUpdate", "tu-2", { taskId: "131", status: "completed" }),
+        ]);
+        expect(await readActiveTaskId(transcriptPath)).toBeNull();
+    });
+    it("picks the most-recently-touched in_progress task when multiple are active", async () => {
+        await writeEvents([
+            assistantToolUse("TaskUpdate", "tu-1", { taskId: "100", status: "in_progress" }),
+            assistantToolUse("TaskUpdate", "tu-2", { taskId: "200", status: "in_progress" }),
+            assistantToolUse("TaskUpdate", "tu-3", { taskId: "300", status: "in_progress" }),
+        ]);
+        expect(await readActiveTaskId(transcriptPath)).toBe("300");
+    });
+    it("coerces numeric taskId to string", async () => {
+        await writeEvents([
+            assistantToolUse("TaskUpdate", "tu-1", { taskId: 131, status: "in_progress" }),
+        ]);
+        expect(await readActiveTaskId(transcriptPath)).toBe("131");
+    });
+    it("ignores TaskUpdate with deleted status", async () => {
+        await writeEvents([
+            assistantToolUse("TaskUpdate", "tu-1", { taskId: "131", status: "in_progress" }),
+            assistantToolUse("TaskUpdate", "tu-2", { taskId: "131", status: "deleted" }),
+        ]);
+        expect(await readActiveTaskId(transcriptPath)).toBeNull();
+    });
+});
+describe("readActiveTaskId — TaskCreate (v0.6.2 fix)", () => {
+    it("does NOT return TaskCreate'd tasks (default status = pending, not in_progress)", async () => {
+        // TaskCreate alone leaves the task as pending. Active-task detection
+        // requires an explicit TaskUpdate(in_progress) — otherwise no gate
+        // for tasks that were created but never started.
+        await writeEvents([
+            assistantToolUse("TaskCreate", "tc-1", {
+                subject: "Some task",
+                description: "...",
+            }),
+            toolResult("tc-1", "Task #131 created successfully: Some task"),
+        ]);
+        expect(await readActiveTaskId(transcriptPath)).toBeNull();
+    });
+    it("returns the assigned id when TaskCreate is followed by TaskUpdate(in_progress)", async () => {
+        await writeEvents([
+            assistantToolUse("TaskCreate", "tc-1", { subject: "X", description: "..." }),
+            toolResult("tc-1", "Task #131 created successfully: X"),
+            assistantToolUse("TaskUpdate", "tu-1", { taskId: "131", status: "in_progress" }),
+        ]);
+        expect(await readActiveTaskId(transcriptPath)).toBe("131");
+    });
+    it("handles TaskCreate without a matching tool_result (truncated transcript)", async () => {
+        await writeEvents([
+            assistantToolUse("TaskCreate", "tc-1", { subject: "X", description: "..." }),
+            // No tool_result follows
+        ]);
+        // No id assigned, no in_progress → null.
+        expect(await readActiveTaskId(transcriptPath)).toBeNull();
+    });
+});
+// =====================================================================
+// Real-world fixture — captured from an actual Claude Code session.
+// The fixture lives at __fixtures__/real-task-shape.jsonl. If Claude
+// Code ever changes the wire format for TaskCreate / TaskUpdate, this
+// test fails BEFORE the workflow gate silently regresses in
+// production. Earlier audit recommendation (v0.6.2 audit MED): synthesized
+// tests passed in v0.6.1 but real-world shape didn't match — the same
+// failure mode would have been caught here.
+// =====================================================================
+describe("readActiveTaskId — real Claude Code transcript fixture", () => {
+    it("recognizes TaskCreate + tool_result + TaskUpdate captured from a real session", async () => {
+        const fixturePath = path.resolve(__dirname, "__fixtures__", "real-task-shape.jsonl");
+        // The fixture is 3 events: TaskCreate "X" → tool_result "Task #1 created" →
+        // TaskUpdate(taskId=1, status=in_progress). Expected active task: "1".
+        const active = await readActiveTaskId(fixturePath);
+        expect(active).toBe("1");
+    });
+});
+// =====================================================================
+// 0.7.9 (#163) — stale in_progress demotion
+// =====================================================================
+function assistantToolUseAt(name, blockId, input, timestamp) {
+    return {
+        type: "assistant",
+        timestamp,
+        message: {
+            role: "assistant",
+            content: [{ type: "tool_use", id: blockId, name, input, caller: { type: "direct" } }],
+        },
+    };
+}
+function userEventAt(timestamp, text = "hello") {
+    return { type: "user", timestamp, message: { role: "user", content: text } };
+}
+describe("readActiveTaskId — stale-task demotion (#163)", () => {
+    const oldDay = "2026-05-16T08:00:00Z"; // ~24h before latest
+    const today = "2026-05-17T08:00:00Z"; // latest activity
+    it("returns null when the only in_progress task is >1hr stale relative to latest activity", async () => {
+        await writeEvents([
+            assistantToolUseAt("TaskUpdate", "tu-1", { taskId: "999", status: "in_progress" }, oldDay),
+            // Many later events with newer timestamps — none touch task 999.
+            userEventAt(today, "new conversation today"),
+        ]);
+        expect(await readActiveTaskId(transcriptPath)).toBeNull();
+    });
+    it("keeps the in_progress task when it was recently touched", async () => {
+        const recent = "2026-05-17T07:30:00Z"; // 30 min before latest
+        await writeEvents([
+            assistantToolUseAt("TaskUpdate", "tu-1", { taskId: "42", status: "in_progress" }, recent),
+            userEventAt(today),
+        ]);
+        expect(await readActiveTaskId(transcriptPath)).toBe("42");
+    });
+    it("picks the more-recent in_progress when two exist (one stale, one fresh)", async () => {
+        const recent = "2026-05-17T07:45:00Z";
+        await writeEvents([
+            assistantToolUseAt("TaskUpdate", "tu-1", { taskId: "X", status: "in_progress" }, oldDay),
+            assistantToolUseAt("TaskUpdate", "tu-2", { taskId: "Y", status: "in_progress" }, recent),
+            userEventAt(today),
+        ]);
+        expect(await readActiveTaskId(transcriptPath)).toBe("Y");
+    });
+    it("falls back to line-idx pick (no demotion) when events have no timestamps", async () => {
+        // Pre-existing behavior preserved when timestamps aren't available.
+        await writeEvents([
+            assistantToolUse("TaskUpdate", "tu-1", { taskId: "no-ts", status: "in_progress" }),
+        ]);
+        expect(await readActiveTaskId(transcriptPath)).toBe("no-ts");
+    });
+});
+describe("readActiveTaskId — mixed TodoWrite + TaskUpdate", () => {
+    it("latest write wins per id, regardless of which tool", async () => {
+        // TodoWrite snapshot says id=5 is in_progress; later TaskUpdate
+        // marks id=5 completed. TaskUpdate is later → wins.
+        await writeEvents([
+            todoWriteEvent([{ id: "5", status: "in_progress" }]),
+            assistantToolUse("TaskUpdate", "tu-1", { taskId: "5", status: "completed" }),
+        ]);
+        expect(await readActiveTaskId(transcriptPath)).toBeNull();
+    });
+    it("TodoWrite snapshot can revive an id that TaskUpdate marked completed if it comes later", async () => {
+        await writeEvents([
+            assistantToolUse("TaskUpdate", "tu-1", { taskId: "5", status: "completed" }),
+            todoWriteEvent([{ id: "5", status: "in_progress" }]),
+        ]);
+        expect(await readActiveTaskId(transcriptPath)).toBe("5");
+    });
+});