opensquid 0.5.395

package/dist/hooks/heartbeat.test.js

@@ -0,0 +1,393 @@
+/**
+ * Tests for #124 — token-threshold heartbeat that replaces the auto-
+ * classifier subprocess.
+ */
+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 { DEFAULT_HEARTBEAT_TOKENS, checkAndMaybeArm, consumePendingHeartbeat, estimateTokens, estimateTranscriptTokens, formatHeartbeatNudge, heartbeatSessionFiles, heartbeatThresholdTokens, readCheckpoint, writeCheckpoint, } from "./heartbeat.js";
+let tmpRoot;
+const SESSION = "heartbeat-test";
+beforeEach(async () => {
+    tmpRoot = path.join(os.tmpdir(), `oscli-heartbeat-${crypto.randomUUID()}`);
+    await fs.mkdir(tmpRoot, { recursive: true });
+    // Ensure no env override leaks across tests.
+    delete process.env.OPENSQUID_HEARTBEAT_TOKENS;
+});
+afterEach(async () => {
+    await fs.rm(tmpRoot, { recursive: true, force: true });
+    delete process.env.OPENSQUID_HEARTBEAT_TOKENS;
+});
+// ---------------------------------------------------------------------
+// estimateTokens / heartbeatThresholdTokens
+// ---------------------------------------------------------------------
+describe("estimateTokens", () => {
+    it("returns 0 for empty / null-ish input", () => {
+        expect(estimateTokens("")).toBe(0);
+    });
+    it("approximates chars/4", () => {
+        expect(estimateTokens("aaaa")).toBe(1);
+        expect(estimateTokens("a".repeat(80))).toBe(20);
+        expect(estimateTokens("a".repeat(100))).toBe(25);
+    });
+});
+describe("heartbeatThresholdTokens", () => {
+    it("returns default when env unset", () => {
+        expect(heartbeatThresholdTokens()).toBe(DEFAULT_HEARTBEAT_TOKENS);
+    });
+    it("honors OPENSQUID_HEARTBEAT_TOKENS positive integer", () => {
+        process.env.OPENSQUID_HEARTBEAT_TOKENS = "5000";
+        expect(heartbeatThresholdTokens()).toBe(5000);
+    });
+    it("falls back to default when env value is zero / negative / NaN", () => {
+        for (const bad of ["0", "-1", "abc", ""]) {
+            process.env.OPENSQUID_HEARTBEAT_TOKENS = bad;
+            expect(heartbeatThresholdTokens()).toBe(DEFAULT_HEARTBEAT_TOKENS);
+        }
+    });
+});
+// ---------------------------------------------------------------------
+// estimateTranscriptTokens
+// ---------------------------------------------------------------------
+describe("estimateTranscriptTokens (0.7.7 #161)", () => {
+    it("returns 0 when transcript file is missing", async () => {
+        const r = await estimateTranscriptTokens(path.join(tmpRoot, "nope.jsonl"));
+        expect(r).toBe(0);
+    });
+    it("returns 0 for an empty file", async () => {
+        const p = path.join(tmpRoot, "empty.jsonl");
+        await fs.writeFile(p, "");
+        expect(await estimateTranscriptTokens(p)).toBe(0);
+    });
+    it("counts user.string content", async () => {
+        const p = path.join(tmpRoot, "transcript.jsonl");
+        const line = JSON.stringify({
+            type: "user",
+            message: { role: "user", content: "x".repeat(400) },
+        });
+        await fs.writeFile(p, line + "\n");
+        // 400 chars / 4 = 100 tokens
+        expect(await estimateTranscriptTokens(p)).toBe(100);
+    });
+    it("counts assistant text blocks", async () => {
+        const p = path.join(tmpRoot, "transcript.jsonl");
+        const line = JSON.stringify({
+            type: "assistant",
+            message: {
+                role: "assistant",
+                content: [
+                    { type: "text", text: "a".repeat(400) },
+                    { type: "text", text: "b".repeat(400) },
+                ],
+            },
+        });
+        await fs.writeFile(p, line + "\n");
+        // 800 chars / 4 = 200 tokens
+        expect(await estimateTranscriptTokens(p)).toBe(200);
+    });
+    it("SKIPS thinking blocks (agent internal CoT)", async () => {
+        const p = path.join(tmpRoot, "transcript.jsonl");
+        const line = JSON.stringify({
+            type: "assistant",
+            message: {
+                content: [
+                    { type: "thinking", thinking: "x".repeat(10000), signature: "sig" },
+                    { type: "text", text: "hello" },
+                ],
+            },
+        });
+        await fs.writeFile(p, line + "\n");
+        // Only "hello" (5 chars) counted → 2 tokens (ceiling)
+        expect(await estimateTranscriptTokens(p)).toBe(2);
+    });
+    it("SKIPS tool_use blocks (compact + outbound work)", async () => {
+        const p = path.join(tmpRoot, "transcript.jsonl");
+        const line = JSON.stringify({
+            type: "assistant",
+            message: {
+                content: [
+                    { type: "tool_use", id: "x", name: "Bash", input: { command: "ls" } },
+                    { type: "text", text: "after the tool" },
+                ],
+            },
+        });
+        await fs.writeFile(p, line + "\n");
+        // Only the text block (14 chars) → 4 tokens
+        expect(await estimateTranscriptTokens(p)).toBe(4);
+    });
+    it("CAPS tool_result content at 2000 chars (prevents tool-result inflation)", async () => {
+        const p = path.join(tmpRoot, "transcript.jsonl");
+        const line = JSON.stringify({
+            type: "user",
+            message: {
+                role: "user",
+                content: [
+                    {
+                        type: "tool_result",
+                        tool_use_id: "x",
+                        content: "z".repeat(50000), // huge file read
+                    },
+                ],
+            },
+        });
+        await fs.writeFile(p, line + "\n");
+        // Capped at 2000 chars / 4 = 500 tokens (NOT 12,500)
+        expect(await estimateTranscriptTokens(p)).toBe(500);
+    });
+    it("counts tool_result content array form (nested blocks)", async () => {
+        const p = path.join(tmpRoot, "transcript.jsonl");
+        const line = JSON.stringify({
+            type: "user",
+            message: {
+                content: [
+                    {
+                        type: "tool_result",
+                        tool_use_id: "x",
+                        content: [
+                            { type: "text", text: "y".repeat(800) },
+                            { type: "text", text: "y".repeat(800) },
+                        ],
+                    },
+                ],
+            },
+        });
+        await fs.writeFile(p, line + "\n");
+        // 1600 chars total (under 2000 cap) → 400 tokens
+        expect(await estimateTranscriptTokens(p)).toBe(400);
+    });
+    it("SKIPS non-conversation line types (system / permission-mode / file-history-snapshot / etc)", async () => {
+        const p = path.join(tmpRoot, "transcript.jsonl");
+        const lines = [
+            JSON.stringify({ type: "permission-mode", permissionMode: "default" }),
+            JSON.stringify({ type: "system", text: "x".repeat(10000) }),
+            JSON.stringify({ type: "file-history-snapshot", snapshot: {} }),
+            JSON.stringify({ type: "attachment", message: { content: "x".repeat(10000) } }),
+            JSON.stringify({ type: "ai-title", title: "Hello" }),
+            JSON.stringify({ type: "last-prompt", prompt: "x".repeat(10000) }),
+        ].join("\n");
+        await fs.writeFile(p, lines);
+        expect(await estimateTranscriptTokens(p)).toBe(0);
+    });
+    it("tolerates malformed JSON lines (skips them)", async () => {
+        const p = path.join(tmpRoot, "transcript.jsonl");
+        const lines = [
+            "not json at all",
+            JSON.stringify({ type: "user", message: { content: "hello" } }),
+            "{partial json",
+        ].join("\n");
+        await fs.writeFile(p, lines);
+        // Only "hello" counted (5 chars) → 2 tokens (ceiling)
+        expect(await estimateTranscriptTokens(p)).toBe(2);
+    });
+});
+// ---------------------------------------------------------------------
+// formatHeartbeatNudge
+// ---------------------------------------------------------------------
+describe("formatHeartbeatNudge", () => {
+    it("includes the delta + threshold + the recall instruction", () => {
+        const nudge = formatHeartbeatNudge(20000, 20000);
+        expect(nudge).toContain("20,000");
+        expect(nudge).toContain("recall");
+        expect(nudge).toContain("memorize");
+        expect(nudge).toContain("🦑");
+    });
+});
+// ---------------------------------------------------------------------
+// Checkpoint IO
+// ---------------------------------------------------------------------
+describe("checkpoint IO", () => {
+    it("returns null when no checkpoint file exists", async () => {
+        expect(await readCheckpoint(SESSION, { dataRoot: tmpRoot })).toBeNull();
+    });
+    it("round-trips via writeCheckpoint", async () => {
+        await writeCheckpoint(SESSION, { last_token_count: 12345, last_checkpoint_at: "2026-05-15T00:00:00Z" }, { dataRoot: tmpRoot });
+        const back = await readCheckpoint(SESSION, { dataRoot: tmpRoot });
+        expect(back?.last_token_count).toBe(12345);
+        expect(back?.last_checkpoint_at).toBe("2026-05-15T00:00:00Z");
+    });
+    it("returns null on malformed JSON", async () => {
+        const p = path.join(tmpRoot, "sessions", SESSION);
+        await fs.mkdir(p, { recursive: true });
+        await fs.writeFile(path.join(p, "heartbeat-checkpoint.json"), "not json");
+        expect(await readCheckpoint(SESSION, { dataRoot: tmpRoot })).toBeNull();
+    });
+});
+// ---------------------------------------------------------------------
+// checkAndMaybeArm — Stop hook entrypoint
+// ---------------------------------------------------------------------
+describe("checkAndMaybeArm", () => {
+    // 0.7.7 (#161): estimator now counts only user/assistant message bodies
+    // from valid JSONL lines, not raw file bytes. Helper writes a synthetic
+    // user message whose content has the requested char-count so existing
+    // crossing-math tests still work without reading a real transcript.
+    async function writeTranscript(chars) {
+        const p = path.join(tmpRoot, "transcript.jsonl");
+        const line = JSON.stringify({
+            type: "user",
+            message: { role: "user", content: "x".repeat(chars) },
+        });
+        await fs.writeFile(p, line + "\n");
+        return p;
+    }
+    it("returns null when transcript is missing / empty", async () => {
+        const r = await checkAndMaybeArm(SESSION, path.join(tmpRoot, "missing.jsonl"), {
+            dataRoot: tmpRoot,
+        });
+        expect(r).toBeNull();
+    });
+    it("arms a heartbeat on first crossing (no prior checkpoint)", async () => {
+        // 80000 chars -> 20000 tokens -> exactly threshold
+        const tpath = await writeTranscript(80000);
+        const nudge = await checkAndMaybeArm(SESSION, tpath, {
+            dataRoot: tmpRoot,
+            thresholdTokens: 20000,
+        });
+        expect(nudge).not.toBeNull();
+        expect(nudge).toContain("20,000");
+        // Checkpoint bumped to the current count.
+        const cp = await readCheckpoint(SESSION, { dataRoot: tmpRoot });
+        expect(cp?.last_token_count).toBe(20000);
+    });
+    it("does NOT arm again until threshold crossed from the new checkpoint", async () => {
+        // First crossing.
+        let tpath = await writeTranscript(80000);
+        expect(await checkAndMaybeArm(SESSION, tpath, { dataRoot: tmpRoot, thresholdTokens: 20000 })).not.toBeNull();
+        // Drain the previous nudge so we can detect a fresh one (or its absence).
+        await consumePendingHeartbeat(SESSION, { dataRoot: tmpRoot });
+        // Transcript grows by less than threshold from the checkpoint.
+        tpath = await writeTranscript(80000 + 4000); // +1000 tokens
+        const second = await checkAndMaybeArm(SESSION, tpath, {
+            dataRoot: tmpRoot,
+            thresholdTokens: 20000,
+        });
+        expect(second).toBeNull();
+        // Checkpoint stays at the first crossing.
+        const cp = await readCheckpoint(SESSION, { dataRoot: tmpRoot });
+        expect(cp?.last_token_count).toBe(20000);
+    });
+    it("resets stale baseline when checkpoint > 10x current (post-0.7.7 estimator migration)", async () => {
+        // Simulate a checkpoint left by the old estimator: 31M tokens for a
+        // 1.5M-token-real transcript. New estimator returns ~1.5M, baseline
+        // says 31M → naive delta is negative → would never fire. Reset
+        // logic must zero the baseline so the next crossing arms.
+        await writeCheckpoint(SESSION, { last_token_count: 31_000_000, last_checkpoint_at: "2026-05-17T00:00:00Z" }, { dataRoot: tmpRoot });
+        const tpath = await writeTranscript(80000); // 20K tokens
+        const nudge = await checkAndMaybeArm(SESSION, tpath, {
+            dataRoot: tmpRoot,
+            thresholdTokens: 20000,
+        });
+        expect(nudge).not.toBeNull();
+        const cp = await readCheckpoint(SESSION, { dataRoot: tmpRoot });
+        expect(cp?.last_token_count).toBe(20000);
+    });
+    it("does NOT reset baseline when checkpoint is within reasonable range", async () => {
+        // Baseline only 2x current — not stale, just slow growth (or
+        // transcript shrunk via compaction). Don't reset.
+        await writeCheckpoint(SESSION, { last_token_count: 40000, last_checkpoint_at: "2026-05-17T00:00:00Z" }, { dataRoot: tmpRoot });
+        const tpath = await writeTranscript(80000); // 20K tokens, baseline 40K, delta = -20K
+        const nudge = await checkAndMaybeArm(SESSION, tpath, {
+            dataRoot: tmpRoot,
+            thresholdTokens: 20000,
+        });
+        expect(nudge).toBeNull(); // negative delta, but no reset → no fire
+    });
+    it("arms again on each subsequent threshold crossing", async () => {
+        // First crossing at 20K tokens.
+        let tpath = await writeTranscript(80000);
+        expect(await checkAndMaybeArm(SESSION, tpath, { dataRoot: tmpRoot, thresholdTokens: 20000 })).not.toBeNull();
+        await consumePendingHeartbeat(SESSION, { dataRoot: tmpRoot });
+        // Second crossing at 40K tokens.
+        tpath = await writeTranscript(160000);
+        expect(await checkAndMaybeArm(SESSION, tpath, { dataRoot: tmpRoot, thresholdTokens: 20000 })).not.toBeNull();
+        const cp = await readCheckpoint(SESSION, { dataRoot: tmpRoot });
+        expect(cp?.last_token_count).toBe(40000);
+    });
+    it("does not arm when below threshold and no prior checkpoint", async () => {
+        const tpath = await writeTranscript(40000); // 10K tokens < 20K threshold
+        const r = await checkAndMaybeArm(SESSION, tpath, {
+            dataRoot: tmpRoot,
+            thresholdTokens: 20000,
+        });
+        expect(r).toBeNull();
+        // No checkpoint written when we didn't arm.
+        expect(await readCheckpoint(SESSION, { dataRoot: tmpRoot })).toBeNull();
+    });
+});
+// ---------------------------------------------------------------------
+// consumePendingHeartbeat — UserPromptSubmit hook entrypoint
+// ---------------------------------------------------------------------
+describe("consumePendingHeartbeat", () => {
+    it("returns null when no pending marker", async () => {
+        expect(await consumePendingHeartbeat(SESSION, { dataRoot: tmpRoot })).toBeNull();
+    });
+    it("returns the armed nudge and removes the marker (one-shot)", async () => {
+        // Arm. 0.7.7 (#161): estimator now requires valid JSONL; wrap the
+        // body content so the line parses as a user message.
+        const tpath = path.join(tmpRoot, "transcript.jsonl");
+        const line = JSON.stringify({ type: "user", message: { content: "x".repeat(80000) } });
+        await fs.writeFile(tpath, line + "\n");
+        await checkAndMaybeArm(SESSION, tpath, { dataRoot: tmpRoot, thresholdTokens: 20000 });
+        const first = await consumePendingHeartbeat(SESSION, { dataRoot: tmpRoot });
+        expect(first).not.toBeNull();
+        expect(first).toContain("🦑");
+        // Second consume returns null — marker was deleted.
+        const second = await consumePendingHeartbeat(SESSION, { dataRoot: tmpRoot });
+        expect(second).toBeNull();
+    });
+});
+// ---------------------------------------------------------------------
+// SessionEnd cleanup hook surface
+// ---------------------------------------------------------------------
+describe("heartbeatSessionFiles", () => {
+    it("returns the two paths SessionEnd should remove", () => {
+        const files = heartbeatSessionFiles(SESSION, tmpRoot);
+        expect(files.some((p) => p.endsWith("heartbeat-checkpoint.json"))).toBe(true);
+        expect(files.some((p) => p.endsWith("heartbeat-pending.txt"))).toBe(true);
+    });
+});
+// =====================================================================
+// 0.7.26 / D7 — recall-required flag (heartbeat → block until recall)
+// =====================================================================
+describe("recall-required flag (D7)", () => {
+    let tmp;
+    beforeEach(async () => {
+        tmp = path.join(os.tmpdir(), `opensquid-recall-flag-${crypto.randomUUID()}`);
+        await fs.mkdir(tmp, { recursive: true });
+    });
+    afterEach(async () => {
+        await fs.rm(tmp, { recursive: true, force: true });
+    });
+    it("isRecallRequired returns false when flag was never set", async () => {
+        const { isRecallRequired } = await import("./heartbeat.js");
+        expect(await isRecallRequired("sess-1", { dataRoot: tmp })).toBe(false);
+    });
+    it("markRecallRequired creates the flag; isRecallRequired returns true", async () => {
+        const { markRecallRequired, isRecallRequired } = await import("./heartbeat.js");
+        await markRecallRequired("sess-2", { dataRoot: tmp });
+        expect(await isRecallRequired("sess-2", { dataRoot: tmp })).toBe(true);
+    });
+    it("clearRecallRequired removes the flag", async () => {
+        const { markRecallRequired, clearRecallRequired, isRecallRequired } = await import("./heartbeat.js");
+        await markRecallRequired("sess-3", { dataRoot: tmp });
+        expect(await isRecallRequired("sess-3", { dataRoot: tmp })).toBe(true);
+        await clearRecallRequired("sess-3", { dataRoot: tmp });
+        expect(await isRecallRequired("sess-3", { dataRoot: tmp })).toBe(false);
+    });
+    it("clearRecallRequired is idempotent (clear without prior mark is fine)", async () => {
+        const { clearRecallRequired } = await import("./heartbeat.js");
+        await expect(clearRecallRequired("sess-never", { dataRoot: tmp })).resolves.toBeUndefined();
+    });
+    it("flags are per-session — setting one session doesn't affect another", async () => {
+        const { markRecallRequired, isRecallRequired } = await import("./heartbeat.js");
+        await markRecallRequired("sess-A", { dataRoot: tmp });
+        expect(await isRecallRequired("sess-A", { dataRoot: tmp })).toBe(true);
+        expect(await isRecallRequired("sess-B", { dataRoot: tmp })).toBe(false);
+    });
+    it("heartbeatSessionFiles includes the recall-required flag path for SessionEnd cleanup", async () => {
+        const { heartbeatSessionFiles } = await import("./heartbeat.js");
+        const files = heartbeatSessionFiles("sess-1", tmp);
+        expect(files.some((p) => p.endsWith("recall-required.flag"))).toBe(true);
+    });
+});

