toolroll 0.9.104 → 0.9.105

package/dist/lead-identity.js

@@ -2,7 +2,6 @@ export const DEFAULT_LEAD_NAME = "Lead";
 export const DEFAULT_LEAD_PERSONA = "Be genuinely helpful, not performative. Have opinions and say which you'd pick. Check before you claim. Be resourceful before asking. Keep it short.";
 export const LEAD_NAME_MAX = 40;
 export const LEAD_PERSONA_MAX = 600;
-/** This person's lead: their saved name and persona, else the defaults. An older store reads as the defaults. */
 export function leadIdentityOf(store, account) {
     if (account == null || account === "")
         return { name: DEFAULT_LEAD_NAME, persona: DEFAULT_LEAD_PERSONA };
@@ -11,14 +10,12 @@ export function leadIdentityOf(store, account) {
         if (saved !== null)
             return { name: saved.name || DEFAULT_LEAD_NAME, persona: saved.persona || DEFAULT_LEAD_PERSONA };
     }
-    catch { /* no lead_config yet: the defaults */ }
+    catch { }
     return { name: DEFAULT_LEAD_NAME, persona: DEFAULT_LEAD_PERSONA };
 }
-/** The name alone, for the places the lead speaks. */
 export function leadNameOf(store, account) {
     return leadIdentityOf(store, account).name;
 }
-/** The saved form of a name and persona, or the problem with them. An empty name or persona means the default. */
 export function checkLeadIdentity(name, persona) {
     const named = name.trim().replace(/\s+/g, " "), described = persona.trim().replace(/\r\n?/g, "\n");
     if (named.length > LEAD_NAME_MAX)

package/dist/lead-latency-schema.js

@@ -1,15 +1,3 @@
-/**
- * v158: the lead's latency records and its quick-answer switch (docs/plans/responsive-chat.md, slice 5). Adds only:
- * a saved row reads as it did. Kept beside nothing else so the update road can read the lists without the store.
- *
- * - `chat_turn.tools`: the tool names one lead step asked for, as a JSON array of names (never arguments); saved rows
- *   read NULL (not recorded). So the next latency decision (a prefetched brief, §7.2) is made from data.
- * - `chat_turn.failure_detail` and `mate_turn.failure_detail`: why a step or reply failed, more exactly than
- *   failure_reason (LEAD_FAILURE_DETAILS); saved rows read NULL (unknown), and read the plain reason's words as before.
- * - `mate_turn.route`: which model answered (§8): `default`, `fast` (the quick model answered) or `escalated` (a quick
- *   step asked for more than reading, so the main model took the reply over); saved rows read NULL (before routing).
- * - `lead_quick_setting`: Settings → Lead's "Quick answers use a faster model", one row; absent reads off.
- */
 export const LEAD_FAILURE_DETAILS = ["not-installed", "sign-in", "refused", "lost", "timeout-silent", "timeout-output"];
 export const LEAD_ROUTES = ["default", "fast", "escalated"];
 const detailCheck = (column) => `TEXT CHECK (${column} IS NULL OR ${column} IN (${LEAD_FAILURE_DETAILS.map(one => `'${one}'`).join(",")}))`;
@@ -32,5 +20,4 @@ export const V158_ADDED_COLUMNS = Object.freeze({
     },
 });
 export const V158_TABLES = Object.freeze(["lead_quick_setting"]);
-/** The v158 migration's steps, in order (a test seam may stop after each). */
 export const V158_STEPS = Object.freeze(["lead-quick-setting", "lead-latency-columns"]);

package/dist/lead-people.js

@@ -1,19 +1,11 @@
-/** Who the lead works with: the people on this installation who share a project with its owner, the subagents in
- * those projects, and the team chats the owner is in. The bundle carries one line each (lead-context.ts); get_person
- * reads one in full, with their open work. Ids stay the same from turn to turn however the list changes: p and c plus a
- * short digest of the account or team chat, t plus the subagent's number. In a team chat the lead speaks for the room,
- * so only that room and its members are listed. Only the owner's own projects are listed, by their r1.. ids; first
- * names are shown on purpose, everything else is scrubbed by the caller. */
 import { createHash } from "node:crypto";
 import { firstNameOf } from "./lead-context.js";
 import { labelOf, nameOf, zonesOf } from "./subagent-admin.js";
 import { parseSoul } from "./subagents.js";
 import { deskOf } from "./subagent-desk.js";
 const OPEN_TASK = new Set(["queued", "running", "failed"]);
-/** get_person's id shapes. */
 export const PERSON_ID = /^(p[0-9a-f]{8}|t[0-9]{1,9}|c[0-9a-f]{8})$/;
 const stableId = (prefix, key) => `${prefix}${createHash("sha256").update(key).digest("hex").slice(0, 8)}`;
-/** The team chat this conversation is, or null when it is the person's own chat with their lead. */
 export function teamRoomOf(store, thread) {
     if (thread === undefined)
         return null;
@@ -23,10 +15,9 @@ export function teamRoomOf(store, thread) {
     }
     catch {
         return null;
-    } // an older store has no team chats
+    }
 }
 const line = (text, max) => { const flat = text.replace(/\s+/g, " ").trim(); return flat.length > max ? `${flat.slice(0, max - 1)}…` : flat; };
