toolroll 0.9.65 → 0.9.68

package/dist/server/render-chat.js

@@ -33,7 +33,6 @@ import { chatMoney, oneLineOf, relativeAge, safePrUrl, screen, sentenceCase, str
 import { chatResultHref, projectChatHref, taskChatHref, taskHref } from "./http.js";
 import {} from "./render-pages.js";
 import { completionReceiptCard } from "./render-results.js";
-import {} from "./render-settings.js";
 import { agentsAvailabilityHtml, agentsBadgesHtml, agentsStripHtml, agentsSummaryWords, agentsWhyHtml, approvalSheetHtml, checkProgressHtml, consentClosedHtml, consentDoorOf, decisionAnswerCard, dispatchHeadline, milestoneProgressHtml, planRevisionLedgerHtml, profileWords, sizeConsequence, taskControlDetailsHtml, taskStatusCard, taskViewSwitch } from "./render-tasks.js";
 /** The installation fact that the lead was turned on by default, once (its value: the provider). */
 export const LEAD_BY_DEFAULT_FACT = "lead-on-by-default";
@@ -260,8 +259,8 @@ export function chatHeading(copy, projectCount, showProjectToggle = true) {
 }
 /** A deliberately small rich-text grammar for model copy. The reply is shaped first (the lead's voice, enforced:
  * no headers, at most three bold anchors, labelled links, no internal ids unless `asked` wanted them); input is
- * escaped before tags are introduced: bullets, numbered steps, bold, inline code and labelled http(s) links are
- * presentation only—never executable HTML. */
+ * escaped before tags are introduced: bullets, numbered steps, bold, inline code, fenced code blocks and labelled
+ * http(s) links are presentation only—never executable HTML. */
 export function renderChatText(raw, asked) {
     const inline = replyHtmlInline;
     const text = shapeReply(raw, { appOrigin: requestContext.getStore()?.appOrigins ?? null, ...(asked === undefined ? {} : { asked }) });
@@ -281,7 +280,31 @@ export function renderChatText(raw, asked) {
         out.push(list.tag === "ul" ? html `<ul>${list.items}</ul>` : html `<ol>${list.items}</ol>`);
         list = null;
     };
+    // A fenced block (shaping leaves it exactly as written) is shown as written: escaped, never parsed.
+    let fence = null;
+    const closeFence = () => {
+        const open = fence;
+        if (open === null)
+            return;
+        out.push(html `<pre class="chat-code"${open.lang === "" ? "" : html ` data-lang="${open.lang}"`}><code>${open.lines.join("\n")}</code></pre>`);
+        fence = null;
+    };
     for (const line of lines) {
+        const open = fence;
+        if (open !== null) {
+            if (/^\s{0,3}```\s*$/.test(line))
+                closeFence();
+            else
+                open.lines.push(line);
+            continue;
+        }
+        const fenceMark = /^\s{0,3}```\s*([A-Za-z0-9_+.#-]{0,24})\s*$/.exec(line);
+        if (fenceMark !== null) {
+            flushParagraph();
+            closeList();
+            fence = { lang: fenceMark[1], lines: [] };
+            continue;
+        }
         const bullet = /^\s*[-*]\s+(.+)$/.exec(line);
         const numbered = /^\s*(\d{1,9})[.)]\s+(.+)$/.exec(line);
         if (bullet !== null || numbered !== null) {
@@ -304,10 +327,35 @@ export function renderChatText(raw, asked) {
             paragraph.push(line);
         }
     }
+    // An unclosed fence still shows its lines as code: the reply may have been cut.
     flushParagraph();
     closeList();
+    closeFence();
     return html `<div class="chat-copy">${out}</div>`;
 }
+/** A line comment from the chat Workbench (src/browser/line-steer.tsx steerMessage): On "<file, as a JSON string>":<line>
+ * [ (removed line)] (run #<n>): <comment>, then a blank line and "> <the line>" (just ">" for a blank line, once the
+ * chat POST has trimmed the message), always last.
+ * The words the lead reads stay exactly as sent; the thread shows them in three parts: a small reference line, the quoted
+ * code as written, and the comment. Null for any other message, which keeps its own plain rendering. Everything is
+ * escaped by the html template. */
+export function steerCommentHtml(text) {
+    const steer = /^On ("(?:[^"\\\n]|\\.){1,1200}"):(\d{1,9})( \(removed line\))? \(run #(\d{1,12})\): ([\s\S]+)\n\n>(?: ([^\n]*))?$/.exec(text);
+    if (steer === null)
+        return null;
+    // A blank line's quote ("> ") reaches the store as ">": the chat POST trims the message (src/server/chat.ts).
+    const [, quoted, line, removed, run, comment, code = ""] = steer;
+    let path;
+    try {
+        path = JSON.parse(quoted);
+    }
+    catch {
+        return null;
+    }
+    if (typeof path !== "string" || path === "" || /[\u0000-\u001f]/.test(path) || comment.trim() === "")
+        return null;
+    return html `<div class="chat-steer" data-steer-comment><p class="chat-steer-ref">${path}:${line}${removed === undefined ? "" : " · removed line"} · run #${run}</p>${code === "" ? "" : html `<pre class="chat-steer-code"><code>${code}</code></pre>`}<p class="chat-steer-note" style="white-space:pre-wrap">${comment}</p></div>`;
+}
 export function chatActivity(activity) {
     return chatActivityDetailsHtml(activity);
 }
@@ -351,8 +399,6 @@ export function chatLimitsHtml(facts) {
     return html `<details class="chat-limits"><summary>Model &amp; limits<span class="meta">${facts.subscription ? "membership" : facts.provider}</span></summary><div class="chat-budget">${rows}</div></details>`;
 }
 export function chatPage(chrome, data) {
-    const formFacts = { keyFacts: data.keyFacts, openrouterModels: data.openrouterModels, ...(data.liveModels === undefined ? {} : { liveModels: data.liveModels }), csrf: data.csrf,
-        returnTo: data.focusTask === null ? "/chat" : taskChatHref(data.focusTask.id) };
     const parts = [
         data.focusTask === null
             ? chatHeading("", data.projects.length, data.enabled.ok)
@@ -803,7 +849,7 @@ export function leadBrowserMessages(rows, back, target = { task: null, project:
     return rows.messages.map(message => ({
         id: message.id, role: message.role, text: message.text,
         html: htmlString(message.role === 'operator'
-            ? (() => { const queued = rows.queue?.get(message.id); return html `${message.text === "" ? "" : html `<p>${message.text}</p>`}${queued === undefined ? "" : queuedStateHtml(queued, back)}`; })()
+            ? (() => { const queued = rows.queue?.get(message.id); return html `${message.text === "" ? "" : steerCommentHtml(message.text) ?? html `<p>${message.text}</p>`}${queued === undefined ? "" : queuedStateHtml(queued, back)}`; })()
             : html `${renderChatText(message.text, askedBy.get(message.id))}${asked(message.turn)}`),
         activity: message.activity, createdAt: message.createdAt,
         ...(() => {
@@ -882,7 +928,7 @@ export function leadThreadHtml(data) {
             asked = message.text;
             // A message that waits its turn (the lead queue) says so, with Remove while it still waits — as in the React thread.
             const queued = data.queue?.get(message.id);
-            thread.push(html `<div class="msg op" data-message-role="operator" data-key="m${message.id}">${message.text === "" ? "" : html `<p style="white-space:pre-wrap">${message.text}</p>`}${queued === undefined ? "" : queuedStateHtml(queued, returnTo)}</div>`);
+            thread.push(html `<div class="msg op" data-message-role="operator" data-key="m${message.id}">${message.text === "" ? "" : steerCommentHtml(message.text) ?? html `<p style="white-space:pre-wrap">${message.text}</p>`}${queued === undefined ? "" : queuedStateHtml(queued, returnTo)}</div>`);
             continue;
         }
         const cards = message.turn === null ? [] : (byTurn.get(message.turn) ?? []);

package/dist/server/render-pages.d.ts

@@ -146,14 +146,39 @@ export declare function systemPage(chrome: Chrome, data: {
     }[];
     now: Date;
 }): Screen;
+/**
+ * A build's stage as one of three steps — set up, writing, checking and
+ * committing — read from the machine's own phase, never a percent. The
+ * steps only move forward: evidence and proof checks run both before and
+ * after the commit (builder.ts), so everything after the agent's turn is
+ * one step, and the stage words say which part. Null for runs that are not
+ * builds (planning, review, investigation): those have no honest steps.
+ */
+export declare const BUILD_STEPS: readonly ["setting up", "writing", "checking and committing"];
+export declare function buildStepOf(claim: NonNullable<BoardCard["claim"]>): number | null;
+/**
+ * The workers a board's strip may show: not retired, bound to at least one
+ * project the server's ceiling admits (never a runner serving only projects
+ * this server must not speak about), and — on a one-project board — bound to
+ * that project.
+ */
+export declare function boardWorkers(runners: readonly Runner[], scope: {
+    all: boolean;
+    project: string | null;
+    visible: (repo: string) => boolean;
+}): Runner[];
 /**
  * The board: the pipeline as lanes, position as meaning — attention, then
- * queued, then waiting, then building, then recently done. Read-only by
- * construction (every card is a link, no forms, no nonces), which is what
- * makes it safe to re-render itself while somebody watches.
+ * queued, then waiting, then building, then recently done — under a strip
+ * of the workers doing it. Read-only by construction (every card is a link,
+ * no forms, no nonces), which is what makes it safe to re-render itself
+ * while somebody watches; a card that changes lane slides there
+ * (regionScript's animate swap, keyed by data-vt).
  */
 export declare function boardBody(data: {
     cards: BoardCard[];
+    /** The workers this board's work can go to (retired ones left out). */
+    workers: readonly Runner[];
     done: ReturnType<Store["listCompletedWorkScoped"]>;
     saturated: boolean;
     now: Date;

package/dist/server/render-pages.js

@@ -207,11 +207,74 @@ export function systemPage(chrome, data) {
                     : html `<span class="meta">syncing normally</span>`}</p>`), "\n")}`,
     ], "\n"), { chrome, refreshSeconds: data.building.length > 0 ? 10 : 60 });
 }
+/**
+ * A build's stage as one of three steps — set up, writing, checking and
+ * committing — read from the machine's own phase, never a percent. The
+ * steps only move forward: evidence and proof checks run both before and
+ * after the commit (builder.ts), so everything after the agent's turn is
+ * one step, and the stage words say which part. Null for runs that are not
+ * builds (planning, review, investigation): those have no honest steps.
+ */
+export const BUILD_STEPS = ["setting up", "writing", "checking and committing"];
+export function buildStepOf(claim) {
+    if (claim.role === "planner" || claim.role === "reviewer" || claim.role === "scout")
+        return null;
+    if (claim.model === null)
+        return 0;
+    if (claim.phase === null || claim.phase === "agent-running")
+        return 1;
+    return 2;
+}
+/** A clock that ticks in the page (boardTickScript) from the server's own start time; the text is the no-script answer. */
+function tickingClock(startedIso, now) {
+    const minutes = Math.max(0, Math.round((now.getTime() - new Date(startedIso).getTime()) / 60_000));
+    return html `<time class="clock" datetime="${startedIso}" data-tick>${minutes}m</time>`;
+}
+/**
+ * The workers a board's strip may show: not retired, bound to at least one
+ * project the server's ceiling admits (never a runner serving only projects
+ * this server must not speak about), and — on a one-project board — bound to
+ * that project.
+ */
+export function boardWorkers(runners, scope) {
+    return runners.filter(runner => runner.retiredAt === null &&
+        runner.repos.some(repo => scope.visible(repo)) &&
+        (scope.all || scope.project === null || runner.repos.includes(scope.project)));
+}
+/**
+ * The worker strip across the top of the board: every worker this board's
+ * work can go to, what it is building here, and its stage and clock. Only
+ * builds the board already shows are named — a worker busy in a project
+ * this reader cannot see reads "no build on this board", never "free".
+ */
+function workerStrip(runners, cards, now) {
+    if (runners.length === 0)
+        return html `<p class="meta crew-empty">No workers yet — work waits in the queue until one joins.</p>`;
+    const tiles = runners.map(runner => {
+        const builds = cards
+            .filter(card => card.lane === "building" && card.claim !== null && card.claim.runner === runner.name)
+            .sort((a, b) => a.claim.claimedAt.localeCompare(b.claim.claimedAt));
+        const online = runnerAlive(runner, now);
+        const state = !online ? "offline" : builds.length > 0 ? "busy" : "idle";
+        const dot = state === "busy" ? html `<span class="dot dot-ok pulse"></span>` : html `<span class="dot dot-off"></span>`;
+        const jobs = builds.length > 0
+            ? builds.map(card => {
+                const claim = card.claim;
+                const words = claim.model === null ? "preparing workspace" : claim.phase === null ? "the agent is working" : phaseWords(claim.phase);
+                return html `<a class="worker-job" href="${card.href}"><span class="t">${card.title}</span><span class="sub"><span>${words}</span>${tickingClock(claim.claimedAt, now)}</span></a>`;
+            })
+            : html `<p class="worker-job idle">${online ? "no build on this board" : html `offline since ${whenTime(runner.heartbeatAt)}`}</p>`;
+        return html `<div class="worker worker-${state}" data-flash="${runner.name}" data-flash-value="${builds.map(card => card.taskId).join(" ")}"><div class="worker-head">${dot}<span class="name">${runner.name}</span><span class="kind">${runner.agents.join(" · ")}</span>${runner.capacity > 1 ? html `<span class="slots">${builds.length}/${runner.capacity}</span>` : null}</div>${jobs}</div>`;
+    });
+    return html `<section class="crew" aria-label="Workers">${tiles}</section>`;
+}
 /**
  * The board: the pipeline as lanes, position as meaning — attention, then
- * queued, then waiting, then building, then recently done. Read-only by
- * construction (every card is a link, no forms, no nonces), which is what
- * makes it safe to re-render itself while somebody watches.
+ * queued, then waiting, then building, then recently done — under a strip
+ * of the workers doing it. Read-only by construction (every card is a link,
+ * no forms, no nonces), which is what makes it safe to re-render itself
+ * while somebody watches; a card that changes lane slides there
+ * (regionScript's animate swap, keyed by data-vt).
  */
 export function boardBody(data, ciRed) {
     const chip = (repo) => !data.all || repo === null ? null : html `<span class="badge">${projectName(repo)}</span>`;
@@ -261,7 +324,7 @@ export function boardBody(data, ciRed) {
         const kept = parts.filter((one) => one !== null);
         return kept.length === 0 ? null : html `<span class="chips">${joinHtml(kept, " ")}</span>`;
     };
-    const plain = (card) => html `<a class="lane-card" href="${card.href}"><span class="id">${card.taskId}</span><span class="t">${card.title}</span><span class="why">${card.reason}</span>${facts([
+    const plain = (card) => html `<a class="lane-card" href="${card.href}" data-vt="${card.taskId}"><span class="id">${card.taskId}</span><span class="t">${card.title}</span><span class="why">${card.reason}</span>${facts([
         ...(card.stalledSince === null ? [] : [["waiting", age(card.stalledSince)]]),
     ])}${chips([
         chip(card.repo),
@@ -279,7 +342,7 @@ export function boardBody(data, ciRed) {
         }
         return heads;
     })();
-    const queuedCard = (card) => html `<a class="lane-card" href="${card.href}"><span class="id">${card.taskId}</span><span class="t">${card.title}</span><span class="why">${card.reason}</span>${facts([
+    const queuedCard = (card) => html `<a class="lane-card" href="${card.href}" data-vt="${card.taskId}"><span class="id">${card.taskId}</span><span class="t">${card.title}</span><span class="why">${card.reason}</span>${facts([
         ["worker", card.assignedRunner === null ? "any free worker" : card.assignedRunner],
     ])}${chips([
         queuedHeads.get(`${card.assignedRunner ?? ""}|${card.repo ?? ""}`) === card.taskId
@@ -292,14 +355,19 @@ export function boardBody(data, ciRed) {
         const claim = card.claim;
         if (claim === null)
             return plain(card);
-        const minutes = Math.max(1, Math.round((data.now.getTime() - new Date(claim.claimedAt).getTime()) / 60_000));
         const workspace = claim.worktree === null ? null : (claim.worktree.split("/").pop() ?? claim.worktree);
         // Chip copy: unknown phases show nothing rather than raw tokens.
         const phase = claim.phase === null ? undefined : PHASE_WORDS[claim.phase];
         // The live strip is the run's own phase and clock — never a percent:
         // a build has no honest progress figure, only a stage and an elapsed.
         const live = claim.model === null ? "preparing workspace" : (phase ?? "the agent is working");
-        return html `<a class="lane-card building" href="${card.href}"><span class="id">${card.taskId}</span><span class="t"><span class="dot dot-ok pulse"></span>${card.title}</span><span class="live-line"><span class="stage">${live}</span><span class="clock">${minutes}m</span></span>${facts([
+        // The steps: where the build is among set up → writing → checking →
+        // committing, from its phase — a stage, never a percent.
+        const step = buildStepOf(claim);
+        const steps = step === null
+            ? null
+            : html `<span class="steps" role="img" aria-label="${`step ${step + 1} of ${BUILD_STEPS.length}: ${BUILD_STEPS[step]}`}">${BUILD_STEPS.map((_, index) => html `<i class="${index < step ? "on" : index === step ? "now" : ""}"></i>`)}</span>`;
+        return html `<a class="lane-card building" href="${card.href}" data-vt="${card.taskId}"><span class="id">${card.taskId}</span><span class="t"><span class="dot dot-ok pulse"></span>${card.title}</span>${steps}<span class="live-line"><span class="stage">${live}</span>${tickingClock(claim.claimedAt, data.now)}</span>${facts([
             ["worker", claim.runner],
             ...(claim.model === null
                 ? []
@@ -316,7 +384,7 @@ export function boardBody(data, ciRed) {
             const pr = row.prNumber === null
                 ? null
                 : html `<span class="badge badge-open">PR #${row.prNumber}</span>${ciRed(row.prNumber) ? html ` <span class="badge badge-failed">CI failing</span>` : null}`;
-            return html `<a class="lane-card" href="${taskHref(row.taskId)}"><span class="id">${row.taskId}</span><span class="t">${row.title}</span>${row.handoff === null ? null : html `<span class="why">${row.handoff.length > 120 ? row.handoff.slice(0, 120) + "…" : row.handoff}</span>`}${facts([
+            return html `<a class="lane-card" href="${taskHref(row.taskId)}" data-vt="${row.taskId}"><span class="id">${row.taskId}</span><span class="t">${row.title}</span>${row.handoff === null ? null : html `<span class="why">${row.handoff.length > 120 ? row.handoff.slice(0, 120) + "…" : row.handoff}</span>`}${facts([
                 ...(row.ranMinutes === null ? [] : [["ran", `${row.ranMinutes}m`]]),
                 ["usage", runCostWords({ authMode: row.authMode, costUsd: row.costUsd, tokensIn: null, tokensOut: null })],
             ])}${chips([
@@ -347,7 +415,8 @@ export function boardBody(data, ciRed) {
         data.all ? null : html `<p class="meta board-view"><strong>State</strong> · <a href="/board?view=order">order →</a> <span class="meta">drag to reorder, or to reserve a task for one worker</span></p>`,
         deltaLine,
         toggle,
-        html `<div class="board">`,
+        workerStrip(data.workers, data.cards, data.now),
+        html `<div class="board" data-now="${String(data.now.getTime())}">`,
         lane("attention", "needs you", "these wait for a person", plain),
         lane("queued", "queued", "starts when a worker is free", queuedCard),
         lane("waiting", "waiting", "paused until a time, another task, or a requirement is ready", plain),

package/dist/server/render-results.d.ts

@@ -95,9 +95,6 @@ export declare function withRefusal(href: string, code: keyof typeof RESULT_REFU
 /** The queue reads at most this many completed tasks — the store's own
  * page ceiling, admission bound before it. */
 export declare const REVIEW_QUEUE_CAP = 100;
-/** The one return road the comment endpoint honors besides its own run
- * page: the cockpit's selected-result link, exactly. */
-export declare const REVIEW_RETURN: RegExp;
 /** Review priority: a deterministic, LABELED presentation aid over facts
  * the done list already carries. Band 0 goes first; the words name why.
  * It is never a verdict — the stored proof verdict stays the authority,
@@ -287,9 +284,6 @@ export declare function reviewCockpitPage(chrome: Chrome, data: {
     user: string;
     now: Date;
 }): Screen;
-/** The selected result: intent → proof → changes → publication → acts,
- * one scan path, every fact labeled by its source. */
-export declare function reviewCockpitDetail(view: ReviewCockpitView, csrf: string, noted: boolean, canRetryReview?: boolean, tab?: ResultTab, user?: string): Html;
 /** The selected result's HTML and, for the rebuilt page, the same result
  * as data: every form and panel body is the one the HTML carries. */
 /** Where a result is shown: its own page (/review), or the Result tab of its task's page (docs/plans/one-page-task-and-agent.md),

package/dist/server/render-results.js

@@ -238,9 +238,6 @@ export function withRefusal(href, code) {
 /** The queue reads at most this many completed tasks — the store's own
  * page ceiling, admission bound before it. */
 export const REVIEW_QUEUE_CAP = 100;
-/** The one return road the comment endpoint honors besides its own run
- * page: the cockpit's selected-result link, exactly. */
-export const REVIEW_RETURN = /^\/review\?result=[A-Za-z0-9._~%-]{1,200}$/;
 export const PRIORITY_LABELS = { 0: "needs action", 1: "review", 2: "no flags" };
 export function reviewPriorityOf(row) {
     if (row.assignment != null && (row.assignment.receipt?.runId ?? null) === row.runId) {
@@ -568,11 +565,6 @@ export function reviewCockpitPage(chrome, data) {
         functional: { script: reviewEvidenceScript() + (selected !== null && selected.detail !== null ? RESULT_REVIEW_SCRIPT : ""), fetches: false },
     });
 }
-/** The selected result: intent → proof → changes → publication → acts,
- * one scan path, every fact labeled by its source. */
-export function reviewCockpitDetail(view, csrf, noted, canRetryReview = false, tab = "summary", user = "") {
-    return reviewCockpitDetailParts(view, csrf, noted, canRetryReview, tab, user).html;
-}
 export function reviewCockpitDetailParts(view, csrf, noted, canRetryReview, tab, user, host = { kind: "review" }) {
     const parts = [];
     const run = view.run;
@@ -1268,7 +1260,9 @@ export function reviewDiffHtml(patch, stat, runId, commentable, anchors = new Ma
                     ? html `<span class="diff-annotate-space"></span>`
                     : html `<button type="button" class="diff-annotate pick-line" data-path="${one.path}" data-line="${lineNumber}" data-side="${side}" aria-label="Annotate ${one.path}, ${side} line ${lineNumber}" title="Annotate this line">${annotateIcon}</button>`;
                 const marker = line.kind === "addition" ? "+" : line.kind === "deletion" ? "−" : line.kind === "context" ? " " : "·";
-                return html `<div class="diff-line diff-${line.kind}">${annotate}<span class="diff-gutter">${line.oldLine ?? ""}</span><span class="diff-gutter">${line.newLine ?? ""}</span><code><b aria-hidden="true">${marker}</b>${line.text}</code></div>`;
+                // Each real line names its file and line, so a comment (or a test) can find the exact row.
+                const named = lineNumber === null || line.kind === "meta" ? "" : html ` data-diff-file="${one.path}" data-diff-line="${lineNumber}"`;
+                return html `<div class="diff-line diff-${line.kind}"${named}>${annotate}<span class="diff-gutter">${line.oldLine ?? ""}</span><span class="diff-gutter">${line.newLine ?? ""}</span><code><b aria-hidden="true">${marker}</b>${line.text}</code></div>`;
             })}</div></section>`;
         });
         const anchor = anchors.get(one.path);

package/dist/server/render-tasks.js

@@ -1,5 +1,6 @@
 /** Task pages: approval, agents, plans, controls, decisions and the task body. */
 import { networkWords } from "../egress.js";
+import { writesWords } from "../writes-mode.js";
 import { ACP_AGENTS, isAcpProfile } from "../acp-agents.js";
 import { html, htmlString, joinHtml, postForm, replaceMarkup, reauth } from "../html.js";
 import { closedQuestionReason, closedQuestionWords } from "../decision.js";
@@ -21,17 +22,16 @@ import { starterForWork } from "../flow-starters.js";
 import {} from "../gaps.js";
 import { readAuthModeStrict } from "../keys.js";
 import { failedAttemptSentence, retryNoteOf } from "../needs-you.js";
-import { agentsSummary, chosenWords, makesNoPlan, postureWords, projectRoute, PHASES as ROUTE_PHASES, TASK_SIZES } from "../phase-routing.js";
+import { chosenWords, makesNoPlan, PHASES as ROUTE_PHASES, TASK_SIZES } from "../phase-routing.js";
 import { parseExecutionPlanDocument } from "../plan.js";
 import {} from "../planner-source.js";
 import { projectName } from "../project.js";
 import { dispatchStatusToken, manualReviewOnly, plainReasonWords, reviewConflict } from "../proof.js";
 import { providerName } from "../provider-auth.js";
-import { PROVIDER_IDS } from "../provider.js";
+import {} from "../provider.js";
 import { qualityModeTitle } from "../quality.js";
-import {} from "../result-evidence-readers.js";
 import { evidenceShortenedWords } from "../result-review.js";
-import { acceptanceToLines, approvalOf, chainFromJson, scopeAuthorityOf } from "../scope.js";
+import { acceptanceToLines, approvalOf, scopeAuthorityOf } from "../scope.js";
 import {} from "../store.js";
 import { runCostWords } from "../summary.js";
 import {} from "../task-control.js";
@@ -43,7 +43,7 @@ import { isOverdue, oneLineOf, projectChip, regionScript, safePrUrl, screen, SEN
 import { steerDestinationWords, steerStandingParts } from "../steer-status.js";
 import { reviewHref, taskChatHref, taskHref } from "./http.js";
 import { coordinatorProposalsSection } from "./render-chat.js";
-import { completionReceiptCard, criterionMatrixHtml, evidenceWords, homePhaseWords, incidentWords, needsCheck, pullRequestCardHtml, reasonWords, receiptStatusOf, repairChainHtml, reportItemsHtml, reviewRetryPanel, runNoun, runOutcomeBadge, semanticCoverageHtml, terminalDiffCard, verificationExplanation, verificationRecovered } from "./render-results.js";
+import { completionReceiptCard, criterionMatrixHtml, evidenceWords, homePhaseWords, incidentWords, needsCheck, pullRequestCardHtml, reasonWords, receiptStatusOf, repairChainHtml, reportItemsHtml, reviewRetryPanel, runNoun, runOutcomeBadge, semanticCoverageHtml, verificationExplanation, verificationRecovered } from "./render-results.js";
 import {} from "./session.js";
 import { linkWords, originNote } from "../task-source.js";
 export function contractChangeHtml(change) {
@@ -541,7 +541,7 @@ export function profileWords(scope) {
                 ? html `<p class="meta">Runs on <span class="mono">${ACP_AGENTS[profile.provider].name} (via ACP) · ${profile.model}</span> — full access inside the OS fence; the agent runs any tool it chooses and nothing asks. No turn limit: stops after ${Math.round(profile.timeoutSeconds / 60)} min, or ${Math.round(profile.idleTimeoutSeconds / 60)} min silent; repairs on ${repair}, ${Math.round(profile.repairTimeoutSeconds / 60)} min, or ${Math.round(profile.repairIdleTimeoutSeconds / 60)} min silent.</p>`
                 : html `<p class="meta">Runs on <span class="mono">${profile.provider} · ${profile.model}</span> — ${profile.sandboxMode === "danger-full-access" ? "FULL permissions via --dangerously-bypass-approvals-and-sandbox; nothing asks" : "workspace-write sandbox"}, no turn limit (${Math.round(profile.timeoutSeconds / 60)} min ${profile.timeoutKind === "idle" ? "without progress" : "per attempt"}); repairs on ${repair}, ${Math.round(profile.repairTimeoutSeconds / 60)} min</p>`;
     // What the build may reach is part of what is approved (egress.ts): said on every approval form.
-    return html `${base}<p class="meta" data-scope-network>${networkWords(profile.network ?? null)}</p>`;
+    return html `${base}<p class="meta" data-scope-network>${networkWords(profile.network ?? null)}</p><p class="meta" data-scope-writes>Writes: ${writesWords(profile.writes)}.</p>`;
 }
 export const ROLE_NOUN = { plan: "Planner", build: "Builder", repair: "Repair", review: "Reviewer" };
 export function agentsStandingWords(view) {

package/dist/server/route-table.d.ts

@@ -91,9 +91,5 @@ export interface RouteDeclaration {
 export declare const ROUTES: readonly RouteDeclaration[];
 /** The first row that declares this method and path, or null: an undeclared request never reaches a handler. */
 export declare function matchRoute(method: string, pathname: string, stage?: Stage): RouteDeclaration | null;
-/** True when some row declares this path for another method (a wrong-method request). */
-export declare function declaredForAnotherMethod(method: string, pathname: string, stage?: Stage): boolean;
 /** Refuses a malformed table at startup: duplicate ids, duplicate method+pattern rows, or a row shadowed by an earlier one for its own sample. */
 export declare function assertRouteTable(routes?: readonly RouteDeclaration[]): void;
-/** The effective policy of every row, as plain data — what the snapshot test compares. */
-export declare const routePolicySnapshot: () => Array<Omit<RouteDeclaration, "sample">>;

package/dist/server/route-table.js

@@ -283,6 +283,7 @@ post("settings", "spend.budget", "/spend/budget", { scope: "step-up", ...operato
 post("settings", "settings.project-concurrency", "/settings/project/concurrency");
 post("settings", "settings.project-live-view", "/settings/project/live-view", { scope: "step-up", callers: ["cookie"] });
 post("settings", "settings.project-network", "/settings/project/network", { scope: "step-up", callers: ["cookie"] });
+post("settings", "settings.project-writes", "/settings/project/writes", { scope: "step-up", callers: ["cookie"] });
 post("settings", "settings.project-delete", "/settings/project/delete", { scope: "step-up", ...operator("An instance operator deletes projects.", "/settings/project") });
 // Lead sweeps (docs/plans/lead-fan-out.md): the table, and cancelling what isn't ready. The handler shows a sweep only in
 // a project the reader can see, and acts only for an approver.
@@ -430,10 +431,6 @@ export function matchRoute(method, pathname, stage) {
     }
     return null;
 }
-/** True when some row declares this path for another method (a wrong-method request). */
-export function declaredForAnotherMethod(method, pathname, stage) {
-    return compiled.some(({ route, test }) => (stage === undefined || route.stage === stage) && !methodMatches(route.method, method) && test.test(pathname));
-}
 /** Refuses a malformed table at startup: duplicate ids, duplicate method+pattern rows, or a row shadowed by an earlier one for its own sample. */
 export function assertRouteTable(routes = ROUTES) {
     const ids = new Set(), keys = new Set();
@@ -465,5 +462,3 @@ export function assertRouteTable(routes = ROUTES) {
     }
 }
 assertRouteTable();
-/** The effective policy of every row, as plain data — what the snapshot test compares. */
-export const routePolicySnapshot = () => ROUTES.map(({ sample: _sample, ...rest }) => ({ ...rest }));