brane 0.0.2 → 0.3.0

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

@@ -0,0 +1,93 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { appendFileSync, mkdirSync, mkdtempSync, writeFileSync } 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 { newCopilotLogCursor, pollCopilotToolLog, toolUseFromCopilotEvent, } from "../copilot-tool-log.js";
+const sessionId = "copilot-test-session";
+function event(type, data, timestamp = "2026-08-16T15:00:00.000Z") {
+    return { type, timestamp, data };
+}
+describe("Copilot tool session log", () => {
+    it("maps start and completion events through their shared call id", () => {
+        const start = toolUseFromCopilotEvent(event("tool.execution_start", {
+            toolCallId: "call-1", toolName: "bash", arguments: { command: "true" },
+        }));
+        const complete = toolUseFromCopilotEvent(event("tool.execution_complete", {
+            toolCallId: "call-1", success: false, error: { message: "nope" },
+        }));
+        assert.equal(start.status, "pending");
+        assert.equal(complete.status, "failed");
+        assert.equal(complete.dedupKey, start.dedupKey);
+    });
+    it("records appended starts and completions once, retaining an incomplete trailing line", () => {
+        const stateRoot = mkdtempSync(join(tmpdir(), "brane-copilot-log-"));
+        const sessionDir = join(stateRoot, sessionId);
+        const eventPath = join(sessionDir, "events.jsonl");
+        mkdirSync(sessionDir, { recursive: true });
+        writeFileSync(eventPath, JSON.stringify(event("tool.execution_start", {
+            toolCallId: "call-2", toolName: "bash", arguments: { command: "echo 🦊" },
+        })) + "\n");
+        const db = createTestDb();
+        const cursor = newCopilotLogCursor();
+        assert.equal(pollCopilotToolLog(db, "copilot-test", sessionId, cursor, stateRoot).length, 1);
+        appendFileSync(eventPath, JSON.stringify(event("tool.execution_complete", {
+            toolCallId: "call-2", success: true, result: { output: "done" },
+        }, "2026-08-16T15:00:01.000Z")) + "\n" + '{"type":"tool.execution_start"');
+        assert.equal(pollCopilotToolLog(db, "copilot-test", sessionId, cursor, stateRoot).length, 1);
+        const rows = readToolUseWindow(db, "copilot-test");
+        assert.equal(rows.length, 1);
+        assert.equal(rows[0].status, "completed");
+        assert.equal(rows[0].name, "bash");
+        assert.equal(rows[0].duration_ms, 1000);
+        assert.equal(pollCopilotToolLog(db, "copilot-test", sessionId, cursor, stateRoot).length, 0);
+    });
+    it("compacts Brane loop calls and removes a duplicate detailed result", () => {
+        const stateRoot = mkdtempSync(join(tmpdir(), "brane-copilot-log-"));
+        const sessionDir = join(stateRoot, sessionId);
+        const eventPath = join(sessionDir, "events.jsonl");
+        mkdirSync(sessionDir, { recursive: true });
+        writeFileSync(eventPath, [
+            event("tool.execution_start", {
+                toolCallId: "bridge-1", toolName: "brane-narrate", arguments: {},
+                mcpServerName: "brane", mcpToolName: "narrate",
+            }),
+            event("tool.execution_complete", {
+                toolCallId: "bridge-1", success: true,
+                result: { content: JSON.stringify({ seq: 42 }), detailedContent: JSON.stringify({ seq: 42 }) },
+            }),
+            event("tool.execution_start", {
+                toolCallId: "bridge-2", toolName: "brane-narrate", arguments: { nid: "claude-target", say: "status" },
+                mcpServerName: "brane", mcpToolName: "narrate",
+            }),
+            event("tool.execution_complete", {
+                toolCallId: "bridge-2", success: true,
+                result: {
+                    content: JSON.stringify({ nid: "claude-target", seq: 12 }),
+                    detailedContent: JSON.stringify({ nid: "claude-target", seq: 12 }),
+                },
+            }),
+            event("tool.execution_start", {
+                toolCallId: "call-3", toolName: "bash", arguments: { command: "true" },
+            }),
+            event("tool.execution_complete", {
+                toolCallId: "call-3", success: true, result: { content: "done", detailedContent: "done" },
+            }),
+        ].map((entry) => JSON.stringify(entry)).join("\n") + "\n");
+        const db = createTestDb();
+        assert.equal(pollCopilotToolLog(db, "copilot-test", sessionId, newCopilotLogCursor(), stateRoot).length, 6);
+        const rows = readToolUseWindow(db, "copilot-test");
+        assert.equal(rows.length, 3);
+        assert.equal(rows[0].name, "mcp__brane__narrate");
+        assert.equal(rows[0].input, "{}");
+        assert.equal(rows[0].output, "{}");
+        assert.equal(rows[1].name, "mcp__brane__narrate");
+        assert.deepEqual(JSON.parse(rows[1].input), { nid: "claude-target" });
+        assert.deepEqual(JSON.parse(rows[1].output), { nid: "claude-target", seq: 12 });
+        assert.equal(rows[2].name, "bash");
+        assert.deepEqual(JSON.parse(rows[2].output), { content: "done" });
+    });
+});
+//# sourceMappingURL=copilot-tool-log.test.js.map