-/** Everyone the owner's lead works with, in order; in a team chat (`room`), only that room and its members. */
 export function peopleIndexOf(store, owner, repos, room = null) {
     const label = (repo) => { const index = repos.indexOf(repo); return index === -1 ? null : `r${index + 1}`; };
     const named = (list) => list.map(label).filter((one) => one !== null);
@@ -37,9 +28,7 @@ export function peopleIndexOf(store, owner, repos, room = null) {
         .filter(({ shared }) => shared.length > 0)
         .map(({ one, shared }) => ({ id: stableId("p", one.name), account: one.name, name: firstNameOf(one.name) || one.name,
         role: one.role === "approver" ? "approves work" : "watches work",
-        // No person has a written profile yet; the field is there for when one does.
         projects: named(shared), profile: null }));
-    // subagents are not members of a team chat.
     const subagents = room !== null ? [] : store.subagents(repos).map(mate => {
         const soul = parseSoul(mate.soul);
         return { id: `t${mate.id}`, mate, name: nameOf(mate), role: soul.ok ? soul.soul.role : labelOf(mate), project: label(mate.repo) ?? "" };
@@ -59,15 +48,14 @@ export function peopleIndexOf(store, owner, repos, room = null) {
                 if (Array.isArray(listed))
                     projects = named(listed.map(String));
             }
-            catch { /* none named */ }
+            catch { }
             const purpose = String(row["instructions"] ?? "").split("\n").map(one => one.trim()).find(one => one !== "") ?? "";
             return { id: stableId("c", String(row["id"])), conversation: String(row["id"]), name: String(row["title"]), members, purpose: purpose || String(row["lead"]), projects };
         });
     }
-    catch { /* an older store has no team chats */ }
+    catch { }
     return { people, subagents, teams };
 }
