toolroll 0.9.73 → 0.9.75

package/dist/serve.js

@@ -1,3 +1,13 @@
+import { secretFolder } from "./tool-secret-store.js";
+import { acceptedIdentities, recoverLearning } from "./project-learning.js";
+import { loadOrCreateVapidKeys } from "./push.js";
+import { checkoutPlan } from "./checkout-cleanup.js";
+import { latestReleaseFor } from "./server/render-settings.js";
+import { LastChecks } from "./server/last-checks.js";
+import { readProviderKey } from "./keys.js";
+import { closeExpiredUnattendedGrants } from "./flow-unattended.js";
+import { isKeyedProvider } from "./acp-agents.js";
+import { PROVIDER_IDS } from "./provider.js";
 import { taskMovedSince } from "./chat-ask.js";
 import { linuxFenceAvailable, macosFenceAvailable } from "./agent-fence.js";
 import { signInsUnavailableWords } from "./check-access.js";
@@ -12,6 +22,10 @@ const RAIL_TASKS = 6;
 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 { sharedActionPayload } from './chat-actions.js';
 import { prepareCodingContext } from './coding-context.js';
@@ -24,6 +38,7 @@ import { configureLeadFollow, recordLeadFollowFailure, runLeadFollowPass } from
 import { leadNameOf } from "./lead-identity.js";
 import { createLiveBus, followWorkspace } from "./live-bus.js";
 import { startMaintenance } from './maintenance.js';
+import { asReadOnlyRequest } from './read-only-request.js';
 import { connectionsOf, localConnectOf, oneClickOf } from "./mcp-connect.js";
 import { MOBILE_VIEWPORT_SCRIPT } from "./mobile-viewport.js";
 import { projectAuthority } from "./project-access.js";
@@ -99,7 +114,7 @@ import { hasForbiddenControls } from "./decision.js";
 import { UPDATE_PAUSED, updateAdmissionPaused } from "./desktop-update-gate.js";
 import { scanForSecrets } from "./evidence.js";
 import { run as execRun } from "./exec.js";
-import { firstRunSteps, signInCommandFor } from "./first-run.js";
+import { findFirstTasks, firstRunSteps, signInCommandFor } from "./first-run.js";
 import { installMethod } from "./install-method.js";
 import { createIntegrationMonitor } from "./integrations.js";
 import { logEvent } from "./log.js";
@@ -139,7 +154,7 @@ import { createSettingsHandlers } from './server/settings.js';
 import { requestContext } from "./server/request-context.js";
 import { chromeScript, DEMO_BANNER, DEMO_BANNER_SHORT, focusDocument, KBD_HELP, pinnedTheme, QUEUE_VIEW, refuse, screen, SENSITIVE_INPUT, shell, sidebarScript } from "./server/chrome.js";
 import { BODY_CAP, form, loginHref, matchTaskPath, page, projectChatHref, redactedPath, redirect, respond, safeReturn, SHUTDOWN_WAIT_MS, taskChatHref } from "./server/http.js";
-import { decisionsFor, LEAD_BY_DEFAULT_FACT, leadBrowserMessages, leadChatVersion, TASK_COMPOSER_MODES, teamProposalCardParts } from "./server/render-chat.js";
+import { decisionsFor, LEAD_BY_DEFAULT_FACT, leadBrowserMessages, leadChatVersion, NOT_STARTED_SESSION, TASK_COMPOSER_MODES, teamProposalCardParts } from "./server/render-chat.js";
 import {} from "./server/render-pages.js";
 import { ssoStepUps, wrongHostPage } from "./server/render-people.js";
 import { NO_PROJECT, NO_TOUCH_FRAGMENTS, NONCE_CAP, NONCE_TTL_MS, PersistentSessions, SESSION_ABSOLUTE_MS, SESSION_IDLE_MS, sessionWithinLifetime, SIGN_IN_LINK_MS, SIGN_IN_LINK_PATH } from "./server/session.js";
