toolroll 0.9.83 → 0.9.85

package/dist/guides.js

@@ -287,9 +287,10 @@ ${AUTHORITY_LINE}
 
 - One command, inside the repository: \`npx toolroll up\` (or
   \`bunx toolroll up\`; Node 22.13+ must be installed — Bun's own
-  runtime cannot host it). \`up\` mints the first login and prints it (saved
-  beside the database as \`up-login.txt\`), registers the machine as a
-  worker, runs the console, opens the browser. Later starts ask for the
+  runtime cannot host it). \`up\` mints the first login and saves it beside the
+  database as \`up-login.txt\` (every start prints that path and the
+  \`cat\` command that shows the password, never the password itself),
+  registers the machine as a worker, runs the console, opens the browser. Later starts ask for the
   password at most once and remember it on that machine.
 - From a phone over a tailnet: add \`--host 0.0.0.0 --allow-host
   <name>:4180\`.

package/dist/integrations-ui.js

@@ -14,7 +14,7 @@ export const INTEGRATIONS_CSS = `.integrations{max-width:760px;min-width:0}.inte
     `.integrations .integration>:not(.integration-action),.integrations .integration-body>*{grid-column:1}.integrations .integration-body{display:contents}.integrations .integration:first-of-type{border-top:0}.integrations .integration-head{margin:0;display:flex;flex-wrap:wrap;gap:6px 10px;align-items:center;min-width:0}` +
     `.integrations .integration .integration-body>*{margin-left:calc(var(--brand-mark) + 10px)}.integrations .integration-head strong{overflow-wrap:anywhere}.integrations .integration p{margin:2px 0 0;min-width:0;overflow-wrap:anywhere}` +
     `.integrations .integration-action{grid-column:2;grid-row:1 / span 3;align-self:center;margin:0}.integrations .integration-action button,.integrations .integration-action .button-link{min-height:44px;white-space:nowrap}` +
-    `.integrations .integration .integration-action button{width:auto}.integrations .integration .integration-action a.integration-quiet{background:var(--so-paper);color:var(--so-ink);border:1px solid var(--so-input-line)}` +
+    `.integrations .integration .integration-action button{width:auto}.integrations .integration .integration-action a.integration-quiet,.integrations .integration .integration-action button.integration-quiet{background:var(--so-paper);color:var(--so-ink);border:1px solid var(--so-input-line)}` +
     `.integrations .integration-fix{color:var(--so-danger)}.integrations code{overflow-wrap:anywhere}.integrations details{margin-top:4px;font-size:.8125rem}.integrations summary{cursor:pointer;padding:4px 0}` +
     `.integration-state{display:inline-flex;align-items:center;gap:6px;font-size:.75rem;font-weight:500;padding:0 8px;border-radius:5px;line-height:20px;white-space:nowrap}` +
     `.integration-state i{width:6px;height:6px;border-radius:50%;background:currentColor}` +