package/dist/test/cors-preflight.test.js

@@ -0,0 +1,49 @@
+import { test, describe } from "node:test";
+import assert from "node:assert/strict";
+import { setCorsHeaders } from "../daemon/server.js";
+/** Just enough of a request/response pair to read headers back off. */
+function exchange(origin) {
+    const headers = new Map();
+    const req = { headers: origin ? { origin } : {} };
+    const res = {
+        setHeader(name, value) {
+            headers.set(name.toLowerCase(), value);
+        },
+    };
+    return { req, res, headers };
+}
+const APP_DOMAIN = "brane.organelle.dev";
+describe("CORS preflight caching", () => {
+    test("an allowed origin is told how long it may reuse the answer", () => {
+        // Without this header Chrome caches a preflight for 5 seconds, which on a
+        // fast link is indistinguishable from caching forever and on a slow one is
+        // indistinguishable from not caching at all — every request pays its own
+        // extra round trip. At 741ms RTT that was fatal rather than merely slow.
+        const { req, res, headers } = exchange(`https://${APP_DOMAIN}`);
+        setCorsHeaders(req, res, APP_DOMAIN, 8080);
+        const maxAge = headers.get("access-control-max-age");
+        assert.ok(maxAge, "preflight answers must be cacheable");
+        assert.ok(Number(maxAge) >= 3600, `max-age ${maxAge} is too short to spare a slow link repeated preflights`);
+    });
+    test("the rest of the CORS contract is unchanged", () => {
+        const { req, res, headers } = exchange(`https://${APP_DOMAIN}`);
+        setCorsHeaders(req, res, APP_DOMAIN, 8080);
+        assert.equal(headers.get("access-control-allow-origin"), `https://${APP_DOMAIN}`);
+        assert.match(headers.get("access-control-allow-methods") ?? "", /GET/);
+        assert.match(headers.get("access-control-allow-headers") ?? "", /Authorization/);
+        assert.equal(headers.get("access-control-allow-credentials"), "true");
+    });
+    test("a disallowed origin is told nothing at all", () => {
+        // Caching must not become a way to hand headers to an origin that would
+        // otherwise have been refused.
+        const { req, res, headers } = exchange("https://evil.example.com");
+        setCorsHeaders(req, res, APP_DOMAIN, 8080);
+        assert.equal(headers.size, 0);
+    });
+    test("a request with no Origin gets no CORS headers", () => {
+        const { req, res, headers } = exchange();
+        setCorsHeaders(req, res, APP_DOMAIN, 8080);
+        assert.equal(headers.size, 0);
+    });
+});
+//# sourceMappingURL=cors-preflight.test.js.map

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

@@ -0,0 +1,31 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { costSampleTargets, lingerCostSampling } from "../daemon/server.js";
+// The sampler's target set: connected narratives plus the recently
+// disconnected, so a session's final turns — written after its MCP bridge
+// tears down — still reach the ledger without a manual backfill.
+describe("costSampleTargets", () => {
+    it("samples a disconnected narrative until its linger expires", () => {
+        const linger = new Map([["claude-gone", 1_090_000]]);
+        // Within the window: sampled alongside the connected.
+        assert.deepEqual(costSampleTargets(new Set(["claude-live"]), linger, 1_000_000), new Set(["claude-live", "claude-gone"]));
+        assert.ok(linger.has("claude-gone"), "not evicted while the window is open");
+        // At the deadline: evicted, and no longer sampled.
+        assert.deepEqual(costSampleTargets(new Set(["claude-live"]), linger, 1_090_000), new Set(["claude-live"]));
+        assert.equal(linger.size, 0);
+    });
+    it("evicts a lingering narrative that reconnects, so a later disconnect starts a fresh window", () => {
+        const linger = new Map([["claude-back", 1_090_000]]);
+        const targets = costSampleTargets(new Set(["claude-back"]), linger, 1_000_000);
+        assert.deepEqual(targets, new Set(["claude-back"]), "sampled once, as connected");
+        assert.equal(linger.size, 0, "the stale deadline does not survive the reconnect");
+    });
+    it("lingerCostSampling feeds the sampler's own map, which linger defaults to", () => {
+        lingerCostSampling("claude-observed", 5_000);
+        assert.ok(costSampleTargets(new Set(), undefined, 10_000).has("claude-observed"));
+        // 5_000 + the 90 s window has passed: expired and evicted, so this test
+        // leaves no residue in the shared map.
+        assert.ok(!costSampleTargets(new Set(), undefined, 200_000).has("claude-observed"));
+    });
+});
+//# sourceMappingURL=cost-linger.test.js.map

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

