toolroll 0.9.104 → 0.9.105

package/dist/acp-client.js

@@ -1,37 +1,5 @@
 import { isRecord } from "./is-record.js";
-/**
- * The Agent Client Protocol, from the plane's side (docs/plans/acp-adapter.md).
- *
- * ACP is JSON-RPC 2.0, one message per line, over the agent's stdio. This
- * module is the whole conversation as a pure state machine: it is handed the
- * agent's lines one at a time and answers with the lines to send back. It
- * never spawns, reads a clock or touches a file — the runner (exec.ts) owns
- * the process, the timers and the shutdown.
- *
- * One conversation is one build: `initialize`, `session/new` in the
- * worktree, the sealed model selected and seen to be current, one
- * `session/prompt` carrying the brief, then `session/update`s until the
- * response to that prompt. Success is that response with
- * `stopReason: "end_turn"` and nothing else — no update, exit code or
- * message text can stand in for it.
- *
- * The plane offers no client capabilities (no file system, no terminal), so
- * every agent request except `session/request_permission` is answered
- * "method not found". A model is chosen only through a `model` config option,
- * whose answer shows the model current: `session/set_model` answers with
- * nothing to observe, so an agent that offers only that is refused until a
- * fixture proves how it confirms. Builds are full access inside the OS fence, so a
- * permission request is granted once (`allow_once`, never `allow_always`);
- * the fence, not this answer, is the boundary — OpenCode runs commands
- * without asking at all.
- *
- * What the runner keeps is not the agent's stream but a short synthetic
- * record (`retained()`), one JSON object per line, typed `acp.*` — a type
- * no agent can emit — which `acpParse` reads into the gateway's envelope.
- */
-/** How many offered models a conversation keeps (each id ≤ 200 characters). */
 export const ACP_OFFERED_CAP = 2000;
-/** The largest line (UTF-8 bytes) the plane reads from an agent; a longer one is a protocol failure. */
 export const ACP_LINE_CAP = 1024 * 1024;
 const MESSAGE_CAP = 64 * 1024;
 const TEXT_CAP = 2048;