package/dist/hooks/honesty-ledger-session-scope.test.js

@@ -0,0 +1,100 @@
+/**
+ * Tests specifically for the session-scope fix (#114).
+ *
+ * Verifies that:
+ *  1. The ledger accumulates across multiple turns within a session.
+ *  2. A claim made in turn N is satisfied by evidence from turn 1.
+ *  3. clearSession wipes both ledger + broken-promises.
+ *  4. Stop hook's de-dupe behavior — re-running reconcile on the same
+ *     text doesn't double-record the broken promise.
+ */
+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, clearTurnLedger, reconcile, readBrokenPromises, readTurnLedger, recordBrokenPromise, recordToolCall, } from "./honesty-ledger.js";
+let tmpRoot;
+const SESSION = "scope-test-session";
+beforeEach(async () => {
+    tmpRoot = path.join(os.tmpdir(), `oscli-honesty-scope-${crypto.randomUUID()}`);
+    await fs.mkdir(tmpRoot, { recursive: true });
+});
+afterEach(async () => {
+    await fs.rm(tmpRoot, { recursive: true, force: true });
+});
+describe("session-scoped ledger (#114 fix)", () => {
+    it("accumulates tool calls across multiple turns", async () => {
+        // Turn 1: ran npm test
+        await recordToolCall(SESSION, "Bash", "npm test", { dataRoot: tmpRoot });
+        // Turn 2: ran cargo check
+        await recordToolCall(SESSION, "Bash", "cargo check", { dataRoot: tmpRoot });
+        // Turn 3: read a file
+        await recordToolCall(SESSION, "Read", "/x.ts", { dataRoot: tmpRoot });
+        const ledger = await readTurnLedger(SESSION, { dataRoot: tmpRoot });
+        expect(ledger).toHaveLength(3);
+        expect(ledger.map((e) => e.tool)).toEqual(["Bash", "Bash", "Read"]);
+    });
+    it("recap text in turn N is satisfied by tool call from turn 1 (THE FIX)", async () => {
+        // Turn 1: actually ran tests
+        await recordToolCall(SESSION, "Bash", "npm test", { dataRoot: tmpRoot });
+        // Turn 5 (much later): assistant says "tests pass" in recap text
+        const recapText = "Here's a summary. Tests pass and build is green.";
+        const ledger = await readTurnLedger(SESSION, { dataRoot: tmpRoot });
+        const broken = reconcile(recapText, ledger);
+        // Before the fix: would flag "tests pass" as a broken promise.
+        // After the fix: ledger has the prior turn's npm test, so satisfied.
+        expect(broken.map((b) => b.claim_id)).not.toContain("running-tests");
+    });
+    it("genuinely lying recap is still caught (no false-negative regression)", async () => {
+        // Turn 1: read a file
+        await recordToolCall(SESSION, "Read", "/foo.ts", { dataRoot: tmpRoot });
+        // Turn 2: claim "tests pass" but NO test was ever run in this session
+        const ledger = await readTurnLedger(SESSION, { dataRoot: tmpRoot });
+        const broken = reconcile("Tests pass.", ledger);
+        expect(broken.map((b) => b.claim_id)).toContain("running-tests");
+    });
+    it("clearTurnLedger removes only the ledger file (not broken-promises)", async () => {
+        await recordToolCall(SESSION, "Bash", "ls", { dataRoot: tmpRoot });
+        await recordBrokenPromise(SESSION, {
+            ts: "t",
+            claim_id: "fake",
+            claim_label: "fake",
+            matched_text: "fake",
+            reason: "fake",
+        }, { dataRoot: tmpRoot });
+        await clearTurnLedger(SESSION, { dataRoot: tmpRoot });
+        expect(await readTurnLedger(SESSION, { dataRoot: tmpRoot })).toEqual([]);
+        // broken-promises survives a turn-ledger clear
+        expect(await readBrokenPromises(SESSION, { dataRoot: tmpRoot })).toHaveLength(1);
+    });
+    it("clearSession wipes BOTH ledger and broken-promises", async () => {
+        await recordToolCall(SESSION, "Bash", "ls", { dataRoot: tmpRoot });
+        await recordBrokenPromise(SESSION, {
+            ts: "t",
+            claim_id: "fake",
+            claim_label: "fake",
+            matched_text: "fake",
+            reason: "fake",
+        }, { dataRoot: tmpRoot });
+        await clearSession(SESSION, { dataRoot: tmpRoot });
+        expect(await readTurnLedger(SESSION, { dataRoot: tmpRoot })).toEqual([]);
+        expect(await readBrokenPromises(SESSION, { dataRoot: tmpRoot })).toEqual([]);
+    });
+    it("clearSession is idempotent (no throw on already-clean session)", async () => {
+        await clearSession(SESSION, { dataRoot: tmpRoot });
+        await clearSession(SESSION, { dataRoot: tmpRoot });
+        // No throw.
+    });
+});
+describe("stuck-broken-promise dedupe (#114 fix companion)", () => {
+    it("reconcile on the same text twice returns the same set", async () => {
+        // No tool calls. Claim text triggers two patterns.
+        const broken1 = reconcile("Tests pass and committed.", []);
+        const broken2 = reconcile("Tests pass and committed.", []);
+        expect(broken1.map((b) => b.claim_id).sort()).toEqual(broken2.map((b) => b.claim_id).sort());
+        // Both should flag running-tests + committed
+        expect(broken1.map((b) => b.claim_id)).toContain("running-tests");
+        expect(broken1.map((b) => b.claim_id)).toContain("committed");
+    });
+});

