toolroll 0.9.76 → 0.9.77

package/dist/sandbox-runtime.d.ts

@@ -63,6 +63,14 @@ export declare const SEATBELT_NO_OTHER_TERMINAL: string;
  * any program read them (anthropics/sandbox-runtime#755). Build agents keep it (Claude Code signs in from the keychain).
  */
 export declare const SEATBELT_NO_KEYCHAIN: string;
+/**
+ * First after the profile's default deny: a mach service lookup the profile doesn't allow is still denied, unreported.
+ * On macOS 26.5 a reported mach-lookup denial now and then never answers: bootstrap_look_up blocks in launchd for good
+ * (seen as npm stuck in Node's DNS setup, dns_configuration_copy → com.apple.SystemConfiguration.DNSConfiguration, about
+ * 1 launch in 70 under load; never with the report off). Every allow after it still wins, so what is reachable is the
+ * same; only the report goes.
+ */
+export declare const SEATBELT_QUIET_MACH_DENY = "(deny mach-lookup (with no-report))";
 /**
  * Chromium, a project check's launch only: Playwright's default browser (its Chromium headless shell) registers its
  * port rendezvous service as org.chromium.Chromium.MachPortRendezvousServer.<its pid> at start, and its helpers look

package/dist/sandbox-runtime.js

@@ -122,8 +122,16 @@ export const SEATBELT_NO_OTHER_TERMINAL = [
  */
 export const SEATBELT_NO_KEYCHAIN = [
     "; Toolroll: no keychain",
-    "(deny mach-lookup (global-name \"com.apple.SecurityServer\") (global-name \"com.apple.securityd.xpc\"))",
+    "(deny mach-lookup (with no-report) (global-name \"com.apple.SecurityServer\") (global-name \"com.apple.securityd.xpc\"))",
 ].join("\n");
+/**
+ * First after the profile's default deny: a mach service lookup the profile doesn't allow is still denied, unreported.
+ * On macOS 26.5 a reported mach-lookup denial now and then never answers: bootstrap_look_up blocks in launchd for good
+ * (seen as npm stuck in Node's DNS setup, dns_configuration_copy → com.apple.SystemConfiguration.DNSConfiguration, about
+ * 1 launch in 70 under load; never with the report off). Every allow after it still wins, so what is reachable is the
+ * same; only the report goes.
+ */
+export const SEATBELT_QUIET_MACH_DENY = "(deny mach-lookup (with no-report))";
 /**
  * Chromium, a project check's launch only: Playwright's default browser (its Chromium headless shell) registers its
  * port rendezvous service as org.chromium.Chromium.MachPortRendezvousServer.<its pid> at start, and its helpers look
@@ -226,11 +234,15 @@ export function withSeatbeltRules(command, rules, expected) {
     const profile = words[exec + 2];
     if (!profile.startsWith("(version 1)\n(deny default"))
         throw shape();
+    // Where the default deny's line ends (the profile's end when it is the last line).
+    const lineEnd = profile.indexOf("\n", "(version 1)\n".length);
+    const opening = lineEnd < 0 ? profile.length : lineEnd;
     if (!/^\/[A-Za-z0-9_./-]+$/.test(words[exec + 3]))
         throw shape();
     if (expected !== undefined && words[exec + 5] !== expected)
         throw shape();
-    return srtQuote([...words.slice(0, exec + 2), `${profile}\n${rules}\n`, ...words.slice(exec + 3)]);
+    const quiet = `${profile.slice(0, opening)}\n${SEATBELT_QUIET_MACH_DENY}${profile.slice(opening)}`;
+    return srtQuote([...words.slice(0, exec + 2), `${quiet}\n${rules}\n`, ...words.slice(exec + 3)]);
 }
 /** The runtime's macOS invocation for `file args` run from `cwd`: a command line for /bin/sh. */
 export function srtMacosCommand(file, args, terms, cwd = process.cwd(), temp) {

package/dist/scope.js

@@ -1,5 +1,6 @@
 // The rubric's vocabulary loads before anything that reaches the plan contract (see contracts/acceptance-terms.ts).
 export { ACCEPTANCE_LIMITS, EVIDENCE_KINDS } from "./contracts/acceptance-terms.js";
+import { mintSecret } from "./secret-mint.js";
 import { passwordlessOn } from "./passwordless.js";
 import { currentPasswordSource, passwordGuardOf, provenPasswordAccount } from "./sign-in-guard.js";
 import { validateScopeText } from "./task-text.js";
@@ -47,10 +48,11 @@ import { z } from "zod";
 import {} from "./contracts/acceptance-terms.js";
 import { parseContract } from "./contracts/contract.js";
 import { readAcceptance, readScopeTerms, storedRubricSchema } from "./contracts/scope.js";
+import { releaseCiHoldOf, releaseCiHoldWords } from "./release-ci-hold.js";
 import { NO_READINESS, exactModelId, legOf, projectRoute, routeDigestOf, routeFromJson, routeJsonProblem, routeWords, } from "./phase-routing.js";
 /** Same shape as a runner's credential, for the same reasons. */
 function mintToken() {
-    return randomBytes(32).toString("base64url");
+    return mintSecret(32);
 }
 export function hashToken(token) {
     return createHash("sha256").update(token, "utf8").digest("hex");
@@ -1098,6 +1100,10 @@ export function approve(store, taskId, by, now, sawDigest, token, mutation = {})
         const releaseProblem = scope.releaseTerms == null ? null : releaseSealProblem(store, scope.releaseTerms);
         if (releaseProblem !== null)
             return { ok: false, reason: "policy", message: releaseProblem };
+        // Filed while CI still ran: nobody approves it before the plane read exact-head CI passing (round 1, finding 4).
+        const ciHold = releaseCiHoldOf(store, taskId);
+        if (ciHold !== null)
+            return { ok: false, reason: "policy", message: releaseCiHoldWords(ciHold) };
         const gate = store.approvalGate(taskId, by, "person");
         if (gate.verdict === "refuse")
             return { ok: false, reason: gate.reason };

package/dist/secret-mint.d.ts

@@ -0,0 +1 @@
+export declare function mintSecret(bytes: number, draw?: (size: number) => Buffer): string;

package/dist/secret-mint.js

@@ -0,0 +1,14 @@
+/**
+ * Secrets a person types or pastes on a command line (passwords, invite and approver tokens, runner credentials):
+ * random base64url, never starting with "-". A value starting with "--" reads as a flag to many parsers (`--token
+ * --abc…` was refused as a missing value: about 1 in 4096 minted passwords), so it is drawn again. The CLI accepts one
+ * anyway (an older secret), but a new one never needs that.
+ */
+import { randomBytes } from "node:crypto";
+export function mintSecret(bytes, draw = randomBytes) {
+    for (;;) {
+        const secret = draw(bytes).toString("base64url");
+        if (!secret.startsWith("-"))
+            return secret;
+    }
+}

package/dist/serve.js

@@ -14,19 +14,15 @@ import { signInsUnavailableWords } from "./check-access.js";
 import { LIVE_VIEW_CONSENT, liveCommandsShown, liveViewConsentDigest } from "./live-detail.js";
 import { html, htmlString, jsonScript, textHtml } from "./html.js";
 import { browserAssetsAvailable, browserWorkspaceDocument } from './browser-shell.js';
-import { NO_COUNTS, projectStates, STATE_WORDS } from './agent-state.js';
+import { accessKey, countsKey, indexKey, projectSummaryOf, RevisionCache, summaryKey } from './console-chrome.js';
 import { usageChipOf } from './limits-ui.js';
-/** Tasks the rail lists under a project; the rest are a count that links to the project's tasks. */
-const RAIL_TASKS = 6;
 /** Any header a proxy adds: a request carrying one is never "from this computer" (password freshness, one-time links). */
 const PROXY_HEADER = /^(forwarded|via|x-forwarded-.+|x-real-ip|x-client-ip|x-original-.+|x-cluster-client-ip|true-client-ip|cf-connecting-ip|fastly-client-ip|x-proxyuser-ip)$/i;
-/** Asks a project names for the chime (its count is complete beyond them). */
-const ASKS_PER_PROJECT = 100;
 /** How often the background checks look at what is due (docs/plans/get-side-effects.md), and how often this
  * computer's agent sign-ins are asked again. */
 const BACKGROUND_CHECKS_MS = 30_000;
 const LOCAL_AGENTS_EVERY_MS = 2 * 60_000;
-import { boundProjectSummary, browserCrewFromIndex, browserCrewOf, browserNavigationOf, browserProjectsOf, needsYouLabelOf } from './browser-workspace.js';
+import { browserCrewFromIndex, browserCrewOf, browserNavigationOf, browserProjectsOf, needsYouLabelOf } from './browser-workspace.js';
 import { sharedActionPayload } from './chat-actions.js';
 import { prepareCodingContext } from './coding-context.js';
 import { CodingWorkspace } from './coding-workspace.js';
@@ -255,6 +251,9 @@ export function createDecisionServer(options) {
         };
     };
     const workspaceRevision = prepareWorkspaceRevision(store);
+    // The sidebar, the Tasks count and the crew: read at most once per workspace revision per reader's exact access
+    // (console-chrome.ts), and filled from a read worker before a page renders when one is attached.
+    const chromeReads = new RevisionCache(workspaceRevision, clock);
     const workspaceIncarnation = randomBytes(16).toString('hex');
     const workspaceValidators = new WorkspaceValidatorCache();
     const providerHome = options.connectionHome ?? homedir();
@@ -881,6 +880,8 @@ export function createDecisionServer(options) {
                 get fresh() { return freshFacts.getStore() != null && ssoNowAvailable(who.name); } } : undefined,
             refusal: (answer, status, body) => sendScreen(answer, status, screen(status === 404 ? "Not found" : "Request refused", body, { chrome: chromeFor(who.via === "cookie" ? who.session.project : null, "work") })),
             workspaceRead,
+            freshWork: ["request", "task", "result"].some(name => url.searchParams.has(name)),
+            ...(workspaceRead && typeof request.headers['if-none-match'] === 'string' ? { workspaceIfNoneMatch: request.headers['if-none-match'] } : {}),
             workspaceRequest: url.searchParams.get('request'),
         };
         if (method === "GET" || method === "POST")
@@ -935,6 +936,16 @@ export function createDecisionServer(options) {
                             facts.workspaceValidator = { key, revision, expiresAt,
                                 etag: '"' + createHash('sha256').update(`${key}:${revision}:${expiresAt}`).digest('hex') + '"' };
                         }
+                        await prefetchChrome(route, url, who);
+                        // The worker wait lets a sign-out, credential/access change or console ceiling change land. Prove the
+                        // cookie and route again before rendering protected content or answering with a content validator.
+                        if (who.via === 'cookie') {
+                            const current = identify(request, false);
+                            if (current?.via !== 'cookie' || current.session !== who.session)
+                                return redirect(response, loginHref(url.pathname + url.search));
+                            if (!projectRequestAllowed(route, route.project, url, who, request, response, null))
+                                return;
+                        }
                         return handleGet(route, url, who, request, response);
                     }
                     return handlePost(route, url, who, request, response, body);