@@ -33,6 +33,10 @@ function action(one, csrf) {
     if (a.kind === "test") {
         return csrf === "" ? "" : postForm("/settings/integrations/test", html `<button type="submit">Send test</button>`, { attrs: { class: "integration-action" }, hidden: { key: one.key } });
     }
+    // A project's youiyoux requests: one switch for that project.
+    if (a.kind === "switch") {
+        return csrf === "" ? "" : postForm("/settings/integrations/youiyoux", html `<button type="submit"${a.on ? "" : html ` class="integration-quiet"`}>${a.label}</button>`, { attrs: { class: "integration-action" }, hidden: { repo: a.repo, on: a.on ? "1" : "0" } });
+    }
     // A command is run where Toolroll runs; a page is linked. Fix and Set up both say which.
     // Fix is the one filled action on the page; Set up stays quiet so a list of unused services doesn't shout.
     if (a.href !== null)
@@ -50,12 +54,13 @@ function row(one, csrf) {
         ? html `<span class="integration-state integration-state--checking"><i aria-hidden="true"></i>Checking</span>`
         : html `<span class="integration-state integration-state--${one.state}"><i aria-hidden="true"></i>${STATE_WORDS[one.state]}</span>`;
     const facts = [one.account, one.detail, one.credentials].filter(Boolean).join(" · ");
-    const command = one.action.kind !== "test" ? one.action.command : null;
-    const fix = one.action.kind === "fix" ? html `<p class="integration-fix" role="status">${one.action.words}</p>` : "";
+    const command = one.action.kind === "setup" || one.action.kind === "fix" ? one.action.command : null;
+    const words = one.action.kind === "fix" || one.action.kind === "switch" ? one.action.words : null;
+    const fix = words !== null ? html `<p class="integration-fix" role="status">${words}</p>` : "";
     const run = command === null || (one.action.kind === "fix" && one.action.words.includes(command)) ? "" : html `<p class="meta">Run <code>${command}</code> on the computer running Toolroll.</p>`;
     const seen = [one.lastSuccessAt === null ? null : html `Last success ${when(one.lastSuccessAt)}`, one.usedBy.length === 0 ? null : html `Used by ${one.usedBy.join(", ")}`].filter(Boolean);
     const history = one.state === "not-set-up" || seen.length === 0 ? "" : html `<p class="meta">${joinHtml(seen, " · ")}</p>`;
-    const lastError = one.lastError === null || one.state === "not-set-up" ? "" : one.state === "broken" && one.action.kind === "fix" && one.action.words === one.lastError
+    const lastError = one.lastError === null || one.state === "not-set-up" ? "" : one.state === "broken" && words === one.lastError
         ? html `<p class="meta">Failed ${when(one.lastErrorAt ?? "")}</p>`
         : html `<details><summary>Last error ${one.lastErrorAt === null ? "" : when(one.lastErrorAt)}</summary><p class="meta">${one.lastError}</p></details>`;
     return html `<div class="integration" data-integration="${one.key}" data-state="${one.state}"><p class="integration-head">${brandMarkHtml(markFor(one), one.name, one.state === "connected")}<strong>${one.name}</strong> ${badge}</p>${action(one, csrf)}<div class="integration-body">${facts === "" ? "" : html `<p class="meta">${facts}</p>`}${fix}${run}${history}${lastError}</div></div>`;

package/dist/integrations.d.ts

@@ -18,7 +18,15 @@ export type IntegrationAction = ({
     kind: "fix";
     label: "Fix";
     words: string;
-} & IntegrationPlace);
+} & IntegrationPlace)
+/** A project's youiyoux requests: one switch, and the problem to fix when it is Broken. */
+ | {
+    kind: "switch";
+    label: "Turn off" | "Turn on";
+    repo: string;
+    on: boolean;
+    words: string | null;
+};
 export type Integration = {
     key: string;
     group: IntegrationGroup;

package/dist/integrations.js

@@ -31,6 +31,7 @@ import { LINEAR_URL, readHooksBase, readLinearKey } from "./flow-triggers.js";
 import { credentialModeOf, projectToolsOf, readToolSecrets, missingSecrets, secretsSetFor, testToolOf } from "./project-tools.js";
 import { origin, readMonitoring } from "./monitoring-settings.js";
 import { targetOf } from "./monitoring.js";
+import { youiyouxState } from "./youiyoux-intake.js";
 export const STATE_WORDS = { connected: "Connected", "not-set-up": "Not set up", broken: "Broken" };
 const NO_ACTIVITY = { okAt: null, error: null, errorAt: null, failing: false };
 const PROBE_MS = 8_000;
@@ -459,10 +460,46 @@ function combine(target, row) {
     }
     return { ...base, ...common, state: "connected", action: { kind: "test", label: "Send test" } };
 }
+/**
+ * youiyoux change requests, one row per project that uses youiyoux (youiyoux-intake.ts): Connected with how many of
+ * its requests are queued, Broken when the last pass couldn't read its folder or some of its files, or Not set up when
+ * a person turned it off; one row Not set up when no project uses it. Read from the store and the folders' presence.
+ */
+function youiyouxIntegrations(io) {
+    // In the order every other row's keys come (combine), so `--json` reads alike.
+    const row = (key, account, facts, state, action) => ({
+        key, group: "code", name: "youiyoux", usedBy: facts.usedBy ?? [], account, detail: facts.detail, checked: true, checkedAt: facts.checkedAt ?? null,
+        lastSuccessAt: facts.lastSuccessAt ?? null, lastError: facts.lastError ?? null, lastErrorAt: facts.lastErrorAt ?? null, state, action,
+    });
+    const rows = io.repos.flatMap((repo) => {
+        let state;
+        try {
+            state = youiyouxState(io.store, repo);
+        }
+        catch {
+            return [];
+        }
+        if (!state.uses)
+            return [];
+        const key = `youiyoux:${repo}`, account = basename(repo);
+        const turn = (on, words) => ({ kind: "switch", label: on ? "Turn on" : "Turn off", repo, on, words });
+        if (state.off)
+            return [row(key, account, { detail: "Turned off" }, "not-set-up", turn(true, null))];
+        const facts = { usedBy: [`Tasks in ${account}`], detail: `${plural(state.queued, "request")} queued`, checkedAt: state.checkedAt };
+        if (state.problem === null)
+            return [row(key, account, { ...facts, lastSuccessAt: state.checkedAt }, "connected", turn(false, null))];
+        const words = scrubIntegrationText(state.problem);
+        return [row(key, account, { ...facts, lastError: words, lastErrorAt: state.checkedAt }, "broken", turn(false, words))];
+    });
+    return rows.length > 0 ? rows : [row("youiyoux", null, { detail: "Starts by itself in a project with a youi.project.json" }, "not-set-up", { kind: "setup", label: "Set up", href: null, command: null })];
+}
 /** Every integration as it stands now, from files and saved history only: no network, no process, never slow. */
 export function integrationsNow(io) {
     const rows = readIntegrationChecks(io.store);
-    return targets(io).map(target => combine(target, rows.get(target.key)));
+    const list = targets(io).map(target => combine(target, rows.get(target.key)));
+    const linear = list.findIndex(one => one.key === "linear");
+    list.splice(linear + 1, 0, ...youiyouxIntegrations(io));
+    return list;
 }
 /** Run the checks (all, or the named ones), record each answer, and return the list. */
 export async function checkIntegrations(io, keys) {
@@ -512,7 +549,11 @@ export function renderIntegrations(list, secrets = null) {
                 lines.push(`${"".padEnd(width)}  last success ${whenText(one.lastSuccessAt)}${one.lastError === null ? "" : ` · last error ${whenText(one.lastErrorAt)}: ${one.lastError}`}`);
             if (one.action.kind === "fix")
                 lines.push(`${"".padEnd(width)}  Fix: ${one.action.words}${one.action.command === null || one.action.words.includes(one.action.command) ? "" : ` (run ${one.action.command})`}`);
-            if (one.action.kind === "setup")
+            if (one.action.kind === "switch" && one.action.words !== null)
+                lines.push(`${"".padEnd(width)}  Fix: ${one.action.words}`);
+            if (one.action.kind === "switch" && one.action.on)
+                lines.push(`${"".padEnd(width)}  Turn on: Settings → Integrations`);
+            if (one.action.kind === "setup" && (one.action.command !== null || one.action.href !== null))
                 lines.push(`${"".padEnd(width)}  Set up: ${one.action.command !== null ? `run ${one.action.command}` : `Settings (${one.action.href ?? "/settings"})`}`);
             return lines;
         }), ...note];