@@ -0,0 +1,72 @@
+import { describe, it } from "node:test";
+import { mkdirSync, mkdtempSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import assert from "node:assert/strict";
+// The price table memoizes ~/.brane/pricing.json on first use, so HOME is
+// sandboxed — with an override file in it — before anything prices a message.
+// node --test runs each file in its own process, so this one owns the memo.
+const home = mkdtempSync(join(tmpdir(), "brane-pricing-home-"));
+process.env.HOME = home;
+mkdirSync(join(home, ".brane"));
+writeFileSync(join(home, ".brane", "pricing.json"), JSON.stringify({
+    // More specific than the built-in `opus` — and than `opus-5-5`, which
+    // would win if overrides were still appended after the defaults.
+    "opus-5-5-fast-test": { input: 1, output: 2 },
+    "kimi-latest": { input: 3, output: 15, cacheRead: 0.25 },
+}));
+const { priceMessage } = await import("../cost/pricing.js");
+const M = 1e6;
+const only = (k) => ({
+    input: 0,
+    output: 0,
+    cacheRead: 0,
+    cacheWrite5m: 0,
+    cacheWrite1h: 0,
+    [k]: M,
+});
+// $ for 1 MTok in each category: input, output, cache read, 5m write, 1h write.
+const rates = (model) => ["input", "output", "cacheRead", "cacheWrite5m", "cacheWrite1h"].map((k) => Math.round(priceMessage(model, only(k)) * 1e6) / 1e6);
+describe("price table (checked against the published rates, 2026-09-23)", () => {
+    it("prices Fable 5.1 and Mythos 5.1 cache reads at $0.25, not 0.1× input", () => {
+        assert.deepEqual(rates("claude-fable-5-1"), [10, 50, 0.25, 12.5, 20]);
+        assert.deepEqual(rates("claude-mythos-5-1"), [10, 50, 0.25, 12.5, 20]);
+    });
+    it("keeps Fable 5 and Mythos 5 at the standard 0.1× cache read", () => {
+        assert.deepEqual(rates("claude-fable-5"), [10, 50, 1, 12.5, 20]);
+        assert.deepEqual(rates("claude-mythos-5"), [10, 50, 1, 12.5, 20]);
+    });
+    it("prices Opus 5.5 at $4/$20 with $0.20 cache reads, apart from the rest of the Opus line", () => {
+        assert.deepEqual(rates("claude-opus-5-5"), [4, 20, 0.2, 5, 8]);
+        for (const m of ["claude-opus-5", "claude-opus-4-8", "claude-opus-4-7", "claude-opus-4-6"]) {
+            assert.deepEqual(rates(m), [5, 25, 0.5, 6.25, 10], m);
+        }
+    });
+    it("prices Sonnet 5 at $2/$10, apart from Sonnet 4.x", () => {
+        assert.deepEqual(rates("claude-sonnet-5"), [2, 10, 0.2, 2.5, 4]);
+        assert.deepEqual(rates("claude-sonnet-4-6"), [3, 15, 0.3, 3.75, 6]);
+    });
+    it("leaves Haiku 4.5 and Kimi K3 where they were", () => {
+        assert.deepEqual(rates("claude-haiku-4-5-20251001"), [1, 5, 0.1, 1.25, 2]);
+        assert.deepEqual(rates("accounts/fireworks/models/kimi-k3"), [3, 15, 0.3, 3.75, 6]);
+        assert.deepEqual(rates("accounts/fireworks/routers/kimi-k3-fast"), [4.5, 22.5, 0.45, 5.625, 9]);
+    });
+    it("doubles every category in fast mode, cache multipliers on top", () => {
+        const u = { input: M, output: M, cacheRead: M, cacheWrite5m: M, cacheWrite1h: M };
+        const standard = priceMessage("claude-opus-5-5", u);
+        assert.equal(priceMessage("claude-opus-5-5", { ...u, speed: "standard" }), standard);
+        assert.equal(priceMessage("claude-opus-5-5", { ...u, speed: "fast" }), 2 * standard);
+        // $8 / $40 per MTok, as published for Opus 5.5 fast mode.
+        assert.equal(priceMessage("claude-opus-5-5", { ...only("input"), speed: "fast" }), 8);
+        assert.equal(priceMessage("claude-opus-5-5", { ...only("output"), speed: "fast" }), 40);
+    });
+});
+describe("pricing.json overrides", () => {
+    it("match before the built-in keys, however general those are", () => {
+        assert.deepEqual(rates("claude-opus-5-5-fast-test").slice(0, 2), [1, 2]);
+    });
+    it("can price a model the defaults don't know, including its cache-read rate", () => {
+        assert.deepEqual(rates("kimi-latest"), [3, 15, 0.25, 3.75, 6]);
+    });
+});
+//# sourceMappingURL=cost-pricing.test.js.map

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

@@ -0,0 +1,139 @@
+import { describe, it } from "node:test";
+import { mkdtempSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import assert from "node:assert/strict";
+// No pricing.json may leak in from the real HOME: the current table must be
+// exactly the built-in one for the amounts below to hold.
+process.env.HOME = mkdtempSync(join(tmpdir(), "brane-reprice-home-"));
+const { createTestDb } = await import("./helpers.js");
+const { priceMessage, priceMessageV1 } = await import("../cost/pricing.js");
+const { recoverCacheWrite1h, repriceLedger } = await import("../cost/reprice.js");
+const { recordUsageEntries } = await import("../daemon/server.js");
+/** A row as the pre-split code wrote it: V1 amount, one cache_write count. */
+function insertV1(db, r) {
+    const amount = priceMessageV1(r.model, {
+        input: r.input,
+        output: r.output,
+        cacheRead: r.cacheRead,
+        cacheWrite5m: r.w5,
+        cacheWrite1h: r.w1,
+    });
+    db.prepare(`INSERT INTO usage_ledger (key, narrative_id, session_id, agent_type, unit, amount, model,
+       input, output, cache_read, cache_write, first_seen)
+     VALUES (?, ?, 's', 'claude', 'USD', ?, ?, ?, ?, ?, ?, 0)`).run(r.key, r.nid, amount, r.model, r.input, r.output, r.cacheRead, r.w5 + r.w1);
+    return amount;
+}
+const current = (r) => priceMessage(r.model, { input: r.input, output: r.output, cacheRead: r.cacheRead, cacheWrite5m: r.w5, cacheWrite1h: r.w1 });
+function narrative(db, nid, cost) {
+    db.prepare(`INSERT INTO narratives (id, brane_id, agent_type, role, created_at, status, cost_amount, cost_unit)
+     VALUES (?, 'brane-test', 'claude', 'worker', 0, 'ended', ?, ?)`).run(nid, cost, cost === null ? null : "USD");
+}
+const col = (db, nid) => db.prepare("SELECT cost_amount FROM narratives WHERE id = ?").get(nid).cost_amount;
+const ledger = (db, key) => db.prepare("SELECT amount, cache_write_1h FROM usage_ledger WHERE key = ?").get(key);
+// Token shapes taken from real rows: a long session's cache-read-heavy turn,
+// with mixed 5m / 1h writes so the split actually matters.
+const FABLE51 = { key: "claude:f1", nid: "claude-f", model: "claude-fable-5-1", input: 6, output: 843, cacheRead: 203752, w5: 1200, w1: 16270 };
+const OPUS55 = { key: "claude:o1", nid: "claude-o", model: "claude-opus-5-5", input: 2, output: 650, cacheRead: 227000, w5: 0, w1: 7000 };
+const SONNET5 = { key: "claude:s1", nid: "claude-s", model: "claude-sonnet-5", input: 2, output: 332, cacheRead: 0, w5: 0, w1: 102607 };
+const OPUS5 = { key: "claude:u1", nid: "claude-u", model: "claude-opus-5", input: 10, output: 900, cacheRead: 150000, w5: 300, w1: 4000 };
+describe("recoverCacheWrite1h", () => {
+    it("recovers the exact split from a V1 amount", () => {
+        for (const r of [FABLE51, OPUS55, SONNET5, OPUS5]) {
+            const amount = priceMessageV1(r.model, { input: r.input, output: r.output, cacheRead: r.cacheRead, cacheWrite5m: r.w5, cacheWrite1h: r.w1 });
+            const row = { model: r.model, amount, input: r.input, output: r.output, cache_read: r.cacheRead, cache_write: r.w5 + r.w1 };
+            assert.equal(recoverCacheWrite1h(row), r.w1, r.model);
+        }
+    });
+    it("refuses an amount no split explains (e.g. priced under an override)", () => {
+        const row = { model: "claude-opus-5", amount: 123.456, input: 1, output: 1, cache_read: 0, cache_write: 10 };
+        assert.equal(recoverCacheWrite1h(row), null);
+    });
+});
+describe("repriceLedger", () => {
+    it("corrects mispriced rows, leaves correct ones, and records the recovered split", () => {
+        const db = createTestDb();
+        for (const r of [FABLE51, OPUS55, SONNET5, OPUS5]) {
+            narrative(db, r.nid, null);
+            insertV1(db, r);
+        }
+        const result = repriceLedger(db);
+        assert.equal(result.scanned, 4);
+        assert.equal(result.recovered, 4);
+        assert.equal(result.unrecoverable, 0);
+        assert.equal(result.changed, 3);
+        for (const r of [FABLE51, OPUS55, SONNET5, OPUS5]) {
+            const row = ledger(db, r.key);
+            assert.ok(Math.abs(row.amount - current(r)) < 1e-12, r.model);
+            assert.equal(row.cache_write_1h, r.w1, r.model);
+        }
+        // A second pass reads the recorded split and finds nothing to do.
+        const again = repriceLedger(db);
+        assert.equal(again.recovered, 0);
+        assert.equal(again.changed, 0);
+    });
+    it("writes nothing on a dry run, and reports what the real run then does", () => {
+        const db = createTestDb();
+        narrative(db, FABLE51.nid, 5);
+        const before = insertV1(db, FABLE51);
+        const dry = repriceLedger(db, { dryRun: true });
+        assert.equal(ledger(db, FABLE51.key).amount, before);
+        assert.equal(ledger(db, FABLE51.key).cache_write_1h, null);
+        assert.equal(col(db, FABLE51.nid), 5);
+        const real = repriceLedger(db);
+        assert.deepEqual({ ...dry, dry_run: false }, real);
+    });
+    it("moves the card total by the correction, keeping pre-ledger cost above the ledger sum", () => {
+        const db = createTestDb();
+        // The column holds $40 more than the ledger — cost from transcripts
+        // that predate the ledger. The correction applies; that $40 survives.
+        const amount = insertV1(db, FABLE51);
+        narrative(db, FABLE51.nid, amount + 40);
+        const result = repriceLedger(db);
+        const delta = current(FABLE51) - amount;
+        assert.ok(delta < 0);
+        assert.ok(Math.abs(col(db, FABLE51.nid) - (amount + 40 + delta)) < 1e-6);
+        assert.equal(result.narratives[0].nid, FABLE51.nid);
+    });
+    it("brings a column equal to the ledger sum down to the new sum", () => {
+        const db = createTestDb();
+        const amount = insertV1(db, OPUS55);
+        narrative(db, OPUS55.nid, amount);
+        repriceLedger(db);
+        assert.ok(Math.abs(col(db, OPUS55.nid) - current(OPUS55)) < 1e-6);
+    });
+    it("leaves session high-water rows and model-less rows alone", () => {
+        const db = createTestDb();
+        db.prepare(`INSERT INTO usage_ledger (key, narrative_id, unit, amount, first_seen)
+       VALUES ('session:goose:x', 'goose-a', 'USD', 22.09, 0)`).run();
+        const result = repriceLedger(db);
+        assert.equal(result.scanned, 0);
+        assert.equal(ledger(db, "session:goose:x").amount, 22.09);
+    });
+    it("new rows carry the split and speed, so they reprice without inference", () => {
+        const db = createTestDb();
+        const u = { input: 1, output: 100, cacheRead: 1000, cacheWrite5m: 50, cacheWrite1h: 70, speed: "fast" };
+        recordUsageEntries(db, "claude-n", "claude", [
+            {
+                sessionId: "s",
+                sig: "1",
+                unit: "USD",
+                entries: [
+                    {
+                        key: "claude:n1",
+                        amount: priceMessage("claude-opus-5-5", u),
+                        model: "claude-opus-5-5",
+                        tokens: { input: 1, output: 100, cacheRead: 1000, cacheWrite: 120, cacheWrite1h: 70 },
+                        speed: "fast",
+                    },
+                ],
+            },
+        ]);
+        const row = db.prepare("SELECT cache_write_1h, speed FROM usage_ledger WHERE key = 'claude:n1'").get();
+        assert.deepEqual({ ...row }, { cache_write_1h: 70, speed: "fast" });
+        const result = repriceLedger(db);
+        assert.equal(result.recovered, 0);
+        assert.equal(result.changed, 0);
+    });
+});
+//# sourceMappingURL=cost-reprice.test.js.map