toolroll 0.9.60 → 0.9.61

package/dist/contracts/lead-tools.d.ts

@@ -656,7 +656,14 @@ export declare const LEAD_TOOL_INPUTS: {
     }, z.core.$strict>;
     readonly propose_steer: z.ZodObject<{
         task: z.ZodString;
-        note: z.ZodString;
+        note: z.ZodOptional<z.ZodString>;
+        mode: z.ZodOptional<z.ZodEnum<{
+            note: "note";
+            pause: "pause";
+            "pause-and-steer": "pause-and-steer";
+            resume: "resume";
+        }>>;
+        question: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strict>;
     readonly propose_dependency_repair: z.ZodObject<{
         task: z.ZodString;
@@ -1318,7 +1325,14 @@ export declare const LEAD_TOOL_READ_INPUTS: {
     }, z.core.$strict>;
     readonly propose_steer: z.ZodObject<{
         task: z.ZodString;
-        note: z.ZodString;
+        note: z.ZodOptional<z.ZodString>;
+        mode: z.ZodOptional<z.ZodEnum<{
+            note: "note";
+            pause: "pause";
+            "pause-and-steer": "pause-and-steer";
+            resume: "resume";
+        }>>;
+        question: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strict>;
     readonly propose_dependency_repair: z.ZodObject<{
         task: z.ZodString;

package/dist/contracts/lead-tools.js

@@ -130,7 +130,11 @@ export const LEAD_TOOL_INPUTS = {
     propose_reserve: z.strictObject({ task: taskRef, worker: text("workerName").nullable() }),
     propose_hold: z.strictObject({ task: taskRef, reason: text("proposalReason") }),
     propose_unhold: z.strictObject({ task: taskRef }),
-    propose_steer: z.strictObject({ task: taskRef, note }),
+    // mode: a note (the default), Pause (stop a running Claude build's turn, keep the build), Pause and steer, or Resume
+    // (a paused build goes on where it stopped, without a note).
+    // question: a running agent's open question (Agents board); the note is its reply, sent as an ordinary note.
+    propose_steer: z.strictObject({ task: taskRef, note: note.optional(), mode: z.enum(["note", "pause", "pause-and-steer", "resume"]).optional(),
+        question: z.number().int().positive().optional().describe("A running agent's open question (get_task agentQuestions): the note becomes its reply and closes it.") }),
     propose_dependency_repair: z.strictObject({ task: taskRef, blocker: taskRef, operation: z.enum(["retry", "unlink", "replace"]), replacement: taskRef.optional() }),
     propose_scope: z.strictObject({ task: taskRef, goal: scopeText, not: scopeText.nullable().optional(), touches: touches.optional(), acceptance }),
     propose_agents: z.strictObject({

package/dist/desktop-update.d.ts

@@ -94,7 +94,6 @@ export declare function prepareDesktopUpdate(stateDir: string, installed: string
 export declare function sqliteLock(file: string, busyTimeoutMs?: number): DatabaseSync | null;
 export declare const installationLock: (j: UpdateJournal) => DatabaseSync | null;
 export declare function desktopUpdateStatus(stateDir: string): {
-    version?: never;
     active: boolean;
     phase: string;
     detail: string;
@@ -108,6 +107,7 @@ export declare function desktopUpdateStatus(stateDir: string): {
     wasRunning?: never;
     backupPath?: never;
     updateId?: never;
+    version?: never;
     buildId?: never;
     workDir?: never;
 } | {

package/dist/evidence-pack.js

@@ -84,7 +84,7 @@ export function evidencePack(store, taskId, access, who, now, evidenceRoot, chec
         result: receipt === null ? null : {
             runId: receipt.runId, base: receipt.base, head: receipt.head, kind: receipt.completionKind,
             checks: { status: receipt.checks.status, command: receipt.checks.command, exitCode: receipt.checks.exitCode, detail: receipt.checks.detail },
-            completedBy: assignment?.completion?.actor ?? null, completedAt: assignment?.completion?.at ?? null, caveats: receipt.caveats,
+            completedBy: assignment?.completion?.landed !== undefined ? `Toolroll, automatically: ${assignment.completion.landed}` : assignment?.completion?.actor ?? null, completedAt: assignment?.completion?.at ?? null, caveats: receipt.caveats,
             publication: assignment?.publication ?? null,
         },
         totals: { runs: allRuns.length, costUsd: Math.round(sum(run => run.costUsd) * 1e6) / 1e6, tokensIn: sum(run => run.tokensIn), tokensOut: sum(run => run.tokensOut) },

package/dist/evidence.d.ts

@@ -51,6 +51,9 @@ export declare const PROPOSAL_PREFIX = "STANDING-ORDERS-PROPOSAL-";
  * writes each operator note into it as NNN.json (a temp name, then a
  * rename); the agent acknowledges a note by moving it into `handled/`. */
 export declare const STEER_PREFIX = "STANDING-ORDERS-STEER-";
+/** The running build's status file (Agents board): JSON lines the agent appends
+ * (working, needs-decision, blocked, done), read forward by the pulse. */
+export declare const STATUS_PREFIX = "STANDING-ORDERS-STATUS-";
 export declare const MAILBOX_SUFFIX = ".json";
 /** v105: left in a run's evidence folder when the retention setting removed its files (retention.ts). */
 export declare const RETENTION_NOTE = "REMOVED-BY-RETENTION";
@@ -86,6 +89,9 @@ export declare function looksLikeProtocolFile(name: string): boolean;
  * `git status` names it: an untracked folder is reported with a trailing
  * slash, or file by file where a repository shows every untracked file. */
 export declare function looksLikeSteerFolder(name: string): boolean;
+/** An agent status file (Agents board), by its exact nonce-shaped name. */
+export declare function looksLikeStatusFile(name: string): boolean;
+export declare function statusFileName(): string;
 export declare function steerFolderName(): string;
 export declare function handoffName(): string;
 export declare function planFileName(): string;

package/dist/evidence.js

@@ -54,6 +54,9 @@ export const PROPOSAL_PREFIX = "STANDING-ORDERS-PROPOSAL-";
  * writes each operator note into it as NNN.json (a temp name, then a
  * rename); the agent acknowledges a note by moving it into `handled/`. */
 export const STEER_PREFIX = "STANDING-ORDERS-STEER-";
+/** The running build's status file (Agents board): JSON lines the agent appends
+ * (working, needs-decision, blocked, done), read forward by the pulse. */
+export const STATUS_PREFIX = "STANDING-ORDERS-STATUS-";
 export const MAILBOX_SUFFIX = ".json";
 /** v105: left in a run's evidence folder when the retention setting removed its files (retention.ts). */
 export const RETENTION_NOTE = "REMOVED-BY-RETENTION";
@@ -132,7 +135,7 @@ export function looksLikeMailbox(name) {
  * The pre-rename NIGHTORDERS- prefix stays recognized here — a worktree cut
  * down before 2026-08-13 may still hold one, and cleanup has no vintage. */
 export function looksLikeProtocolFile(name) {
-    if (looksLikeSteerFolder(name))
+    if (looksLikeSteerFolder(name) || looksLikeStatusFile(name))
         return true;
     return ((name.startsWith(MAILBOX_PREFIX) ||
         name.startsWith(HANDOFF_PREFIX) ||
@@ -153,6 +156,13 @@ export function looksLikeProtocolFile(name) {
 export function looksLikeSteerFolder(name) {
     return /^STANDING-ORDERS-STEER-[0-9a-f]{16}(?:\/.*)?$/.test(name);
 }
+/** An agent status file (Agents board), by its exact nonce-shaped name. */
+export function looksLikeStatusFile(name) {
+    return /^STANDING-ORDERS-STATUS-[0-9a-f]{16}\.jsonl$/.test(name);
+}
+export function statusFileName() {
+    return `${STATUS_PREFIX}${randomBytes(8).toString("hex")}.jsonl`;
+}
 export function steerFolderName() {
     return `${STEER_PREFIX}${randomBytes(8).toString("hex")}`;
 }
@@ -550,8 +560,9 @@ export function quarantineMailboxes(worktree, root, runId) {
         const path = join(worktree, name);
         // An earlier attempt's steering folder holds copies of notes the
         // database already keeps: removed whole (a symlink is removed, never
-        // followed), never quarantined.
-        if (looksLikeSteerFolder(name)) {
+        // followed), never quarantined. So is its status file: the database
+        // already read every line it will ever need.
+        if (looksLikeSteerFolder(name) || looksLikeStatusFile(name)) {
             try {
                 rmSync(path, { recursive: true, force: true });
                 swept.push(name);

package/dist/exec.d.ts

@@ -9,6 +9,7 @@
 import { type ProcessTreeObserver } from "./process-tree.js";
 import { type ContainmentBackendId } from "./containment.js";
 import type { Store } from "./store.js";
+import type { LiveInput } from "./live-input.js";
 export type ExecResult = {
     /** Process exit code, or one of the synthetic codes below. */
     code: number;
@@ -112,6 +113,15 @@ export type RunOptions = ProcessTreeObserver & {
      * currently only the streaming transport can deliver this early).
      */
     onSessionId?: (id: string) => void;
+    /**
+     * Live input (live-input.ts): a Claude transport that declares `streamInput`
+     * keeps stdin piped and open, hands it to this session, and shows it every
+     * stdout event. The session sends the brief first and decides when stdin
+     * closes; the run then ends with the process, and the LAST primary result
+     * is the accounting envelope (one result per turn), with every main
+     * result's usage and turns added up (cumulativeLiveResult).
+     */
+    liveInput?: LiveInput;
     /** Fires once the child exists, with its pid (the process-group id when
      * processGroup is set) — the slot ledger records it (v14 finding 26). */
     onSpawn?: (pid: number) => void;
@@ -202,6 +212,17 @@ export declare function run(file: string, args: readonly string[], options?: Run
  * worst useful case while remaining a hard, per-event memory boundary.
  */
 export declare const JSONL_EVENT_HARD_CAP: number;
+/**
+ * The accounting an oversized Claude result still carries, read by a bounded scan of its kept prefix and tail: the
+ * session's running `total_cost_usd`, its `usage` and `num_turns`, and whether it is a main result at all (an
+ * `origin` naming anything but a person makes it a background task's). Anything unreadable or seen twice is absent.
+ */
+export declare function scanOversizedClaudeResult(prefix: Buffer, tail: Buffer | undefined): {
+    primary: boolean;
+    account: Record<string, unknown>;
+};
+/** Marks a Claude result whose session cost could not be read: the gateway charges the run's dollar cap instead. */
+export declare const CLAUDE_COST_UNKNOWN = "standing_orders_cost_unknown";
 export declare function runStreamJsonl(file: string, args: readonly string[], options?: RunOptions): Promise<ExecResult>;
 /**
  * The streaming transport for gemini's stream-json dialect (Phase 3 D1/A7).
@@ -225,4 +246,15 @@ export declare function runStreamJsonl(file: string, args: readonly string[], op
  * semantics match `runStreamJsonl`.
  */
 export declare function runGeminiStreamJsonl(file: string, args: readonly string[], options?: RunOptions): Promise<ExecResult>;
+/**
+ * A live session's account so far (one main result per turn, checked on Claude Code 2.1.290): the latest result's
+ * session, ending, words and cost — `total_cost_usd` is already the session's running total — with the usage token
+ * fields and `num_turns`, which count only their own message, added up across every main result. A field that is not
+ * a non-negative number adds nothing.
+ */
+export declare function cumulativeLiveResult(previous: Record<string, unknown>, latest: Record<string, unknown>): Record<string, unknown>;
+/** This transport can keep stdin open for a live session (RunOptions.liveInput). */
+export declare const STREAM_INPUT: unique symbol;
+/** Whether a runner declares it keeps stdin open for a live session; an injected runner opts in by carrying the mark. */
+export declare const streamsInput: (runner: unknown) => boolean;
 export declare function runClaudeStreamJsonl(file: string, args: readonly string[], options?: RunOptions): Promise<ExecResult>;

package/dist/exec.js

@@ -420,7 +420,10 @@ export const DEFAULT_MAX_BUFFER = 8 * 1024 * 1024;
  * watchdog with no wall-clock deadline. Both roads share the same kill and
  * settlement semantics.
  */
-function streamWatchdog(options, onTimeout) {
+function streamWatchdog(options, onTimeout, 
+/** The idle limit was reached: true when the caller ended the wait its own way (a paused live session closes
+ * stdin), so the same limit runs again for the process to exit before it is killed. */
+onIdle) {
     const hardMs = options.timeoutMs ?? (options.idleTimeoutMs === undefined ? DEFAULT_TIMEOUT_MS : undefined);
     const idleMs = options.idleTimeoutMs;
     let fired = false;
@@ -432,12 +435,25 @@ function streamWatchdog(options, onTimeout) {
         fired = true;
         onTimeout();
     };
+    const idle = () => {
+        let handled = false;
+        try {
+            handled = onIdle?.() === true;
+        }
+        catch {
+            handled = false;
+        }
+        if (handled)
+            armIdle();
+        else
+            fire();
+    };
     const armIdle = () => {
         if (idleMs === undefined)
             return;
         if (idleTimer !== undefined)
             clearTimeout(idleTimer);
-        idleTimer = setTimeout(fire, idleMs);
+        idleTimer = setTimeout(idle, idleMs);
         idleTimer.unref?.();
     };
     if (hardMs !== undefined) {
@@ -725,14 +741,36 @@ const JSONL_OVERFLOW_PREFIX_CAP = 4 * 1024;
  * storage can be reused for the next record. Counting the original bytes
  * (rather than JavaScript characters) makes the overflow receipt exact.
  */
-function boundedJsonlFramer(cap, onLine, inspectDiscriminants = false) {
+function boundedJsonlFramer(cap, onLine, inspectDiscriminants = false, tailCap = 0) {
     const retained = Buffer.allocUnsafe(cap);
     let retainedBytes = 0;
     let originalBytes = 0;
     let nonWhitespace = false;
     let discriminants = inspectDiscriminants ? jsonlDiscriminants() : null;
+    // An oversized line's last tailCap bytes, kept only once the line passes the cap (Claude's result carries its cost
+    // after the words that made it too large). Seeded from the retained prefix's end, so it is always the line's true end.
+    const tailSize = Math.max(0, Math.min(tailCap, cap));
+    const tail = tailSize === 0 ? null : Buffer.allocUnsafe(tailSize);
+    let tailBytes = 0;
+    let tailSeeded = false;
+    const keepTail = (part) => {
+        if (tail === null)
+            return;
+        if (!tailSeeded) {
+            tailSeeded = true;
+            tailBytes = retained.copy(tail, 0, retainedBytes - tailSize, retainedBytes);
+        }
+        if (part.length >= tailSize) {
+            tailBytes = part.copy(tail, 0, part.length - tailSize);
+            return;
+        }
+        const keepOld = Math.min(tailBytes, tailSize - part.length);
+        tail.copyWithin(0, tailBytes - keepOld, tailBytes);
+        tailBytes = keepOld + part.copy(tail, keepOld);
+    };
     const append = (part) => {
         discriminants?.push(part);
+        const before = originalBytes;
         originalBytes += part.length;
         if (!nonWhitespace) {
             for (const byte of part) {
@@ -745,6 +783,9 @@ function boundedJsonlFramer(cap, onLine, inspectDiscriminants = false) {
         if (retainedBytes < cap) {
             retainedBytes += part.copy(retained, retainedBytes, 0, cap - retainedBytes);
         }
+        // The bytes up to the cap are in the prefix; only what runs past it moves the tail.
+        if (tail !== null && originalBytes > cap)
+            keepTail(before >= cap ? part : part.subarray(cap - before));
     };
     const emit = () => {
         onLine({
@@ -752,7 +793,10 @@ function boundedJsonlFramer(cap, onLine, inspectDiscriminants = false) {
             bytesOriginal: originalBytes,
             overflowed: originalBytes > cap,
             ...(discriminants === null ? {} : { discriminants: discriminants.finish() }),
+            ...(tail !== null && originalBytes > cap ? { tail: tail.subarray(0, tailBytes) } : {}),
         });
+        tailBytes = 0;
+        tailSeeded = false;
         retainedBytes = 0;
         originalBytes = 0;
         nonWhitespace = false;
@@ -866,6 +910,85 @@ function leadingClaudeSystemSubtype(prefix) {
     const match = /^\s*\{\s*"type"\s*:\s*"system"\s*,\s*"subtype"\s*:\s*"([A-Za-z0-9._-]+)"/.exec(prefix.toString("utf8", 0, Math.min(prefix.length, 512)));
     return match?.[1] ?? null;
 }
+/** How much of an oversized Claude result's end is kept to read its cost and usage (they follow the words). */
+const CLAUDE_RESULT_TAIL_CAP = 64 * 1024;
+/**
+ * Where a key's value starts in a fragment of JSON text, once and only once. `"key":` never occurs inside a JSON
+ * string (every quote there is escaped, so `y":` cannot appear), so each match is a real key, though possibly of a
+ * nested object. A key seen more than once is ambiguous and reads as absent.
+ */
+function soleKeyValueAt(texts, key) {
+    const pattern = new RegExp(`"${key}"\\s*:\\s*`, "g");
+    let found = null;
+    for (const text of texts) {
+        for (const match of text.matchAll(pattern)) {
+            if (found !== null)
+                return null;
+            found = { text, at: match.index + match[0].length };
+        }
+    }
+    return found;
+}
+/** The JSON object starting at `at`, read to its matching brace (strings and escapes respected), or null. */
+function jsonObjectAt(text, at) {
+    if (text[at] !== "{")
+        return null;
+    let depth = 0, inString = false;
+    for (let i = at; i < text.length && i - at < CLAUDE_RESULT_TAIL_CAP; i += 1) {
+        const c = text[i];
+        if (inString) {
+            if (c === "\\")
+                i += 1;
+            else if (c === '"')
+                inString = false;
+        }
+        else if (c === '"')
+            inString = true;
+        else if (c === "{")
+            depth += 1;
+        else if (c === "}" && --depth === 0) {
+            try {
+                const value = JSON.parse(text.slice(at, i + 1));
+                return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+            }
+            catch {
+                return null;
+            }
+        }
+    }
+    return null;
+}
+/**
+ * The accounting an oversized Claude result still carries, read by a bounded scan of its kept prefix and tail: the
+ * session's running `total_cost_usd`, its `usage` and `num_turns`, and whether it is a main result at all (an
+ * `origin` naming anything but a person makes it a background task's). Anything unreadable or seen twice is absent.
+ */
+export function scanOversizedClaudeResult(prefix, tail) {
+    const texts = [prefix.toString("utf8"), ...(tail === undefined ? [] : [tail.toString("utf8")])];
+    const origin = soleKeyValueAt(texts, "origin");
+    const originObject = origin === null ? null : jsonObjectAt(origin.text, origin.at);
+    const primary = originObject === null || String(originObject["kind"] ?? "") === "human";
+    const account = {};
+    const number = (key) => {
+        const at = soleKeyValueAt(texts, key);
+        const match = at === null ? null : /^-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?/.exec(at.text.slice(at.at, at.at + 64));
+        const value = match === null ? NaN : Number(match[0]);
+        return Number.isFinite(value) && value >= 0 ? value : null;
+    };
+    const cost = number("total_cost_usd");
+    if (cost !== null)
+        account["total_cost_usd"] = cost;
+    const turns = number("num_turns");
+    if (turns !== null)
+        account["num_turns"] = turns;
+    const usageAt = soleKeyValueAt(texts, "usage");
+    const usage = usageAt === null ? null : jsonObjectAt(usageAt.text, usageAt.at);
+    if (usage !== null)
+        account["usage"] = usage;
+    return { primary, account };
+}
+/** Marks a Claude result whose session cost could not be read: the gateway charges the run's dollar cap instead. */
+export const CLAUDE_COST_UNKNOWN = "standing_orders_cost_unknown";
 function malformedCodexEventIsLoadBearing(prefix) {
     const type = leadingJsonObjectType(prefix);
     if (type === "thread.started" || type === "turn.completed" || type === "turn.failed")
@@ -1331,15 +1454,45 @@ function primaryResultOrigin(event) {
         return true;
     return false; // task-notification, channel, peer, coordinator, unknown: never the envelope
 }
+/** The usage fields Claude reports per message (not per session): a live session's account adds them up. */
+const LIVE_SUMMED_USAGE = ["input_tokens", "output_tokens", "cache_creation_input_tokens", "cache_read_input_tokens"];
+/**
+ * A live session's account so far (one main result per turn, checked on Claude Code 2.1.290): the latest result's
+ * session, ending, words and cost — `total_cost_usd` is already the session's running total — with the usage token
+ * fields and `num_turns`, which count only their own message, added up across every main result. A field that is not
+ * a non-negative number adds nothing.
+ */
+export function cumulativeLiveResult(previous, latest) {
+    const count = (value) => typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : null;
+    const usageOf = (event) => event["usage"] !== null && typeof event["usage"] === "object" && !Array.isArray(event["usage"]) ? event["usage"] : null;
+    const before = usageOf(previous), now = usageOf(latest);
+    const usage = { ...(now ?? {}) };
+    for (const key of LIVE_SUMMED_USAGE) {
+        const a = before === null ? null : count(before[key]), b = now === null ? null : count(now[key]);
+        if (a !== null || b !== null)
+            usage[key] = (a ?? 0) + (b ?? 0);
+    }
+    const turnsBefore = count(previous["num_turns"]), turnsNow = count(latest["num_turns"]);
+    return {
+        ...latest,
+        ...(before === null && now === null ? {} : { usage }),
+        ...(turnsBefore === null && turnsNow === null ? {} : { num_turns: (turnsBefore ?? 0) + (turnsNow ?? 0) }),
+    };
+}
+/** This transport can keep stdin open for a live session (RunOptions.liveInput). */
+export const STREAM_INPUT = Symbol.for("toolroll.streamInput");
+/** Whether a runner declares it keeps stdin open for a live session; an injected runner opts in by carrying the mark. */
+export const streamsInput = (runner) => typeof runner === "function" && runner[STREAM_INPUT] === true;
 export function runClaudeStreamJsonl(file, args, options = {}) {
     const { cwd } = options;
     const childEnv = resolveChildEnv(options);
+    const live = options.liveInput ?? null;
     return new Promise(resolve => {
         let child;
         let container = null;
         let attachFailure = null;
         try {
-            const spawned = spawnStream(file, args, options, ["ignore", "pipe", "pipe"], childEnv);
+            const spawned = spawnStream(file, args, options, [live === null ? "ignore" : "pipe", "pipe", "pipe"], childEnv);
             child = spawned.child;
             container = spawned.container;
             void spawned.attached.then(outcome => { if (!outcome.ok)
@@ -1359,6 +1512,12 @@ export function runClaudeStreamJsonl(file, args, options = {}) {
         let conflictingInitLine = null;
         let initSessionId = null;
         let resultLine = null;
+        let resultOverflowed = false;
+        // The run's account: the first main result, or for a live session every main result added up (each oversized
+        // one's scanned cost and usage too). Its cost is the highest running total seen; costUnknown when the latest main
+        // result's cost could not be read (an oversized one), which only a later readable result can clear.
+        let account = null;
+        let costUnknown = false;
         let overflowLine = null;
         let receiptFired = false;
         let stderr = "";
@@ -1380,6 +1539,26 @@ export function runClaudeStreamJsonl(file, args, options = {}) {
                 // note stays honestly unreceipted and re-attaches later.
             }
         };
+        const tally = (event, line) => {
+            const before = account;
+            account = account === null || live === null ? event : { ...(line === null ? account : {}), ...cumulativeLiveResult(account, event) };
+            const cost = event["total_cost_usd"];
+            const readable = typeof cost === "number" && Number.isFinite(cost) && cost >= 0;
+            // The running total only grows: an earlier, higher total stands (a session's cost is never given back).
+            const prior = before?.["total_cost_usd"];
+            if (readable && typeof prior === "number" && prior > cost)
+                account = { ...account, total_cost_usd: prior };
+            if (line === null)
+                costUnknown = !readable;
+            else if (readable)
+                costUnknown = false;
+            if (resultOverflowed)
+                return;
+            if (line !== null && account === event)
+                resultLine = line;
+            else if (line !== null || resultLine !== null)
+                resultLine = JSON.stringify(account);
+        };
         const keep = (framed) => {
             if (framed.overflowed) {
                 // An oversized result is the first primary candidate and therefore
@@ -1404,10 +1583,22 @@ export function runClaudeStreamJsonl(file, args, options = {}) {
                         overflowLine = claudeOverflowLine(framed);
                     return;
                 }
-                if (resultLine === null)
+                // Nothing inside an oversized result is trusted: the agent shapes its bytes (tool inputs in permission_denials
+                // are real JSON objects), so a planted total_cost_usd or origin could read as genuine. It counts as the main
+                // result with an unknown cost, charged at the run's cap, and a live session's input closes.
+                const scanned = { primary: true, account: {} };
+                if (live !== null || resultLine === null)
+                    tally(scanned.account, null);
+                if (resultLine === null) {
                     resultLine = claudeOverflowLine(framed);
+                    resultOverflowed = true;
+                }
                 else if (overflowLine === null)
                     overflowLine = claudeOverflowLine(framed);
+                // A live session whose main result was too large to read cannot be steered safely: close its input, so the
+                // process ends instead of running further turns nobody can account for.
+                if (live !== null && scanned.primary)
+                    live.close("settled");
                 return;
             }
             const line = framed.prefix.toString("utf8");
@@ -1458,8 +1649,11 @@ export function runClaudeStreamJsonl(file, args, options = {}) {
                 // v105: the plan's usage windows, as Claude says them each turn (the Tasks page's limits).
                 noteLimits(claudeLimitsOf(event));
             }
-            else if (type === "result" && resultLine === null && primaryResultOrigin(event)) {
-                resultLine = line;
+            else if (type === "result" && (resultLine === null || live !== null) && primaryResultOrigin(event)) {
+                // A live session ends a turn with a result each time: the run's account is the last one, with every main
+                // result's usage and turns added up (account). After an oversized main result the retained result stays the
+                // fail-closed overflow, but later results still count toward its cost.
+                tally(event, line);
                 // Fallback receipt (finding 11): a SUCCESSFUL main-query completion
                 // entails the prompt ran even if the stream elided assistant
                 // events. Error results never fire — startup death is not delivery.
@@ -1474,15 +1668,32 @@ export function runClaudeStreamJsonl(file, args, options = {}) {
                     // Observational only: a broken listener never touches the run.
                 }
             }
+            // After the run's own bookkeeping: the session may close stdin on this event.
+            if (live !== null)
+                live.observe(event);
         };
-        const framing = boundedJsonlFramer(JSONL_EVENT_HARD_CAP, keep);
+        // The retained main result as the run's account: an oversized one stays the fail-closed overflow but carries the
+        // cost and usage read from it and from later results; a cost that could not be read says so (CLAUDE_COST_UNKNOWN).
+        const accountedResultLine = () => {
+            if (resultLine === null || (!resultOverflowed && !costUnknown))
+                return resultLine;
+            const kept = JSON.parse(resultLine);
+            const counted = {};
+            if (resultOverflowed && account !== null) {
+                for (const key of ["total_cost_usd", "usage", "num_turns"])
+                    if (account[key] !== undefined)
+                        counted[key] = account[key];
+            }
+            return JSON.stringify({ ...kept, ...counted, ...(costUnknown ? { [CLAUDE_COST_UNKNOWN]: true } : {}) });
+        };
+        const framing = boundedJsonlFramer(JSONL_EVENT_HARD_CAP, keep, false, CLAUDE_RESULT_TAIL_CAP);
         const watchdog = streamWatchdog(options, () => {
             timedOut = true;
             if (options.processGroup === true)
                 killGroup(child);
             else
                 child.kill("SIGKILL");
-        });
+        }, live === null ? undefined : () => live.idleLimit());
         child.stdout?.on("data", (chunk) => {
             watchdog.touch();
             framing.push(chunk);
@@ -1501,7 +1712,8 @@ export function runClaudeStreamJsonl(file, args, options = {}) {
             watchdog.stop();
             liveProviders.delete(child);
             framing.finish();
-            const lines = [initLine, initIdentityLine, conflictingInitLine, resultLine, overflowLine]
+            live?.detach();
+            const lines = [initLine, initIdentityLine, conflictingInitLine, accountedResultLine(), overflowLine]
                 .filter((one) => one !== null)
                 .filter((line, index, all) => all.indexOf(line) === index);
             const settlement = container === null ? Promise.resolve(null) : settleContainer(container, options);
@@ -1521,5 +1733,12 @@ export function runClaudeStreamJsonl(file, args, options = {}) {
             finish(null);
         });
         child.on("close", code => finish(code));
+        if (live !== null && child.stdin !== null) {
+            const input = child.stdin;
+            // A pipe the child closed (it exited) ends live input; the run settles on the process, as always.
+            input.on("error", () => live.detach("input-failed"));
+            live.attach({ write: line => { input.write(line, "utf8"); }, end: () => { input.end(); } });
+        }
     });
 }
+runClaudeStreamJsonl[STREAM_INPUT] = true;