@@ -1480,7 +1491,10 @@ export function createDecisionServer(options) {
                 const project = s.chrome.active === 'chat' ? null : s.chrome.project;
                 crew = extras.team?.tasks ? browserCrewFromIndex(extras.team.tasks, extras.team.selected?.id) : requestFacts.workCrew?.project === project ? browserCrewFromIndex(requestFacts.workCrew.page)
                     // The reader's own lead's claims read "<name> is on it" here too.
-                    : browserCrewOf(store, clock(), { principal: 'operator', repos: managedRepos(), includeUnplaced: false, viewer: requestFacts.actor ?? null }, { evidenceRoot, project });
+                    : (() => {
+                        const access = { principal: 'operator', repos: managedRepos(), includeUnplaced: false, viewer: requestFacts.actor ?? null };
+                        return chromeRead(`crew\u0000${accessKey(access)}\u0000${project ?? ''}`, () => browserCrewOf(store, clock(), access, { evidenceRoot, project }));
+                    })();
             }
             catch {
                 notices.push('Crew updates are unavailable. Open Tasks to inspect saved work.');
@@ -1586,7 +1600,17 @@ export function createDecisionServer(options) {
                     workspaceValidators.set(validator.key, validator);
                     response.setHeader('ETag', validator.etag);
                 }
-                return respond(response, status, 'application/json; charset=utf-8', JSON.stringify(workspace));
+                const body = JSON.stringify(workspace);
+                // Every other page's re-read after a live `change` (chat keeps its own validator, and its receipt, task and
+                // result reads none): when what it renders now is exactly what the page holds, it hears 304 and keeps its view
+                // (no transfer, no re-render).
+                if (status === 200 && validator === undefined && path.pathname !== '/chat') {
+                    const etag = '"w' + createHash('sha256').update(body).digest('base64url') + '"';
+                    response.setHeader('ETag', etag);
+                    if (requestFacts.workspaceIfNoneMatch === etag)
+                        return respond(response, 304, 'application/json; charset=utf-8', '');
+                }
+                return respond(response, status, 'application/json; charset=utf-8', body);
             }
             const nonce = randomBytes(16).toString('base64');
             // React owns the conversation and its refresh/draft lifecycle. Native