package/dist/hooks/honesty-ledger.d.ts

@@ -0,0 +1,123 @@
+/**
+ * Honesty ledger — catches claim-vs-action gaps in assistant turns.
+ *
+ * The agent makes claims like "running tests now" or "starting research"
+ * or "committed" in its text output. These claims are checkable against
+ * the tool calls that actually happened in the same turn. When the
+ * claim has no matching tool call, that's a "broken promise" — opensquid
+ * records it so the next turn surfaces it to the agent for correction.
+ *
+ * Storage:
+ *   <data-root>/sessions/<session-id>/turn-ledger.jsonl
+ *     One JSON line per tool call this turn, appended by the PreToolUse
+ *     hook. Cleared at turn-end after reconciliation.
+ *
+ *   <data-root>/sessions/<session-id>/broken-promises.jsonl
+ *     Append-only ledger of claims that lacked matching evidence.
+ *     Surfaced to the agent on the NEXT turn via SessionStart/
+ *     UserPromptSubmit hook output.
+ */
+export type ClaimEvidenceShape = {
+    kind: "any_tool";
+} | {
+    kind: "bash_contains";
+    needle: string;
+} | {
+    kind: "bash_regex";
+    pattern: string;
+} | {
+    kind: "tool_called";
+    tool: string;
+} | {
+    kind: "any_of";
+    options: ClaimEvidenceShape[];
+} | {
+    kind: "input_contains";
+    tool: string;
+    needle: string;
+};
+export interface ClaimPattern {
+    /** Stable id (e.g. "research-start"). */
+    id: string;
+    /** Regex matched against assistant text. */
+    text_regex: string;
+    /** What proof of action satisfies this claim. */
+    evidence: ClaimEvidenceShape;
+    /** Short label surfaced to the agent when the promise is broken. */
+    promise_label: string;
+}
+/**
+ * Claim catalog — sourced from the bundled-default codex (0.7.17,
+ * drift-as-codex chunk 3b). Previously a hand-maintained TS array;
+ * now loaded once at module init from
+ * `src/codex/bundled-default/codex.yaml` via the chunk-2 loader.
+ *
+ * Fail-open: if the codex is unloadable, the catalog is empty and
+ * no claims fire. Better silent under-enforcement than a hook crash.
+ */
+export declare const CLAIM_PATTERNS: ClaimPattern[];
+/**
+ * One tool-call entry, persisted across ALL turns in the same Claude
+ * Code session. Cleared only at session end (or explicit
+ * `clearSessionLedger`).
+ *
+ * #114 (2026-05-15) — v0.4.C.1 fix: previously this was a PER-TURN
+ * ledger that got cleared by the Stop hook, which caused recap text
+ * describing prior-turn work to be flagged as broken promises. Now
+ * the ledger accumulates across the whole session so claims like
+ * "tests pass" satisfy against any `npm test` from any earlier turn
+ * in the same session.
+ */
+export interface TurnLedgerEntry {
+    ts: string;
+    tool: string;
+    /** Subset of tool_input relevant to reconciliation. */
+    input_summary: string;
+}
+/** Called by PreToolUse hook to record what the agent is about to do. */
+export declare function recordToolCall(sessionId: string, tool: string, inputSummary: string, options?: {
+    dataRoot?: string;
+}): Promise<void>;
+/** Read the session-scoped ledger (every tool call so far this session). */
+export declare function readTurnLedger(sessionId: string, options?: {
+    dataRoot?: string;
+}): Promise<TurnLedgerEntry[]>;
+/**
+ * Clear the session ledger. ONLY called at session end (or by tests).
+ * Stop hook does NOT call this anymore — the ledger persists across
+ * turns to avoid recap-text false-positives.
+ */
+export declare function clearTurnLedger(sessionId: string, options?: {
+    dataRoot?: string;
+}): Promise<void>;
+/**
+ * Explicit session-end clear: wipes everything opensquid wrote under
+ * this session's directory — turn ledger, broken promises, plus the
+ * heartbeat checkpoint and pending marker (#124). Files are removed
+ * individually so unrelated files in the session dir survive (in case
+ * a future hook drops something else there).
+ */
+export declare function clearSession(sessionId: string, options?: {
+    dataRoot?: string;
+}): Promise<void>;
+export interface BrokenPromise {
+    ts: string;
+    claim_id: string;
+    claim_label: string;
+    matched_text: string;
+    reason: string;
+}
+/**
+ * Scan assistant text for claim phrases, reconcile against the ledger,
+ * return any unfulfilled promises.
+ */
+export declare function reconcile(assistantText: string, ledger: TurnLedgerEntry[]): BrokenPromise[];
+/** Append a broken promise to the session's append-only ledger. */
+export declare function recordBrokenPromise(sessionId: string, promise: BrokenPromise, options?: {
+    dataRoot?: string;
+}): Promise<void>;
+/** Read all broken promises for a session (used by next turn's hook). */
+export declare function readBrokenPromises(sessionId: string, options?: {
+    dataRoot?: string;
+}): Promise<BrokenPromise[]>;
+//# sourceMappingURL=honesty-ledger.d.ts.map