-/** One line each, as the bundle carries them. Free text goes through `redact`; names and project ids do not. */
 export function peopleLines(index, redact) {
     return {
         people: index.people.map(one => `${one.id} ${one.name}: ${one.role}; ${one.projects.join(", ")}${one.profile === null ? "" : `; ${line(redact(one.profile), 120)}`}`),
@@ -75,7 +63,6 @@ export function peopleLines(index, redact) {
         teams: index.teams.map(one => `${one.id} ${line(redact(one.name), 60)}: ${one.members.join(", ")}; ${line(redact(one.purpose), 120)}`),
     };
 }
-/** The work still open for one person: tasks last filed, approved or handed to them in the owner's projects, and flow cards they own. */
 function openWorkOf(store, account, repos) {
     const repoId = (repo) => `r${repos.indexOf(repo) + 1}`;
     const tasks = repos.length === 0 ? [] : store.handle.prepare(`SELECT r.external_id AS task, r.repo FROM task_ref r JOIN task_act a ON a.id = (SELECT MAX(id) FROM task_act WHERE task_ref = r.id AND act IN ('filed', 'approved', 'asked'))
@@ -85,8 +72,6 @@ function openWorkOf(store, account, repos) {
     const cards = repos.flatMap(repo => store.activeFlowCards(repo).filter(card => card.owner === account).map(card => ({ card: card.id, flow: card.flow, title: card.title, zone: card.stage, repo: repoId(repo) }))).slice(0, 10);
     return { tasks, cards };
 }
-/** One entry in full by its id (p3fa91c2e, t5, c07b1d9a4) or by name; the candidates when a name fits several, null when
- * none. In a team chat (`room`), only that room and its members. */
 export function personEntry(store, owner, repos, ask, room = null) {
     const index = peopleIndexOf(store, owner, repos, room);
     const wanted = ask.name?.trim().toLowerCase() ?? "";

package/dist/lead-progress.js

@@ -1,8 +1,4 @@
-/** Live progress of one lead turn (chat streaming): what the lead is doing
- * and the reply as it is written. Nothing here is durable or authoritative —
- * the finished turn's saved message and cards remain the record. */
 import { topLevelEvent } from "./stream-scope.js";
-/** Plain words for each tool the lead uses, as the person watching reads them. */
 const TOOL_LABELS = {
     get_brief: "Catching up on your work",
     get_project_context: "Reading the project",
@@ -50,8 +46,6 @@ export function leadToolLabel(name) {
         return TOOL_LABELS[name];
     return name.startsWith("propose_") ? "Preparing a card for you to confirm" : "Working on it";
 }
-/** Tool errors instruct the model how to retry. Only known, fixed copy belongs
- * in the live UI; never echo arguments, redaction placeholders or exceptions. */
 const TOOL_FAILURE_REASONS = new Map([
     ["Choose a project from list_repos.", "That project isn't available."],
     ["Choose an available project from list_repos.", "That project isn't available."],
@@ -74,9 +68,6 @@ const TOOL_FAILURE_REASONS = new Map([
 export function leadToolFailureReason(name, message) {
     return TOOL_FAILURE_REASONS.get(message) ?? `That step didn't work (${leadToolLabel(name)}).`;
 }
-/** The `text` of a structured answer still being written, when the answer
- * opens with it (`{"text": "…`); null until then. Escapes are decoded, and
- * an escape cut off at the end is left for the next chunk. */
 export function partialAnswerText(partial) {
     const opening = /^\s*\{\s*"text"\s*:\s*"/.exec(partial);
     if (opening === null)
@@ -109,8 +100,6 @@ export function partialAnswerText(partial) {
     }
     return out;
 }
-/** A reader for `claude -p --output-format stream-json --include-partial-messages`:
- * follows the structured-output block and reports its text as it grows. */
 export function claudeStreamReader(onText, capBytes = 1_048_576) {
     let pending = "";
     let json = "";
@@ -133,7 +122,6 @@ export function claudeStreamReader(onText, capBytes = 1_048_576) {
             catch {
                 continue;
             }
-            // A subagent's frames (parent_tool_use_id set) are not the lead's reply: they never start, feed or end it.
             if (!record(event) || !topLevelEvent(event) || event["type"] !== "stream_event" || !record(event["event"]))
                 continue;
             const inner = event["event"];

package/dist/lead-queue-runtime.js

@@ -1,10 +1,3 @@
-/**
- * Runs the personal lead queue (docs/plans/lead-message-queue.md): one message per turn, in order, through the engine's
- * own admission. Each claim is re-proved from its row — the person's standing at the generation it was sent under, the
- * session it was sent under (never a newer one), the project set it was sent under, its task and result still there —
- * and re-checked before every model step. A refusal before admission waits with its words and wakes when what refused
- * it changes; anything after admission is settled from the turn's own record and never sent again.
- */
 import { AsyncResource } from "node:async_hooks";
 import { createHash, randomUUID } from "node:crypto";
 import { runLeadTurn } from "./lead.js";
@@ -12,8 +5,6 @@ import { PersonalQueue } from "./lead-queue.js";
 import { verifyApproverStanding } from "./principal.js";
 import { updateAdmissionPaused } from "./desktop-update-gate.js";
 import { TURN_WALL_CLOCK_MS } from "./converse.js";
-/** The context a lead turn is given for what the person was looking at: the same words for a message sent now and one
- * that waited. Null when the message was sent from the lead's own chat. */
 export function leadTurnContext(store, context, names) {
     if (context === null)
         return undefined;
@@ -27,24 +18,16 @@ export function leadTurnContext(store, context, names) {
         return `Current project: ${names.project(context.project)} (${context.project}). Keep this conversation about that project unless the operator explicitly asks to broaden it; use it as the repo for project tools.`;
     return undefined;
 }
-/** Refusals before admission that wait (with their words) rather than end the message: what wakes each one is in its
- * stamp (a turn ends, the day or week or month rolls, the cost is confirmed, a budget is raised). */
 const WAITS = new Set(["concurrent", "backlog", "daily-cap", "over-budget", "monthly-budget", "latched"]);
 const UPDATE_WAIT = "Waiting: Toolroll is updating. It runs once the update is done.";
 export function createPersonalQueueRuntime(options) {
     const { store } = options, clock = options.clock ?? (() => new Date());
     const queue = new PersonalQueue(store);
     const runner = `personal:${process.pid}:${randomUUID()}`;
-    /** A deferred message's admission stamp: it is not tried again until something that refused it changes. */
     const waiting = new Map();
     let timer = null, closed = false, passing = false;
-    /** The server's own async context, captured at start (no request in it). A wake from inside a browser request runs
-     * its pass from here, so no request's session facts (its actor, form token or Passwordless session) ever reach a
-     * queued turn — the queue re-proves each message's person itself. */
     let detached = null;
     const active = new Set();
-    /** What openLeadTurn checks for this person, and the chat configuration (its caps and budget), with a minute bucket
-     * as the belt for what is not named here (weekly and monthly spend roll over within it): a change wakes a waiting message. */
     function stamp(row) {
         const now = clock();
         const live = store.handle.prepare("SELECT id, state FROM mate_turn WHERE approver = ? AND state IN ('queued','running') ORDER BY id").all(row.approver);
@@ -54,7 +37,6 @@ export function createPersonalQueueRuntime(options) {
         return createHash("sha256").update(JSON.stringify([live, liveChat, store.chatTurnsToday(row.approver, now), session?.spentMicrousd ?? null,
             session?.ceilingMicrousd ?? null, latched?.["n"] ?? 0, updateAdmissionPaused(store.raw()), options.provider()?.config ?? null, Math.floor(now.getTime() / 60_000)])).digest("hex");
     }
-    /** The person as the row was sent: same generation, same session (live, theirs), same projects. Null: it can't run. */
     function standing(row) {
         const session = store.getLeadSession(row.session);
         if (session === null || session.endedAt !== null || session.approver !== row.approver)
@@ -87,7 +69,6 @@ export function createPersonalQueueRuntime(options) {
                     waiting.set(claim.message, stamp(claim));
                 return;
             }
-            // An update is being installed (or the console is stopping): the message waits for the next start, words kept.
             const holding = () => closed || updateAdmissionPaused(store.raw());
             if (holding()) {
                 if (queue.defer(claim, UPDATE_WAIT))
@@ -100,8 +81,6 @@ export function createPersonalQueueRuntime(options) {
             outcome = await runLeadTurn({
                 store, who: proof.who, session, thread, config: provider.config, key: provider.key, message: claim.text, requestId: claim.requestId,
                 queuedMessageId: claim.message, queueClaim: { message: claim.message, runner: claim.runner, generation: claim.generation },
-                // The live reply display starts only once this message holds the turn: a refused attempt never blanks the display
-                // of a turn that is still running in the same conversation.
                 onAdmitted: turn => {
                     if (!queue.bindTurn(claim, turn))
                         throw new Error("The queued message changed before admission.");
@@ -109,7 +88,6 @@ export function createPersonalQueueRuntime(options) {
                 },
                 ...(context === undefined ? {} : { context }), channel: "console", clock, evidenceRoot: options.evidenceRoot,
                 ...(options.live === undefined ? {} : { onProgress: (event) => progress?.(event) }),
-                // Before every step: still this claim, still this person at this generation and session, still the same projects.
                 revalidate: async () => {
                     if (holding()) {
                         held = true;
@@ -125,7 +103,6 @@ export function createPersonalQueueRuntime(options) {
                 return;
             }
             if ("refused" in outcome) {
-                // Refused before admission because an update paused it: that is a wait too (the words stay; the pause ending wakes it).
                 if (outcome.refused === "channel" && held) {
                     if (queue.defer(claim, UPDATE_WAIT))
                         waiting.set(claim.message, stamp(claim));
@@ -138,7 +115,6 @@ export function createPersonalQueueRuntime(options) {
                     queue.finish(claim, { status: "failed", error: `Not sent: ${outcome.message}` }, clock());
                 return;
             }
-            // After admission: settled from the turn's record; an unknown outcome is never sent again.
             queue.finish(claim, { status: "unknownSpend" in outcome && outcome.unknownSpend ? "uncertain" : "failed", error: outcome.message, ...("turn" in outcome ? { turnId: outcome.turn } : {}) }, clock());
         }
         catch {
@@ -171,8 +147,6 @@ export function createPersonalQueueRuntime(options) {
     }
     return {
         queue,
-        /** Look now (a turn just ended, a message was just queued): the next message of each person may start. Safe to call
-         * from a request: the pass runs in the server's own context, never the caller's. Before start, the timer will look. */
         kick() {
             const scope = detached;
             if (scope === null || closed)

package/dist/lead-queue.js

@@ -1,18 +1,7 @@
-/**
- * The personal lead queue (docs/plans/lead-message-queue.md): a message sent while one of its author's personal lead
- * turns runs (or while earlier ones wait) waits here and runs one turn per message, in order — the same machinery
- * shared team conversations use (team-leads.ts), for the person's own threads (/chat, a task's or a project's chat).
- *
- * The row's words are its lead_message (pending until the engine's admission binds it, which clears pending in the
- * same statement). Admission itself is the engine's (runLeadTurn with queuedMessageId + onAdmitted): this module only
- * decides queue-or-run at send, claims the backlog's oldest row, binds, finishes, defers, removes and expires.
- */
 import { createHash } from "node:crypto";
-/** At most this many messages wait per person, and this many characters in all; a waiting message expires after 7 days. */
 export const LEAD_QUEUE_MAX_MESSAGES = 10;
 export const LEAD_QUEUE_MAX_CHARS = 20_000;
 export const LEAD_QUEUE_EXPIRY_MS = 7 * 86_400_000;
-/** The identity of a send: the same request with the same words and context is the same message. */
 export function leadQueuePayloadHash(thread, text, context) {
     return createHash("sha256").update(JSON.stringify([thread, text, context === null ? null : canonical(context)])).digest("hex");
 }
@@ -32,11 +21,9 @@ export class PersonalQueue {
         this.store = store;
     }
     get db() { return this.store.handle; }
-    /** The approver's backlog: rows waiting or claimed but not yet bound to a turn, oldest first. */
     backlog(approver) {
         return this.db.prepare(`${SELECT} WHERE q.approver = ? AND (q.status = 'queued' OR (q.status = 'running' AND q.turn_id IS NULL)) ORDER BY q.message`).all(approver).map(readRow);
     }
-    /** Every queue row of a thread (what the thread shows next to its messages). */
     forThread(thread) {
         return this.db.prepare(`${SELECT} WHERE q.thread = ? ORDER BY q.message`).all(thread).map(readRow);
     }
@@ -44,12 +31,6 @@ export class PersonalQueue {
         const row = this.db.prepare(`${SELECT} WHERE q.message = ?`).get(message);
         return row === undefined ? null : readRow(row);
     }
-    /**
-     * Send: run now, or wait — in ONE transaction, so a turn ending between the check and the insert can't strand a
-     * message. A request already saved with the same words and context is that message (never a second send, never a
-     * removed one resurrected); with different ones it conflicts. Busy means a personal lead turn of this person is
-     * queued or running, or something of theirs already waits.
-     */
     sendOrQueue(input, now) {
         return this.store.transact(() => {
             const hash = leadQueuePayloadHash(input.thread, input.text, input.context);
@@ -72,14 +53,8 @@ export class PersonalQueue {
             return { kind: "queued", row: this.get(message), already: false };
         });
     }
-    /**
-     * The next message to run: per person, only the oldest of their backlog, only while none of theirs runs, and only when
-     * `eligible` agrees (the runtime's admission stamp). Claiming keeps it in the backlog until its turn binds it.
-     */
     claimNext(runner, now, eligible = () => true) {
         return this.store.transact(() => {
-            // An uncertain row does not hold the person's later messages (unlike a team room): its outcome is shown on it, and
-            // an unknown cost already pauses chat through its own latch.
             const heads = this.db.prepare(`${SELECT} WHERE q.status = 'queued'
         AND NOT EXISTS (SELECT 1 FROM lead_queue r WHERE r.approver = q.approver AND r.status = 'running')
         AND NOT EXISTS (SELECT 1 FROM lead_queue e WHERE e.approver = q.approver AND e.status = 'queued' AND e.message < q.message)
@@ -96,12 +71,10 @@ export class PersonalQueue {
             return null;
         });
     }
-    /** The claim still stands: running, this runner, this generation and revision, unbound or bound to `turn`. */
     current(claim) {
         return this.db.prepare("SELECT 1 FROM lead_queue WHERE message = ? AND status = 'running' AND runner = ? AND generation = ? AND revision = ?")
             .get(claim.message, claim.runner, claim.generation, claim.revision) !== undefined;
     }
-    /** Inside the engine's admission transaction (onAdmitted): the claim binds to the turn that took it, exactly once. */
     bindTurn(claim, turnId) {
         if (!this.current(claim))
             return false;
@@ -111,8 +84,6 @@ export class PersonalQueue {
         return Number(this.db.prepare("UPDATE lead_queue SET turn_id = ? WHERE message = ? AND turn_id IS NULL AND status = 'running' AND generation = ?")
             .run(turnId, claim.message, claim.generation).changes) === 1;
     }
-    /** The claim ends: answered (its turn's reply is in the thread), failed or cancelled (words kept as the error), or
-     * uncertain (an outcome that can't be confirmed — never sent again). A message that never got a turn loses its words. */
     finish(claim, result, now) {
         return this.store.transact(() => {
             const row = this.db.prepare("SELECT turn_id FROM lead_queue WHERE message = ? AND status = 'running' AND runner = ? AND generation = ?").get(claim.message, claim.runner, claim.generation);
@@ -127,12 +98,10 @@ export class PersonalQueue {
             return true;
         });
     }
-    /** A refusal before admission (a cap, a budget, a latch, another turn): back to waiting with the words to show. */
     defer(claim, error) {
         return Number(this.db.prepare(`UPDATE lead_queue SET status = 'queued', generation = generation + 1, revision = revision + 1, runner = NULL, claimed_at = NULL, error = ?
       WHERE message = ? AND status = 'running' AND turn_id IS NULL AND runner = ? AND generation = ?`).run(error, claim.message, claim.runner, claim.generation).changes) === 1;
     }
-    /** Remove a waiting message (its author only, while it still waits): its words are forgotten, its request kept. */
     remove(approver, message, now) {
         return this.store.transact(() => {
             const row = this.db.prepare("SELECT status FROM lead_queue WHERE message = ? AND approver = ?").get(message, approver);
@@ -145,8 +114,6 @@ export class PersonalQueue {
             return "removed";
         });
     }
-    /** Settle rows whose bound turn ended (by its recorded state), expire week-old waiting rows, and mark a claim that
-     * never bound by its turn deadline uncertain (the binding is the proof; elapsed time never resends). */
     reconcile(now, turnDeadlineMs) {
         return this.store.transact(() => {
             let changed = 0;
@@ -169,7 +136,6 @@ export class PersonalQueue {
             return changed;
         });
     }
-    /** End every waiting message sent under a session (it ended, or its person's chat was revoked). */
     cancelForSession(session, why, now) {
         return this.store.transact(() => {
             const rows = this.db.prepare("SELECT message FROM lead_queue WHERE session = ? AND status = 'queued'").all(session);
@@ -180,7 +146,6 @@ export class PersonalQueue {
             return rows.length;
         });
     }
-    /** A message that never ran keeps no words, context or search copy (it stays pending, so never history). */
     forgetWords(message) {
         this.store.forgetQueuedLeadMessage(message);
     }

package/dist/lead-route.js

@@ -1,38 +1,20 @@
-/**
- * The quick-answer router (docs/plans/responsive-chat.md §8, owner decision 7): which model answers a reply, decided
- * before the turn, deterministically and conservatively. A reply goes to the faster model only when quick answers are
- * on, the lead runs on the Claude membership, the organisation policy allows that model, the message carries no task
- * or reply context, it doesn't answer the lead's own open question, and it reads as a status or read question with no
- * act word. Everything else stays on the main model, unchanged.
- *
- * A quick reply is read-only by construction: its requests advertise only QUICK_READ_TOOLS (and find_tools, the way to
- * ask for more). A quick step that asks for anything else has its calls discarded unrun, and the main model takes the reply over from that step (lead.ts).
- */
 import { aliasTarget } from "./model-catalog.js";
 import { exactModelId } from "./phase-routing.js";
 import { SONNET } from "./model-choices.js";
-/** Words that ask for something to be done (§8's fixed list, plus a few plain synonyms). Any of them keeps a message on
- * the main model. Matched as whole words in their plain form, the form a request takes ("fix it", "can you merge",
- * "file a task"): "what's running?" or "is it merged?" ask about a state and stay quick. A quick step that asks to act
- * anyway is escalated (quickStepEscalates), so this list is the first line, not the only one. */
 export const QUICK_ACT_WORDS = Object.freeze([
     "file", "make", "create", "add", "fix", "change", "build", "plan", "approve", "confirm", "merge", "release", "ship",
     "deploy", "cancel", "pause", "hold", "resume", "retry", "steer", "remember", "delete", "archive", "send", "run",
     "start", "stop",
-    // Plain synonyms of the same acts.
     "rerun", "redo", "undo", "revert", "push", "publish", "kill", "edit", "remove", "rename", "reset", "restart",
     "install", "upgrade", "enable", "disable", "accept", "reject", "schedule", "assign", "write", "draft", "set", "move",
     "close", "reopen", "unhold", "dismiss", "prioritize", "prioritise", "split", "revise",
 ]);
-/** Openings that ask about the state of things. */
 const ASKING_OPENINGS = new Set([
     "what", "what's", "whats", "which", "who", "who's", "whose", "why", "when", "where", "how", "how's", "is", "are", "was",
     "were", "did", "does", "do", "has", "have", "had", "any", "anything", "show", "list", "status", "tell", "give",
 ]);
-/** The longest message the quick model takes: longer ones are rarely a plain status question. */
 export const QUICK_MESSAGE_MAX_CHARS = 240;
 const words = (text) => text.toLowerCase().replace(/[’]/g, "'").split(/[^a-z0-9']+/).filter(one => one !== "");
-/** Whether a message reads as a status or read question with no act word (§8's message rule). */
 export function quickQuestion(message) {
     const text = message.trim();
     if (text === "" || text.length > QUICK_MESSAGE_MAX_CHARS || /[\r\n]/.test(text))
@@ -42,18 +24,10 @@ export function quickQuestion(message) {
         return false;
     if (all.some(word => QUICK_ACT_WORDS.includes(word.replace(/'s$/, ""))))
         return false;
-    // A negated or conditional request ("don't…", "if…, then…") is a judgement call: the main model takes it.
     if (all.some(word => word === "don't" || word === "dont" || word === "if" || word === "please"))
         return false;
     return text.endsWith("?") || ASKING_OPENINGS.has(all[0]);
 }
-/**
- * The tools a quick reply's requests advertise: reads only. Every one is a read of saved state as this person sees it;
- * none drafts, records a question, a promise, a memory or a card, or opens a page. `find_tools` is advertised beside them
- * but is not one of them: it is how a quick step says it needs something else ("search before saying something can't
- * be done"), so calling it hands the reply to the main model, unrun (more conservative than §8's "find_tools for
- * something to change": any search escalates).
- */
 export const QUICK_READ_TOOLS = new Set([
     "get_brief", "get_project_context", "get_code_map", "get_project_activity", "get_actions", "get_action_status", "get_skills",
     "get_acceptance_evidence", "recap", "list_repos", "list_tasks", "get_task", "get_result", "get_result_images", "get_controls",
@@ -61,17 +35,13 @@ export const QUICK_READ_TOOLS = new Set([
     "get_project_tools", "get_flows", "get_flow_insights", "list_decisions", "get_decision", "queue",
     "get_findings", "get_subagents", "get_person", "get_integrations", "get_capabilities", "search_project_memory", "get_models", "get_sweep",
 ]);
-/** Whether a quick step's request advertises this tool: the reads, and find_tools as the way to ask for more. */
 export function quickAdvertises(name) {
     return QUICK_READ_TOOLS.has(name) || name === "find_tools";
 }
-/** The faster model, as the model catalog names it: the newest Sonnet this computer's Claude has been seen to run, else
- * the compiled current one. Always an exact id, never an alias that could move under a recorded route. */
 export function quickLeadModel(store) {
     const seen = aliasTarget(store, "sonnet")?.id ?? null;
     return seen !== null && exactModelId(seen) ? seen : SONNET;
 }
-/** Which model answers: the faster one only when every condition holds. */
 export function quickRoute(input) {
     if (!input.enabled || input.provider !== "claude-subscription" || !input.quickAllowed)
         return { route: "default" };
@@ -79,11 +49,9 @@ export function quickRoute(input) {
         return { route: "default" };
     return quickQuestion(input.message) ? { route: "fast", model: input.quickModel } : { route: "default" };
 }
-/** Whether a quick step asked for anything beyond the quick reads: its calls are then discarded unrun (§8). */
 export function quickStepEscalates(calls) {
     return calls.some(call => !QUICK_READ_TOOLS.has(call.name));
 }
-/** "Sonnet 5.5" for claude-sonnet-5-5; the id itself for anything else. */
 export function modelName(model) {
     if (model === "default")
         return "the main model";
@@ -94,7 +62,6 @@ export function modelName(model) {
         return `${model.charAt(0).toUpperCase()}${model.slice(1)}`;
     return model;
 }
-/** The activity line's words for a routed reply: "answered by Sonnet 5.5", "moved to Opus"; nothing for the default. */
 export function routeWords(route, quickModel, mainModel) {
     if (route === "fast")
         return `answered by ${modelName(quickModel)}`;

package/dist/lead-status.js

@@ -1,5 +1,3 @@
-/** Cheap lead-facing status. Every fact comes from indexed SQLite records;
- * this module never opens a repository, retained evidence, or a live log. */
 import { familyCompleted } from "./result-completion.js";
 import { windowLabel } from "./provider-limits.js";
 import { openAuthPauses, signInCommand, signInReason } from "./provider-auth.js";
@@ -58,11 +56,6 @@ function newestAttemptSince(store, taskRef, run) {
     FROM run INDEXED BY lead_status_task_run LEFT JOIN run_check AS rc ON rc.run = run.id
     WHERE run.task_ref = ? AND run.id >= ? ORDER BY run.id DESC LIMIT 1`).get(taskRef, run);
 }
-/** One indexed observation for `task wait`. `watchedRun` is the attempt the
- * caller first saw. Each poll follows the task's newest attempt from there, so
- * a retry that lands between polls is reported with its own run and outcome,
- * and `replacedRun` says which attempt it replaced. Undefined means no attempt
- * has been observed yet. */
 export function taskWaitSnapshot(store, taskId, now, watchedRun) {
     const task = store.handle.prepare(`SELECT task.id, task.state, ref.id AS task_ref, ref.plan, ref.strikes
     FROM task INDEXED BY sqlite_autoindex_task_1
@@ -82,8 +75,6 @@ export function taskWaitSnapshot(store, taskId, now, watchedRun) {
     const check = checkOf(shown);
     const phase = shown === undefined ? null : phaseWords(phaseOf(shown));
     const answer = (outcome, next, terminal, exitCode, reason) => ({ task: taskId, outcome, run, replacedRun, phase, check, next, terminal, exitCode, reason });
-    // The followed attempt's own failure is the answer, even if the task's state
-    // has already moved on; a task-level success must not stand in for it.
     if (watchedRun !== undefined && attempt !== undefined && attempt["outcome"] !== null && state !== "failed" && state !== "cancelled") {
         const outcome = String(attempt["outcome"]);
         if (outcome === "parked")
@@ -93,7 +84,6 @@ export function taskWaitSnapshot(store, taskId, now, watchedRun) {
         if (state !== "done")
             return answer("Ready", "Open result", true, 0, "ready");
     }
-    // A completed family is Complete from any of its tasks.
     const completed = state === "done" && familyCompleted(store, taskId);
     if (completed)
         return answer("Complete", "No action needed", true, 0, "complete");
@@ -115,16 +105,11 @@ export function taskWaitSnapshot(store, taskId, now, watchedRun) {
         const next = holdKind === "operator" ? "Remove hold" : holdKind === "revision" ? "Review plan" : holdKind === "stop" ? "Resume or close attempt" : "Review task";
         return answer("Needs a person", next, true, 1, "needs-person");
     }
-    // An admitted attempt is already the work being watched. Its immutable
-    // approval snapshot lives on the run, so a damaged or later-edited current
-    // scope must not make `wait` abandon that attempt before it settles.
     if (attempt !== undefined)
         return answer("Running", phase === null ? "Wait for attempt" : `Wait — ${phase}`, false, null, null);
     const scope = store.handle.prepare(`SELECT digest, approved_digest, profile_state,
     (approved_at IS NOT NULL AND approved_by IS NOT NULL AND approved_digest = digest) AS approved
     FROM task_scope WHERE task_id = ?`).get(taskId);
-    // Approved only as dispatch reads it (approval policy): a seal whose authority doesn't stand — an old seal a lead token
-    // made, an ended mode — waits for a person, never for a worker.
     const approvedNow = Number(scope?.["approved"]) === 1 && store.modeApprovalLive(taskRef, now);
     if (task["plan"] === "drafted" && !approvedNow)
         return answer("Needs a person", "Approve plan", true, 1, "needs-person");
@@ -173,20 +158,10 @@ function queueReason(row) {
         return "needs approval";
     return "ready for a worker";
 }
-/** Whole-installation status, deliberately aggregated and bounded. */
-/** The one-off repair on start. An older build left finished runs' process
- * exits unrecorded and counted completed families as waiting; nothing about
- * a status is stored, so recording every exit that can now be proven and
- * re-deriving each open task's headline from the shared projection clears
- * them. What can't be proven stays as it was. */
 export function repairStaleStatuses(store, now) {
     const exitsRecorded = store.recordFinishedRunExits(now);
     return { exitsRecorded, readyForReview: workReadyForReview(store, now, { principal: "operator", repos: null, includeUnplaced: true }, 0).count };
 }
-/** `viewer`: the person asking (the lead asks as its person); null when nobody is known, which shows no lead.
- * `repos`: the only projects to report (a remote person limited to some projects); null is the whole installation.
- * A limited report counts only those projects' tasks and leaves out what belongs to the installation as a whole:
- * the release check, plan windows and the lead line are empty, never another project's. */
 export function installationStatus(store, now, viewer = currentActor()?.account ?? null, repos = null, root) {
     const admitted = (row) => repos === null || typeof row["repo"] === "string" && repos.includes(row["repo"]);
     const access = { principal: "operator", repos, includeUnplaced: repos === null };
@@ -232,14 +207,9 @@ export function installationStatus(store, now, viewer = currentActor()?.account
         if (queuedTasks.length < 8)
             queuedTasks.push({ task: String(row["id"]), reason });
     }
-    // One per family, from the same projection as the Tasks list: a completed
-    // family (root or any revision) and a superseded version never count.
     const ready = workReadyForReview(store, now, access, 5);
-    // The most urgent tasks and Home's figures, from one read of the work index.
     const index = workIndexPage(store, now, { ...access, viewer }, { limit: 8, ...(root === undefined ? {} : { root }) });
     const checkRow = (run) => store.handle.prepare(`SELECT ${CHECK_COLUMNS} FROM run_check AS rc WHERE rc.run = ?`).get(run);
-    // Run ids grow with time, so the newest finished release check is the
-    // first finished row down the partial index.
     const release = repos !== null ? undefined : store.handle.prepare(`SELECT run.id, run.finished_at, ${CHECK_COLUMNS}, ref.external_id AS task
     FROM run_check AS rc INDEXED BY run_check_release
     JOIN run ON run.id = rc.run
@@ -271,23 +241,18 @@ export function installationStatus(store, now, viewer = currentActor()?.account
         tasks: index.items.map(one => ({ task: one.rootId, title: one.title, headline: one.status.label, sentence: one.status.detail })),
         figures: homeFiguresOf(index.totals),
         lead: repos !== null ? null : (() => {
-            // Only the asker's own lead: another person's lead is never "Your lead".
             const activity = leadActivity(store, viewer);
             return activity === null ? null : { owner: activity.owner, doing: activity.doing, at: activity.at, task: activity.taskId, line: leadActivityLine(activity, now) };
         })(),
     };
 }
-/** `limited`: a report over some projects (installationStatus's `repos`), which has no release check or plan windows to state. */
 export function renderInstallationStatus(status, limited = false) {
     const lines = [];
-    // A paused provider comes first: it is the one thing a person must do.
     for (const one of status.signIn)
         lines.push(`${one.reason} — run \`${one.command}\`. Its tasks wait until then.`);
-    // Then Home's figures, the same words and counts as Home.
     lines.push(homeFiguresLine(status.figures));
     if (status.lead != null)
         lines.push(status.lead.line);
-    // Each task's one headline, the same words as the console and chat cards.
     if (status.tasks.length > 0) {
         lines.push("Tasks:");
         for (const one of status.tasks)
@@ -296,7 +261,6 @@ export function renderInstallationStatus(status, limited = false) {
     lines.push(status.running.count === 0 ? "Building: none" : `Building: ${status.running.count} — ${status.running.tasks.map(one => `${one.task} (#${one.run}, ${one.phase})`).join(", ")}${status.running.count > status.running.tasks.length ? ", …" : ""}`);
     lines.push(status.queued.count === 0 ? "Queued: none" : `Queued: ${status.queued.count} — ${status.queued.tasks.map(one => `${one.task} (${queueReasonWords(one.reason)})`).join(", ")}${status.queued.count > status.queued.tasks.length ? ", …" : ""}`);
     lines.push(status.waitingForReview.count === 0 ? "Ready for review: none" : `Ready for review: ${status.waitingForReview.count} — ${status.waitingForReview.results.map(one => one.run === null ? one.task : `${one.task} (#${one.run})`).join(", ")}${status.waitingForReview.count > status.waitingForReview.results.length ? ", …" : ""}`);
-    // Neither the release check nor plan windows belong to a person's projects: a limited report leaves both out.
     if (limited)
         return lines;
     if (status.releaseCheck === null) {
@@ -332,7 +296,6 @@ export function renderTaskWait(snapshot, outcome = snapshot.outcome) {
     const run = snapshot.run === null ? "no run" : snapshot.replacedRun === null ? `run #${snapshot.run}` : `run #${snapshot.run}, a retry that replaced run #${snapshot.replacedRun}`;
     return `${outcome} | ${run} | ${check} | next: ${snapshot.next === "Wait for a worker" ? "Wait for a builder" : snapshot.next}`;
 }
-/** A queue reason as people read it (the JSON keeps its own words). */
 export function queueReasonWords(reason) {
     return reason === "ready for a worker" ? "ready for a builder" : reason === "needs a scope" ? "needs a plan" : reason;
 }