@@ -1623,8 +1647,9 @@ export function createDecisionServer(options) {
         return page(response, status, document, nonce, s.functional?.fetches === true || chromeLayer || sensitiveChrome !== "");
     }
     /** The needs-you count every surface wears, read from this request's own
-     * Work counts (one query per request, never a cached earlier one), so a
-     * live page's badge and its Needs you tab always agree. */
+     * Work counts (one read per request, kept only while the workspace revision
+     * it was read at stands), so a live page's badge and its Needs you tab
+     * always agree. */
     function needsYouBadge(project) {
         return needsYouCount(project);
     }
@@ -1653,44 +1678,8 @@ export function createDecisionServer(options) {
     function projectSummary() {
         const projects = sidebarProjects();
         const actor = requestContext.getStore()?.actor ?? '';
-        const states = new Map(projectStates(store, workAccess(), actor, clock(), evidenceRoot, projects.map(one => one.path)).map(one => [one.repo, one]));
-        // A row that needs a person or failed says what the Tasks list says it needs (its own next step); a row at work says
-        // what its agent did last; a finished one says Done.
-        const asking = [...states.values()].flatMap(one => one.families.slice(0, RAIL_TASKS)).filter(one => one.state === 'needs-you' || one.state === 'failed').map(one => one.rootId);
-        const needWords = new Map();
-        if (asking.length > 0) {
-            try {
-                // Every row the rail may list, in pages the index allows.
-                for (let at = 0; at < asking.length; at += WORK_INDEX_MAX_LIMIT)
-                    for (const item of workIndexPage(store, clock(), workAccess(), { roots: asking.slice(at, at + WORK_INDEX_MAX_LIMIT), limit: WORK_INDEX_MAX_LIMIT, root: evidenceRoot }).items)
-                        needWords.set(item.rootId, item.status.detail !== '' ? item.status.detail : item.status.label);
-            }
-            catch { /* the rows keep their state's words */ }
-        }
-        // The chime's subjects: an opaque key per obligation and version, scoped to this reader (no words, no ids in it).
-        const keyOf = (...parts) => createHash('sha256').update([actor, ...parts].join('\u0000')).digest('base64url').slice(0, 22);
-        // Newest first, so a new ask always has a key however many older ones wait (those were heard when they were new).
-        const asksOf = (state) => [
-            ...(state?.families ?? []).flatMap(one => one.ask === undefined ? [] : [{ at: one.ask.at, ask: { key: keyOf('task', one.rootId, one.ask.version), task: one.rootId, run: one.ask.run, at: one.ask.at } }]),
-            ...(state?.flowAsks ?? []).map(one => ({ at: one.at, ask: { key: keyOf('flow', one.card, one.stage, one.entry), task: null, run: null, at: one.at } })),
-        ].sort((a, b) => b.at.localeCompare(a.at)).slice(0, ASKS_PER_PROJECT).map(one => one.ask);
-        const railOf = (state) => {
-            const families = state?.families ?? [];
-            const tasks = families.slice(0, RAIL_TASKS).flatMap((one) => {
-                const task = store.getTask(one.rootId);
-                const line = one.state === 'needs-you' || one.state === 'failed' ? needWords.get(one.rootId) ?? null : one.line;
-                return task === null ? [] : [{ id: one.rootId, title: task.title, href: `/t/${encodeURIComponent(one.rootId)}`, state: one.state, line: line ?? STATE_WORDS[one.state] }];
-            });
-            return { tasks, more: Math.max(0, families.length - RAIL_TASKS), asks: asksOf(state) };
-        };
-        const rows = projects.map(one => {
-            const state = states.get(one.path);
-            return { path: one.path, name: one.name, href: `/work?project=${encodeURIComponent(one.path)}`, state: state?.state ?? 'idle', counts: state?.counts ?? { ...NO_COUNTS }, ...railOf(state) };
-        });
-        const unplaced = states.get(null);
-        if (unplaced !== undefined && unplaced.state !== 'idle')
-            rows.push({ path: null, name: 'No project', href: '/work', state: unplaced.state, counts: unplaced.counts, ...railOf(unplaced) });
-        return boundProjectSummary(rows);
+        const access = workAccess();
+        return chromeRead(summaryKey(actor, access, projects), () => projectSummaryOf(store, clock(), access, actor, projects, evidenceRoot));
     }
     /** What one account may see now, as the summary room keys it: a narrowed ceiling or grant is a different key, so a
      * snapshot read for the wider scope never reaches it. Null: no such account. */
@@ -1777,13 +1766,15 @@ export function createDecisionServer(options) {
             ...(scope === undefined ? {} : { scope }),
         };
     }