package/dist/hooks/honesty-ledger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"honesty-ledger.d.ts","sourceRoot":"","sources":["../../src.legacy/hooks/honesty-ledger.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAaH,MAAM,MAAM,kBAAkB,GAC1B;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE,GACpB;IAAE,IAAI,EAAE,eAAe,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GACzC;IAAE,IAAI,EAAE,YAAY,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GACvC;IAAE,IAAI,EAAE,aAAa,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAKrC;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,OAAO,EAAE,kBAAkB,EAAE,CAAA;CAAE,GACjD;IAAE,IAAI,EAAE,gBAAgB,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAE7D,MAAM,WAAW,YAAY;IAC3B,yCAAyC;IACzC,EAAE,EAAE,MAAM,CAAC;IACX,4CAA4C;IAC5C,UAAU,EAAE,MAAM,CAAC;IACnB,iDAAiD;IACjD,QAAQ,EAAE,kBAAkB,CAAC;IAC7B,oEAAoE;IACpE,aAAa,EAAE,MAAM,CAAC;CACvB;AA4CD;;;;;;;;GAQG;AACH,eAAO,MAAM,cAAc,EAAE,YAAY,EAUrC,CAAC;AAML;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,eAAe;IAC9B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,uDAAuD;IACvD,aAAa,EAAE,MAAM,CAAC;CACvB;AAgBD,yEAAyE;AACzE,wBAAsB,cAAc,CAClC,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,MAAM,EACZ,YAAY,EAAE,MAAM,EACpB,OAAO,GAAE;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAO,GAClC,OAAO,CAAC,IAAI,CAAC,CAaf;AAED,4EAA4E;AAC5E,wBAAsB,cAAc,CAClC,SAAS,EAAE,MAAM,EACjB,OAAO,GAAE;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAO,GAClC,OAAO,CAAC,eAAe,EAAE,CAAC,CAU5B;AAED;;;;GAIG;AACH,wBAAsB,eAAe,CACnC,SAAS,EAAE,MAAM,EACjB,OAAO,GAAE;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAO,GAClC,OAAO,CAAC,IAAI,CAAC,CAMf;AAED;;;;;;GAMG;AACH,wBAAsB,YAAY,CAChC,SAAS,EAAE,MAAM,EACjB,OAAO,GAAE;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAO,GAClC,OAAO,CAAC,IAAI,CAAC,CAcf;AAMD,MAAM,WAAW,aAAa;IAC5B,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;IACrB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;GAGG;AACH,wBAAgB,SAAS,CAAC,aAAa,EAAE,MAAM,EAAE,MAAM,EAAE,eAAe,EAAE,GAAG,aAAa,EAAE,CAqB3F;AA0BD,mEAAmE;AACnE,wBAAsB,mBAAmB,CACvC,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,aAAa,EACtB,OAAO,GAAE;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAO,GAClC,OAAO,CAAC,IAAI,CAAC,CAQf;AAED,yEAAyE;AACzE,wBAAsB,kBAAkB,CACtC,SAAS,EAAE,MAAM,EACjB,OAAO,GAAE;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAO,GAClC,OAAO,CAAC,aAAa,EAAE,CAAC,CAU1B"}