@@ -245,8 +260,26 @@ export function createDecisionServer(options) {
     const providerHome = options.connectionHome ?? homedir();
     const checkConnection = createConnectionChecker({ home: providerHome, clock, ...(options.connectionProbe === undefined ? {} : { probe: options.connectionProbe }) });
     // Every sign-in check the console makes also answers a sign-in pause.
+    // Whether this computer can fence agents: asked once as the console starts (a sandbox running /usr/bin/true), so
+    // Settings → Project never starts a process (docs/plans/get-side-effects.md).
+    const fenceHere = options.fenceAvailable === undefined ? macosFenceAvailable() || linuxFenceAvailable() : false;
+    // Phone notifications' signing pair, made once as the console starts so /push/key only reads it.
+    if (options.telegramTokenFile !== undefined) {
+        try {
+            loadOrCreateVapidKeys(dirname(options.telegramTokenFile));
+        }
+        catch { /* /push/key says push is not set up */ }
+    }
+    // The last answer of every other check a page shows (docs/plans/get-side-effects.md).
+    const lastChecks = new LastChecks();
+    /** The newest release, asked of npm (Settings → Updates shows the last answer). */
+    const checkRelease = () => lastChecks.run("release", () => latestReleaseFor(options.updates?.latest));
+    // What each sign-in check said last: what a page shows (docs/plans/get-side-effects.md). A page never checks.
+    const knownConnections = new Map();
+    const connectionKnown = (provider) => knownConnections.get(provider) ?? null;
     const connectionCheck = async (provider, fresh) => {
         const value = await checkConnection(provider, fresh);
+        knownConnections.set(provider, value);
         try {
             noteSignInProbe(store, provider, value.state, clock());
         }
@@ -382,6 +415,17 @@ export function createDecisionServer(options) {
             ssoProvider = { issuer, provider: found.provider, at: Date.now() };
         return found;
     }
+    /** The identity provider as last discovered: what starting a sign-in uses (a GET, so it fetches nothing,
+     * docs/plans/get-side-effects.md). Discovered as the console starts, by the background checks every ten minutes, and
+     * when sign-in settings are saved or tested. */
+    function providerKnown(issuer) {
+        return ssoProvider !== null && ssoProvider.issuer === issuer ? ssoProvider.provider : null;
+    }
+    {
+        const settings = ssoSettings();
+        if (settings !== null)
+            void providerFor(settings.issuer).catch(() => undefined);
+    }
     /** Password sign-in is only for instance operators when the provider says so (a way in if it's down). */
     const passwordAllowed = (name) => { const settings = ssoSettings(); return settings === null || settings.passwords === "everyone" || store.isInstanceOperator(name); };
     const minutesWords = (ms) => { const minutes = Math.max(1, Math.ceil(ms / 60_000)); return minutes >= 120 ? `${Math.round(minutes / 60)} hours` : `${minutes} minute${minutes === 1 ? "" : "s"}`; };
@@ -456,7 +500,7 @@ export function createDecisionServer(options) {
             setting: store.projectCheckAccess(repo), changed: store.projectCheckAccessChange(repo),
             canNarrow: who.via === "cookie" && who.role === "approver" && !store.isDemo() && store.accountCanAccess(who.name, repo),
             canWiden: who.via === "cookie" && !store.isDemo() && store.isInstanceOperator(who.name),
-            unconfinedHere: !(options.fenceAvailable?.() ?? (macosFenceAvailable() || linuxFenceAvailable())) && store.unfencedAgentsAllowed(),
+            unconfinedHere: !(options.fenceAvailable?.() ?? fenceHere) && store.unfencedAgentsAllowed(),
             signInsUnavailable: signInsUnavailableWords(options.platform ?? process.platform),
         },
         liveView: (() => {
@@ -613,7 +657,9 @@ export function createDecisionServer(options) {
     const server = createServer((request, response) => {
         instrumentRequest(store.telemetry, request, response);
         // Every password checked while answering counts against where this request came from (sign-in-guard.ts).
-        void withPasswordSource(joinSourceOf(request), () => handle(request, response)).catch(error => {
+        // A GET or HEAD only reads (docs/plans/get-side-effects.md): store reads that would tidy up as they go don't.
+        const answer = () => handle(request, response);
+        void withPasswordSource(joinSourceOf(request), () => request.method === "GET" || request.method === "HEAD" ? asReadOnlyRequest(answer) : answer()).catch(error => {
             // Every unhandled error is logged (v99): the path and the message, never the request's body or query.
             logEvent("error", "serve.error", { method: request.method, path: redactedPath(new URL(request.url ?? "/", "http://placeholder").pathname), error: error instanceof Error ? error.message : String(error) });
             if (envValue(process.env, "SERVE_DEBUG") === "1")
@@ -775,7 +821,9 @@ export function createDecisionServer(options) {
         // Passive polls authenticate without extending the browser session.
         const fragmentName = url.searchParams.get("fragment");
         const workspaceRead = method === "GET" && url.searchParams.get('format') === 'workspace';
-        const touch = !(method === "GET" && (edgeRoute?.domain === 'live' || workspaceRead || (fragmentName !== null && NO_TOUCH_FRAGMENTS.has(fragmentName)) || /^\/code\/[a-f0-9]{32}\/state$/.test(url.pathname) || url.pathname === '/term/state'));
+        const touch = !(method === "GET" && (edgeRoute?.domain === 'live' || workspaceRead || (fragmentName !== null && NO_TOUCH_FRAGMENTS.has(fragmentName)) || /^\/code\/[a-f0-9]{32}\/state$/.test(url.pathname) || url.pathname === '/term/state'
+            // The Agents view's Live grid only watches: its polls never extend or write the session.
+            || url.pathname === '/agents/live' || /^\/agents\/live\/[0-9]{1,15}$/.test(url.pathname) || (url.pathname === '/agents' && url.searchParams.get('view') === 'live')));
         const refuseBudget = (admitted) => {
             if (admitted.ok)
                 return false;
@@ -1071,9 +1119,9 @@ export function createDecisionServer(options) {
             .finally(() => { localSignInChecking = null; });
         return localSignInChecking;
     }
+    /** The last answer only (docs/plans/get-side-effects.md): this computer is asked again by the background checks or a
+     * person's Check now, never because a page was opened. */
     function localAgentSignedIn() {
-        if (localSignInChecking === null && (localSignIn === null || Date.now() - localSignIn.at > 30_000))
-            void checkLocalAgents();
         return localSignIn?.signedIn ?? null;
     }
     /**
@@ -1139,12 +1187,15 @@ export function createDecisionServer(options) {
         const allCoordinatorRows = store.listCoordinatorProposals({ repos: managedRepos(), states: ["pending", "confirmed", "refused"], limit: 30 });
         const coordinatorProposals = focusTask !== null ? allCoordinatorRows.filter(one => focusTask.family.versions.some(version => version.id === one.payload["task"]))
             : chatProject !== null ? allCoordinatorRows.filter(one => one.repo === chatProject) : allCoordinatorRows;
-        const opened = store.openLeadThread(who.name, principal.ceilingDigest, now, chatScopeOf(focusTask, chatProject));
-        const proposals = store.listLeadProposals(opened.thread.id);
+        // A visit only reads (quiet page visits): this opens no thread. The first message opens it (chatSend), and a
+        // live thread kept under another ceiling is what that message replaces, so it reads here as the earlier one.
+        const found = store.liveLeadThreadFor(who.name, chatScopeOf(focusTask, chatProject));
+        const thread = found !== null && found.ceilingDigest === principal.ceilingDigest ? found : null;
+        const proposals = thread === null ? [] : store.listLeadProposals(thread.id);
         // One reply runs at a time per person; this thread shows it only when
         // the reply is its own.
         const live = store.liveLeadTurnFor(who.name);
-        const messages = store.listLeadMessages(opened.thread.id, 40);
+        const messages = thread === null ? [] : store.listLeadMessages(thread.id, 40);
         // The lead's question with buttons, while its reply is the last word in the thread.
         const last = messages.at(-1);
         const asking = last?.role === "assistant" && last.turn !== null && store.getLeadTurn(last.turn)?.approver === who.name ? store.leadAskOpen(last.turn, now) : null;
@@ -1155,9 +1206,10 @@ export function createDecisionServer(options) {
         // Answered questions stay readable above the answer; only their buttons go.
         const asks = new Map(messages.flatMap(one => { const asked = one.role === "assistant" && one.turn !== null ? store.leadAsk(one.turn) : null; return asked === null ? [] : [[asked.turn, asked]]; }));
         // The person's queued messages in this thread: each shows waiting (with Remove) or why it was not sent.
-        const queue = new Map(personalQueue.queue.forThread(opened.thread.id).map(row => [row.message, row]));
-        // The thread a ceiling change replaced (ruling 9): read after the open, display only.
-        const replaced = store.replacedLeadThread(opened.thread);
+        const queue = new Map(thread === null ? [] : personalQueue.queue.forThread(thread.id).map(row => [row.message, row]));
+        // The thread a ceiling change replaced (ruling 9), display only: closed already, or still live under the old ceiling.
+        const replaced = thread !== null ? store.replacedLeadThread(thread)
+            : found !== null && found.scope.kind === "lead" && store.listLeadMessages(found.id, 1).length > 0 ? found : null;
         const previousProposals = replaced === null ? [] : store.listLeadProposals(replaced.id);
         return {
             previous: replaced === null ? null : { messages: store.listLeadMessages(replaced.id, 40), proposals: previousProposals, decisions: decisionsFor(store, previousProposals) },
@@ -1169,7 +1221,7 @@ export function createDecisionServer(options) {
             proposals,
             decisions: decisionsFor(store, [...proposals, ...coordinatorProposals]),
             coordinatorProposals,
-            pending: live !== null && live.thread === opened.thread.id ? live : null,
+            pending: live !== null && thread !== null && live.thread === thread.id ? live : null,
             recent: store.recentLeadTurns(who.name, 5),
         };
     }
@@ -1182,7 +1234,9 @@ export function createDecisionServer(options) {
     /** The Ask panel (v77): the conversation a task, result or project page
      * docks beside itself — that page's own thread, the same session and
      * cards as /chat. Null when this person has no lead chat here. A page
-     * view may start a membership conversation, as /chat does. */
+     * view starts nothing (quiet page visits): with no membership
+     * conversation yet, the panel binds its sends to NOT_STARTED_SESSION and
+     * the first message starts one (chatSend). */
     function dockedConversation(who, focusTask, chatProject, now, back, resultRunId = null) {
         if (who.via !== "cookie" || who.role !== "approver" || (focusTask === null && chatProject === null))
             return null;
@@ -1190,16 +1244,14 @@ export function createDecisionServer(options) {
         const principal = enabled.ok ? leadPrincipal(who) : null;
         if (!enabled.ok || principal === null)
             return null;
-        let session = store.activeLeadSession(who.name);
-        if ((session === null || session.ceilingDigest !== principal.ceilingDigest) && enabled.billing === "subscription" && !requestContext.getStore()?.workspaceRead) {
-            startLeadConversation(who, principal, enabled, 0, false, now);
-            session = store.activeLeadSession(who.name);
-        }
-        if (session === null || session.ceilingDigest !== principal.ceilingDigest || session.approverGeneration !== principal.generation)
+        const found = store.activeLeadSession(who.name);
+        const notStarted = (found === null || found.ceilingDigest !== principal.ceilingDigest) && enabled.billing === "subscription";
+        const session = notStarted ? null : found;
+        if (!notStarted && (session === null || session.ceilingDigest !== principal.ceilingDigest || session.approverGeneration !== principal.generation))
             return null;
         const rows = leadConversationRows(who, principal, focusTask, now, chatProject);
         return {
-            sessionId: session.id, user: session.approver, version: leadChatVersion({ ...rows, focusTask }),
+            sessionId: session?.id ?? NOT_STARTED_SESSION, user: session?.approver ?? who.name, version: leadChatVersion({ ...rows, focusTask }),
             messages: leadBrowserMessages(rows, back, { task: focusTask?.id ?? null, project: chatProject }),
             pendingTurnId: rows.pending?.id ?? null, requestId: randomBytes(16).toString("hex"), maxChars: LEAD_MESSAGE_MAX_CHARS,
             taskId: focusTask?.id ?? null, resultRunId, project: focusTask === null ? chatProject : null,
@@ -1210,11 +1262,17 @@ export function createDecisionServer(options) {
     /** Start the person's lead conversation: the session every later turn
      * debits (a membership spends nothing; direct API gets a per-conversation
      * ceiling) and its thread. Starting ends any older session. */
-    function startLeadConversation(who, principal, enabled, ceilingUsd, follow, now) {
+    function startLeadConversation(who, principal, enabled, ceilingUsd, follow, now, scope = LEAD_THREAD, request) {
+        // A page's first send (quiet page visits) starts it under that send's request: the start and its record are one
+        // write, so a retry of the same request finds the conversation it started and never starts another.
+        if (request !== undefined) {
+            return store.transact(() => store.replay({ idempotencyKey: `mate-start:${who.name}:${request}`, actor: who.name, at: now }, "mate-start", () => ({ session: startLeadConversation(who, principal, enabled, ceilingUsd, follow, now, scope) })).session);
+        }
         const ceilingMicrousd = enabled.billing === "subscription" ? 0 : Math.round(ceilingUsd * 1_000_000);
         const termsDigest = createHash("sha256").update(`${ceilingMicrousd}\n${principal.ceilingDigest}`).digest("hex");
         const sessionId = store.mintLeadSession({ approver: who.name, approverGeneration: principal.generation, credentialKey: enabled.credentialKey, ceilingMicrousd, ceilingDigest: principal.ceilingDigest, termsDigest }, now);
-        const thread = store.openLeadThread(who.name, principal.ceilingDigest, now).thread;
+        // The thread the first message goes to (quiet page visits: a task's first message opens only the task's thread).
+        const thread = store.openLeadThread(who.name, principal.ceilingDigest, now, scope).thread;
         if (follow)
             configureLeadFollow(store, principal, store.getLeadSession(sessionId), thread, true, now);
         leadSaid.delete(who.session.csrf);
@@ -1293,6 +1351,11 @@ export function createDecisionServer(options) {
      * whole catalog, not a hand-pinned shortlist). null = no key or the
      * catalog is unreachable; callers fall back to the compiled table. */
     let catalogCache = null;
+    /** The catalog as last fetched, for a page to show (docs/plans/get-side-effects.md): a page never fetches it. The
+     * background checks keep it current while an OpenRouter key is saved; saving a choice fetches it (chatCatalog). */
+    function chatCatalogKnown() {
+        return chatKeyFor("openrouter-api") === null ? null : catalogCache?.models ?? null;
+    }
     async function chatCatalog() {
         const key = chatKeyFor("openrouter-api")?.key;
         if (key === undefined)
@@ -1323,7 +1386,7 @@ export function createDecisionServer(options) {
     function paletteIndexTag(project) {
         const admitted = project === null ? admissionList() : null;
         const entries = [
-            { label: "work", href: "/work" },
+            { label: "tasks", href: "/work" },
             { label: "needs you", href: "/work?view=needs-you" },
             { label: "inbox", href: "/" },
             { label: "board", href: "/board?scope=all" },
@@ -1332,7 +1395,6 @@ export function createDecisionServer(options) {
             { label: "flows", href: "/flows" },
             { label: "done", href: "/done" },
             { label: "review cockpit", href: "/review" },
-            { label: "task list", href: "/tasks" },
             { label: "fleet", href: "/fleet" },
             { label: "activity", href: "/activity" },
             { label: "action ledger", href: "/ledger" },
@@ -1347,8 +1409,8 @@ export function createDecisionServer(options) {
             entries.push({ label: `${one.id} — ${one.title}`, href: `/t/${encodeURIComponent(one.id)}` });
         }
         const saturated = open.length > 200;
-        const safeEntries = restricted() ? entries.filter(one => ["/work", "/work?view=needs-you", "/", "/board", "/flows", "/done", "/review", "/tasks", "/runs", "/projects", "/ledger"].includes(one.href) || one.href.startsWith("/t/")) : entries;
-        return jsonScript(saturated ? [...safeEntries, { label: "… more in the task list", href: "/tasks" }] : safeEntries, { id: "palette-index" });
+        const safeEntries = restricted() ? entries.filter(one => ["/work", "/work?view=needs-you", "/", "/board", "/flows", "/done", "/review", "/runs", "/projects", "/ledger"].includes(one.href) || one.href.startsWith("/t/")) : entries;
+        return jsonScript(saturated ? [...safeEntries, { label: "… more in Tasks", href: "/work" }] : safeEntries, { id: "palette-index" });
     }
     /**
      * The palette cache (arc 4, finding 6), and its honest contract: a
@@ -1809,6 +1871,106 @@ export function createDecisionServer(options) {
             onError: error => recordLeadFollowFailure(store, error, clock()),
         });
     });
+    // Background checks (docs/plans/get-side-effects.md): what pages show about this computer's agent sign-ins and the
+    // services Toolroll uses is asked here, on a timer, and a page reads the last answer. A page visit never starts a
+    // process or a network call, and never acts on what a check finds: lifting a sign-in pause and the lead-by-default
+    // rule run from this pass (or a person's Check now), not from a GET.
+    let backgroundChecks = null;
+    let agentsCheckedAt = 0;
+    if (options.backgroundChecks === true)
+        server.once('listening', () => {
+            // This Toolroll's folder for secrets, checked once now, so a page can read which are set without preparing it.
+            try {
+                secretFolder();
+            }
+            catch { /* a page says secrets can't be read; the next action reports why */ }
+            backgroundChecks = startMaintenance({ intervalMs: options.backgroundChecksMs ?? BACKGROUND_CHECKS_MS, shouldStop: () => leadClosing,
+                run: async () => {
+                    const now = Date.now();
+                    const waits = [];
+                    if (now - agentsCheckedAt >= (options.backgroundChecksMs ?? LOCAL_AGENTS_EVERY_MS)) {
+                        agentsCheckedAt = now;
+                        waits.push(checkLocalAgents());
+                        // The other agents Settings lists: their last answer is what the page shows.
+                        for (const provider of PROVIDER_IDS.filter(isKeyedProvider).filter(one => one !== "claude" && one !== "codex"))
+                            waits.push(connectionCheck(provider).catch(() => undefined));
+                    }
+                    integrations.refreshIfDue();
+                    const sso = ssoSettings();
+                    if (sso !== null && (ssoProvider === null || ssoProvider.issuer !== sso.issuer || Date.now() - ssoProvider.at >= 10 * 60_000))
+                        waits.push(providerFor(sso.issuer));
+                    if (chatKeyFor("openrouter-api") !== null)
+                        waits.push(chatCatalog());
+                    const openrouter = readProviderKey("openrouter", providerHome);
+                    // The cache answers until its list is due again (ten minutes, or 30 s after a failure), then fetches.
+                    if (openrouter !== null)
+                        waits.push(modelCatalog(openrouter));
+                    // What used to be closed by whichever page read it first: an operating mode or a flow's "runs on its own"
+                    // grant past its expiry, a stalled update, old coordinator proposals. (Lead turns past their deadline are the
+                    // follow pass's, which settles them even while an update drains.)
+                    const at = clock();
+                    store.closeExpiredModes(at);
+                    closeExpiredUnattendedGrants(store, at);
+                    store.sweepCoordinatorProposals(at);
+                    // The demo's scripted story, if a beat timer missed (its pages only read it).
+                    try {
+                        options.demoLead?.advance(at);
+                    }
+                    catch { /* the next pass tries again */ }
+                    const databaseFile = store.databaseFile();
+                    if (databaseFile !== null && !updateChecksOff(process.env, options.configDir ?? dirname(databaseFile)).off) {
+                        const last = lastChecks.known("release");
+                        if (lastChecks.due("release", last !== null && "problem" in last.value ? 60_000 : 15 * 60_000))
+                            waits.push(checkRelease());
+                    }
+                    // Chat's first tasks (issues and TODOs) while the first run is open and nothing is filed yet.
+                    if (firstRunStepsNow(clock()) !== null && !store.hasAnyWork()) {
+                        for (const repo of managedRepos()) {
+                            const entry = firstTasks.get(repo);
+                            if (entry !== undefined && (entry.reading || entry.until > Date.now()))
+                                continue;
+                            const reading = { until: Date.now() + 10 * 60_000, found: entry?.found ?? null, reading: true };
+                            firstTasks.set(repo, reading);
+                            waits.push(findFirstTasks(repo, options.firstTaskRunner ?? execRun).then(found => { reading.found = found; }, () => { }).finally(() => { reading.reading = false; }));
+                        }
+                    }
+                    // Learning recovered from reviewed runs (and a project's saved rows carried to its current identity), which
+                    // Settings → Learning and Knowledge used to do as they opened.
+                    if (lastChecks.due("learning", 10 * 60_000)) {
+                        waits.push(lastChecks.run("learning", async () => {
+                            for (const repo of managedRepos()) {
+                                try {
+                                    acceptedIdentities(store, repo);
+                                }
+                                catch { /* the next pass tries again */ }
+                                try {
+                                    recoverLearning(store, evidenceRoot, repo);
+                                }
+                                catch { /* the next pass tries again */ }
+                            }
+                        }));
+                    }
+                    // What Codex has configured, per project, for Settings → Tools to offer.
+                    for (const repo of managedRepos()) {
+                        if (lastChecks.due(`codex-tools:${repo}`, 10 * 60_000))
+                            waits.push(lastChecks.run(`codex-tools:${repo}`, () => codexServers(repo)));
+                    }
+                    if (databaseFile !== null && lastChecks.due("storage", 30 * 60_000)) {
+                        waits.push(lastChecks.run("storage", () => checkoutPlan(store, storagePool(databaseFile), clock(), { manual: true })));
+                    }
+                    // The same reading the chrome does, outside a page visit, so it releases a stalled `toolroll update` and a stalled
+                    // desktop update in every folder the chrome looks in.
+                    if (databaseFile !== null) {
+                        try {
+                            waitingUpdate(databaseFile, run => store.stopQuiescenceProblem(run) !== null, at);
+                        }
+                        catch { /* shown as last saved */ }
+                    }
+                    await Promise.all(waits);
+                },
+                onError: () => { }, });
+            void backgroundChecks.runNow();
+        });
     // Keep native process custody until shutdown has verified agent/tool exit.
     // Coding custody does not depend on subagents or the lead's follow pass, so
     // it closes at once and never waits behind a model turn: a stop must release
@@ -1837,7 +1999,7 @@ export function createDecisionServer(options) {
         liveHandlers.close();
         detachReads();
         liveFollower.close();
-        void Promise.all([closeCoding(), terminalClosing.close?.().then(problem => { terminalClosing.problem = problem; }), bounded(team.close()), bounded(personalQueue.close()), bounded(leadMaintenance?.stop()), bounded(reads?.close())])
+        void Promise.all([closeCoding(), terminalClosing.close?.().then(problem => { terminalClosing.problem = problem; }), bounded(team.close()), bounded(personalQueue.close()), bounded(leadMaintenance?.stop()), bounded(backgroundChecks?.stop()), bounded(reads?.close())])
             // The server always closes; a terminal whose processes couldn't be proved stopped is the close's error.
             .then(() => closeServer(error => callback?.(error ?? terminalClosing.problem ?? undefined))).catch(error => {
             if (callback)
@@ -1913,6 +2075,7 @@ export function createDecisionServer(options) {
         get liveRefreshSeconds() { return liveRefreshSeconds; },
         get chatKeyFor() { return chatKeyFor; },
         get chatCatalog() { return chatCatalog; },
+        get chatCatalogKnown() { return chatCatalogKnown; },
         get leadRecheckedAt() { return leadRecheckedAt; },
         set leadRecheckedAt(value) { leadRecheckedAt = value; },
         get checkLocalAgents() { return checkLocalAgents; },
@@ -1920,6 +2083,9 @@ export function createDecisionServer(options) {
         set localSignIn(value) { localSignIn = value; },
         get agentSignInCommand() { return agentSignInCommand; },
         get connectionCheck() { return connectionCheck; },
+        get connectionKnown() { return connectionKnown; },
+        get lastChecks() { return lastChecks; },
+        get checkRelease() { return checkRelease; },
         get modelCatalog() { return modelCatalog; },
         get modelSeams() { return modelSeams; },
         get toolsViewOf() { return toolsViewOf; },
@@ -1949,6 +2115,7 @@ export function createDecisionServer(options) {
         get ssoProvider() { return ssoProvider; },
         set ssoProvider(value) { ssoProvider = value; },
         get providerFor() { return providerFor; },
+        get providerKnown() { return providerKnown; },
         get connectVisits() { return connectVisits; },
         get defaultProject() { return defaultProject; },
         get googleVisits() { return googleVisits; },

package/dist/server/agents-live-filed.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Work a lead filed, nested under it on the Live grid (docs/plans/lead-dispatched-tiles.md): which of the viewer's
+ * tiles were filed through the viewer's OWN lead chat, and which chat. Proved from the store only, at request time: the
+ * task's family root was filed through the lead (`filed_via = 'mate'`) by the viewer as a person, and exactly one record
+ * links that root to one of the viewer's own personal lead threads — a confirmed task card the viewer confirmed (its
+ * door-written outcome, never the model's payload) or a sweep the viewer started from a card still kept. Attribution is
+ * to the chat that filed the family's ORIGINAL task: a revision asked for in another chat stays with the family. Anything
+ * short of that is no link:
+ * the tile stays a top-level tile, as it is today. A link only groups tiles the viewer already gets; it never adds one.
+ */
+import type { Store } from "../store.js";
+export type FiledBy = {
+    thread: number;
+    chat: "lead" | "project" | "task";
+};
+/** For each run id given (the tiles already in this viewer's answer), the viewer's lead chat that filed its task. */
+export declare function leadFiledLinks(store: Store, viewer: string, runIds: readonly number[]): Map<number, FiledBy>;

package/dist/server/agents-live-filed.js

@@ -0,0 +1,97 @@
+const BUILT_IN = "built-in";
+/** The family root of a built-in task, or null when its lineage can't be proved: the family's own proof (taskFamilyOf:
+ * every revision in the root's project, each bound by its brief to its parent's own run), and the task one of it. */
+function rootOf(store, taskId) {
+    const family = store.taskFamilyOf(taskId, null, false);
+    return family === null || family.problem !== null || !family.versions.some(version => version.id === taskId) ? null : family.root.id;
+}
+const parse = (text) => {
+    if (typeof text !== "string")
+        return null;
+    try {
+        const value = JSON.parse(text);
+        return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+    }
+    catch {
+        return null;
+    }
+};
+/** For each run id given (the tiles already in this viewer's answer), the viewer's lead chat that filed its task. */
+export function leadFiledLinks(store, viewer, runIds) {
+    const links = new Map();
+    const db = store.handle;
+    // The viewer's own personal threads (never a team conversation's), by id.
+    const threads = new Map();
+    for (const row of db.prepare(`SELECT id, scope_kind FROM lead_thread WHERE approver = ? AND NOT EXISTS (SELECT 1 FROM team_conversation tc WHERE tc.thread = lead_thread.id)`).all(viewer)) {
+        const kind = row["scope_kind"];
+        threads.set(Number(row["id"]), kind === "project" ? "project" : kind === "task" ? "task" : "lead");
+    }
+    if (threads.size === 0)
+        return links;
+    // Each run's family root, proved once per task (attempts of one task share it), and only roots the viewer filed
+    // through the lead as a person go further.
+    const rootOfTask = new Map();
+    const runRoots = new Map();
+    const repos = new Map();
+    const refRow = db.prepare("SELECT repo, filed_via, filed_by, filed_by_kind FROM task_ref WHERE backend = ? AND external_id = ?");
+    for (const runId of runIds) {
+        const row = db.prepare("SELECT r.backend, r.external_id FROM run JOIN task_ref r ON r.id = run.task_ref WHERE run.id = ?").get(runId);
+        if (row === undefined || row["backend"] !== BUILT_IN)
+            continue;
+        const task = String(row["external_id"]);
+        if (!rootOfTask.has(task))
+            rootOfTask.set(task, rootOf(store, task));
+        const root = rootOfTask.get(task);
+        if (root === null || root === undefined)
+            continue;
+        if (!repos.has(root)) {
+            const ref = refRow.get(BUILT_IN, root);
+            // Filed through the lead, by the viewer, as a person.
+            const filed = ref !== undefined && ref["filed_via"] === "mate" && ref["filed_by_kind"] === "person" && ref["filed_by"] === viewer && typeof ref["repo"] === "string";
+            repos.set(root, filed ? String(ref["repo"]) : "");
+        }
+        if (repos.get(root) !== "")
+            runRoots.set(runId, root);
+    }
+    const roots = [...new Set(runRoots.values())];
+    if (roots.length === 0)
+        return links;
+    // Every confirmed task card in the viewer's own threads naming one of these roots: ONE read per request, through the
+    // viewer's threads (lead_thread by approver, lead_proposal by thread and state), never once per family.
+    const found = new Map(roots.map(root => [root, []]));
+    const spoiled = new Set();
+    const cards = db.prepare(`SELECT p.thread, p.resolved_by, p.payload_json, p.outcome_json, json_extract(p.outcome_json, '$.taskId') AS task FROM lead_proposal p
+    JOIN lead_thread t ON t.id = p.thread WHERE t.approver = ? AND p.kind = 'task' AND p.state = 'confirmed' AND json_valid(p.outcome_json)
+    AND json_extract(p.outcome_json, '$.taskId') IN (${roots.map(() => "?").join(",")})`).all(viewer, ...roots);
+    for (const row of cards) {
+        const root = String(row["task"]);
+        const outcome = parse(row["outcome_json"]), payload = parse(row["payload_json"]);
+        // The door's own outcome (the model writes only the payload), confirmed by the viewer, for this project.
+        if (outcome?.["ok"] !== true || outcome["kind"] !== "task" || outcome["taskId"] !== root || row["resolved_by"] !== viewer || payload?.["repo"] !== repos.get(root))
+            spoiled.add(root);
+        else
+            found.get(root)?.push(Number(row["thread"]));
+    }
+    // A sweep links while the card that started it is kept, as a task card does: ending a chat (or revocation) erases its
+    // cards, and with them every link it made — one retention rule for both.
+    const sweeps = db.prepare(`SELECT k.root_task, s.owner, s.thread, s.repo, p.thread AS card_thread, p.state AS card_state, p.resolved_by AS card_by
+    FROM lead_sweep_task k JOIN lead_sweep s ON s.id = k.sweep LEFT JOIN lead_proposal p ON p.id = s.proposal
+    WHERE k.root_task IN (${roots.map(() => "?").join(",")})`).all(...roots);
+    for (const row of sweeps) {
+        const root = String(row["root_task"]);
+        if (row["owner"] !== viewer || row["repo"] !== repos.get(root) || row["thread"] === null || row["card_thread"] !== row["thread"] || row["card_state"] !== "confirmed" || row["card_by"] !== viewer)
+            spoiled.add(root);
+        else
+            found.get(root)?.push(Number(row["thread"]));
+    }
+    for (const [runId, root] of runRoots) {
+        // Exactly one record, nothing amiss beside it, naming one of the viewer's own personal threads.
+        const named = found.get(root) ?? [];
+        if (spoiled.has(root) || named.length !== 1)
+            continue;
+        const chat = threads.get(named[0]);
+        if (chat !== undefined)
+            links.set(runId, { thread: named[0], chat });
+    }
+    return links;
+}

package/dist/server/agents-live-lead.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Lead tiles on the Live grid (docs/plans/agents-view.md slice 8): the viewer's OWN lead chat turns, and only through
+ * the chat room's own admission — an approver with a lead standing, the thread theirs, open, the newest for its scope,
+ * never a team conversation, under the ceiling it opened with, and its project or task still theirs to see. Team
+ * threads wait for their own admission. The words go through one stateful redactor per turn (one key state carried
+ * across every step and every line of the turn's current snapshot), then controls out, then a cap. Memory only: the
+ * tile is the live turn's, and leaves with it (60 s after the turn ends).
+ */
+import type { LeadLiveStep } from "../lead-progress.js";
+import type { ServerRuntime } from "./runtime.js";
+import type { Who } from "./session.js";
+/** A lead tile keeps at most this many lines, and this many bytes of them (the newest). */
+export declare const LEAD_LINES = 200, LEAD_BYTES: number;
+export type LeadTile = {
+    thread: number;
+    /** The turn being answered (lead.ts's turn id), once the turn has said it. */
+    turn: number | null;
+    scope: "lead" | "project" | "task";
+    title: string;
+    project: string | null;
+    state: "working" | "done" | "failed";
+    startedAt: string;
+    endedAt: string | null;
+    /** When each step began. */
+    stepAt: string[];
+    /** What it is doing now, in fixed words; null once it ended. */
+    doing: string | null;
+    lines: string[];
+    /** Whether older lines were cut to fit. */
+    earlier: boolean;
+    chatHref: string;
+    taskHref: string | null;
+};
+/** One turn's lines, redacted as one stream: every step's tools and words in order through ONE key state (a key block
+ * opened in one step stays hidden into the next), each line cleaned and cut, then the newest kept within the caps.
+ * `confirmed[i]`: step i's text is its finished answer, secret-checked whole. */
+export declare function leadLines(steps: readonly LeadLiveStep[], confirmed?: readonly boolean[]): {
+    lines: string[];
+    earlier: boolean;
+};
+type LeadDeps = Pick<ServerRuntime, "store" | "liveTurns" | "leadPrincipal" | "familyOf" | "visible" | "managedRepos">;
+/** The viewer's own live lead turns, admitted as the chat room admits them, proved now. */
+export declare function leadTilesFor(deps: LeadDeps, who: Who): LeadTile[];
+/** The tiles projected earlier that are still this viewer's right now (the whole admission proved again, with the
+ * session as it is saved now): what is delivered is never more than what is admitted at the moment of delivery. */
+export declare function leadsStillAdmitted(deps: LeadDeps, who: Who, tiles: readonly LeadTile[]): LeadTile[];
+export {};