-    // All project counts are read together. No task artifacts or processes are
-    // inspected to paint a badge or a project switcher.
+    // All project counts are read together, at most once per workspace revision
+    // for this reader's access. No task artifacts or processes are inspected to
+    // paint a badge or a project switcher.
     function projectCounts(now) {
         const facts = requestContext.getStore();
         if (facts?.workCounts !== undefined)
             return facts.workCounts;
-        const counts = workCountsByProject(store, now, workAccess());
+        const access = workAccess();
+        const counts = chromeRead(countsKey(access), () => workCountsByProject(store, now, access));
         if (facts !== undefined)
             facts.workCounts = counts;
         return counts;
@@ -1793,6 +1784,64 @@ export function createDecisionServer(options) {
             .reduce((sum, one) => sum + one.totals['needs-you'], 0);
         return { count, saturated: false };
     }
+    /** One work index page for an already-admitted reader, through the chrome cache: a whole view the chat landing reads
+     * on every refresh. */
+    function sharedIndexPage(access, options) {
+        // Receipt reconciliation, task and result reads always read work afresh (disk state included).
+        if (requestContext.getStore()?.freshWork === true)
+            return workIndexPage(store, clock(), access, options);
+        return chromeRead(indexKey(access, options), () => workIndexPage(store, clock(), access, options));
+    }
+    /** A chrome read for this request: what it already read (its prefetch included) stands for the whole request, else
+     * the revision cache's value, else `compute()` now. */
+    function chromeRead(key, compute) {
+        const facts = requestContext.getStore();
+        const held = facts?.chromeReads?.get(key);
+        if (held !== undefined)
+            return held;
+        const value = chromeReads.read(key, compute);
+        if (facts !== undefined)
+            (facts.chromeReads ??= new Map()).set(key, value);
+        return value;
+    }
+    /** The chat landing's three whole views (chat.ts chatHomeOf), as it asks for them. */
+    const chatHomeViews = () => ["all", "needs-you", "completed"]
+        .map(view => ({ view, limit: WORK_INDEX_MAX_LIMIT, ...(evidenceRoot === undefined ? {} : { root: evidenceRoot }) }));
+    /** Pages that wear the chrome (the sidebar's states and the Tasks count). */
+    const CHROME_PAGES = new Set(["home", "work", "board", "agents", "agents.live", "task.page", "run.page", "chat.page", "review", "tasks", "inbox",
+        "next", "done", "projects.page", "flows.page", "flow.page", "settings.page", "decision.page", "menu"]);
+    /** Before a chromed page renders: its chrome reads (and the chat landing's views) run on a read worker, so the
+     * request thread finds them cached instead of computing them. The reader is the one this request admitted; the keys
+     * carry its exact access (console-chrome.ts). Without a worker, or when one fails, the page computes them as before. */
+    async function prefetchChrome(route, url, who) {
+        if (reads === null || who.via !== "cookie" || !CHROME_PAGES.has(route.id))
+            return;
+        try {
+            const actor = requestContext.getStore()?.actor ?? "";
+            const access = workAccess(), projects = sidebarProjects(), now = clock();
+            // Populate only the revision cache. Each answer must still pass its revision/expiry check when rendering:
+            // another job can remain pending while an earlier answer's approval or Needs-you state changes.
+            const fill = async (key, read) => { await chromeReads.fill(key, read); };
+            const jobs = [
+                fill(countsKey(access), () => reads.workCounts(now, access)),
+                fill(summaryKey(actor, access, projects), () => reads.projectSummary(now, access, actor, projects, evidenceRoot)),
+            ];
+            if (route.id === "chat.page") {
+                if (!["project", "room", "team"].some(name => url.searchParams.has(name)) && requestContext.getStore()?.freshWork !== true)
+                    for (const options of chatHomeViews())
+                        jobs.push(fill(indexKey(access, options), () => reads.workIndexPage(now, access, options)));
+                // The conversation's briefing (chat.ts: the fleet snapshot's states), read as chat reads it.
+                const repos = managedRepos();
+                if (repos.length > 0 && requestContext.getStore()?.freshWork !== true) {
+                    const fleet = { principal: "operator", repos, includeUnplaced: false, viewer: who.name };
+                    const options = { limit: 100, ...(evidenceRoot === undefined ? {} : { root: evidenceRoot }) };
+                    jobs.push(fill(indexKey(fleet, options), () => reads.workIndexPage(now, fleet, options)));
+                }
+            }
+            await Promise.all(jobs);
+        }
+        catch { /* the page computes what is missing */ }
+    }
     /** A live page's own beat without a docked chat: 10 s while any admitted task is building, else 30 s. */
     function liveRefreshSeconds() {
         return projectCounts(clock()).some(one => one.totals.running > 0) ? 10 : 30;
@@ -2073,6 +2122,7 @@ export function createDecisionServer(options) {
         get projectFamilyPeek() { return projectFamilyPeek; },
         get needsYouBadge() { return needsYouBadge; },
         get liveRefreshSeconds() { return liveRefreshSeconds; },
+        get sharedIndexPage() { return sharedIndexPage; },
         get chatKeyFor() { return chatKeyFor; },
         get chatCatalog() { return chatCatalog; },
         get chatCatalogKnown() { return chatCatalogKnown; },

package/dist/server/chat.js

@@ -44,7 +44,7 @@ import {} from "./render-pages.js";
 import { completionForm, hardBlockerOf, homePhaseWords, owedAcceptanceOf, resultPanelHtml } from "./render-results.js";
 import { browserCaller, oneLineUa } from "./session.js";
 export function createChatHandlers(runtime) {
-    const { firstRunStepsNow, managedRepos, leadWords, store, options, phoneSetup, visible, liveTurns, leadSaid, evidenceRoot, clock, sessions, CHAT_CANDIDATE_TTL_MS, chatFetcher, CHAT_CANDIDATES_PER_APPROVER, chatCeilingDigest, workAccess, familyOf, firstTasks, leadPrincipal, taskChatFocus, chatScopeOf, leadConversationRows, demoLeadHere, sendScreen, chromeFor, teamBrowserReply, team, teamChatProvider, runVisible, runIsLive, resultDetailOf, pullRequestTargetOf, chatEnablement, startLeadConversation, projectFamilyPeek, needsYouBadge, liveRefreshSeconds, chatKeyFor, chatCatalog, chatCatalogKnown, providerHome, mintApprovalNonce, checkLocalAgents, agentSignInCommand, bustBadge, authenticateApprover, revisionDestination, armTaskResume, consumeApprovalNonce } = runtime;
+    const { firstRunStepsNow, managedRepos, leadWords, store, options, phoneSetup, visible, liveTurns, leadSaid, evidenceRoot, clock, sessions, CHAT_CANDIDATE_TTL_MS, chatFetcher, CHAT_CANDIDATES_PER_APPROVER, chatCeilingDigest, workAccess, familyOf, firstTasks, leadPrincipal, taskChatFocus, chatScopeOf, leadConversationRows, demoLeadHere, sendScreen, chromeFor, teamBrowserReply, team, teamChatProvider, runVisible, runIsLive, resultDetailOf, pullRequestTargetOf, chatEnablement, sharedIndexPage, startLeadConversation, projectFamilyPeek, needsYouBadge, liveRefreshSeconds, chatKeyFor, chatCatalog, chatCatalogKnown, providerHome, mintApprovalNonce, checkLocalAgents, agentSignInCommand, bustBadge, authenticateApprover, revisionDestination, armTaskResume, consumeApprovalNonce } = runtime;
     // The read-only refresh (package 2): the same JSON status as before —
     // session binding, the send receipt, the live turn — plus a version
     // of the DISPLAYED facts and, only when the caller's version differs,
@@ -273,7 +273,7 @@ export function createChatHandlers(runtime) {
         if (repos.length > 0) {
             try {
                 fleetSnapshot = store.chatSnapshot(repos, now);
-                const summaries = workIndexPage(store, now, { principal: 'operator', repos, includeUnplaced: false, viewer: who.name }, { limit: 100, root: evidenceRoot }).items;
+                const summaries = sharedIndexPage({ principal: 'operator', repos, includeUnplaced: false, viewer: who.name }, { limit: 100, ...(evidenceRoot === undefined ? {} : { root: evidenceRoot }) }).items;
                 fleetSnapshot.assignmentStates = Object.fromEntries(summaries.flatMap(value => [value.rootId, value.activeTaskId].map(id => [id, { state: value.assignmentState, label: value.status.label, detail: value.status.detail }])));
                 fleetSnapshot.attentionCount = needsYouBadge(null);
             }
@@ -1452,9 +1452,9 @@ export function createChatHandlers(runtime) {
                 agent: `${providerName(run.provider)} on ${run.runner}`, phase: homePhaseWords(run), project: run.repo === null ? null : projectName(run.repo), since: run.startedAt,
                 activity: runActivityOf(store, run, now) };
         });
-        const all = workIndexPage(store, now, access, { view: "all", limit: WORK_INDEX_MAX_LIMIT, root: evidenceRoot });
-        const needs = workIndexPage(store, now, access, { view: "needs-you", limit: WORK_INDEX_MAX_LIMIT, root: evidenceRoot });
-        const done = workIndexPage(store, now, access, { view: "completed", limit: WORK_INDEX_MAX_LIMIT, root: evidenceRoot });
+        // The three whole views, read at most once per workspace revision (and on a read worker first when one is attached).
+        const view = (name) => sharedIndexPage(access, { view: name, limit: WORK_INDEX_MAX_LIMIT, ...(evidenceRoot === undefined ? {} : { root: evidenceRoot }) });
+        const all = view("all"), needs = view("needs-you"), done = view("completed");
         const weekAgo = new Date(now.getTime() - 7 * 86_400_000).toISOString();
         const counts = [
             { key: "working", label: "Working now", value: agents.length, href: "/work?view=running" },

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

@@ -533,6 +533,8 @@ export declare function taskBodyParts(data: {
         kind: "checking" | "approved";
         candidate: string;
     } | null;
+    /** A release task filed while its pull request's CI still runs (a person may approve now; nothing deploys before CI passes). */
+    releaseCiRunning?: boolean;
     /** One approval per release (release-once.md): the release this task belongs to, and whether this reader may stop it. */
     release?: ReleaseView | null;
     canStopRelease?: boolean;

package/dist/server/render-tasks.js

@@ -1,6 +1,7 @@
 /** Task pages: approval, agents, plans, controls, decisions and the task body. */
 import { networkWords } from "../egress.js";
 import { releaseAsksAgainWords, releaseTermsSentence } from "../scope.js";
+import { RELEASE_CI_RUNNING_WORDS } from "../release-ci-hold.js";
 import { writesWords } from "../writes-mode.js";
 import { checkAccessWords } from "../check-access.js";
 import { sandboxTermsWords } from "../project-sandbox.js";
@@ -1501,7 +1502,7 @@ export function taskBodyParts(data) {
             scope.touches.length === 0 ? "" : html `<p class="scope-paths"><strong>Touches</strong> ${scope.touches.join(", ")}</p>`,
             html `<p><strong>Quality</strong> ${qualityModeTitle(scope.qualityMode ?? "default")}</p>`,
             acceptanceCeremonyHtml(scope.acceptance),
-            scope.releaseTerms == null ? "" : html `<p><strong>Release</strong></p><p class="recap">${releaseTermsSentence(scope.releaseTerms)}</p>${scope.releaseTerms.policy.carry ? html `<details><summary>What asks again</summary><ul>${joinHtml(releaseAsksAgainWords(scope.releaseTerms).map(line => html `<li>${line}</li>`), "")}</ul></details>` : ""}`,
+            scope.releaseTerms == null ? "" : html `<p><strong>Release</strong></p><p class="recap">${releaseTermsSentence(scope.releaseTerms)}</p>${data.releaseCiRunning === true ? html `<p class="meta">${RELEASE_CI_RUNNING_WORDS}</p>` : ""}${scope.releaseTerms.policy.carry ? html `<details><summary>What asks again</summary><ul>${joinHtml(releaseAsksAgainWords(scope.releaseTerms).map(line => html `<li>${line}</li>`), "")}</ul></details>` : ""}`,
             approval.approved && data.autoRelease != null
                 ? html `<p class="meta scope-seal">${autoReleaseWords(data.autoRelease)} · <span class="seal">signs ${shortDigest(scope.digest)}</span></p>`
                 : approval.approved && data.release?.kind === "carried"

package/dist/server/request-context.d.ts

@@ -20,12 +20,18 @@ export type RequestFacts = {
     createdTask?: string;
     browser?: boolean;
     workspaceRead?: boolean;
+    /** Receipt reconciliation, task and result reads (`request`, `task`, `result`): work is read afresh, never cached. */
+    freshWork?: boolean;
+    /** A workspace re-read's If-None-Match: the content validator it holds from its last read. */
+    workspaceIfNoneMatch?: string;
     workspaceRequest?: string | null;
     workCounts?: ReturnType<typeof workCountsByProject>;
     workCrew?: {
         project: string | null;
         page: WorkIndexPage;
     };
+    /** The chrome this request already read (console-chrome.ts keys): one snapshot per request, however often it asks. */
+    chromeReads?: Map<string, unknown>;
     lens?: string | null;
     workspaceValidator?: {
         key: string;

package/dist/server/runtime.d.ts

@@ -153,6 +153,8 @@ export interface ServerRuntime {
         saturated: boolean;
     };
     liveRefreshSeconds: () => number;
+    /** One work index page for an already-admitted reader, read at most once per workspace revision (console-chrome.ts). */
+    sharedIndexPage: (access: import("../work-summary.js").WorkSummaryAccess, options: import("../work-index.js").WorkIndexOptions) => import("../work-index.js").WorkIndexPage;
     chatKeyFor: (provider: DirectChatProviderId) => {
         key: string;
         source: "environment" | "stored";

package/dist/server/task-views.js

@@ -1,9 +1,10 @@
 import { releaseViewOf } from "../release-view.js";
+import { releaseCiRunningOf } from "../release-ci-hold.js";
 import { releaseObligationsOf } from "../release-recheck.js";
 import { approvalProofOf, freshlyApprovable, freshnessFor, withFreshness } from "../scope.js";
 import { liveAttemptOf, steerControlsFor } from "../steer-controls.js";
 import { originOf } from "../task-source.js";
-import { taskBaseOf } from "../task-base.js";
+import { recentGitReads, taskBaseOf } from "../task-base.js";
 import { assignmentPresentationOf, historicalAssessmentReason } from '../assignment-presentation.js';
 import { html, joinHtml } from "../html.js";
 import { assignmentStatusOf, assignmentWithEvidence } from '../assignment-ui.js';
@@ -53,6 +54,9 @@ import {} from "../store.js";
 import { taskControlOf } from "../task-control.js";
 import { lastErrorLineOf, missedRequirementOf, workStatusOf } from "../workspace-ui.js";
 export function createTaskViews(runtime) {
+    // The task page's base line reads Git through a frozen view of the project (~0.2-0.5 s on a large repository) and
+    // the page renders it twice per view and again on every live refresh: its answers are kept for a moment.
+    const baseGit = recentGitReads();
     /** The first task's way to Ready shows until the first Ready result, and stays on the installation's first task. */
     function guided(rootId, now) {
         if (runtime.store.isDemo())
@@ -491,12 +495,13 @@ export function createTaskViews(runtime) {
                 return { rows, decisions: decisionsFor(runtime.store, rows), now };
             })(),
             steering: ref === null ? [] : runtime.store.listSteerNotes(ref.id),
-            base: taskBaseOf(runtime.store, taskId),
+            base: taskBaseOf(runtime.store, taskId, baseGit),
             steeringLive: ref !== null && runtime.store.steeringLiveBuild(ref.id, now) !== null,
             steeringRun: ref === null ? null : runtime.store.steeringLiveBuild(ref.id, now),
             release: ref === null ? null : releaseViewOf(runtime.store, ref.externalId, now, authority => releaseObligationsOf(runtime.store, runtime.evidenceRoot, authority)),
             canStopRelease: who.role === "approver" && who.via === "cookie",
             autoRelease: ref === null ? null : autoReleaseOf(runtime.store.getScope(ref.externalId)),
+            releaseCiRunning: ref !== null && releaseCiRunningOf(runtime.store, ref.externalId) !== null,
             approvalProof: (() => {
                 // The proof of the approval shown: its approver, its exact sealed digest (approvedDigest === digest when approved).
                 const scope = ref === null ? null : runtime.store.getScope(ref.externalId);

package/dist/setup-guide.d.ts

@@ -15,10 +15,10 @@ export declare function detectPreparation(repo: string): {
 } | null;
 /** Browser installation may write only this known file inside its project. */
 export declare function previewProjectInstructions(repo: string): {
-    content?: never;
     ok: false;
     message: string;
     plan?: never;
+    content?: never;
     fingerprint?: never;
     installed?: never;
 } | {
@@ -30,10 +30,10 @@ export declare function previewProjectInstructions(repo: string): {
     installed: boolean;
 };
 export declare function addProjectInstructions(repo: string, fingerprint: string): {
-    content?: never;
     ok: false;
     message: string;
     plan?: never;
+    content?: never;
     fingerprint?: never;
     installed?: never;
 } | import("./skills.js").InstallResult;

package/dist/storage.d.ts

@@ -36,3 +36,8 @@ export declare function storageReport(store: Store, databaseFile: string, checko
     lines: StorageLine[];
 };
 export declare function bytesWords(bytes: number): string;
+/** diskBytes without holding the event loop: the same one `du` per 200 paths and the same bounds, awaited. A console
+ * measuring its checkouts (tens of GB) used to stall every page for as long as `du` took. */
+export declare function diskBytesAsync(paths: readonly string[], run?: typeof duOnce): Promise<Map<string, number>>;
+/** `du -sk` over a batch, its output whatever it managed (a slow disk or a failure answers what it has, or nothing). */
+declare function duOnce(batch: readonly string[]): Promise<string>;

package/dist/storage.js

@@ -7,7 +7,7 @@
  * what slips through: stale test temp folders, leftover processes, extra
  * staged runtimes and dependency installs unused for a week.
  */
-import { spawnSync } from "node:child_process";
+import { execFile, spawnSync } from "node:child_process";
 import { lstatSync, readdirSync } from "node:fs";
 import { basename, dirname, join } from "node:path";
 import { DEPS_FOLDER, sharedCopies } from "./shared-deps.js";
@@ -190,3 +190,30 @@ export function bytesWords(bytes) {
         return `${Math.round(bytes / 1024 ** 2)} MB`;
     return `${Math.round(bytes / 1024)} KB`;
 }
+/** diskBytes without holding the event loop: the same one `du` per 200 paths and the same bounds, awaited. A console
+ * measuring its checkouts (tens of GB) used to stall every page for as long as `du` took. */
+export async function diskBytesAsync(paths, run = duOnce) {
+    const sizes = new Map();
+    if (paths.length === 0)
+        return sizes;
+    if (process.platform !== "win32") {
+        for (let at = 0; at < paths.length; at += 200) {
+            const batch = paths.slice(at, at + 200);
+            for (const line of (await run(batch)).split("\n")) {
+                const match = /^(\d+)\t(.+)$/.exec(line);
+                if (match !== null && batch.includes(match[2]))
+                    sizes.set(match[2], Number(match[1]) * 1024);
+            }
+        }
+    }
+    for (const path of paths)
+        if (!sizes.has(path))
+            sizes.set(path, treeBytes(path));
+    return sizes;
+}
+/** `du -sk` over a batch, its output whatever it managed (a slow disk or a failure answers what it has, or nothing). */
+function duOnce(batch) {
+    return new Promise(resolve => {
+        execFile("du", ["-sk", ...batch], { encoding: "utf8", maxBuffer: 16 * 1024 * 1024, timeout: 60_000 }, (_error, stdout) => resolve(typeof stdout === "string" ? stdout : ""));
+    });
+}

package/dist/store.d.ts

@@ -7780,3 +7780,13 @@ export type AgentsLiveRun = Run & {
  * Visibility is the caller's: it filters each by the console's ceiling and the viewer's access.
  */
 export declare function agentsLiveRuns(store: Store, endedSince: Date): AgentsLiveRun[];
+/**
+ * This runner's watches a predecessor left needing recovery (Codex review round 1, finding 2): a watch lease still
+ * live, or one whose holder left a claim open (or a run open under a claim a reaper already released). A replacement
+ * worker takes each over — recovering the holder's incarnation in the same transaction — before it admits new work,
+ * whichever projects its start names (a project being removed when the predecessor died is in none of them).
+ */
+export declare function predecessorWatches(store: Store, runner: string, now: Date): {
+    repo: string;
+    owner: string;
+}[];