brane 0.1.1 → 0.3.0

package/dist/commands/token.js

@@ -0,0 +1,153 @@
+import { defineCommand } from "citty";
+import { resolveDaemonEndpoint, daemonRequest, warnIfVersionMismatch, } from "../daemon/client.js";
+import { announcePresenceWait } from "./meld.js";
+/** Sign out every device. One request: this shell holds no token, so there
+ *  is none to swap and nothing to confirm — once the operator passes the
+ *  presence prompt the daemon revokes every device token before it answers
+ *  (`signOutDevices`, src/daemon/token-ring.ts). A device's rotation is the
+ *  two-step one (docs/token-rotation.md); an answer in that shape means the
+ *  daemon is older than this CLI, and is reported rather than taken for a
+ *  sign-out that did not happen. */
+export async function rotateDaemonToken(endpoint) {
+    announcePresenceWait();
+    const rotation = await daemonRequest(endpoint, "/api/token/rotate", {
+        method: "POST",
+    });
+    if (typeof rotation.signed_out !== "number") {
+        throw new Error("The daemon answered as an older brane does, and nobody was signed out; run `brane daemon restart` and try again");
+    }
+    return { signed_out: rotation.signed_out, replaced: rotation.replaced === true };
+}
+export function formatRotateResult(rotation) {
+    const n = rotation.signed_out;
+    return [
+        `Signed out ${n === 0 ? "no devices (none were signed in)" : n === 1 ? "1 device" : `${n} devices`}` +
+            `${rotation.replaced ? " (a rotation a device began and never confirmed was pending; it is now void)" : ""}.`,
+        "This shell and running agents are unaffected.",
+        "Re-admit a device with `brane meld`.",
+    ].join("\n");
+}
+const rotateCommand = defineCommand({
+    meta: {
+        name: "rotate",
+        description: "Sign out every web client (device); this shell and running agents are unaffected",
+    },
+    async run() {
+        try {
+            const endpoint = await resolveDaemonEndpoint();
+            warnIfVersionMismatch(endpoint);
+            console.log(formatRotateResult(await rotateDaemonToken(endpoint)));
+        }
+        catch (err) {
+            console.error(err instanceof Error ? err.message : String(err));
+            process.exit(1);
+        }
+    },
+});
+function formatTime(ms) {
+    return new Date(ms).toISOString().slice(0, 16).replace("T", " ") + "Z";
+}
+/** The Devices list as text: one block per token, the id first so it can be
+ *  pasted into `brane token revoke`. */
+export function formatTokenList(tokens) {
+    if (tokens.length === 0)
+        return "No live tokens.";
+    return tokens
+        .map((t) => {
+        const name = t.kind === "local" ? "this machine (CLI)" : t.kind === "agent" ? `agent ${t.owner_nid ?? t.label}` : t.device ?? "unknown device";
+        const marks = [
+            t.current ? "this request" : null,
+            t.origin === "adopted" ? "adopted from before hashing" : null,
+            t.unused && t.expires_at !== null ? `unscanned, lapses ${formatTime(t.expires_at)}` : null,
+        ].filter(Boolean);
+        const seen = t.connected
+            ? "connected now"
+            : t.last_used_at !== null
+                ? `last seen ${formatTime(t.last_used_at)}`
+                : "never used";
+        const lines = [
+            `${t.id}  ${name}${marks.length ? ` [${marks.join("; ")}]` : ""}`,
+            `    "${t.label}", created ${formatTime(t.created_at)}${t.minted_by_device ? ` by ${t.minted_by_device}` : ""}, ${seen}${t.remote_addr ? `, from ${t.remote_addr}` : ""}`,
+        ];
+        if (t.descendants?.length)
+            lines.push(`    added ${t.descendants.length} device(s): ${t.descendants.join(", ")} (revoke --cascade takes them too)`);
+        const running = (t.agents ?? []).filter((a) => a.status !== "ended");
+        if (running.length)
+            lines.push(`    started ${running.length} running agent(s): ${running.map((a) => a.id).join(", ")}`);
+        if (t.elsewhere_at != null) {
+            const where = [t.last_device, t.last_remote_addr].filter(Boolean).join(" at ");
+            lines.push(`    ! also used from another address${where ? ` (latest: ${where})` : ""}, ${formatTime(t.elsewhere_at)}`);
+        }
+        return lines.join("\n");
+    })
+        .join("\n");
+}
+const listCommand = defineCommand({
+    meta: {
+        name: "list",
+        description: "List the daemon's live tokens: this machine's, and one per melded device",
+    },
+    async run() {
+        try {
+            const endpoint = await resolveDaemonEndpoint();
+            warnIfVersionMismatch(endpoint);
+            const { tokens } = await daemonRequest(endpoint, "/api/tokens");
+            console.log(formatTokenList(tokens));
+        }
+        catch (err) {
+            console.error(err instanceof Error ? err.message : String(err));
+            process.exit(1);
+        }
+    },
+});
+const revokeCommand = defineCommand({
+    meta: {
+        name: "revoke",
+        description: "Sign out one melded device (ids from `brane token list`)",
+    },
+    args: {
+        id: { type: "positional", description: "Token id", required: true },
+        cascade: {
+            type: "boolean",
+            description: "Also revoke every device it added (see `brane token list`)",
+            default: false,
+        },
+    },
+    async run({ args }) {
+        try {
+            const endpoint = await resolveDaemonEndpoint();
+            warnIfVersionMismatch(endpoint);
+            const id = String(args.id);
+            // Read first: what it is (an agent's revoke reads differently) and,
+            // with --cascade, what it added. Revoked rows aren't listed afterwards.
+            const { tokens } = await daemonRequest(endpoint, "/api/tokens");
+            const target = tokens.find((t) => t.id === id);
+            const also = args.cascade ? target?.descendants ?? [] : [];
+            const query = also.length ? `?also=${also.map(encodeURIComponent).join(",")}` : "";
+            // Signing out a device waits for the operator; stopping an agent doesn't.
+            if (target?.kind === "device" || also.length)
+                announcePresenceWait();
+            const { label } = await daemonRequest(endpoint, `/api/tokens/${encodeURIComponent(id)}/revoke${query}`, { method: "POST" });
+            console.log(`Revoked "${label}"${also.length ? ` and ${also.length} token(s) it added` : ""}. ` +
+                (target?.kind === "agent"
+                    ? "That agent's brane tools stop; end its session and revive it to bring it back."
+                    : "That device is signed out until it scans a fresh Meld QR."));
+        }
+        catch (err) {
+            console.error(err instanceof Error ? err.message : String(err));
+            process.exit(1);
+        }
+    },
+});
+export const tokenCommand = defineCommand({
+    meta: {
+        name: "token",
+        description: "Manage the daemon's bearer tokens",
+    },
+    subCommands: {
+        list: listCommand,
+        revoke: revokeCommand,
+        rotate: rotateCommand,
+    },
+});
+//# sourceMappingURL=token.js.map

