toolroll 0.9.60 → 0.9.62

package/dist/cli.js

@@ -506,7 +506,14 @@ async function runReposCommand(argv, write, onboard) {
     const tokenAt = argv.indexOf("--token");
     const tokenFlag = tokenAt === -1 ? undefined : argv[tokenAt + 1];
     const bare = argv.filter((argument, index) => argument !== "--json" && (tokenAt === -1 || (index !== tokenAt && index !== tokenAt + 1)));
-    const [action, ...paths] = bare;
+    const remoteAt = bare.indexOf("--remote");
+    const remoteUrl = remoteAt === -1 ? undefined : bare[remoteAt + 1];
+    const [action, ...paths] = bare.filter((_, i) => remoteAt === -1 || (i !== remoteAt && i !== remoteAt + 1));
+    if (remoteAt !== -1 && (action !== "add" || bare.filter(v => v === "--remote").length !== 1 || remoteUrl === undefined || remoteUrl.startsWith("-") || paths.length > 1)) {
+        const message = "Use repos add <project> --remote <url> for one project.";
+        write(json ? envelopeJson({ ok: false, command: "repos", reason: "usage", message }) : message);
+        return USAGE_EXIT;
+    }
     const databaseFile = databasePath(process.env, homedir());
     const file = registryBeside(databaseFile);
     if (tokenAt !== -1 && (tokenFlag === undefined || tokenFlag.startsWith("-"))) {
@@ -529,11 +536,18 @@ async function runReposCommand(argv, write, onboard) {
         return 1;
     }
     if (action === undefined) {
-        if (json) {
-            write(envelopeJson({ ok: true, command: "repos", count: loaded.repos.length, repos: loaded.repos, file }));
-            return 0;
+        const store = openStore(databaseFile);
+        try {
+            const projects = loaded.repos.map(repo => ({ repo, remoteUrl: store.projectRemote(repo) }));
+            if (json) {
+                write(envelopeJson({ ok: true, command: "repos", count: loaded.repos.length, repos: loaded.repos, projects, file }));
+                return 0;
+            }
+            return listRepos(loaded.repos, file, write, new Map(projects.map(p => [p.repo, p.remoteUrl])));
+        }
+        finally {
+            store.close();
         }
-        return listRepos(loaded.repos, file, write);
     }
     if (action !== "add" && action !== "remove") {
         const message = `unknown command \`repos ${action}\` — try \`repos\`, \`repos add\`, \`repos remove\`, or \`repos add-from-github <owner/name>\``;
@@ -545,7 +559,7 @@ async function runReposCommand(argv, write, onboard) {
     const lines = [];
     const said = {};
     const say = json ? (line) => lines.push(line) : write;
-    const code = await withAdmission({ databaseFile, registryFile: file, ...(leadToken === undefined ? {} : { leadToken }) }, say, said, admission => action === "add" ? addToRepos(admission, targets, say, said) : removeFromRepos(admission, targets, say, said));
+    const code = await withAdmission({ databaseFile, registryFile: file, ...(leadToken === undefined ? {} : { leadToken }) }, say, said, admission => action === "add" ? addToRepos(admission, targets, say, said, remoteUrl) : removeFromRepos(admission, targets, say, said));
     if (json) {
         write(envelopeJson({
             ok: code === 0,
@@ -582,7 +596,7 @@ async function withAdmission(where, write, said, body) {
         store.close();
     }
 }
-function listRepos(repos, file, write) {
+function listRepos(repos, file, write, remotes) {
     if (repos.length === 0) {
         write("No repositories connected. Toolroll reports on everything it can find.");
         write("");
@@ -592,8 +606,10 @@ function listRepos(repos, file, write) {
         return 0;
     }
     write(`${repos.length === 1 ? "1 repository" : `${repos.length} repositories`} connected:`);
-    for (const repo of repos)
+    for (const repo of repos) {
         write(`  ${repo}${existsSync(repo) ? "" : "   (missing)"}`);
+        write(`    Recorded remote: ${remotes.get(repo) ?? "None"}`);
+    }
     write("");
     write("  toolroll repos add <path>      add another; it is in the console at once");
     write("  toolroll repos remove <path>   take one out of the console; its tasks stay");
@@ -606,7 +622,7 @@ function listRepos(repos, file, write) {
 function admissionExit(reason) {
     return reason === "not-git" || reason === "unavailable" ? USAGE_EXIT : 1;
 }
-async function addToRepos(admission, targets, write, said) {
+async function addToRepos(admission, targets, write, said, remoteUrl) {
     // Every folder is proved before anything is written: one that is not a
     // repository fails here, not later and further away.
     let refused = false;
@@ -624,7 +640,7 @@ async function addToRepos(admission, targets, write, said) {
     const running = consoleRunning(admission.store, now);
     const projects = [];
     for (const path of targets) {
-        const admitted = await admitProject(admission.store, { registryFile: admission.registryFile, path, actor: admission.actor, now });
+        const admitted = await admitProject(admission.store, { registryFile: admission.registryFile, path, actor: admission.actor, now, captureOrigin: true, ...(remoteUrl === undefined ? {} : { remoteUrl }) });
         if (!admitted.ok) {
             // The updater's own taxonomy survives (verification finding 4): a held
             // lock or a malformed registry is an operational fact, never "usage".
@@ -633,8 +649,9 @@ async function addToRepos(admission, targets, write, said) {
             write(admitted.message);
             return admissionExit(admitted.reason);
         }
-        projects.push({ repo: admitted.repo, name: admitted.name, added: admitted.added });
+        projects.push({ repo: admitted.repo, name: admitted.name, added: admitted.added, remoteUrl: admitted.remote.url });
         write(addedWords(admitted.name, admitted.added, running));
+        write(`Recorded remote: ${admitted.remote.url ?? "None. Use repos add <project> --remote <url> to record one."}`);
     }
     said.projects = projects;
     return 0;

package/dist/contracts/console-api.d.ts

@@ -156,7 +156,8 @@ export declare const CONSOLE_FORMS: {
     readonly revise: FormContract<"batch" | "return" | "source">;
     readonly followUp: FormContract<"level" | "return">;
     readonly resolveIncident: FormContract<"return">;
-    readonly taskSteer: FormContract<"note">;
+    readonly taskSteer: FormContract<"note" | "return" | "run">;
+    readonly taskReply: FormContract<"answer" | "question">;
     readonly taskHold: FormContract<"reason">;
     readonly taskBlock: FormContract<"on">;
     readonly taskRepairDependency: FormContract<"blocker" | "operation" | "replacement">;
@@ -173,6 +174,7 @@ export declare const CONSOLE_FORMS: {
     readonly taskAcceptProof: FormContract<"note" | "return" | "run">;
     readonly taskComplete: FormContract<"accept" | "note" | "publish" | "receipt" | "return" | "run">;
     readonly taskStop: FormContract<"return" | "run">;
+    readonly taskPause: FormContract<"mode" | "note" | "request" | "return" | "run">;
     readonly taskResume: FormContract<"nonce" | "return" | "run" | "token">;
 };
 export type ConsoleFormName = keyof typeof CONSOLE_FORMS;

package/dist/contracts/console-api.js

@@ -167,7 +167,8 @@ export const CONSOLE_FORMS = {
     followUp: formContract("POST /r/<run>/checks|add-tests", ["return", "level"]),
     resolveIncident: formContract("POST /i/<id>/resolve", ["return"]),
     // A task's verbs (/t/<task>/<verb>), one body each.
-    taskSteer: formContract("POST /t/<task>/steer", ["note"]),
+    taskSteer: formContract("POST /t/<task>/steer", ["note", "return", "run"]),
+    taskReply: formContract("POST /t/<task>/reply", ["question", "answer"]),
     taskHold: formContract("POST /t/<task>/hold", ["reason"]),
     taskBlock: formContract("POST /t/<task>/block|unblock", ["on"]),
     taskRepairDependency: formContract("POST /t/<task>/repair-dependency", ["blocker", "operation", "replacement"]),
@@ -184,6 +185,9 @@ export const CONSOLE_FORMS = {
     taskAcceptProof: formContract("POST /t/<task>/accept-proof", ["run", "note", "return"]),
     taskComplete: formContract("POST /t/<task>/complete", ["receipt", "run", "accept", "note", "publish", "return"]),
     taskStop: formContract("POST /t/<task>/stop", ["run", "return"]),
+    // Pause, or Pause and steer when a note rides along, or Resume (mode=resume): the exact run shown, and the page's own
+    // request id.
+    taskPause: formContract("POST /t/<task>/pause", ["run", "request", "note", "mode", "return"]),
     taskResume: formContract("POST /t/<task>/resume|resume-arm", ["run", "token", "nonce", "return"]),
 };
 /** The console POSTs whose handlers read no field (sign-out not even the shared guard): their contract is the empty form. */

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>;