package/dist/landed-cleanup.d.ts

@@ -1,3 +1,4 @@
+import { type AssignmentSnapshot } from "./assignment.js";
 import type { RemoteMainRead, RemoteMains } from "./remote-main.js";
 import type { Store } from "./store.js";
 import { type Git } from "./teardown-git.js";
@@ -70,6 +71,9 @@ export type LandedCandidate = {
     targets: LandedTarget[];
     keeps: LandedKeep[];
 };
+/** Use the current manual completion guards. Only a recorded merge of this exact result can settle them. Also why a
+ * youiyoux options task a person decided on in the hub stays for review (youiyoux-intake.ts). */
+export declare function completionProblem(store: Store, assignment: AssignmentSnapshot, root: string): string | null;
 /**
  * Results in a project whose work landed, with what their teardown would remove and what stays. Reads only.
  * `limit` caps how many results are read against git (reconcile's bound; results read before and unchanged since

package/dist/landed-cleanup.js

@@ -237,8 +237,9 @@ function resultProblem(store, runId, head) {
         return "its result couldn't be read";
     return run.outcome === "no-change" || run.baseRevision === head ? "its result has no new work" : null;
 }
-/** Use the current manual completion guards. Only a recorded merge of this exact result can settle them. */
-function completionProblem(store, assignment, root) {
+/** Use the current manual completion guards. Only a recorded merge of this exact result can settle them. Also why a
+ * youiyoux options task a person decided on in the hub stays for review (youiyoux-intake.ts). */
+export function completionProblem(store, assignment, root) {
     if (assignment.state !== "ready-to-check" && assignment.state !== "complete")
         return "it needs a decision first";
     if (assignment.state === "complete")

package/dist/lead-capabilities.js

@@ -181,7 +181,8 @@ export function integrationCapabilities(list) {
     return list.map(one => {
         const link = one.group === "agents" ? "providers" : one.group === "tools" ? "tools" : INTEGRATION_LINK[one.key.replace(/^.*:/, "").toLowerCase()] ?? INTEGRATION_LINK[one.name.toLowerCase()] ?? "integrations";
         const lets = one.usedBy.length > 0 ? `use ${one.name} for ${one.usedBy.join(", ")}` : `use ${one.name}`;
-        const next = one.action.kind === "setup" ? `Not set up: set up ${one.name} in Settings` : one.action.kind === "fix" ? `Fix: ${one.action.words}` : null;
+        const next = one.action.kind === "setup" ? `Not set up: set up ${one.name} in Settings` : one.action.kind === "fix" ? `Fix: ${one.action.words}`
+            : one.action.kind === "switch" ? (one.action.words !== null ? `Fix: ${one.action.words}` : one.action.on ? `Turned off: turn ${one.name} on in Settings → Integrations` : null) : null;
         return { name: one.name, kind: one.group, state: STATE_WORDS[one.state], ok: one.state === "connected", account: one.account, usedBy: one.usedBy, lastError: one.lastError, lets, next, link: next === null ? null : link };
     });
 }

package/dist/lead-cli.js

@@ -1,3 +1,4 @@
+import { parseFeedbackImage } from "./result-review.js";
 import { configureLeadFollow, leadFollowStatus } from './lead-follow.js';
 import { closedQuestionWords } from "./decision.js";
 /**
@@ -104,7 +105,8 @@ export function proposalBlock(store, proposal, repos, number) {
         const snapshot = proposal.payload["snapshot"];
         const selected = Array.isArray(proposal.payload["notes"]) ? proposal.payload["notes"] : [];
         const notes = snapshot?.notes.filter(one => selected.includes(one.id)) ?? [];
-        return [line, ...notes.map(one => `     ${one.path === null ? "" : `${one.path}${one.line === null ? "" : `:${one.line}`}: `}${one.note}`),
+        const image = parseFeedbackImage(proposal.payload["image"]);
+        return [line, ...(image ? [`     Screenshot ${image.artifact} · result #${image.run}`] : []), ...notes.map(one => `     ${one.image ? `Screenshot ${one.image.artifact} · result #${one.image.run}: ` : ""}${one.path === null ? "" : `${one.path}${one.line === null ? "" : `:${one.line}`}: `}${one.note}`),
             proposal.payload["operation"] === "revise" ? "     Creates a revision of the same task; approval is separate." : "     Saves feedback; no work starts."];
     }
     return proposal.kind === "answer" ? [line, ...answerContextLines(store, proposal.payload)] : [line];

package/dist/lead-tools.d.ts

@@ -1,3 +1,4 @@
+import { type FeedbackImage } from "./result-review.js";
 import { type CommitmentChannel } from "./lead-commitments.js";
 import { type Integration } from "./integrations.js";
 import type { AuthMode } from "./keys.js";
@@ -23,6 +24,7 @@ export type LeadToolContext = {
         step: number;
         snapshot: ReviewSnapshot;
     }>;
+    replyImage?: FeedbackImage;
     /** Where evidence lives, when the surface knows — a scout's report reads from here. */
     evidenceRoot?: string;
     /** Records the screenshots this turn selected, under the turn, for a channel that delivers files; returns how many are recorded. Absent: nothing durable is kept. */

package/dist/lead-tools.js

@@ -1,9 +1,11 @@
+import { sameFeedbackImage } from "./result-review.js";
 import { sweepLine, sweepTable } from "./lead-sweep.js";
 import { connectionsOf, oneClickOf } from "./mcp-connect.js";
 import { checkLevelFromWords, isCheckLevel } from "./check-levels.js";
 import { policyParts } from "./policy.js";
 import { randomUUID } from 'node:crypto';
 import { dirname, join } from 'node:path';
+import { projectOutcomes, projectOutcomesPage } from './project-outcomes.js';
 import { repositoryContextRead } from './repository-context.js';
 import { assignmentCatchUp } from './assignment-brief.js';
 import { CHAT_ACTIONS, CHAT_ACTION_FIELDS, isChatAction, prepareSharedAction, sharedActionNeedsReview, sharedActionPayload } from './chat-actions.js';
@@ -18,6 +20,7 @@ import { cancelCommitment, CHECK_RESULTS, conditionWords, latestResultRun, recor
 import { searchMemory } from "./project-memory.js";
 import { integrationsNow, STATE_WORDS } from "./integrations.js";
 import { CAPABILITIES_UNREAD, capabilitiesOf, needsCapabilities } from "./lead-capabilities.js";
+import { feedbackImageProblem } from "./result-actions.js";
 import { readChatResult, reviewInputProblem } from "./chat-review.js";
 import { RESULT_IMAGES_PER_TURN_CAP, selectResultImages } from "./chat-evidence.js";
 import { CHAT_CONTROLS, isChatControl } from "./chat-controls.js";
@@ -377,7 +380,7 @@ export function agentsOver(store, taskId, now) {
  * find_tools and advertised from the next request of the same reply.
  */
 export const LEAD_CORE_TOOLS = new Set([
-    "find_tools", "get_brief", "recap", "list_repos", "get_project_context", "search_project_memory", "get_capabilities",
+    "find_tools", "get_brief", "recap", "list_repos", "get_project_context", "get_project_activity", "search_project_memory", "get_capabilities",
     "list_tasks", "get_task", "get_result", "get_diff", "get_check_log", "list_decisions", "get_decision",
     "get_actions", "get_action_status", "propose_action", "propose_task", "propose_scope", "propose_steer",
     "propose_answer", "propose_review", "remember", "ask_owner", "commit_to",
@@ -475,6 +478,15 @@ const LEAD_TOOL_HANDLERS = {
             return { ok: true, body: assignmentCatchUp(ctx.store, ctx.now, { principal: 'operator', repos: ctx.who.repos }, repo === null ? {} : { repo }, ctx.evidenceRoot) };
         },
     },
+    get_project_activity: {
+        description: 'Read project Activity: current Ready backlog, finished-to-decision elapsed time, explicit revisions and recorded cost for completed families in the last 60 days. Includes coverage and a page of underlying tasks (offset: nextOffset for more); not review labor or a quality score.',
+        handle: (ctx, args) => {
+            const repo = repoPathOf(ctx.who, args['repo']);
+            if (!repo || !ctx.store.accountCanAccess(ctx.who.name, repo))
+                return { ok: false, message: 'Choose an available project from list_repos.' };
+            return { ok: true, body: projectOutcomesPage(projectOutcomes(ctx.store, repo, ctx.now, { principal: 'operator', repos: ctx.who.repos }), Number(args['offset'] ?? 0)) };
+        },
+    },
     get_project_context: {
         description: 'Find source excerpts or advisory import impact. Read-only; unavailable indexing falls back to source search.',
         handle: (ctx, args) => {
@@ -656,6 +668,7 @@ const LEAD_TOOL_HANDLERS = {
                     changes: snippet.slice(0, 1000), changesShortened: snippet.length > 1000,
                     verification: ctx.store.proofVerdictFor(snapshot.run)?.verdict ?? "not verified",
                     accepted: ctx.store.proofAcceptance(snapshot.run) !== null,
+                    images: (snapshot.images ?? []).map(one => ({ id: one.artifact, run: one.run })),
                     evidenceTool: "get_acceptance_evidence",
                     canRevise: snapshot.execution === snapshot.task } };
         },
@@ -789,7 +802,7 @@ const LEAD_TOOL_HANDLERS = {
         },
     },
     propose_review: {
-        description: "Read get_result first. revise uses selected saved_notes plus optional note on the SAME task; note saves only. Omitted saved_notes stays untouched.",
+        description: "Read get_result first. revise uses selected saved_notes plus optional note on the SAME task; note saves only. Omitted saved_notes stays untouched. To comment on a screenshot, use its image id from get_result_images. If this channel cannot select one, link to the result Comment control and say feedback still needs submitting there.",
         handle: (ctx, args) => {
             const read = ctx.readResults?.get(Number(args["run"]));
             if (read === undefined || read.step >= ctx.step)
@@ -812,8 +825,20 @@ const LEAD_TOOL_HANDLERS = {
                 return { ok: false, message: "Write feedback or select saved notes for a revision." };
             if (operation === "revise" && read.snapshot.task !== read.snapshot.execution)
                 return { ok: false, message: "A newer revision is current. Read that version before requesting changes." };
+            const wanted = args["image"] === null ? undefined : args["image"] ?? (note !== null && ctx.replyImage?.run === read.snapshot.run ? ctx.replyImage.artifact : undefined);
+            let image = null;
+            if (wanted !== undefined) {
+                image = read.snapshot.images?.find(one => one.artifact === wanted) ?? null;
+                if (image === null || ctx.evidenceRoot === undefined || note === null)
+                    return { ok: false, message: "Choose a saved screenshot from the result you read and write feedback." };
+                if (ctx.replyImage?.artifact === wanted && !sameFeedbackImage(ctx.replyImage, image))
+                    return { ok: false, message: "The screenshot you replied to changed. Open the result and select it again." };
+                const problem = feedbackImageProblem(ctx.store, ctx.evidenceRoot, read.snapshot.run, image);
+                if (problem !== null)
+                    return { ok: false, message: problem };
+            }
             const id = ctx.draft("review", { task: read.snapshot.task, taskTitle: read.snapshot.title, run: read.snapshot.run,
-                snapshot: read.snapshot, operation, note, path, line, notes });
+                snapshot: read.snapshot, operation, note, path, line, notes, image });
             return id === null ? tooMany() : { ok: true, body: { proposal: id, kind: "review", awaiting: "confirmation", operation } };
         },
     },
@@ -1497,7 +1522,8 @@ const LEAD_TOOL_HANDLERS = {
             const integrations = list.map(one => ({
                 name: one.name, kind: one.group, state: STATE_WORDS[one.state], account: one.account, detail: one.detail, usedBy: one.usedBy,
                 lastSuccessAt: one.lastSuccessAt, lastError: one.lastError,
-                next: one.action.kind === "setup" ? "Not set up: open Settings → Integrations to set it up" : one.action.kind === "fix" ? `Fix: ${one.action.words}` : null,
+                next: one.action.kind === "setup" ? "Not set up: open Settings → Integrations to set it up" : one.action.kind === "fix" ? `Fix: ${one.action.words}`
+                    : one.action.kind === "switch" ? (one.action.words !== null ? `Fix: ${one.action.words}` : one.action.on ? "Turned off: turn it on in Settings → Integrations" : null) : null,
             }));
             return { ok: true, body: { integrations, settings: "show_control integrations opens Settings → Integrations; never invent a link" } };
         },

package/dist/lead.d.ts

@@ -38,6 +38,8 @@ export type LeadTurnInput = {
      * visible thread so a task-scoped composer still reads like a normal
      * conversation. */
     context?: string;
+    /** Exact image from the transport record of the message being answered. */
+    replyImage?: import("./result-review.js").FeedbackImage;
     fetcher?: typeof fetch;
     /** Injected by tests; production invokes the isolated local harness. */
     subscriptionRunner?: SubscriptionLeadRunner;

package/dist/lead.js

@@ -110,7 +110,7 @@ function settleBy(work, ms) {
     const late = new Promise(resolve => { timer = setTimeout(() => resolve(LATE), Math.max(0, ms)); });
     return Promise.race([work, late]).finally(() => clearTimeout(timer));
 }
-const READ_TOOLS = new Set(["get_brief", "get_project_context", "get_actions", "get_action_status", "get_skills", "get_acceptance_evidence", "recap", "list_repos", "list_tasks", "get_task", "get_result", "get_result_images", "get_controls", "get_agents", "get_project_knowledge", "get_task_conversation", "get_diff", "get_check_log", "get_project_tools", "get_flows", "get_flow_insights", "list_decisions", "get_decision", "queue"]);
+const READ_TOOLS = new Set(["get_brief", "get_project_context", "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", "get_agents", "get_project_knowledge", "get_task_conversation", "get_diff", "get_check_log", "get_project_tools", "get_flows", "get_flow_insights", "list_decisions", "get_decision", "queue"]);
 /** The last messages of the thread as provider-neutral history, newest kept first until the byte cap. */
 export function historyFor(store, thread, queuedMessageId, named = queuedMessageId !== undefined) {
     // Admitted messages only (v128): a queued message — this one, a teammate's, or one removed while waiting — never
@@ -205,7 +205,7 @@ export async function runLeadTurn(input) {
         return refuse("thread-closed");
     if (liveSession.ceilingDigest !== who.ceilingDigest || liveThread.ceilingDigest !== who.ceilingDigest)
         return refuse("ceiling-changed");
-    const digest = createHash("sha256").update(JSON.stringify([thread.id, message, input.context ?? null])).digest("hex");
+    const digest = createHash("sha256").update(JSON.stringify([thread.id, message, input.context ?? null, ...(input.replyImage === undefined ? [] : [input.replyImage])])).digest("hex");
     const receipt = request === undefined ? null : store.leadRequestReceipt(session.id, request);
     if (receipt !== null)
         return receipt.digest === digest ? { ok: true, replayed: true, turn: receipt.turn } : refuse("request-changed");
@@ -568,7 +568,7 @@ export async function runLeadTurn(input) {
             // caller of executeLeadTool): the model learns the road (find_tools, then the next step) and the reply goes on.
             const outcome = !advertisedNames.has(call.name)
                 ? { ok: false, message: `${call.name} isn't available in this step. Call find_tools with what you want to do; tools it finds can be called from your next step.` }
-                : executeLeadTool({ store, who, now: clock(), draft, selectEvidence, step: steps, readDecisions, readResults, searchedMemory, checkedCapabilities, ask, findTools, ...(input.integrations === undefined ? {} : { integrations: input.integrations }), thread: thread.id, turn: turnId, ...(promiseChannelOfTurn(input.channel) === undefined ? {} : { channel: promiseChannelOfTurn(input.channel) }), ...(input.evidenceRoot === undefined ? {} : { evidenceRoot: input.evidenceRoot }), ...(input.mediaDelivery === undefined ? {} : { mediaDelivery: input.mediaDelivery }) }, call.name, call.args, view);
+                : executeLeadTool({ store, who, now: clock(), draft, selectEvidence, ...(input.replyImage === undefined ? {} : { replyImage: input.replyImage }), step: steps, readDecisions, readResults, searchedMemory, checkedCapabilities, ask, findTools, ...(input.integrations === undefined ? {} : { integrations: input.integrations }), thread: thread.id, turn: turnId, ...(promiseChannelOfTurn(input.channel) === undefined ? {} : { channel: promiseChannelOfTurn(input.channel) }), ...(input.evidenceRoot === undefined ? {} : { evidenceRoot: input.evidenceRoot }), ...(input.mediaDelivery === undefined ? {} : { mediaDelivery: input.mediaDelivery }) }, call.name, call.args, view);
             let displayOutcome = { state: "succeeded" };
             if (!outcome.ok) {
                 const reason = leadToolFailureReason(call.name, outcome.message);

package/dist/model-catalog.d.ts

@@ -47,6 +47,11 @@ export declare const RUNTIME_TOOLS: Record<RuntimeTool, {
     pkg: string;
 }>;
 export declare const WATCH_EVERY_MS: number;
+/** The current Claude models by exact id, offered even before the first catalog check has run. */
+export declare const CLAUDE_EXACT: readonly {
+    value: string;
+    label: string;
+}[];
 /** `anthropic/claude-opus-5.5` → `claude-opus-5-5`, the name the Claude CLI and API use. */
 export declare function claudeIdOf(openrouterId: string): string | null;
 /** The Codex CLI's own list — account-specific, maintained by the CLI. */

package/dist/model-catalog.js

@@ -58,6 +58,12 @@ export const WATCH_EVERY_MS = 6 * 3_600_000;
 const NEW_FOR_MS = 14 * 86_400_000;
 const FAMILIES = ["opus", "sonnet", "haiku", "fable"];
 const ALIAS_WORDS = { opus: "complex tasks", sonnet: "everyday coding", haiku: "smaller tasks" };
+/** The current Claude models by exact id, offered even before the first catalog check has run. */
+export const CLAUDE_EXACT = Object.freeze([
+    { value: "claude-opus-5-5", label: "Claude Opus 5.5" },
+    { value: "claude-sonnet-5-5", label: "Claude Sonnet 5.5" },
+    { value: "claude-haiku-5-5", label: "Claude Haiku 5.5" },
+]);
 const title = (word) => word.charAt(0).toUpperCase() + word.slice(1);
 const stripVendor = (name) => name.replace(/^(Anthropic|OpenAI|Google): /, "");
 /** `anthropic/claude-opus-5.5` → `claude-opus-5-5`, the name the Claude CLI and API use. */
@@ -182,12 +188,15 @@ export function modelWords(store, provider, model) {
 export function modelOptions(store, provider, now, home = homedir()) {
     const option = (model) => ({ value: model.id, label: `${model.name} · ${priceWords(model)}${isNewModel(model, now) ? " · New" : ""}`, isNew: isNewModel(model, now) });
     if (provider === "claude") {
+        // Exact ids first (Settings → Models presets write only these); the short names float to the newest version.
+        const seen = seenModels(store, "claude").slice(0, 20);
+        const builtIn = CLAUDE_EXACT.filter(one => !seen.some(model => model.id === one.value)).map(one => ({ ...one, isNew: false }));
         const aliases = ["sonnet", "opus", "haiku"].map(alias => {
             const target = aliasTarget(store, alias);
             // Short enough that a phone's select still shows which model it means.
-            return { value: alias, label: target === null ? `${title(alias)} — ${ALIAS_WORDS[alias]}` : `${title(alias)} · latest (${target.name.replace(/^Claude /, "")})`, isNew: false };
+            return { value: alias, label: target === null ? `${title(alias)} (floating) — ${ALIAS_WORDS[alias]}` : `${title(alias)} (floating) · now ${target.name.replace(/^Claude /, "")}`, isNew: false };
         });
-        return [...aliases, ...seenModels(store, "claude").slice(0, 20).map(option)];
+        return [...seen.map(option), ...builtIn, ...aliases];
     }
     if (provider === "codex") {
         const live = codexCatalog(home);

package/dist/model-choices.d.ts

@@ -0,0 +1,188 @@
+import { type SeenModel } from "./model-catalog.js";
+import { type PhaseRoute } from "./phase-routing.js";
+import type { Store } from "./store.js";
+export type SlotPhase = "plan" | "build" | "repair" | "review";
+export type SlotTier = "routine" | "light" | "strong";
+export type Slot = {
+    phase: SlotPhase;
+    tier: SlotTier;
+};
+export type Pair = {
+    provider: string;
+    model: string | null;
+};
+/** One row to set (an exact pair) or clear (null). */
+/** A model is null only on the command line's `config set <phase> --provider p` (its harness default). */
+export type ModelChange = {
+    slot: Slot;
+    to: {
+        provider: string;
+        model: string | null;
+    } | null;
+};
+/** Every row the editor owns, in the order the page and the diff show them. Alternates (`--also`) and the strong
+ * repair row stay CLI-only; presets clear the strong repair row so repairs follow the builder. */
+export declare const SLOTS: readonly Slot[];
+/** Every row the write path accepts: the editor's, plus the strong repair row the CLI also sets. */
+export declare const ALL_SLOTS: readonly Slot[];
+export declare const slotKey: (slot: Slot) => string;
+export declare function slotOf(key: string): Slot | null;
+/** The role in plain words. */
+export declare function slotWords(slot: Slot): string;
+export declare function rowAt(store: Store, scope: string, slot: Slot): Pair | null;
+/** Every value the editor shows for a scope: its own rows and, for a project, the installation rows it inherits, and
+ * the alternates described in words. A change to any of them makes an open form stale. */
+export declare function stateDigest(store: Store, scope: string): string;
+/** The exact change a preview showed: its target and every set and clear, in slot order. */
+export declare function changeDigest(scope: string, change: readonly ModelChange[]): string;
+export type DiffRow = {
+    slot: Slot;
+    before: Pair | null;
+    after: Pair | null;
+};
+/** What a preview showed: the scope and every row's before → after. Bound into the apply, so a row that moved in
+ * between, or a change the preview never showed, is refused. */
+export declare function diffDigest(scope: string, diff: readonly DiffRow[]): string;
+/** A preview read from ONE snapshot: the rows it moves, what a cleared project row would inherit, and both digests
+ * the apply must match. */
+export declare function previewModelChange(store: Store, scope: string, change: readonly ModelChange[]): {
+    rows: (DiffRow & {
+        inherited: Pair | null;
+    })[];
+    state: string;
+    change: string;
+};
+/** The rows this change really moves (a set to the value already there is no change). */
+export declare function diffOf(store: Store, scope: string, change: readonly ModelChange[]): DiffRow[];
+export declare const OPUS = "claude-opus-5-5";
+export declare const SONNET = "claude-sonnet-5-5";
+export declare const HAIKU = "claude-haiku-5-5";
+export type PresetName = "sized" | "opus";
+export declare const PRESETS: Record<PresetName, {
+    label: string;
+    words: string;
+    rows: Record<string, string | null>;
+}>;
+export declare const DEFAULT_PRESET: PresetName;
+export declare const isPresetName: (value: string | null) => value is PresetName;
+/** A preset as a change: every slot, as exact Claude ids, never an alias. Repair rows are cleared so repairs follow
+ * the builder of each size. */
+export declare function presetChange(name: PresetName): ModelChange[];
+/** The routes a task filed now would get at a scope, for every size and demand that picks a tier (inheritance,
+ * review following the planner, and repair following each size's builder included), or the words for why none can. */
+export declare const ROUTE_CASES: readonly {
+    label: string;
+    size: "small" | "medium" | "large";
+    risky: boolean;
+    strict: boolean;
+}[];
+export declare function effectiveRoutes(store: Store, repo: string | null): {
+    ok: true;
+    routes: {
+        label: string;
+        route: PhaseRoute;
+    }[];
+} | {
+    ok: false;
+    problem: string;
+};
+/** Which preset a scope's EFFECTIVE configuration matches (what each size would really run, inherited rows
+ * included), or null ("a custom set"). */
+export declare function presetInUse(store: Store, scope: string): PresetName | null;
+/** "Switch to it": every row at this scope that names `from` names `to` instead. */
+export declare function switchChange(store: Store, scope: string, from: string, to: string): ModelChange[];
+/** For each exact Claude id this scope uses, the newest model of its family the watch has seen, when that is newer. */
+export declare function newerModels(store: Store, scope: string): {
+    from: string;
+    to: SeenModel;
+    slots: Slot[];
+}[];
+/** Who is acting, proved by the caller's own step-up, and re-proved here inside the transaction: the same account,
+ * still active, still an unrestricted instance operator, at the credential generation the proof was made under, on a
+ * session (or local CLI login) that is still live. */
+export type ModelAuthority = {
+    actor: string;
+    /** The credential generation the proof was checked against (read before the proof, never after). */
+    generation: number;
+    /** How the person proved it (scope.ts AuthMethod): a Passwordless session or remembered CLI login stands only while
+     * Passwordless is still on, and is re-checked here. */
+    method: string;
+    live: () => boolean;
+};
+export type ApplyInput = {
+    scope: string;
+    change: readonly ModelChange[];
+    /** The state a page showed, and (for a preview) the exact change it showed; null on the command line, which shows
+     * nothing before it writes. */
+    expected: {
+        state: string;
+        change?: string;
+    } | null;
+    /** The console: exact ids only. The CLI may also name a floating name, or a routine row with no model. The
+     * resulting configuration is checked the same way for both. */
+    strict: boolean;
+    knownProject: (repo: string) => boolean;
+    /** The command line's other rows, under the same proof, target and result checks: another provider's candidate on
+     * a tier (`--also`), and removing a light planner left from before light became build-only. */
+    extra?: readonly ExtraWrite[];
+};
+export type ExtraWrite = {
+    kind: "also-set";
+    phase: "plan" | "build";
+    tier: SlotTier;
+    provider: string;
+    model: string;
+} | {
+    kind: "also-clear";
+    phase: "plan" | "build";
+    tier: SlotTier;
+    provider: string | null;
+} | {
+    kind: "legacy-light-clear";
+    phase: SlotPhase;
+};
+export type ApplyRefusal = {
+    ok: false;
+    reason: "authority" | "unknown-project" | "stale" | "invalid";
+    problem: string;
+};
+export type ApplyResult = {
+    ok: true;
+    diff: DiffRow[];
+    unresolved: string | null;
+    extra: number;
+} | ApplyRefusal;
+export type ScopeCheck = {
+    kind: "ok";
+} | {
+    kind: "incomplete" | "invalid";
+    problem: string;
+};
+/**
+ * Whether tasks can be filed at a scope with its resulting configuration. INCOMPLETE: a role has no exact model yet
+ * (setup in progress; saved, and said). INVALID: something set can't run: an unknown provider, an ineligible reviewer,
+ * or a route of any size or demand (small, routine, large, risky, strict) whose repair can't resume its builder,
+ * inherited rows included. An invalid result is never saved.
+ */
+export declare function checkScope(store: Store, repo: string | null): ScopeCheck;
+/** A resolver's words for a browser: what is wrong, never a terminal command to fix it. */
+export declare function browserWords(problem: string): string;
+/** The problem alone, or null when tasks can be filed. */
+export declare function scopeProblem(store: Store, repo: string | null): string | null;
+/**
+ * Apply one change in ONE transaction: re-prove the actor, check the target and that nothing moved since the person
+ * looked, check every row, write every set and clear, check the resulting configuration (no scope it reaches, the
+ * target or a project inheriting from it, may stop resolving), and ledger before → after for each row. Any refusal
+ * rolls everything back: a preset that fails on its last row writes nothing.
+ */
+export declare function applyModelChoices(store: Store, input: ApplyInput, authority: ModelAuthority, now: Date): ApplyResult;
+export type RecentRun = {
+    runId: number;
+    taskId: string;
+    role: string;
+    chosen: string | null;
+    ranOn: string | null;
+    at: string;
+};
+/** The latest runs' floating or exact choice next to the model their provider reported: no verdict. */
+export declare function recentRuns(store: Store, limit?: number): RecentRun[];