@@ -44,13 +12,11 @@ function bounded(text, cap) {
 function line(message) {
     return JSON.stringify(message);
 }
-/** The model a `session/new` (or `set_config_option`) result offers, by mechanism. */
 function modelOffer(result) {
     const options = result["configOptions"];
     if (Array.isArray(options)) {
         const model = options.find(one => isRecord(one) && one["id"] === "model" && one["type"] === "select");
         if (isRecord(model) && Array.isArray(model["options"])) {
-            // Choices, or groups of choices — read as the same variant validation accepted: all choices, or all groups.
             const options = model["options"];
             const choices = options.every(configChoice) ? options : options.every(configGroup) ? options.flatMap(one => one["options"]) : [];
             const offered = choices.flatMap(one => isRecord(one) && typeof one["value"] === "string" ? [one["value"]] : []);
@@ -65,11 +31,6 @@ function modelOffer(result) {
     return null;
 }
 const OPTION_KINDS = new Set(["allow_once", "allow_always", "reject_once", "reject_always"]);
-/**
- * The answer to a permission request: the `allow_once` option, else the `reject_once` one. The whole list must be
- * well formed — every option an object with a non-empty id and a known kind, no id twice — or nothing is chosen: an
- * id shared by "once" and "always" would make the answer mean either.
- */
 export function permissionAnswer(params) {
     if (!isRecord(params) || !meta(params) || !Array.isArray(params["options"]) || params["options"].length === 0 || params["options"].length > 16)
         return null;
@@ -100,39 +61,33 @@ const TOOL_KINDS = new Set(["read", "edit", "delete", "move", "search", "execute
 const TOOL_STATUSES = new Set(["pending", "in_progress", "completed", "failed"]);
 const PLAN_PRIORITIES = new Set(["high", "medium", "low"]);
 const PLAN_STATUSES = new Set(["pending", "in_progress", "completed"]);
-/** An optional field: absent, null, or of its type. */
 const optional = (value, is) => value === undefined || value === null || is(value);
-/** Each parsed wire object's number tokens, by key, exactly as written (acp-client's JSON.parse reviver records them). */
 const NUMBER_SOURCES = new WeakMap();
-/** The integer a JSON number token writes exactly (1e3, 1000.0, 0e-999 and 1.000…0 do), or null when it writes none. */
 function exactInteger(source) {
     const parts = /^(-?)(\d+)(?:\.(\d+))?(?:[eE]([+-]?\d+))?$/.exec(source);
     if (parts === null)
         return null;
     let digits = `${parts[2]}${parts[3] ?? ""}`.replace(/^0+/, "");
     if (digits === "")
-        return 0n; // zero, at any exponent
+        return 0n;
     const trailing = digits.length - digits.replace(/0+$/, "").length;
     digits = digits.slice(0, digits.length - trailing);
     const exponent = Number(parts[4] ?? "0") - (parts[3]?.length ?? 0) + trailing;
     if (!Number.isSafeInteger(exponent) || exponent < 0)
-        return null; // a fraction, or no number at all
+        return null;
     if (digits.length + exponent > 400)
-        return null; // far past any field's range
+        return null;
     const exact = BigInt(digits) * 10n ** BigInt(exponent);
     return parts[1] === "-" ? -exact : exact;
 }
-/** `holder[key]` as an integer in [min, max]: on the wire, exactly the integer its token writes; built in memory, a safe one. */
 function wireInteger(holder, key, min, max) {
     const value = holder[key];
     if (typeof value !== "number")
         return false;
-    // Every number the client reads came off the wire with its token: one without is refused, never taken as it reads.
     const source = NUMBER_SOURCES.get(holder)?.get(key);
     const exact = source === undefined ? null : exactInteger(source);
     return exact !== null && exact >= min && exact <= max;
 }
-/** A number as the agent wrote it: past 2^53, its exact decimal string (when its token writes an integer). */
 function exactNumber(holder, key, item) {
     if (Number.isSafeInteger(item))
         return item;
@@ -140,9 +95,6 @@ function exactNumber(holder, key, item) {
     const exact = source === undefined ? null : exactInteger(source);
     return exact === null ? item : exact.toString();
 }
-/** `holder[key]`, copied with every integer JavaScript would round (past 2^53) as its exact decimal string, so what
- * is shown and kept is what the agent said — at any depth, in objects and arrays alike (iteratively: no nesting can
- * exhaust the stack). Every key, `__proto__` included, is the copy's own data, never an inherited field. */
 function exactField(holder, key) {
     const root = holder[key];
     if (typeof root === "number")
@@ -174,16 +126,13 @@ const UINT64 = [0n, 2n ** 64n - 1n];
 const UINT32 = [0n, 2n ** 32n - 1n];
 const INT32 = [-(2n ** 31n), 2n ** 31n - 1n];
 const bool = (value) => typeof value === "boolean";
-/** A list whose every entry passes. */
 const listOf = (is) => (value) => Array.isArray(value) && value.every(is);
-/** `_meta`, wherever the protocol allows it: absent, null, or an object. */
 const meta = (value) => optional(value["_meta"], isRecord);
 const ROLES = new Set(["user", "assistant"]);
 const annotations = (value) => optional(value, one => isRecord(one) && meta(one)
     && optional(one["audience"], list => Array.isArray(list) && list.every(role => str(role) && ROLES.has(role)))
     && optional(one["priority"], n => typeof n === "number" && Number.isFinite(n))
     && optional(one["lastModified"], str));
-/** One ACP content block, every field the protocol defines for its type checked (text, image, audio, a resource link, an embedded resource). */
 function wellFormedContent(block) {
     if (!isRecord(block) || !str(block["type"]) || !annotations(block["annotations"]) || !meta(block))
         return false;
@@ -195,8 +144,6 @@ function wellFormedContent(block) {
             return str(block["uri"]) && str(block["name"]) && optional(block["mimeType"], str) && optional(block["title"], str)
                 && optional(block["description"], str) && optionalInteger(block, "size", ...INT64);
         case "resource": {
-            // An embedded resource is one of two shapes — text contents or blob contents — beside its uri; a field the
-            // matched shape doesn't define is the agent's own, and isn't read.
             const resource = block["resource"];
             return isRecord(resource) && meta(resource) && str(resource["uri"]) && (str(resource["text"]) || str(resource["blob"]))
                 && optional(resource["mimeType"], str);
@@ -204,7 +151,6 @@ function wellFormedContent(block) {
         default: return false;
     }
 }
-/** A tool call's content: content blocks, diffs, or terminals. */
 function wellFormedToolContent(item) {
     if (!isRecord(item) || !str(item["type"]) || !meta(item))
         return false;
@@ -216,8 +162,6 @@ function wellFormedToolContent(item) {
         return str(item["terminalId"]);
     return false;
 }
-/** The fields a tool call or its update may carry: each, when present, of the type the protocol gives it. */
-/** `initial`: a tool call's first report, whose fields are never null when present; an update's may be (unchanged). */
 function wellFormedToolFields(update, initial = false) {
     if (!meta(update))
         return false;
@@ -236,7 +180,6 @@ function wellFormedToolFields(update, initial = false) {
         return false;
     return true;
 }
-/** A session config option, every field its schema gives (a select's current value and choices, or groups of them). */
 const configChoice = (one) => isRecord(one) && meta(one) && str(one["value"]) && str(one["name"]) && optional(one["description"], str);
 const configGroup = (one) => isRecord(one) && meta(one) && str(one["group"]) && str(one["name"]) && listOf(configChoice)(one["options"]);
 function wellFormedConfigOption(option) {
@@ -253,12 +196,9 @@ const sessionModes = (value) => isRecord(value) && meta(value) && str(value["cur
     && listOf(mode => isRecord(mode) && meta(mode) && str(mode["id"]) && str(mode["name"]) && optional(mode["description"], str))(value["availableModes"]);
 const sessionModels = (value) => isRecord(value) && meta(value) && str(value["currentModelId"])
     && listOf(model => isRecord(model) && meta(model) && str(model["modelId"]) && str(model["name"]) && optional(model["description"], str))(value["availableModels"]);
-/** A field that may be left out but, when present, is never null. */
 const absentOr = (value, is) => value === undefined || is(value);
 const capabilities = (value, flags) => absentOr(value, one => isRecord(one) && meta(one) && flags.every(flag => absentOr(one[flag], bool)));
-/** The session capabilities the schema names (each an optional, nullable object); others are left uninterpreted. */
 const SESSION_CAPABILITIES = ["list", "delete", "additionalDirectories", "resume", "close"];
-/** initialize's answer, every field the schema gives it. */
 function wellFormedInitialize(result) {
     const info = result["agentInfo"];
     if (!meta(result) || !isRecord(info) || !meta(info) || !str(info["name"]) || !str(info["version"]) || !optional(info["title"], str))
@@ -272,11 +212,9 @@ function wellFormedInitialize(result) {
             && SESSION_CAPABILITIES.every(name => optional(sessions[name], entry => isRecord(entry) && meta(entry))))
         && absentOr(caps["auth"], auth => isRecord(auth) && meta(auth) && optional(auth["logout"], logout => isRecord(logout) && meta(logout))));
 }
-/** session/new's answer: the id, and every field of the modes, models and config options it may carry. */
 function wellFormedNewSession(result) {
     return meta(result) && optional(result["configOptions"], wellFormedConfigOptions) && optional(result["modes"], sessionModes) && optional(result["models"], sessionModels);
 }
-/** Whether a known update kind carries what it must; an unknown kind is left alone (not shown, not trusted). */
 function wellFormedUpdate(kind, update) {
     const id = (key) => str(update[key]) && update[key] !== "" && update[key].length <= 256;
     switch (kind) {
@@ -285,7 +223,6 @@ function wellFormedUpdate(kind, update) {
         case "user_message_chunk":
             return wellFormedContent(update["content"]) && optional(update["messageId"], str);
         case "tool_call":
-            // The first report of a call carries its content as a list when it carries any (null is for updates).
             return id("toolCallId") && str(update["title"]) && update["content"] !== null && wellFormedToolFields(update, true);
         case "tool_call_update":
             return id("toolCallId") && wellFormedToolFields(update);
@@ -313,8 +250,6 @@ function wellFormedUpdate(kind, update) {
             return true;
     }
 }
-/** The update kinds passed on to the live view: the ones the plane knows and never declined. Notices and compaction,
- * which this client does not advertise, are validated when sent anyway, and go no further. */
 const KNOWN_UPDATES = new Set(["agent_message_chunk", "agent_thought_chunk", "user_message_chunk", "tool_call", "tool_call_update", "plan",
     "available_commands_update", "current_mode_update", "config_option_update", "session_info_update", "usage_update"]);
 const AUTH_REQUIRED = -32000;
@@ -330,15 +265,10 @@ export function createAcpConversation(options) {
     let mechanism = null;
     let offered = [];
     let nextId = 0;
-    /** Set once the plane asked the prompt to stop: from then on every permission request is answered "cancelled". */
     let cancelled = false;
-    /** Our requests not yet answered, by id. */
     const pending = new Map();
-    /** Ids we have seen answered — a second answer to any of them is a protocol failure. */
     const answered = new Set();
-    /** The words since the last tool call: the agent's last message. */
     let message = "";
-    /** The agent's own accounts of what it used: the prompt answer's `usage`, and the last `usage_update`. Never priced. */
     let promptUsage = null;
     let usageUpdate = null;
     const retained = [];
@@ -356,7 +286,6 @@ export function createAcpConversation(options) {
         pending.set(id, purpose);
         return line({ jsonrpc: "2.0", id, method, params });
     };
-    /** A reply under the request's id, written as its token: an integer exactly (int64, past 2^53 too), a string, or null. */
     const reply = (idToken, outcome) => {
         const body = line({ jsonrpc: "2.0", ...outcome });
         return `{"jsonrpc":"2.0","id":${idToken},${body.slice('{"jsonrpc":"2.0",'.length)}`;
@@ -370,7 +299,6 @@ export function createAcpConversation(options) {
         const errorCode = error === null ? null : typeof error["code"] === "number" ? error["code"] : null;
         if (purpose === "close") {
             closeDone = true;
-            // An error to close is the agent's to have; an answer must be the empty object the schema gives it.
             if (error === null && !(isRecord(result) && meta(result)))
                 return fail("protocol", "session/close was answered with something other than an object");
             return { send: [], live: [] };
@@ -436,8 +364,6 @@ export function createAcpConversation(options) {
             if (offer === null)
                 return fail("model-unavailable", "the agent offers no way to choose a model");
             mechanism = offer.mechanism;
-            // An agent can offer many hundreds (OpenCode lists every model of every provider it knows): kept bounded, and
-            // the model asked for is always among them when offered.
             offered = offer.offered.filter(one => one.length <= 200).slice(0, ACP_OFFERED_CAP);
             if (offer.offered.includes(options.model) && !offered.includes(options.model))
                 offered.push(options.model);
@@ -449,7 +375,6 @@ export function createAcpConversation(options) {
             phase = "model";
             return { send: [request("session/set_config_option", { sessionId: id, configId: "model", value: options.model }, "model")], live: [] };
         }
-        // purpose === "model": the answer must be a well-formed set of config options, showing the model current.
         if (!meta(result) || !wellFormedConfigOptions(result["configOptions"]))
             return fail("model-unavailable", "the model choice was answered with malformed config options");
         const chosen = modelOffer(result);
@@ -485,7 +410,6 @@ export function createAcpConversation(options) {
         }
         return { send: [], live: KNOWN_UPDATES.has(kind) ? [exactField(params, "update")] : [] };
     };
-    /** One line from the agent: what to send back, and what to show. */
     const receiveLine = (raw) => {
         if (raw.length > ACP_LINE_CAP || Buffer.byteLength(raw, "utf8") > ACP_LINE_CAP)
             return fail("protocol", "the agent wrote a line too long to read");
@@ -493,9 +417,6 @@ export function createAcpConversation(options) {
             return { send: [], live: [] };
         let incoming;
         try {
-            // Every number's token is kept beside it: where the client reads an integer (a location's line, a resource's
-            // size, an error's code, a usage count), it is exactly the integer on the wire — 1e3 is 1000, but
-            // 1.0000000000000001 is not 1. Opaque data (raw input and output, metadata) is never read, so never judged.
             incoming = JSON.parse(raw, function (key, value, context) {
                 if (typeof value === "number" && context?.source !== undefined && this !== null && typeof this === "object") {
                     const holder = this;
@@ -511,8 +432,6 @@ export function createAcpConversation(options) {
         }
         if (!isRecord(incoming) || incoming["jsonrpc"] !== "2.0")
             return fail("protocol", "the agent wrote something that is not JSON-RPC 2.0");
-        // The message's own id is read by its token, as an exact integer (4, 4e0 and 4.0 are one id; 1.0000000000000001
-        // is none), so no reply goes out under, and no answer is taken for, an id other than the one on the wire.
         const hasId = Object.prototype.hasOwnProperty.call(incoming, "id");
         const id = incoming["id"];
         let idToken = null;
@@ -533,21 +452,17 @@ export function createAcpConversation(options) {
         const method = incoming["method"];
         if (typeof method === "string") {
             const params = incoming["params"];
-            // Anything that names a session must name ours.
             if (isRecord(params) && params["sessionId"] !== undefined && params["sessionId"] !== sessionId)
                 return fail("protocol", "a message for another session");
             if (!hasId) {
-                // A notification. Only session updates mean anything; the rest are ignored.
                 return method === "session/update" ? onUpdate(params) : { send: [], live: [] };
             }
-            // An id we answer under goes back exactly as sent: an integer, a bounded string, or null.
             if (idToken === null)
                 return fail("protocol", "an agent request with a malformed id");
             if (method === "session/request_permission") {
                 if (!isRecord(params) || sessionId === null || params["sessionId"] !== sessionId)
                     return fail("protocol", "a permission request for another session");
                 const call = params["toolCall"];
-                // The tool call it asks about must be as well formed as one sent in an update, or nothing is granted.
                 const answer = isRecord(call) && typeof call["toolCallId"] === "string" && call["toolCallId"] !== "" && call["toolCallId"].length <= 256 && wellFormedToolFields(call)
                     ? permissionAnswer(params)
                     : null;
@@ -557,8 +472,6 @@ export function createAcpConversation(options) {
                     title: isRecord(call) && typeof call["title"] === "string" ? call["title"] : null,
                     kind: isRecord(call) && typeof call["kind"] === "string" ? call["kind"] : null,
                 };
-                // Granted only while our prompt runs and was not cancelled: before the model is confirmed, after the answer,
-                // or after a cancel, the request is answered "cancelled".
                 if (cancelled || phase !== "prompt") {
                     return { send: [reply(idToken, { result: { outcome: { outcome: "cancelled" } } })], live: [{ ...step, granted: false }] };
                 }
@@ -572,7 +485,6 @@ export function createAcpConversation(options) {
             }
             return { send: [reply(idToken, { error: { code: -32601, message: "this client offers no such method" } })], live: [] };
         }
-        // A response to one of ours.
         if (idNumber === null)
             return fail("protocol", "a response with an id the plane never sent");
         if (answered.has(idNumber))
@@ -602,7 +514,6 @@ export function createAcpConversation(options) {
         receive(raw) {
             if (phase === "failed")
                 return { send: [], live: [] };
-            // Nothing the agent writes may throw out of the client: whatever does is the agent's protocol failure.
             try {
                 return receiveLine(raw);
             }
@@ -635,14 +546,12 @@ export function createAcpConversation(options) {
         mechanism: () => mechanism,
         offered: () => offered.slice(),
         retained: () => {
-            // The agent's own usage accounts ride every outcome — a failure spent too.
             const usage = promptUsage === null && usageUpdate === null ? [] : [line({ type: "acp.reported", usage: bounded(JSON.stringify({ prompt: promptUsage, update: usageUpdate }), USAGE_CAP) })];
             const all = [...retained, ...usage];
             return all.length === 0 ? "" : `${all.join("\n")}\n`;
         },
     };
 }
-/** Read a conversation's retained record. Lines not typed `acp.*` are ignored. */
 export function acpParse(stdout) {
     let agentSeen = false;
     let sessionId = null;

package/dist/acp-inspect.js

@@ -1,22 +1,8 @@
-/**
- * What can be known about an ACP agent's binary without running it
- * (docs/plans/acp-adapter.md § Identity): nothing outside the one spawning
- * gateway executes an ACP agent — not readiness, not the providers screen,
- * not a version probe. So readiness and the screens look, and never run:
- * PATH lookup, realpath, lstat, and for a script launcher a bounded read of
- * the nearest package.json for its name and version.
- *
- * None of this is evidence an agent may run. That is its conformance check
- * (attestation), which this only helps describe.
- */
 import { closeSync, constants, fstatSync, lstatSync, openSync, readSync, realpathSync, statSync } from "node:fs";
 import { delimiter, dirname, isAbsolute, join } from "node:path";
 import { ACP_AGENTS } from "./acp-agents.js";
-/** The most bytes read from a launcher (its first line) or a package.json. */
 const READ_CAP = 64 * 1024;
-/** How many folders up from the launcher a package.json is looked for. */
 const PACKAGE_DEPTH = 6;
-/** Read at most `cap` bytes from the start of a regular file, without following a final symlink. */
 function readHead(file, cap) {
     let fd = null;
     try {
@@ -39,14 +25,12 @@ function kindOf(head) {
     if (head === null || head.length < 4)
         return "unknown";
     if (head[0] === 0x23 && head[1] === 0x21)
-        return "script"; // "#!"
+        return "script";
     const magic = head.readUInt32BE(0);
-    // ELF, Mach-O (both byte orders, 32/64-bit) and fat binaries.
     if (magic === 0x7f454c46 || [0xfeedface, 0xfeedfacf, 0xcefaedfe, 0xcffaedfe, 0xcafebabe, 0xbebafeca].includes(magic))
         return "native";
     return "unknown";
 }
-/** The nearest package.json above a script, by bounded read; its name and plain version, or null. */
 function packageOf(realpath) {
     let folder = dirname(realpath);
     for (let depth = 0; depth < PACKAGE_DEPTH; depth += 1) {
@@ -60,7 +44,6 @@ function packageOf(realpath) {
                     return { name, version };
             }
             catch {
-                // A package.json past the cap or not JSON says nothing.
             }
             return null;
         }
@@ -71,7 +54,6 @@ function packageOf(realpath) {
     }
     return null;
 }
-/** Find an agent's binary on PATH, and describe it without running it. */
 export function inspectAcpAgent(provider, env = process.env) {
     const binary = ACP_AGENTS[provider].binary;
     for (const folder of (env["PATH"] ?? "").split(delimiter)) {
@@ -100,7 +82,6 @@ export function inspectAcpAgent(provider, env = process.env) {
     }
     return { found: false, binary };
 }
-/** The words a screen says for an inspection: "installed at …, version …" or "not installed". */
 export function inspectionWords(inspection) {
     if (!inspection.found)
         return `\`${inspection.binary}\` is not installed on this computer's PATH`;

package/dist/action-ledger.js

@@ -1,7 +1,4 @@
-/** v99: sign-ins (and refusals, lockouts, sign-outs) and policy changes are their own kinds of event.
- * v110: commands a person ran on this server with their API token, from the CLI ('api') or their agent ('mcp'). */
 export const LEDGER_SOURCES = ["work", "request", "access", "sign-in", "policy", "api", "mcp"];
-/** The table as v99 made it (v107 has it): the one earlier shape the v110 rebuild accepts. */
 export const LEDGER_V99_TABLE = (name) => `CREATE TABLE ${name} (
   id INTEGER PRIMARY KEY AUTOINCREMENT,
   at TEXT NOT NULL, actor TEXT NOT NULL, repo TEXT,
@@ -28,16 +25,11 @@ BEGIN SELECT RAISE(ABORT, 'action history is append-only'); END;
 CREATE TRIGGER IF NOT EXISTS action_ledger_no_delete BEFORE DELETE ON action_ledger
 BEGIN SELECT RAISE(ABORT, 'action history is append-only'); END;
 `;
-/** Installed after all table migrations. Work events commit with the work,
- * including CLI and unattended workers; no prompts, tool arguments, tokens,
- * decision text, or transcript content are copied into the ledger. */
 export function installLedgerTriggers(db) {
     const repo = (ref) => `(SELECT repo FROM task_ref WHERE id = ${ref})`;
     const task = (ref) => `(SELECT external_id FROM task_ref WHERE id = ${ref})`;
     const runRef = `(SELECT task_ref FROM run WHERE id = NEW.run)`;
     const event = (at, actor, project, taskId, runId, action, outcome) => `INSERT INTO action_ledger(at,actor,repo,task_id,run_id,action,outcome,source) VALUES (${at},${actor},${project},${taskId},${runId},'${action}',${outcome},'work');`;
-    // v119: closing a question without an answer is its own event. Replace only the old trigger's future behavior;
-    // every ledger entry already recorded, and its seal, stays unchanged.
     const answeredTrigger = db.prepare("SELECT sql FROM sqlite_master WHERE type = 'trigger' AND name = 'ledger_decision_answered'").get();
     if (answeredTrigger !== undefined && !String(answeredTrigger["sql"]).includes("superseded_reason"))
         db.exec("DROP TRIGGER ledger_decision_answered");

package/dist/activity-line.js

@@ -1,15 +1,4 @@
-/**
- * What a running agent did last, in one line (live tasks): "Ran a command ·
- * 40 s ago". Pure and shared: the server sends the facts, and each page words
- * them against its own clock, so the age keeps counting between reads.
- *
- * After five minutes with no word the line says when it last heard, in the
- * same quiet secondary text (a quiet agent isn't something a person must do;
- * the needs-you mark is for what needs you). A worker whose heartbeat stopped says that
- * instead, and that one is marked: the builder going away needs a person.
- */
 export const QUIET_AFTER_MS = 5 * 60_000;
-/** The words for each fixed activity kind (live.ts's vocabulary) and for a progress checkpoint. */
 export const ACTIVITY_WORDS = {
     session: "Started work",
     message: "Wrote an update",
@@ -24,7 +13,6 @@ export const ACTIVITY_WORDS = {
     progress: "Reported progress",
     started: "Started",
 };
-/** "just now", "40 s ago", "3 min ago", "2 h ago". */
 export function agoWords(ms) {
     const seconds = Math.max(0, Math.floor(ms / 1000));
     if (seconds < 10)
@@ -36,8 +24,6 @@ export function agoWords(ms) {
         return `${minutes} min ago`;
     return `${Math.floor(minutes / 60)} h ago`;
 }
-/** The line itself. `quiet` (marked): the worker is offline, which needs a person. `stale`: silent five minutes or
- * more, said in the same neutral words as any other update. */
 export function activityLine(activity, now) {
     const at = Date.parse(activity.at);
     const since = Number.isNaN(at) ? 0 : Math.max(0, now - at);

package/dist/actor.js

@@ -1,31 +1,16 @@
-/**
- * Who is acting right now, for pings that follow responsibility.
- *
- * A lead is an agent acting for one person under a lead token (`toolroll lead
- * token`, a `credential` row of kind 'lead', api-tokens.ts): it signs in as that person, and its acts are recorded as "lead for
- * <owner>". A person acting for themselves is recorded by name. Work whose
- * actor is the lead pings nobody, and nobody is pinged about their own act.
- *
- * The actor is held for one command or one console request, never for a
- * long-running service: a worker's facts are nobody's act.
- */
 import { AsyncLocalStorage } from "node:async_hooks";
-/** The slot is mutable so a command can name its person after it has verified their password. */
 const slot = new AsyncLocalStorage();
-/** Run `fn` with this actor (or an empty slot a verified sign-in may fill). */
 export function withActor(actor, fn) {
     return slot.run({ actor }, fn);
 }
 export function currentActor() {
     return slot.getStore()?.actor ?? null;
 }
-/** A person verified their password inside this command: their acts are now theirs. A lead keeps its own label. */
 export function claimActor(account) {
     const held = slot.getStore();
     if (held !== undefined && held.actor === null)
         held.actor = { account, lead: false };
 }
-/** How the ledger names an actor. */
 export function actorLabel(actor) {
     return actor.lead ? `lead for ${actor.account}` : actor.account;
 }

package/dist/advanced-schema.js

@@ -0,0 +1,12 @@
+export const V160_SCHEMA = `
+CREATE TABLE IF NOT EXISTS view_preference (
+  account    TEXT PRIMARY KEY,
+  advanced   INTEGER NOT NULL CHECK (advanced IN (0, 1)),
+  source     TEXT NOT NULL CHECK (source IN ('upgrade', 'person')),
+  updated_at TEXT
+);
+`;
+export const V160_BACKFILL = `INSERT OR IGNORE INTO view_preference (account, advanced, source, updated_at)
+  SELECT name, 1, 'upgrade', NULL FROM approver WHERE revoked_at IS NULL`;
+export const V160_TABLES = Object.freeze(["view_preference"]);
+export const V160_STEPS = Object.freeze(["advanced-preference"]);

package/dist/advanced-view.js

@@ -0,0 +1,26 @@
+let shownNow = () => true;
+export function provideAdvancedShown(source) { shownNow = source; }
+export function advancedShownNow() {
+    try {
+        return shownNow();
+    }
+    catch {
+        return true;
+    }
+}
+export const ADVANCED_PAGES = Object.freeze([
+    { title: "Flows", href: "/flows", words: "Work that starts on a schedule, a webhook or a form" },
+    { title: "Agents", href: "/agents", words: "Every agent at work now, and the computers that build" },
+    { title: "Spend", href: "/spend", words: "What agent work cost, and monthly limits", operator: true },
+    { title: "Subagents", href: "/settings/lead/subagents", words: "Helpers the lead looks after" },
+    { title: "Skills", href: "/settings/skills", words: "Reusable instructions for agents" },
+    { title: "Learning", href: "/settings/learning", words: "Lessons kept from finished work" },
+    { title: "Operating mode", href: "/mode", words: "Let a project run for a while without asking" },
+    { title: "Policy", href: "/settings/policy", words: "Limits no task can go past" },
+    { title: "Release approval", href: "/settings/approval#release-approval", words: "Approve releases automatically when checks pass" },
+    { title: "Sign-in with a provider", href: "/settings/sign-in", words: "Let people sign in with your identity provider", operator: true },
+    { title: "Passwordless", href: "/settings/passwordless", words: "Sign in once; most approvals then need no password", operator: true },
+    { title: "Monitoring", href: "/settings/monitoring", words: "Send the audit stream and traces to your own systems", operator: true },
+    { title: "Builders", href: "/fleet", words: "Every computer that builds" },
+    { title: "For each project", href: "/settings/projects", words: "Fallback agents, live view commands, code map and flaky tests, on each project’s page" },
+]);

package/dist/advanced.js

@@ -0,0 +1,61 @@
+import { currentLocalOwner, localOwnerInFlight, localOwnerStandsNow } from "./local-owner.js";
+import { isOpen, policyParts, readPolicy } from "./policy.js";
+import { machineActing } from "./scope.js";
+import { advancedPreferenceOf, writeAdvancedPreference } from "./store.js";
+export function advancedShownFor(store, account) {
+    try {
+        const own = account === null ? null : advancedPreferenceOf(store, account);
+        return own ?? store.isDemo();
+    }
+    catch {
+        return true;
+    }
+}
+const LAPSED = "Your sign-in changed. Sign in again, then change this.";
+export function setAdvancedPreference(store, door, on, now) {
+    try {
+        return proveAndWrite(store, door, on, now);
+    }
+    catch (error) {
+        return { ok: false, problem: error instanceof Error ? error.message : LAPSED };
+    }
+}
+function proveAndWrite(store, door, on, now) {
+    return store.transact(() => {
+        if (machineActing() || process.env["TOOLROLL_LEAD_TOKEN"] !== undefined)
+            return { ok: false, problem: LAPSED };
+        const local = currentLocalOwner();
+        if (door.kind === "local-owner") {
+            if (local === null || !localOwnerInFlight(local) || local.act !== "view-preference" || local.account !== door.actor || !localOwnerStandsNow(store, local))
+                return { ok: false, problem: LAPSED };
+        }
+        else {
+            if (local !== null)
+                return { ok: false, problem: LAPSED };
+            const account = store.accountOf(door.actor);
+            if (account === null || account.revokedAt !== null || account.generation !== door.generation || !door.live())
+                return { ok: false, problem: LAPSED };
+        }
+        if (!writeAdvancedPreference(store, door.actor, on, now))
+            return { ok: false, problem: LAPSED };
+        store.recordAction({ at: now.toISOString(), actor: door.actor, repo: null, taskId: null, runId: null, action: "advanced features", outcome: on ? "shown" : "hidden", source: "request", detail: door.kind === "local-owner" ? "local owner" : "browser" });
+        return { ok: true, on };
+    });
+}
+export function policyInForce(store) {
+    const unsure = "Limits apply: open Policy to see them";
+    try {
+        const row = store.handle.prepare("SELECT providers_json, models_json, tools_json, ceiling FROM org_policy WHERE id = 1").get();
+        if (row === undefined)
+            return null;
+        const policy = readPolicy(store.handle);
+        const raw = row["providers_json"] !== null || row["models_json"] !== null || row["tools_json"] !== null || row["ceiling"] !== "escalated";
+        if (isOpen(policy))
+            return raw ? unsure : null;
+        const parts = policyParts(policy);
+        return `Providers: ${parts.providers} · models: ${parts.models} · tools: ${parts.tools} · ceiling: ${parts.ceiling}`;
+    }
+    catch {
+        return unsure;
+    }
+}