brane 0.1.1 → 0.3.0

package/dist/test/cost-sessions.test.js

@@ -0,0 +1,301 @@
+import { after, before, describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { createTestDb } from "./helpers.js";
+import { recordSessionId, getSessionIds, sumCostReadings, backfillCostLedger, ledgerTotal } from "../daemon/server.js";
+import { getAgentAdapter } from "../agents.js";
+import { priceMessage } from "../cost/pricing.js";
+function seed(db, id, opts = {}) {
+    db.prepare(`INSERT INTO narratives (id, brane_id, agent_type, role, created_at, status, agent_session_id, session_ids)
+     VALUES (?, 'brane-test', 'claude', 'worker', 0, 'active', ?, ?)`).run(id, opts.agent_session_id ?? null, opts.session_ids ?? null);
+}
+function storedIds(db, id) {
+    return db.prepare("SELECT session_ids FROM narratives WHERE id = ?").get(id).session_ids;
+}
+describe("recordSessionId", () => {
+    it("appends the first session as a JSON array", () => {
+        const db = createTestDb();
+        seed(db, "claude-a");
+        recordSessionId(db, "claude-a", "sess-1");
+        assert.deepEqual(JSON.parse(storedIds(db, "claude-a")), ["sess-1"]);
+    });
+    it("accumulates distinct sessions in order, deduping repeats", () => {
+        const db = createTestDb();
+        seed(db, "claude-a", { session_ids: '["sess-1"]' });
+        recordSessionId(db, "claude-a", "sess-2");
+        recordSessionId(db, "claude-a", "sess-1"); // dup — ignored
+        recordSessionId(db, "claude-a", "sess-3");
+        assert.deepEqual(JSON.parse(storedIds(db, "claude-a")), ["sess-1", "sess-2", "sess-3"]);
+    });
+    it("is a no-op for an empty session id or unknown narrative", () => {
+        const db = createTestDb();
+        seed(db, "claude-a", { session_ids: '["sess-1"]' });
+        recordSessionId(db, "claude-a", undefined);
+        recordSessionId(db, "claude-a", "");
+        recordSessionId(db, "claude-missing", "sess-x"); // no row → no throw
+        assert.deepEqual(JSON.parse(storedIds(db, "claude-a")), ["sess-1"]);
+    });
+    it("recovers from a malformed session_ids value by starting fresh", () => {
+        const db = createTestDb();
+        seed(db, "claude-a", { session_ids: "{not json" });
+        recordSessionId(db, "claude-a", "sess-1");
+        assert.deepEqual(JSON.parse(storedIds(db, "claude-a")), ["sess-1"]);
+    });
+});
+describe("session_ids migration backfill", () => {
+    // Pins the exact backfill SQL from openDatabase(): seed the set from the
+    // current session for rows that predate the column, and never clobber a set
+    // that's already populated.
+    const BACKFILL = `UPDATE narratives SET session_ids = '["' || agent_session_id || '"]'
+       WHERE session_ids IS NULL AND agent_session_id IS NOT NULL`;
+    it("seeds session_ids from agent_session_id for a pre-column row", () => {
+        const db = createTestDb();
+        seed(db, "claude-a", { agent_session_id: "550e8400-e29b-41d4-a716-446655440000", session_ids: null });
+        db.exec(BACKFILL);
+        assert.deepEqual(JSON.parse(storedIds(db, "claude-a")), ["550e8400-e29b-41d4-a716-446655440000"]);
+    });
+    it("leaves an already-populated set untouched and skips session-less rows", () => {
+        const db = createTestDb();
+        seed(db, "claude-has-set", { agent_session_id: "sess-cur", session_ids: '["sess-old","sess-cur"]' });
+        seed(db, "claude-no-session"); // both null
+        db.exec(BACKFILL);
+        assert.deepEqual(JSON.parse(storedIds(db, "claude-has-set")), ["sess-old", "sess-cur"]);
+        assert.equal(storedIds(db, "claude-no-session"), null);
+    });
+});
+describe("getSessionIds", () => {
+    it("returns the stored set unioned with the current agent_session_id", () => {
+        const db = createTestDb();
+        seed(db, "claude-a", { agent_session_id: "sess-2", session_ids: '["sess-1","sess-2"]' });
+        assert.deepEqual(getSessionIds(db, "claude-a"), ["sess-1", "sess-2"]);
+    });
+    it("appends the current session when the set somehow missed it", () => {
+        const db = createTestDb();
+        seed(db, "claude-a", { agent_session_id: "sess-3", session_ids: '["sess-1","sess-2"]' });
+        assert.deepEqual(getSessionIds(db, "claude-a"), ["sess-1", "sess-2", "sess-3"]);
+    });
+    it("falls back to agent_session_id for a legacy row with no set", () => {
+        const db = createTestDb();
+        seed(db, "claude-a", { agent_session_id: "sess-legacy", session_ids: null });
+        assert.deepEqual(getSessionIds(db, "claude-a"), ["sess-legacy"]);
+    });
+    it("returns [] for a narrative with neither set nor current session, and for unknown ids", () => {
+        const db = createTestDb();
+        seed(db, "claude-a");
+        assert.deepEqual(getSessionIds(db, "claude-a"), []);
+        assert.deepEqual(getSessionIds(db, "claude-missing"), []);
+    });
+});
+describe("sumCostReadings", () => {
+    const r = (amount, unit = "USD", tokens) => tokens ? { amount, unit, tokens } : { amount, unit };
+    it("sums amounts across sessions of the same unit", () => {
+        const total = sumCostReadings([r(1.5), r(2.25), r(0.25)]);
+        assert.deepEqual(total, { amount: 4, unit: "USD" });
+    });
+    it("sums token breakdowns component-wise", () => {
+        const total = sumCostReadings([
+            r(1, "USD", { input: 10, output: 5, cacheRead: 2, cacheWrite: 1 }),
+            r(2, "USD", { input: 20, output: 7, cacheRead: 3, cacheWrite: 4 }),
+        ]);
+        assert.deepEqual(total, {
+            amount: 3,
+            unit: "USD",
+            tokens: { input: 30, output: 12, cacheRead: 5, cacheWrite: 5 },
+        });
+    });
+    it("skips null readings (transcript gone) and still totals the rest", () => {
+        const total = sumCostReadings([r(1), null, r(3), null]);
+        assert.deepEqual(total, { amount: 4, unit: "USD" });
+    });
+    it("returns null when there are no usable readings", () => {
+        assert.equal(sumCostReadings([]), null);
+        assert.equal(sumCostReadings([null, null]), null);
+    });
+    it("never adds across differing units — keeps the first, skips mismatches", () => {
+        const total = sumCostReadings([r(1, "USD"), r(1000, "AIC"), r(2, "USD")]);
+        assert.deepEqual(total, { amount: 3, unit: "USD" });
+    });
+});
+// The claude adapter reads real transcripts under ~/.claude/projects/, and the
+// pricing table overlays an optional ~/.brane/pricing.json — so both suites
+// below sandbox HOME to a temp dir (same pattern as model-resolution.test.ts)
+// and fabricate session JSONLs there.
+describe("claude usage reading and pricing", () => {
+    let origHome;
+    let homeDir;
+    const FOLD = "/work/proj-cost";
+    const SESSION_A = "aaaaaaaa-0000-0000-0000-000000000001";
+    const SESSION_B = "bbbbbbbb-0000-0000-0000-000000000002";
+    const SESSION_GONE = "cccccccc-0000-0000-0000-000000000003";
+    const usage = (input, output) => ({
+        input,
+        output,
+        cacheRead: 0,
+        cacheWrite5m: 0,
+        cacheWrite1h: 0,
+    });
+    function usageLine(id, model, u) {
+        return JSON.stringify({
+            type: "assistant",
+            message: {
+                ...(id ? { id } : {}),
+                model,
+                role: "assistant",
+                usage: {
+                    input_tokens: u.input,
+                    output_tokens: u.output,
+                    cache_read_input_tokens: u.cacheRead,
+                    cache_creation: {
+                        ephemeral_5m_input_tokens: u.cacheWrite5m,
+                        ephemeral_1h_input_tokens: u.cacheWrite1h,
+                    },
+                },
+            },
+        });
+    }
+    // Session A: two id-bearing messages plus one id-less synthetic record.
+    // Session B: fork of A — A's id-bearing lines copied verbatim (same ids),
+    // then two genuinely new messages, one of them streamed twice (duplicate id
+    // within the file).
+    const A1 = { id: "msg_a1", model: "claude-opus-4-8", u: usage(1000, 500) };
+    const A2 = { id: "msg_a2", model: "claude-opus-4-8", u: usage(2000, 700) };
+    const A_SYNTH = { id: undefined, model: "<synthetic>", u: usage(10, 5) };
+    const B1 = { id: "msg_b1", model: "claude-fable-5", u: usage(3000, 900) };
+    const B2 = { id: "msg_b2", model: "claude-fable-5", u: usage(4000, 1100) };
+    const cost = (m) => priceMessage(m.model, m.u);
+    const round4 = (n) => Math.round(n * 1e4) / 1e4;
+    const costA = round4(cost(A1) + cost(A2) + cost(A_SYNTH));
+    const costAB = round4(cost(A1) + cost(A2) + cost(A_SYNTH) + cost(B1) + cost(B2));
+    before(() => {
+        origHome = process.env.HOME;
+        homeDir = mkdtempSync(join(tmpdir(), "brane-cost-home-"));
+        process.env.HOME = homeDir;
+        const projectDir = join(homeDir, ".claude", "projects", FOLD.replace(/\//g, "-"));
+        mkdirSync(projectDir, { recursive: true });
+        const aLines = [
+            usageLine(A1.id, A1.model, A1.u),
+            usageLine(A2.id, A2.model, A2.u),
+            usageLine(A_SYNTH.id, A_SYNTH.model, A_SYNTH.u),
+        ];
+        const bLines = [
+            usageLine(A1.id, A1.model, A1.u), // fork-copied history, same ids
+            usageLine(A2.id, A2.model, A2.u),
+            usageLine(B1.id, B1.model, B1.u),
+            usageLine(B1.id, B1.model, B1.u), // streamed duplicate within the file
+            usageLine(B2.id, B2.model, B2.u),
+        ];
+        writeFileSync(join(projectDir, `${SESSION_A}.jsonl`), aLines.join("\n") + "\n");
+        writeFileSync(join(projectDir, `${SESSION_B}.jsonl`), bLines.join("\n") + "\n");
+    });
+    after(() => {
+        if (origHome === undefined)
+            delete process.env.HOME;
+        else
+            process.env.HOME = origHome;
+    });
+    describe("readUsage / readUsageMany fork dedup", () => {
+        const claude = getAgentAdapter("claude");
+        it("readUsage prices a single session, counting id-less records and deduping streamed duplicates", () => {
+            const a = claude.readUsage({ sessionId: SESSION_A, foldPath: FOLD });
+            assert.equal(a?.amount, costA);
+            assert.deepEqual(a?.tokens, {
+                input: A1.u.input + A2.u.input + A_SYNTH.u.input,
+                output: A1.u.output + A2.u.output + A_SYNTH.u.output,
+                cacheRead: 0,
+                cacheWrite: 0,
+            });
+            const b = claude.readUsage({ sessionId: SESSION_B, foldPath: FOLD });
+            assert.equal(b?.amount, round4(cost(A1) + cost(A2) + cost(B1) + cost(B2)));
+        });
+        it("readUsageMany counts fork-copied messages once: total = cost(A) + cost(B new only)", () => {
+            const total = claude.readUsageMany({ sessionIds: [SESSION_A, SESSION_B], foldPath: FOLD });
+            assert.equal(total?.amount, costAB);
+            assert.equal(total?.unit, "USD");
+            assert.deepEqual(total?.tokens, {
+                input: A1.u.input + A2.u.input + A_SYNTH.u.input + B1.u.input + B2.u.input,
+                output: A1.u.output + A2.u.output + A_SYNTH.u.output + B1.u.output + B2.u.output,
+                cacheRead: 0,
+                cacheWrite: 0,
+            });
+        });
+        it("repeated sampling is stable (memoized parse, same totals)", () => {
+            const first = claude.readUsageMany({ sessionIds: [SESSION_A, SESSION_B], foldPath: FOLD });
+            const second = claude.readUsageMany({ sessionIds: [SESSION_A, SESSION_B], foldPath: FOLD });
+            assert.deepEqual(second, first);
+        });
+        it("readUsageEntries keys messages by id, and id-less records by file position", () => {
+            const readings = claude.readUsageEntries({ sessionIds: [SESSION_A, SESSION_B, SESSION_GONE], foldPath: FOLD });
+            assert.equal(readings?.length, 2);
+            const [a, b] = readings;
+            assert.equal(a.sessionId, SESSION_A);
+            assert.equal(a.unit, "USD");
+            assert.deepEqual(a.entries.map((e) => [e.key, e.amount]), [["claude:msg_a1", cost(A1)], ["claude:msg_a2", cost(A2)], [`claude:${SESSION_A}#2`, cost(A_SYNTH)]]);
+            // Fork-copied ids repeat verbatim — the ledger's primary key is what
+            // collapses them — while the in-file streamed duplicate is already gone.
+            assert.deepEqual(b.entries.map((e) => e.key), ["claude:msg_a1", "claude:msg_a2", "claude:msg_b1", "claude:msg_b2"]);
+            assert.ok(a.sig && b.sig);
+            assert.equal(claude.readUsageEntries({ sessionIds: [SESSION_GONE], foldPath: FOLD }), null);
+        });
+        it("skips missing session files, and returns null when none are readable", () => {
+            const partial = claude.readUsageMany({ sessionIds: [SESSION_A, SESSION_GONE], foldPath: FOLD });
+            assert.equal(partial?.amount, costA);
+            assert.equal(claude.readUsageMany({ sessionIds: [SESSION_GONE], foldPath: FOLD }), null);
+            assert.equal(claude.readUsageMany({ sessionIds: [], foldPath: FOLD }), null);
+        });
+    });
+    describe("backfillCostLedger", () => {
+        function seedFold(db, id, createdAt, sessionId, cost) {
+            db.prepare(`INSERT INTO narratives (id, brane_id, agent_type, role, created_at, status, fold_path, agent_session_id, session_ids, cost_amount, cost_unit)
+         VALUES (?, 'brane-test', 'claude', 'worker', ?, 'ended', ?, ?, ?, ?, ?)`).run(id, createdAt, FOLD, sessionId, JSON.stringify([sessionId]), cost ?? null, cost == null ? null : "USD");
+        }
+        it("walks oldest first, so the original claims fork-copied messages before its twin", () => {
+            const db = createTestDb();
+            // Inserted newest-first to prove the order comes from created_at, not rowid.
+            seedFold(db, "claude-twin", 200, SESSION_B);
+            seedFold(db, "claude-orig", 100, SESSION_A);
+            const dry = backfillCostLedger(db, { dryRun: true });
+            assert.equal(dry.scanned, 2);
+            assert.deepEqual(dry.samples.map((s) => s.nid), ["claude-orig", "claude-twin"]);
+            assert.equal(ledgerTotal(db, "claude-orig"), null, "dry run writes nothing");
+            const real = backfillCostLedger(db);
+            assert.equal(real.samples.length, 2);
+            // The ledger keeps six decimals where the old reader rounded to four.
+            assert.equal(round4(ledgerTotal(db, "claude-orig").amount), costA);
+            assert.equal(round4(ledgerTotal(db, "claude-twin").amount), round4(cost(B1) + cost(B2)));
+            const col = (id) => db.prepare("SELECT cost_amount FROM narratives WHERE id = ?").get(id).cost_amount;
+            assert.equal(round4(col("claude-orig")), costA);
+            assert.equal(round4(col("claude-twin")), round4(cost(B1) + cost(B2)));
+            // Idempotent: nothing new on a second pass.
+            const again = backfillCostLedger(db);
+            assert.ok(again.samples.every((s) => s.new_rows === 0 && s.before === s.after));
+        });
+        it("keeps a frozen column that exceeds what the surviving transcripts show", () => {
+            const db = createTestDb();
+            seedFold(db, "claude-frozen", 100, SESSION_A, 99.5);
+            backfillCostLedger(db);
+            assert.equal(round4(ledgerTotal(db, "claude-frozen").amount), costA);
+            const col = db.prepare("SELECT cost_amount FROM narratives WHERE id = ?").get("claude-frozen").cost_amount;
+            assert.equal(col, 99.5);
+        });
+    });
+    describe("priceMessage tiers", () => {
+        const oneMTokEach = usage(1e6, 1e6);
+        it("prices fable and mythos at $10/$50 — exactly 2× opus for the same usage", () => {
+            const opus = priceMessage("claude-opus-4-8", oneMTokEach);
+            assert.equal(opus, 30);
+            assert.equal(priceMessage("claude-fable-5", oneMTokEach), 2 * opus);
+            assert.equal(priceMessage("claude-mythos-5", oneMTokEach), 2 * opus);
+        });
+        it("keeps cache multipliers relative to the fable input price", () => {
+            const cacheOnly = { input: 0, output: 0, cacheRead: 1e6, cacheWrite5m: 1e6, cacheWrite1h: 1e6 };
+            // 0.1× + 1.25× + 2× of the $10 input price.
+            assert.equal(priceMessage("claude-fable-5", cacheOnly), 1 + 12.5 + 20);
+        });
+        it("prices unknown models at the most expensive known tier (fable)", () => {
+            assert.equal(priceMessage("claude-newthing-9", oneMTokEach), 60);
+        });
+    });
+});
+//# sourceMappingURL=cost-sessions.test.js.map

package/dist/test/crush-tool-log.test.js

@@ -0,0 +1,289 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import Database from "better-sqlite3";
+import { mkdtempSync, mkdirSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { createTestDb } from "./helpers.js";
+import { readToolUseWindow } from "../db/tool-uses.js";
+import { toolUsesFromCrushParts, resolveCrushSessionIds, pollCrushToolLog, newCrushLogCursor, crushDbPath, crushLogSignature, } from "../crush-tool-log.js";
+/** crush's schema, copied from a live `~/dev/crush/.crush/crush.db` — including
+ *  the comments that claim milliseconds on columns that hold seconds. */
+const CRUSH_SCHEMA = `
+CREATE TABLE sessions (
+  id TEXT PRIMARY KEY,
+  parent_session_id TEXT,
+  title TEXT NOT NULL,
+  message_count INTEGER NOT NULL DEFAULT 0,
+  prompt_tokens INTEGER NOT NULL DEFAULT 0,
+  completion_tokens INTEGER NOT NULL DEFAULT 0,
+  cost REAL NOT NULL DEFAULT 0.0,
+  updated_at INTEGER NOT NULL,  -- Unix timestamp in milliseconds
+  created_at INTEGER NOT NULL   -- Unix timestamp in milliseconds
+);
+CREATE TABLE messages (
+  id TEXT PRIMARY KEY,
+  session_id TEXT NOT NULL,
+  role TEXT NOT NULL,
+  parts TEXT NOT NULL DEFAULT '[]',
+  model TEXT,
+  created_at INTEGER NOT NULL,
+  updated_at INTEGER NOT NULL,
+  finished_at INTEGER,
+  provider TEXT
+);
+`;
+/** Real part shapes, from the live database. Note the double encoding: `input`
+ *  and `metadata` are JSON strings inside a JSON document. */
+const TOOL_CALL_PART = JSON.stringify([
+    {
+        type: "tool_call",
+        data: {
+            id: "bash_88",
+            name: "bash",
+            input: '{"command": "sleep 25"}',
+            provider_executed: false,
+            finished: false,
+        },
+    },
+]);
+const TOOL_RESULT_PART = JSON.stringify([
+    {
+        type: "tool_result",
+        data: {
+            tool_call_id: "bash_88",
+            name: "bash",
+            content: "done",
+            is_error: false,
+            metadata: '{"start_time":1786903334560,"end_time":1786903335561,"description":"sleep"}',
+        },
+    },
+]);
+function crushFold() {
+    const fold = mkdtempSync(join(tmpdir(), "brane-crush-"));
+    mkdirSync(join(fold, ".crush"), { recursive: true });
+    return fold;
+}
+function seedCrush(fold) {
+    const crush = new Database(crushDbPath(fold));
+    crush.exec(CRUSH_SCHEMA);
+    return crush;
+}
+function addSession(crush, id, createdAt, parent) {
+    crush
+        .prepare("INSERT INTO sessions (id, parent_session_id, title, updated_at, created_at) VALUES (?, ?, 'x', ?, ?)")
+        .run(id, parent ?? null, createdAt, createdAt);
+}
+function addMessage(crush, id, sessionId, parts, at) {
+    crush
+        .prepare("INSERT INTO messages (id, session_id, role, parts, created_at, updated_at) VALUES (?, ?, 'assistant', ?, ?, ?)")
+        .run(id, sessionId, parts, at, at);
+}
+function seedNarrative(db, fold, createdAtMs) {
+    const nid = "crush-test0001";
+    db.prepare("INSERT INTO narratives (id, brane_id, agent_type, role, status, fold_path, created_at) VALUES (?, 'brane-test', 'crush', 'worker', 'active', ?, ?)").run(nid, fold, createdAtMs);
+    return nid;
+}
+describe("toolUsesFromCrushParts", () => {
+    // crush persists the tool_call part before the tool runs, which is the whole
+    // reason a session-log tail can stand in for a PreToolUse hook.
+    it("reads a call as pending and un-double-encodes its input", () => {
+        const [call] = toolUsesFromCrushParts(TOOL_CALL_PART, {});
+        assert.equal(call.dedupKey, "bash_88");
+        assert.equal(call.name, "bash");
+        assert.equal(call.status, "pending");
+        assert.deepEqual(call.input, { command: "sleep 25" }, "input arrives as a JSON string");
+        assert.equal(call.source, "session_log");
+        assert.equal(call.agentType, "crush");
+    });
+    // `finished` says the call returned, not that it worked. The outcome lives in
+    // the tool_result part, which may not be written yet — so reading `finished`
+    // as success would mark failed calls completed.
+    it("keeps a finished call pending until its result part arrives", () => {
+        const finished = TOOL_CALL_PART.replace('"finished":false', '"finished":true');
+        assert.equal(toolUsesFromCrushParts(finished, {})[0].status, "pending");
+    });
+    it("completes the call from its result, with a duration in the right unit", () => {
+        const [result] = toolUsesFromCrushParts(TOOL_RESULT_PART, {});
+        assert.equal(result.dedupKey, "bash_88", "same key as the call — one row, not two");
+        assert.equal(result.status, "completed");
+        assert.equal(result.output, "done");
+        // metadata's start_time/end_time are milliseconds, unlike the columns.
+        assert.equal(result.durationMs, 1_001);
+        assert.equal(result.startedAt, 1_786_903_334_560);
+    });
+    it("reads is_error as a failure", () => {
+        const failed = TOOL_RESULT_PART.replace('"is_error":false', '"is_error":true');
+        assert.equal(toolUsesFromCrushParts(failed, {})[0].status, "failed");
+    });
+    it("survives junk parts rather than throwing inside a poll", () => {
+        assert.deepEqual(toolUsesFromCrushParts("not json", {}), []);
+        assert.deepEqual(toolUsesFromCrushParts('{"not":"an array"}', {}), []);
+        assert.deepEqual(toolUsesFromCrushParts('[{"type":"text","data":{"text":"hi"}}]', {}), []);
+        assert.deepEqual(toolUsesFromCrushParts('[{"type":"tool_call","data":{}}]', {}), []);
+        // A result with no metadata still completes; it just has no duration.
+        const [bare] = toolUsesFromCrushParts('[{"type":"tool_result","data":{"tool_call_id":"x_1","name":"x","content":"ok"}}]', {});
+        assert.equal(bare.status, "completed");
+        assert.equal(bare.durationMs, undefined);
+    });
+});
+describe("resolveCrushSessionIds", () => {
+    it("prefers the ids brane recorded over any heuristic", () => {
+        const fold = crushFold();
+        const crush = seedCrush(fold);
+        addSession(crush, "recorded-one", 1_000);
+        addSession(crush, "newer-other", 9_999);
+        assert.deepEqual(resolveCrushSessionIds(crush, { recorded: ["recorded-one"], narrativeCreatedAtMs: 1_000_000 }), ["recorded-one"]);
+    });
+    // The fallback compares against crush's clock, which counts seconds — the
+    // schema comment says milliseconds and the live rows do not. A narrative's
+    // created_at is milliseconds, so an unconverted comparison matches nothing,
+    // forever, and reads exactly like a session that made no tool calls.
+    it("compares against crush's seconds, not brane's milliseconds", () => {
+        const fold = crushFold();
+        const crush = seedCrush(fold);
+        const spawnedAtMs = 1_786_900_000_000;
+        addSession(crush, "before", Math.floor(spawnedAtMs / 1000) - 60);
+        addSession(crush, "after", Math.floor(spawnedAtMs / 1000) + 60);
+        assert.deepEqual(resolveCrushSessionIds(crush, { narrativeCreatedAtMs: spawnedAtMs }), ["after"]);
+    });
+    // The exclusion has to happen in the query. Asking for the newest row and
+    // then discarding it if it turns out to be bookkeeping reports "no session"
+    // while a perfectly good one sits directly underneath it — and the poller
+    // then captures nothing at all until the next real session is created.
+    it("skips past bookkeeping rows to the newest real session", () => {
+        const fold = crushFold();
+        const crush = seedCrush(fold);
+        addSession(crush, "real-session", 1_000);
+        // Both shapes are live in the operator's own crush database today. Give
+        // them null parents: sub-agent rows are parented in the logs seen so far,
+        // but nothing guarantees every kind of synthetic row is.
+        addSession(crush, "title-real-session", 2_000);
+        addSession(crush, "a0ffd9e8$$agentic_fetch_68", 3_000);
+        assert.deepEqual(resolveCrushSessionIds(crush, { narrativeCreatedAtMs: 0 }), ["real-session"]);
+        assert.deepEqual(resolveCrushSessionIds(crush, { recorded: ["title-x", "real-session"], narrativeCreatedAtMs: 0 }), ["real-session"]);
+    });
+});
+describe("pollCrushToolLog", () => {
+    it("records a running call, then settles it when the result lands", () => {
+        const fold = crushFold();
+        const crush = seedCrush(fold);
+        const db = createTestDb();
+        const nid = seedNarrative(db, fold, 1_000_000);
+        addSession(crush, "s1", 1_000);
+        addMessage(crush, "m1", "s1", TOOL_CALL_PART, 1_100);
+        const cursor = newCrushLogCursor();
+        const first = pollCrushToolLog(db, nid, { foldPath: fold, narrativeCreatedAtMs: 0 }, cursor);
+        assert.equal(first.length, 1);
+        assert.equal(first[0].status, "pending");
+        addMessage(crush, "m2", "s1", TOOL_RESULT_PART, 1_101);
+        const second = pollCrushToolLog(db, nid, { foldPath: fold, narrativeCreatedAtMs: 0 }, cursor);
+        assert.equal(second.length, 1);
+        assert.equal(second[0].status, "completed");
+        assert.equal(second[0].duration_ms, 1_001);
+        const rows = readToolUseWindow(db, nid);
+        assert.equal(rows.length, 1, "the call and its result are one row, not two");
+        assert.equal(rows[0].source, "session_log");
+    });
+    // Every write bumps rev, and rev is the client's sync cursor — so re-writing
+    // a settled row would re-push it to every connected client on every poll,
+    // forever.
+    it("writes nothing when nothing changed", () => {
+        const fold = crushFold();
+        const crush = seedCrush(fold);
+        const db = createTestDb();
+        const nid = seedNarrative(db, fold, 1_000_000);
+        addSession(crush, "s1", 1_000);
+        addMessage(crush, "m1", "s1", TOOL_CALL_PART, 1_100);
+        addMessage(crush, "m2", "s1", TOOL_RESULT_PART, 1_100);
+        const cursor = newCrushLogCursor();
+        assert.equal(pollCrushToolLog(db, nid, { foldPath: fold, narrativeCreatedAtMs: 0 }, cursor).length, 2, "the call and its completion are both new the first time");
+        for (let i = 0; i < 3; i++) {
+            assert.deepEqual(pollCrushToolLog(db, nid, { foldPath: fold, narrativeCreatedAtMs: 0 }, cursor), []);
+        }
+        assert.equal(readToolUseWindow(db, nid)[0].rev, 2, "rev stopped moving once the row settled");
+    });
+    // crush timestamps have one-second resolution, so a strict `>` cursor would
+    // skip anything written in the same second as the last message read.
+    it("does not skip a message written in the same second as the cursor", () => {
+        const fold = crushFold();
+        const crush = seedCrush(fold);
+        const db = createTestDb();
+        const nid = seedNarrative(db, fold, 1_000_000);
+        addSession(crush, "s1", 1_000);
+        addMessage(crush, "m1", "s1", TOOL_CALL_PART, 1_100);
+        const cursor = newCrushLogCursor();
+        pollCrushToolLog(db, nid, { foldPath: fold, narrativeCreatedAtMs: 0 }, cursor);
+        // Same second, different message — the very next tool call in a fast turn.
+        addMessage(crush, "m2", "s1", TOOL_CALL_PART.replace(/bash_88/g, "bash_89"), 1_100);
+        const next = pollCrushToolLog(db, nid, { foldPath: fold, narrativeCreatedAtMs: 0 }, cursor);
+        assert.equal(next.length, 1);
+        assert.equal(next[0].dedup_key, "bash_89");
+    });
+    it("captures a sub-agent's calls and nests them under the call that spawned it", () => {
+        const fold = crushFold();
+        const crush = seedCrush(fold);
+        const db = createTestDb();
+        const nid = seedNarrative(db, fold, 1_000_000);
+        addSession(crush, "s1", 1_000);
+        // crush encodes the spawning tool call in a sub-agent session's own id.
+        addSession(crush, "msg7$$agentic_fetch_68", 1_050, "s1");
+        addSession(crush, "title-s1", 1_060, "s1");
+        addMessage(crush, "m1", "msg7$$agentic_fetch_68", TOOL_CALL_PART, 1_100);
+        addMessage(crush, "m2", "title-s1", TOOL_CALL_PART.replace(/bash_88/g, "title_1"), 1_100);
+        const written = pollCrushToolLog(db, nid, { foldPath: fold, sessionIds: ["s1"], narrativeCreatedAtMs: 0 }, newCrushLogCursor());
+        assert.equal(written.length, 1, "the title-generation session is not a conversation");
+        assert.equal(written[0].parent_id, "agentic_fetch_68");
+    });
+    // This poller ticks every couple of seconds, so almost all of its work is
+    // avoiding work: an unchanged log is never opened at all.
+    it("does not open the log when nothing has changed", () => {
+        const fold = crushFold();
+        const crush = seedCrush(fold);
+        const db = createTestDb();
+        const nid = seedNarrative(db, fold, 1_000_000);
+        addSession(crush, "s1", 1_000);
+        addMessage(crush, "m1", "s1", TOOL_CALL_PART, 1_100);
+        const cursor = newCrushLogCursor();
+        pollCrushToolLog(db, nid, { foldPath: fold, narrativeCreatedAtMs: 0 }, cursor);
+        const signature = cursor.signature;
+        assert.ok(signature, "a log that was read leaves a signature to compare against");
+        // Break the log so that opening it would throw. A poll that still returns
+        // cleanly is a poll that never opened it.
+        const table = new Database(crushDbPath(fold));
+        table.exec("ALTER TABLE messages RENAME TO messages_moved");
+        table.close();
+        // Restore the signature: the rename changed the file, and the point of the
+        // test is the unchanged case.
+        cursor.signature = crushLogSignature(fold);
+        assert.deepEqual(pollCrushToolLog(db, nid, { foldPath: fold, narrativeCreatedAtMs: 0 }, cursor), []);
+    });
+    it("notices a write that lands only in the WAL sibling", () => {
+        const fold = crushFold();
+        const crush = seedCrush(fold);
+        crush.pragma("journal_mode = WAL");
+        const db = createTestDb();
+        const nid = seedNarrative(db, fold, 1_000_000);
+        addSession(crush, "s1", 1_000);
+        const cursor = newCrushLogCursor();
+        pollCrushToolLog(db, nid, { foldPath: fold, narrativeCreatedAtMs: 0 }, cursor);
+        // In WAL mode this write lands in <db>-wal and may not move the main
+        // file's mtime at all — a gate that stats only the database would go blind
+        // during exactly the burst of activity it exists to catch.
+        addMessage(crush, "m1", "s1", TOOL_CALL_PART, 1_100);
+        const written = pollCrushToolLog(db, nid, { foldPath: fold, narrativeCreatedAtMs: 0 }, cursor);
+        assert.equal(written.length, 1);
+        assert.equal(written[0].status, "pending");
+    });
+    it("degrades to silence when there is no crush log, or it is unreadable", () => {
+        const db = createTestDb();
+        const bare = mkdtempSync(join(tmpdir(), "brane-crush-"));
+        const nid = seedNarrative(db, bare, 1_000_000);
+        assert.deepEqual(pollCrushToolLog(db, nid, { foldPath: bare, narrativeCreatedAtMs: 0 }, newCrushLogCursor()), []);
+        // A file that exists but is not a crush database at all.
+        const fold = crushFold();
+        new Database(crushDbPath(fold)).exec("CREATE TABLE unrelated (x TEXT)");
+        assert.deepEqual(pollCrushToolLog(db, nid, { foldPath: fold, narrativeCreatedAtMs: 0 }, newCrushLogCursor()), []);
+    });
+});
+//# sourceMappingURL=crush-tool-log.test.js.map