package/dist/copilot-tool-log.js

@@ -0,0 +1,145 @@
+import { closeSync, openSync, readSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { recordToolUse } from "./db/tool-uses.js";
+export function copilotEventsPath(sessionId, stateRoot) {
+    return join(stateRoot ?? join(process.env.HOME ?? "/tmp", ".copilot", "session-state"), sessionId, "events.jsonl");
+}
+export function newCopilotLogCursor() {
+    return { offset: 0, signature: null, startedAt: new Map(), names: new Map(), inputs: new Map() };
+}
+function copilotToolName(data) {
+    if (typeof data.toolName !== "string")
+        return undefined;
+    if (data.mcpServerName === "brane" &&
+        (data.mcpToolName === "narrate" || data.mcpToolName === "listen")) {
+        return `mcp__brane__${data.mcpToolName}`;
+    }
+    return data.toolName;
+}
+function copilotResult(result) {
+    if (typeof result !== "object" || result === null || Array.isArray(result))
+        return result;
+    const record = result;
+    if (record.content !== undefined && record.content === record.detailedContent) {
+        const { detailedContent: _detailedContent, ...withoutDuplicate } = record;
+        if (typeof withoutDuplicate.content !== "string")
+            return withoutDuplicate;
+        try {
+            return JSON.parse(withoutDuplicate.content);
+        }
+        catch {
+            return withoutDuplicate;
+        }
+    }
+    return result;
+}
+/** Translate Copilot's persisted tool start/complete events into the common
+ * row shape. Its call id is stable across both halves, so no heuristic pairing
+ * is needed. */
+export function toolUseFromCopilotEvent(event) {
+    if (typeof event !== "object" || event === null)
+        return undefined;
+    const e = event;
+    if (typeof e.data !== "object" || e.data === null)
+        return undefined;
+    const data = e.data;
+    const id = data.toolCallId;
+    if (typeof id !== "string")
+        return undefined;
+    const startedAt = typeof e.timestamp === "string" ? Date.parse(e.timestamp) : NaN;
+    const parentId = typeof data.parentToolCallId === "string" ? data.parentToolCallId : undefined;
+    if (e.type === "tool.execution_start" && typeof data.toolName === "string") {
+        const name = copilotToolName(data);
+        if (!name)
+            return undefined;
+        return {
+            dedupKey: id, name, input: data.arguments, status: "pending",
+            source: "session_log", agentType: "copilot", parentId,
+            ...(Number.isFinite(startedAt) ? { startedAt } : {}),
+        };
+    }
+    if (e.type === "tool.execution_complete" && typeof data.success === "boolean") {
+        return {
+            dedupKey: id, name: "unknown", output: data.success ? copilotResult(data.result) : undefined,
+            status: data.success ? "completed" : "failed",
+            error: data.success ? undefined : typeof data.error === "string" ? data.error : data.error === undefined ? undefined : JSON.stringify(data.error),
+            source: "session_log", agentType: "copilot", parentId,
+            ...(Number.isFinite(startedAt) ? { startedAt } : {}),
+        };
+    }
+    return undefined;
+}
+/** Read only appended JSONL bytes. Newlines are single-byte UTF-8 delimiters,
+ * so a byte cursor never splits a multi-byte payload character. An incomplete
+ * final line remains unconsumed until Copilot finishes writing it later. */
+export function pollCopilotToolLog(db, narrativeId, sessionId, cursor, stateRoot) {
+    const path = copilotEventsPath(sessionId, stateRoot);
+    let signature;
+    try {
+        const stat = statSync(path);
+        signature = `${stat.size}:${stat.mtimeMs}`;
+        if (signature === cursor.signature)
+            return [];
+        if (stat.size < cursor.offset) {
+            cursor.offset = 0;
+            cursor.startedAt.clear();
+            cursor.names.clear();
+            cursor.inputs.clear();
+        }
+        const bytes = stat.size - cursor.offset;
+        if (bytes === 0) {
+            cursor.signature = signature;
+            return [];
+        }
+        const fd = openSync(path, "r");
+        const pending = Buffer.allocUnsafe(bytes);
+        let bytesRead;
+        try {
+            bytesRead = readSync(fd, pending, 0, bytes, cursor.offset);
+        }
+        finally {
+            closeSync(fd);
+        }
+        const content = pending.subarray(0, bytesRead);
+        const completeEnd = content.lastIndexOf(0x0a);
+        if (completeEnd < 0)
+            return [];
+        cursor.offset += completeEnd + 1;
+        cursor.signature = signature;
+        const written = [];
+        for (const line of content.subarray(0, completeEnd).toString("utf8").split("\n")) {
+            try {
+                const event = JSON.parse(line);
+                const toolUse = toolUseFromCopilotEvent(event);
+                if (!toolUse || !toolUse.dedupKey)
+                    continue;
+                if (toolUse.status === "pending" && toolUse.startedAt !== undefined) {
+                    cursor.startedAt.set(toolUse.dedupKey, toolUse.startedAt);
+                    cursor.names.set(toolUse.dedupKey, toolUse.name);
+                    cursor.inputs.set(toolUse.dedupKey, toolUse.input);
+                }
+                else if (toolUse.status !== "pending") {
+                    toolUse.name = cursor.names.get(toolUse.dedupKey) ?? toolUse.name;
+                    toolUse.input = cursor.inputs.get(toolUse.dedupKey);
+                    const startedAt = cursor.startedAt.get(toolUse.dedupKey);
+                    if (startedAt !== undefined && toolUse.startedAt !== undefined && toolUse.startedAt >= startedAt) {
+                        toolUse.durationMs = toolUse.startedAt - startedAt;
+                    }
+                    cursor.startedAt.delete(toolUse.dedupKey);
+                    cursor.names.delete(toolUse.dedupKey);
+                    cursor.inputs.delete(toolUse.dedupKey);
+                }
+                written.push(recordToolUse(db, narrativeId, toolUse));
+            }
+            catch {
+                // A malformed record cannot prevent later well-formed entries.
+            }
+        }
+        return written;
+    }
+    catch (err) {
+        console.error(`[copilot-log] reading ${path} for ${narrativeId} failed: ${err}`);
+        return [];
+    }
+}
+//# sourceMappingURL=copilot-tool-log.js.map

package/dist/cost/pricing.js

@@ -0,0 +1,116 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+// Fast mode (Opus 5.5, Opus 5, Opus 4.8) bills every token category at 2× the
+// model's standard rate, with the cache multipliers applied on top — $8/$40 on
+// Opus 5.5, $10/$50 on Opus 5 and 4.8. One multiplier rather than a second
+// table, because that is how the rates are defined.
+const FAST_MULTIPLIER = 2;
+// Insertion order is load-bearing: priceForModel returns the FIRST substring
+// hit, so any key that is a substring of another must come after it. Hence
+// `fable-5-1` above `fable`, `opus-5-5` above `opus`, `sonnet-5` above
+// `sonnet`, and `kimi-k3-fast` above `kimi-k3` — each wrong order silently
+// prices the specific model at its family's rate.
+const DEFAULT_PRICES = {
+    // Fable 5.1 / Mythos 5.1 read cache at 0.025× input; Fable 5 / Mythos 5 at
+    // the standard 0.1×. Same model tier, same input and output price.
+    "fable-5-1": { input: 10.0, output: 50.0, cacheRead: 0.25 },
+    "mythos-5-1": { input: 10.0, output: 50.0, cacheRead: 0.25 },
+    fable: { input: 10.0, output: 50.0 },
+    mythos: { input: 10.0, output: 50.0 },
+    // Opus 5.5 is cheaper than the rest of the Opus line, and reads cache at
+    // 0.05× input.
+    "opus-5-5": { input: 4.0, output: 20.0, cacheRead: 0.2 },
+    opus: { input: 5.0, output: 25.0 },
+    // Sonnet 5's launch price, announced as introductory, became its standard
+    // price; the increase to $3/$15 scheduled for 2026-09-01 did not happen.
+    "sonnet-5": { input: 2.0, output: 10.0 },
+    sonnet: { input: 3.0, output: 15.0 },
+    haiku: { input: 1.0, output: 5.0 },
+    // Fireworks-hosted Kimi K3 (open-weight), used by the goose/cline/crush
+    // harnesses. Fireworks' published serverless rates; cached input is exactly
+    // 0.1× input, matching the default cache-read multiplier, and cache *writes*
+    // are free — so callers pass zero write tokens.
+    "kimi-k3-fast": { input: 4.5, output: 22.5 },
+    "kimi-k3": { input: 3.0, output: 15.0 },
+};
+// The table as it stood from #385 until this revision, frozen. Ledger rows
+// written under it kept one `cache_write` count rather than the 5-minute /
+// 1-hour split, and this is what lets `brane cost reprice` recover that split
+// from the amount it produced (see src/cost/reprice.ts). Never edit it: it
+// describes rows that already exist.
+export const LEGACY_PRICES_V1 = [
+    ["fable", { input: 10.0, output: 50.0 }],
+    ["mythos", { input: 10.0, output: 50.0 }],
+    ["opus", { input: 5.0, output: 25.0 }],
+    ["sonnet", { input: 3.0, output: 15.0 }],
+    ["haiku", { input: 1.0, output: 5.0 }],
+    ["kimi-k3-fast", { input: 4.5, output: 22.5 }],
+    ["kimi-k3", { input: 3.0, output: 15.0 }],
+];
+// Fallback when a model matches no known tier — assume the most expensive
+// known tier (fable/mythos) so cost is never silently under-reported.
+const DEFAULT_TIER = { input: 10.0, output: 50.0 };
+let _table = null;
+/** Price table = an optional operator-supplied `~/.brane/pricing.json` (same
+ *  `{ substring: {input, output, cacheRead?} }` shape) ahead of the built-in
+ *  defaults, so prices can be corrected without a rebuild. Override keys are
+ *  matched first: appended after the defaults, as they once were, an entry
+ *  for `opus-5-5` could never win against `opus`. Read once and memoized. */
+function priceTable() {
+    if (_table)
+        return _table;
+    const overrides = [];
+    try {
+        const raw = readFileSync(join(homedir(), ".brane", "pricing.json"), "utf-8");
+        const parsed = JSON.parse(raw);
+        for (const [key, val] of Object.entries(parsed)) {
+            if (val && typeof val.input === "number" && typeof val.output === "number") {
+                const price = { input: val.input, output: val.output };
+                if (typeof val.cacheRead === "number")
+                    price.cacheRead = val.cacheRead;
+                overrides.push([key.toLowerCase(), price]);
+            }
+        }
+    }
+    catch {
+        // No override file (the common case) — defaults stand.
+    }
+    _table = [...overrides, ...Object.entries(DEFAULT_PRICES)];
+    return _table;
+}
+function lookup(table, model) {
+    const m = model.toLowerCase();
+    for (const [substr, price] of table) {
+        if (m.includes(substr))
+            return price;
+    }
+    return DEFAULT_TIER;
+}
+function price(p, u) {
+    // `tokens * 0.1 * input`, in that order, rather than `tokens * (0.1 * input)`:
+    // the default multiplier keeps the float associativity amounts were always
+    // computed with, so an unchanged model reprices to the identical double.
+    const cacheRead = p.cacheRead !== undefined ? u.cacheRead * p.cacheRead : u.cacheRead * 0.1 * p.input;
+    const base = (u.input * p.input +
+        u.output * p.output +
+        cacheRead +
+        u.cacheWrite5m * 1.25 * p.input +
+        u.cacheWrite1h * 2 * p.input) /
+        1e6;
+    return u.speed === "fast" ? base * FAST_MULTIPLIER : base;
+}
+/** USD cost of a single message's token usage, priced by its own model. */
+export function priceMessage(model, u) {
+    return price(lookup(priceTable(), model), u);
+}
+/** What `priceMessage` returned for this usage before this revision's table,
+ *  with no pricing.json override and no fast mode. Only reprice uses it. */
+export function priceMessageV1(model, u) {
+    return price(lookup(LEGACY_PRICES_V1, model), { ...u, speed: undefined });
+}
+/** The input price the legacy table charged `model`, for split recovery. */
+export function legacyInputPriceV1(model) {
+    return lookup(LEGACY_PRICES_V1, model).input;
+}
+//# sourceMappingURL=pricing.js.map

package/dist/cost/reprice.js

@@ -0,0 +1,136 @@
+import { priceMessage, priceMessageV1, legacyInputPriceV1 } from "./pricing.js";
+// `brane cost reprice`: the explicit re-pricing the Cost Ledger section has
+// always said the ledger makes possible. Entry rows carry the model and token
+// counts that priced them, so a corrected price table can be applied to what
+// was already recorded — including messages whose transcript is long gone.
+//
+// One fact is missing from older rows: `cache_write` holds 5-minute and
+// 1-hour writes together, and they bill at 1.25× and 2× input. It is
+// recoverable, because the amount on the row was produced by a known table
+// (LEGACY_PRICES_V1) from exactly those tokens: pricing every write as
+// 5-minute undershoots the amount by 0.75 × input × (1-hour tokens). A
+// recovered split is accepted only if it is a whole number of tokens inside
+// [0, cache_write] that reproduces the recorded amount; anything else — a row
+// priced under a pricing.json override, say — is left alone and counted as
+// unrecoverable. The first reprice writes the split it recovers, so later
+// ones read it and never infer again.
+/** Relative tolerance for "reproduces the recorded amount". Amounts are
+ *  doubles computed once from integers, so an honest row matches to ~1e-15. */
+const EPSILON = 1e-9;
+/** The 1-hour share of a V1-priced row's `cache_write`, or null when the
+ *  recorded amount admits no consistent split. Exported for the tests. */
+export function recoverCacheWrite1h(row) {
+    const all5m = {
+        input: row.input,
+        output: row.output,
+        cacheRead: row.cache_read,
+        cacheWrite5m: row.cache_write,
+        cacheWrite1h: 0,
+    };
+    const pin = legacyInputPriceV1(row.model);
+    const w1 = Math.round(((row.amount - priceMessageV1(row.model, all5m)) * 1e6) / (0.75 * pin));
+    if (!(w1 >= 0 && w1 <= row.cache_write))
+        return null;
+    const check = priceMessageV1(row.model, { ...all5m, cacheWrite5m: row.cache_write - w1, cacheWrite1h: w1 });
+    const scale = Math.max(Math.abs(row.amount), 1e-6);
+    return Math.abs(check - row.amount) <= EPSILON * scale ? w1 : null;
+}
+const round6 = (n) => Math.round(n * 1e6) / 1e6;
+/** Re-price every USD entry row that carries a model and token counts under
+ *  the current table, and move each affected narrative's cached
+ *  `cost_amount` by the same delta. Moving the column by the delta, rather
+ *  than resetting it to the ledger sum, is deliberate: a column above the
+ *  ledger sum holds pre-ledger cost from transcripts that may be gone
+ *  (sampleNarrativeCostDetailed keeps it for that reason), and a reprice must
+ *  correct the rows it touched without discarding that. One transaction; a
+ *  dry run computes the same result and writes nothing. */
+export function repriceLedger(db, opts = {}) {
+    const rows = db
+        .prepare(`SELECT key, narrative_id, model, amount, input, output, cache_read, cache_write, cache_write_1h, speed
+         FROM usage_ledger
+        WHERE unit = 'USD' AND model IS NOT NULL
+          AND input IS NOT NULL AND output IS NOT NULL
+          AND cache_read IS NOT NULL AND cache_write IS NOT NULL
+        ORDER BY key`)
+        .all();
+    const models = new Map();
+    const deltas = new Map();
+    const updates = [];
+    let recovered = 0;
+    let unrecoverable = 0;
+    for (const row of rows) {
+        const line = models.get(row.model) ?? { model: row.model, rows: 0, changed: 0, before: 0, after: 0 };
+        models.set(row.model, line);
+        line.rows++;
+        line.before += row.amount;
+        let w1 = row.cache_write_1h;
+        if (w1 === null) {
+            w1 = recoverCacheWrite1h(row);
+            if (w1 === null) {
+                unrecoverable++;
+                line.after += row.amount;
+                continue;
+            }
+            recovered++;
+        }
+        const amount = priceMessage(row.model, {
+            input: row.input,
+            output: row.output,
+            cacheRead: row.cache_read,
+            cacheWrite5m: row.cache_write - w1,
+            cacheWrite1h: w1,
+            speed: row.speed ?? undefined,
+        });
+        line.after += amount;
+        const changed = Math.abs(amount - row.amount) > EPSILON * Math.max(Math.abs(row.amount), 1e-6);
+        if (changed) {
+            line.changed++;
+            deltas.set(row.narrative_id, (deltas.get(row.narrative_id) ?? 0) + (amount - row.amount));
+        }
+        if (changed || row.cache_write_1h === null) {
+            updates.push({ key: row.key, amount: changed ? amount : row.amount, w1 });
+        }
+    }
+    const ledgerSum = db.prepare("SELECT SUM(amount) AS amount FROM usage_ledger WHERE narrative_id = ? AND unit = 'USD'");
+    const column = db.prepare("SELECT cost_amount, cost_unit FROM narratives WHERE id = ?");
+    const narratives = [];
+    for (const [nid, delta] of deltas) {
+        const before = ledgerSum.get(nid).amount ?? 0;
+        const after = before + delta;
+        const col = column.get(nid);
+        const colBefore = col && col.cost_unit === "USD" ? col.cost_amount : null;
+        narratives.push({
+            nid,
+            ledger_before: round6(before),
+            ledger_after: round6(after),
+            column_before: colBefore,
+            column_after: colBefore === null ? null : round6(Math.max(after, colBefore + delta)),
+        });
+    }
+    narratives.sort((a, b) => a.ledger_after - a.ledger_before - (b.ledger_after - b.ledger_before));
+    if (!opts.dryRun) {
+        const setRow = db.prepare("UPDATE usage_ledger SET amount = ?, cache_write_1h = ? WHERE key = ?");
+        const setColumn = db.prepare("UPDATE narratives SET cost_amount = ? WHERE id = ? AND cost_unit = 'USD'");
+        db.transaction(() => {
+            for (const u of updates)
+                setRow.run(u.amount, u.w1, u.key);
+            for (const n of narratives) {
+                if (n.column_after !== null)
+                    setColumn.run(n.column_after, n.nid);
+            }
+        })();
+    }
+    const modelLines = [...models.values()]
+        .map((m) => ({ ...m, before: round6(m.before), after: round6(m.after) }))
+        .sort((a, b) => b.before - a.before);
+    return {
+        dry_run: !!opts.dryRun,
+        scanned: rows.length,
+        changed: modelLines.reduce((n, m) => n + m.changed, 0),
+        recovered,
+        unrecoverable,
+        models: modelLines,
+        narratives,
+    };
+}
+//# sourceMappingURL=reprice.js.map