toolroll 0.9.73 → 0.9.75

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

@@ -0,0 +1,116 @@
+import { capLive, cleanLiveText, HIDDEN_KEY_BLOCK, HIDDEN_LINE, liveLine, redactLiveLines } from "../live-records.js";
+import { projectChatHref, taskChatHref } from "./http.js";
+/** A lead tile keeps at most this many lines, and this many bytes of them (the newest). */
+export const LEAD_LINES = 200, LEAD_BYTES = 32 * 1024;
+/** A tool's line: fixed copy from lead-progress.ts (labels and failure reasons), still cleaned and cut. */
+function toolLine(tool) {
+    return liveLine(tool.state === "running" ? `· ${tool.label}…` : tool.state === "failed" ? `· ${tool.reason}` : `· ${tool.label}`);
+}
+/** One step's words, redacted, with only what is settled: the last word of the step's text waits for the space after
+ * it unless the provider's finished answer for that step was confirmed (lead.ts sends it once, secret-checked whole).
+ * A snapshot that would have completed a credential is never stored (lead.ts drops it), so the one kept can end
+ * part-way through one: ending the turn or starting the next step confirms nothing. The last line is redacted on its
+ * own (after the rest, with the same key state), the whole line checked for secrets first, and its unfinished word
+ * found in the line as shown (invisible characters removed), so no hidden character can stand in for the space. */
+function stepLines(text, keys, confirmed) {
+    const raw = text.split(/\r?\n/);
+    const lastRaw = raw.pop() ?? "";
+    const out = redactLiveLines(raw, keys);
+    // Empty when the last line is inside a key block (never shown).
+    for (const shown of redactLiveLines([lastRaw], keys)) {
+        const whole = shown === HIDDEN_LINE || shown === HIDDEN_KEY_BLOCK || confirmed || /\s$/.test(cleanLiveText(lastRaw));
+        out.push((whole ? shown : shown.replace(/\S+$/, "")).trimEnd());
+    }
+    while (out.length > 0 && out[out.length - 1].trim() === "")
+        out.pop();
+    return out;
+}
+/** 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 function leadLines(steps, confirmed = []) {
+    const keys = { inKey: false };
+    const all = [];
+    steps.forEach((step, index) => {
+        // Tools are not the conversation's text: they never open or close a key block, and inside one they are not shown.
+        for (const tool of step.toolCalls)
+            if (!keys.inKey)
+                all.push(toolLine(tool));
+        if (step.text !== "")
+            all.push(...stepLines(step.text, keys, confirmed[index] === true));
+    });
+    const kept = [];
+    let bytes = 0;
+    for (let index = all.length - 1; index >= 0 && kept.length < LEAD_LINES; index -= 1) {
+        const one = capLive(all[index], LEAD_BYTES);
+        const size = Buffer.byteLength(one, "utf8") + 1;
+        if (bytes + size > LEAD_BYTES)
+            break;
+        kept.unshift(one);
+        bytes += size;
+    }
+    return { lines: kept, earlier: kept.length < all.length };
+}
+/** What the turn is doing now, in fixed words only. */
+function doingOf(turn) {
+    if (turn.done)
+        return null;
+    const step = turn.steps.at(-1);
+    const running = step?.toolCalls.filter(tool => tool.state === "running").at(-1);
+    if (running !== undefined)
+        return running.label;
+    return step !== undefined && step.text.trim() !== "" ? "Writing a reply" : "Thinking";
+}
+/** One thread admitted for this viewer now, as the chat room admits (server/live.ts, room "chat"); null when refused. */
+function admitLead(deps, who, id) {
+    const { store, leadPrincipal, familyOf, visible, managedRepos } = deps;
+    if (who.via !== "cookie" || who.role !== "approver")
+        return null;
+    const principal = leadPrincipal(who);
+    if (principal === null)
+        return null;
+    const thread = store.getLeadThread(id);
+    if (thread === null || thread.approver !== who.name || thread.closedAt !== null)
+        return null;
+    // The owner's current thread for its scope (never a team conversation's), under the ceiling it opened with.
+    if (store.liveLeadThreadFor(who.name, thread.scope)?.id !== id || thread.ceilingDigest !== principal.ceilingDigest)
+        return null;
+    if (thread.scope.kind === "project") {
+        const repo = thread.scope.key;
+        if (!visible(repo) || !managedRepos().includes(repo) || !store.accountCanAccess(who.name, repo))
+            return null;
+        return { scope: "project", title: "Project chat", project: repo, chatHref: projectChatHref(repo), taskHref: null };
+    }
+    if (thread.scope.kind === "task") {
+        const family = familyOf(thread.scope.key);
+        const repo = family?.root.repo ?? null;
+        if (family === null || family.problem !== null || family.root.id !== thread.scope.key || repo === null || !visible(repo) || !store.accountCanAccess(who.name, repo))
+            return null;
+        return { scope: "task", title: family.root.title, project: repo, chatHref: taskChatHref(family.root.id), taskHref: `/t/${encodeURIComponent(family.root.id)}` };
+    }
+    return { scope: "lead", title: "Lead chat", project: null, chatHref: "/chat", taskHref: null };
+}
+/** The viewer's own live lead turns, admitted as the chat room admits them, proved now. */
+export function leadTilesFor(deps, who) {
+    const tiles = [];
+    for (const [id, turn] of deps.liveTurns) {
+        const admitted = admitLead(deps, who, id);
+        if (admitted === null)
+            continue;
+        const { lines, earlier } = leadLines(turn.steps, turn.confirmed);
+        tiles.push({
+            thread: id, turn: turn.turn ?? null, ...admitted,
+            state: !turn.done ? "working" : turn.ok ? "done" : "failed",
+            startedAt: new Date(turn.startedAt ?? Date.now()).toISOString(),
+            endedAt: turn.endedAt === undefined ? null : new Date(turn.endedAt).toISOString(),
+            stepAt: (turn.stepAt ?? []).map(at => new Date(at).toISOString()),
+            doing: doingOf(turn), lines, earlier,
+        });
+    }
+    return tiles.sort((a, b) => a.thread - b.thread);
+}
+/** 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 function leadsStillAdmitted(deps, who, tiles) {
+    return tiles.filter(tile => deps.liveTurns.has(tile.thread) && admitLead(deps, who, tile.thread) !== null);
+}

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

@@ -0,0 +1,23 @@
+import { type LiveBus, type LiveViewer } from "../live-bus.js";
+import type { Store } from "../store.js";
+/** How often a viewer's runs and files are looked at again. */
+export declare const LIVE_POLL_MS = 2000;
+/** At most this many of a viewer's runs have their files looked at (the grid streams at most this many). */
+export declare const LIVE_WATCHED_RUNS = 24;
+export declare function createAgentsLiveRooms<V extends LiveViewer>(input: {
+    store: Store;
+    bus: LiveBus;
+    evidenceRoot: string;
+    localRunner: string | undefined;
+    clock: () => Date;
+    /** Whether the console shows this project at all (its ceiling). */
+    visible: (repo: string | null) => boolean;
+    /** The keyed viewer's own lead tiles as they stand now (agents-live-lead.ts), proved from their saved session. */
+    leads?: (key: string) => unknown;
+    /** Told when a page's room is gone. */
+    forget?: (key: string) => void;
+}): {
+    rooms: import("../live-bus.js").LiveRooms<string, V>;
+    keyOf: (account: string, scope: string, page?: string) => string;
+    looked: () => number;
+};

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

@@ -0,0 +1,91 @@
+/**
+ * The Live grid's room (docs/plans/agents-view.md §3): one room per viewer and scope, never shared, so one viewer's
+ * view is never cached for another. Every LIVE_POLL_MS it re-proves each viewer (before any read and before any send,
+ * keep-alives included — createLiveRooms' own boundary), then takes the viewer's fingerprint: the tiles they may see
+ * and, for this computer's runs, each live file's identity and size through the checked opener. The page hears only
+ * that something it can see moved; the fingerprint is an opaque digest, never sizes or file identities. Expiry needs
+ * no database write (the tiles are derived from the clock), and the room goes with its last viewer.
+ */
+import { createHash } from "node:crypto";
+import { closeSync } from "node:fs";
+import { agentsLiveOf } from "../agents-live.js";
+import { createLiveRooms } from "../live-bus.js";
+import { openLiveTrusted } from "../live-open.js";
+import { leadFiledLinks } from "./agents-live-filed.js";
+import { requestContext } from "./request-context.js";
+/** How often a viewer's runs and files are looked at again. */
+export const LIVE_POLL_MS = 2_000;
+/** At most this many of a viewer's runs have their files looked at (the grid streams at most this many). */
+export const LIVE_WATCHED_RUNS = 24;
+/** One file as the room sees it: its identity and size, or that it is missing or unavailable. Never its contents. */
+function fileMark(root, name) {
+    const opened = openLiveTrusted(root, name);
+    if (typeof opened === "string")
+        return opened;
+    try {
+        return `${opened.gen}/${opened.size}`;
+    }
+    finally {
+        closeSync(opened.fd);
+    }
+}
+export function createAgentsLiveRooms(input) {
+    const { store, evidenceRoot, localRunner, clock, visible } = input;
+    const keyOf = (account, scope, page = "") => JSON.stringify([account, scope, page]);
+    /** One look at a run's two files, shared by every viewer's room: at most once per LIVE_POLL_MS per run, however
+     * many viewers or bus signals there are (a burst of writes re-proves at once, but never opens files more often). */
+    const looked = new Map();
+    const marksOf = (runId, stillSees) => {
+        // A run's files are this viewer's to look at (or have looked at) only while the run is still theirs and this
+        // computer's, proved from its row now — a look another viewer's room took included.
+        if (!stillSees())
+            return null;
+        const now = Date.now();
+        const kept = looked.get(runId);
+        // One attempt per run per poll, whether it looked or stopped part-way: nothing makes files opened more often.
+        if (kept !== undefined && now - kept.at < LIVE_POLL_MS)
+            return kept.marks;
+        looked.set(runId, { at: now, marks: null });
+        const main = fileMark(evidenceRoot, `${runId}.jsonl`);
+        if (!stillSees())
+            return null;
+        const sub = fileMark(evidenceRoot, `${runId}.sub.jsonl`);
+        if (!stillSees())
+            return null;
+        const marks = [main, sub];
+        looked.set(runId, { at: now, marks });
+        return marks;
+    };
+    const rooms = createLiveRooms(key => {
+        const [account] = JSON.parse(key);
+        // Read as the keyed account (its own request context), never as whoever's write woke the bus.
+        return requestContext.run({ actor: account, csrf: "", returnTo: "/agents" }, () => {
+            const sees = (runId) => () => {
+                const run = store.getRun(runId);
+                const repo = run === null ? null : store.refForId(run.taskRef)?.repo ?? null;
+                return run !== null && repo !== null && visible(repo) && store.accountCanAccess(account, repo) && localRunner !== undefined && run.runner === localRunner;
+            };
+            const tiles = agentsLiveOf(store, clock(), {
+                canSee: run => run.repo !== null && visible(run.repo) && store.accountCanAccess(account, run.repo),
+                localRunner,
+            });
+            const marks = tiles.filter(tile => tile.local).slice(0, LIVE_WATCHED_RUNS).map(tile => [tile.runId, marksOf(tile.runId, sees(tile.runId))]);
+            for (const [runId] of [...looked])
+                if (Date.now() - looked.get(runId).at > 10 * LIVE_POLL_MS)
+                    looked.delete(runId);
+            // The digest's every run proved again from its current row after the looks: one that left view isn't in it.
+            const still = (runId) => {
+                const run = store.getRun(runId);
+                const repo = run === null ? null : store.refForId(run.taskRef)?.repo ?? null;
+                return repo !== null && visible(repo) && store.accountCanAccess(account, repo);
+            };
+            const kept = new Set(tiles.filter(tile => still(tile.runId)).map(tile => tile.runId));
+            // Which of the viewer's own lead chats filed each run (agents-live-filed.ts): a link made or erased is a change too.
+            const filed = leadFiledLinks(store, account, [...kept]);
+            const seen = tiles.filter(tile => kept.has(tile.runId)).map(tile => [tile.runId, tile.state, tile.why, tile.endedAt, filed.get(tile.runId)?.thread ?? null]);
+            const shownMarks = marks.filter(([runId]) => kept.has(runId) && (!tiles.find(tile => tile.runId === runId)?.local || sees(runId)()));
+            return createHash("sha256").update(JSON.stringify([seen, shownMarks, input.leads?.(key) ?? null])).digest("base64url");
+        });
+    }, null, { bus: input.bus, safetyNetMs: LIVE_POLL_MS, onEmpty: key => input.forget?.(key) });
+    return { rooms, keyOf, looked: () => looked.size };
+}

package/dist/server/chat.js

@@ -28,7 +28,7 @@ import { projectName } from "../project.js";
 import { fileTaskProposal } from "../proposal.js";
 import { providerName } from "../provider-auth.js";
 import { validModelId } from "../provider.js";
-import { loadOrCreateVapidKeys, validatePushEndpoint } from "../push.js";
+import { loadOrCreateVapidKeys, loadVapidKeys, validatePushEndpoint } from "../push.js";
 import { parseResultTab, RESULT_REVIEW_SCRIPT } from "../result-review.js";
 import {} from "../store.js";
 import { runActivityOf } from "../task-activity.js";
@@ -39,12 +39,12 @@ import { html, htmlString, postForm, reauth } from "../html.js";
 import { requestContext } from "./request-context.js";
 import { refuse, screen, whenTime } from "./chrome.js";
 import { chatResultHref, chatReturnWithLatest, chatReturnWithSaid, projectChatHref, redirect, respond, safeChatReturn, safeReturn, taskChatHref, taskHref } from "./http.js";
-import { chatAckPage, chatPage, coordinatorProposalsSection, decisionsFor, leadAfterComposerHtml, leadChatVersion, leadMintCard, leadPage, leadThreadHtml, PHONE_CARD_FACT, TASK_COMPOSER_MODES, taskChatLiveRegion, teamProposalCardParts } from "./render-chat.js";
+import { chatAckPage, chatPage, NOT_STARTED_SESSION, coordinatorProposalsSection, decisionsFor, leadAfterComposerHtml, leadChatVersion, leadMintCard, leadPage, leadThreadHtml, PHONE_CARD_FACT, TASK_COMPOSER_MODES, taskChatLiveRegion, teamProposalCardParts } from "./render-chat.js";
 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, 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, 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,
@@ -54,25 +54,30 @@ export function createChatHandlers(runtime) {
     async function mateStatus(ctx) {
         const { url, response, now } = ctx;
         const who = browserCaller(ctx.who);
-        const session = store.activeLeadSession(who.name);
+        const found = store.activeLeadSession(who.name);
         const principal = leadPrincipal(who);
-        if (session === null || principal === null || session.ceilingDigest !== principal.ceilingDigest || session.approverGeneration !== principal.generation) {
+        // Quiet page visits: a membership conversation not started yet is still a page to keep current (its task's
+        // progress and approval); it reads as session 0, and nothing here starts it.
+        const enabled = chatEnablement();
+        const notStarted = principal !== null && enabled.ok && enabled.billing === "subscription" && (found === null || found.ceilingDigest !== principal.ceilingDigest);
+        const session = notStarted ? null : found;
+        if (principal === null || (!notStarted && (session === null || session.ceilingDigest !== principal.ceilingDigest || session.approverGeneration !== principal.generation))) {
             return respond(response, 200, "application/json", JSON.stringify({ session: null }));
         }
-        store.sweepStaleLeadTurns(now);
+        const sessionId = session?.id ?? NOT_STARTED_SESSION;
         const request = url.searchParams.get("request") ?? "";
         // Received: the engine took it, or the lead queue holds it (a queued acknowledgement lost on the way still frees the draft).
-        const received = /^[a-f0-9]{32}$/.test(request) && store.leadRequestReceived(session.id, request);
+        const received = session !== null && /^[a-f0-9]{32}$/.test(request) && store.leadRequestReceived(session.id, request);
         const requestedTask = url.searchParams.get("task");
         const focusTask = requestedTask === null || requestedTask === "" ? null : taskChatFocus(requestedTask, now, who, { mintNonce: false });
         if (requestedTask !== null && requestedTask !== "" && focusTask === null) {
             // The lens's task is gone or no longer admitted: the page keeps its
             // draft and says so; it never falls back to the unified thread.
-            return respond(response, 200, "application/json", JSON.stringify({ session: session.id, task: requestedTask, unavailable: true, received }));
+            return respond(response, 200, "application/json", JSON.stringify({ session: sessionId, task: requestedTask, unavailable: true, received }));
         }
         const chatProject = focusTask !== null ? null : chatProjectOf(url.searchParams.getAll("project").filter(one => one !== ""));
         if (chatProject === undefined)
-            return respond(response, 200, "application/json", JSON.stringify({ session: session.id, unavailable: true, received }));
+            return respond(response, 200, "application/json", JSON.stringify({ session: sessionId, unavailable: true, received }));
         const rows = leadConversationRows(who, principal, focusTask, now, chatProject);
         const version = leadChatVersion({ ...rows, focusTask });
         const known = url.searchParams.get("version") ?? "";
@@ -80,12 +85,12 @@ export function createChatHandlers(runtime) {
         const fragments = known === version
             ? null
             : {
-                thread: htmlString(leadThreadHtml({ ...rows, focusTask, csrf, now, problem: takeLeadNote(csrf, session.id), chatProject })),
+                thread: htmlString(leadThreadHtml({ ...rows, focusTask, csrf, now, problem: takeLeadNote(csrf, session?.id ?? null), chatProject })),
                 after: htmlString(leadAfterComposerHtml({ messages: rows.messages, pending: rows.pending, focusTask })),
                 live: focusTask === null ? null : htmlString(taskChatLiveRegion(focusTask, csrf, true, rows.pending !== null)),
             };
         return respond(response, 200, "application/json", JSON.stringify({
-            session: session.id,
+            session: sessionId,
             task: focusTask?.id ?? "",
             version,
             pending: rows.pending !== null,
@@ -145,9 +150,8 @@ export function createChatHandlers(runtime) {
                 chrome: chromeFor(null, 'chat', undefined, 'all'), workspace: { team: reply.snapshot, notices: [DEPRECATED_PAGE.team, ...(said ? [said] : [])] },
             }));
         }
-        store.sweepStaleChatTurns(now);
-        store.sweepStaleLeadTurns(now);
-        store.sweepCoordinatorProposals(now);
+        // Settling a turn past its deadline (its spend) and expiring old proposals are the background passes' work, never a
+        // page visit's (docs/plans/get-side-effects.md); the lead's follow pass sweeps every few seconds.
         sweepChatDrafts(Date.now());
         const requestedTask = url.searchParams.get("task");
         const focusTask = taskChatFocus(requestedTask, now, who, { mintNonce: !requestContext.getStore()?.workspaceRead });
@@ -237,24 +241,22 @@ export function createChatHandlers(runtime) {
         // The mate (mate arc §5): while a mate session is live, /chat IS the
         // thread — the same rows the CLI reads. Without one, fleet chat as
         // before, plus the card that mints a session.
-        let leadSession = enabled.ok && who.role === "approver" ? store.activeLeadSession(who.name) : null;
+        const leadSession = enabled.ok && who.role === "approver" ? store.activeLeadSession(who.name) : null;
         const principal = enabled.ok && who.role === "approver" ? leadPrincipal(who) : null;
         // Chat opens ready to talk (2026-09-23): an approver in good standing
-        // needs no second password to start their own conversation. The one
-        // exception to "a GET writes nothing": the strict same-site session
-        // cookie keeps other sites out, and starting spends nothing. Actions
-        // the lead proposes still go through their own confirmation cards.
-        // Membership chat only: it spends no dollars. Direct-API chat keeps a
-        // one-tap Start with its visible spending limit (no password).
+        // needs no second password to start their own conversation. Quiet page
+        // visits (2026-10-27): a visit only shows it. With no membership
+        // conversation yet (or only one under another ceiling), the page shows
+        // the composer and the first message starts one (chatSend); nothing
+        // here writes. Direct-API chat keeps a one-tap Start with its visible
+        // spending limit (no password).
         const settingsView = url.searchParams.get("settings") === "1";
-        if (!settingsView && enabled.ok && enabled.billing === "subscription" && principal !== null && (leadSession === null || leadSession.ceilingDigest !== principal.ceilingDigest) && !requestContext.getStore()?.workspaceRead) {
-            startLeadConversation(who, principal, enabled, 0, false, now);
-            leadSession = store.activeLeadSession(who.name);
-        }
+        const notStarted = !settingsView && enabled.ok && enabled.billing === "subscription" && principal !== null &&
+            (leadSession === null || leadSession.ceilingDigest !== principal.ceilingDigest);
         // A session under another ceiling is not continuable from here; a GET
         // writes nothing (slice-2 review, finding 7) — the mint card below
         // starts a new conversation, and minting ends the old session.
-        const ceilingStale = enabled.ok && leadSession !== null && principal !== null && leadSession.ceilingDigest !== principal.ceilingDigest;
+        const ceilingStale = !notStarted && enabled.ok && leadSession !== null && principal !== null && leadSession.ceilingDigest !== principal.ceilingDigest;
         const catchUp = leadBriefHtml(assignmentCatchUp(store, now, { principal: "operator", repos }, { limit: 6 }, evidenceRoot));
         const chatProjects = repos.map((repo, index) => {
             let peek = null;
@@ -288,11 +290,12 @@ export function createChatHandlers(runtime) {
         const withFirstRun = (shown) => firstRun === undefined && phone === undefined && home === null ? shown
             : { ...shown, ...(home === null ? {} : { refreshSeconds: liveRefreshSeconds() }),
                 workspace: { ...shown.workspace, ...(firstRun === undefined ? {} : { firstRun }), ...(phone === undefined ? {} : { phone }), ...(home === null ? {} : { home }) } };
-        if (enabled.ok && leadSession !== null && principal !== null && !ceilingStale) {
+        if (enabled.ok && principal !== null && (notStarted || (leadSession !== null && !ceilingStale))) {
             {
-                const said = takeLeadNote(who.session.csrf, leadSession.id);
+                const said = takeLeadNote(who.session.csrf, notStarted ? null : leadSession?.id ?? null);
                 return sendScreen(response, 200, withFirstRun(leadPage(chromeFor(null, "chat", undefined, "all"), {
-                    session: leadSession,
+                    session: notStarted ? null : leadSession,
+                    approver: who.name,
                     ...leadConversationRows(who, principal, focusTask, now, chatProject),
                     chatProject,
                     latched,
@@ -336,7 +339,7 @@ export function createChatHandlers(runtime) {
                     tail: found === null || found.source === "environment" ? null : redactToken(found.key),
                 };
             }),
-            openrouterModels: (await chatCatalog())?.map(one => one.id) ?? null,
+            openrouterModels: chatCatalogKnown()?.map(one => one.id) ?? null,
             liveModels: [...modelOptions(store, "claude", now, providerHome), ...modelOptions(store, "codex", now, providerHome)],
             csrf: who.session.csrf,
             problem: url.searchParams.get("said") ??
@@ -420,22 +423,39 @@ export function createChatHandlers(runtime) {
         const { who, response } = ctx;
         if (who.via !== "cookie")
             return respond(response, 403, "application/json", JSON.stringify({ error: "session" }));
-        const keys = loadOrCreateVapidKeys(dirname(options.telegramTokenFile ?? "."));
+        // The pair is made as the console starts (docs/plans/get-side-effects.md); this only reads it.
+        const keys = options.telegramTokenFile === undefined ? null : loadVapidKeys(dirname(options.telegramTokenFile));
         response.setHeader("cache-control", "no-store");
+        if (keys === null)
+            return respond(response, 503, "application/json", JSON.stringify({ error: "push is not set up on this console" }));
         return respond(response, 200, "application/json", JSON.stringify({ key: keys.publicKey }));
     }
-    // While no agent is signed in, Chat asks this computer again on its own (onboarding): a fresh, non-spending sign-in
-    // check at most every few seconds, and the lead turns on as soon as one is found.
+    // What this computer's agent CLIs said last, and whether the lead is on. A read: the answer comes from the background
+    // checks or a Check now (POST /lead/check), never from this request (docs/plans/get-side-effects.md).
+    const leadState = () => JSON.stringify({ lead: store.getChatConfig() === null ? "off" : "on", agent: runtime.localSignIn?.signedIn ?? null,
+        checkedAt: runtime.localSignIn === null ? null : new Date(runtime.localSignIn.at).toISOString(), command: agentSignInCommand() });
     async function leadStatus(ctx) {
         const { who, response } = ctx;
         if (who.via !== "cookie")
             return respond(response, 403, "application/json", JSON.stringify({ error: "sign in" }));
+        response.setHeader("cache-control", "no-store");
+        return respond(response, 200, "application/json", leadState());
+    }
+    // While no agent is signed in, Chat asks this computer again on its own (onboarding), and Settings → Lead has Check
+    // now: a fresh, non-spending sign-in check at most every few seconds, and the lead turns on as soon as one is found
+    // (the lead-by-default rule). A POST with the person's form token, so no prefetch or link preview can set it off.
+    async function leadCheck(ctx) {
+        const { response, posted } = ctx;
+        const body = readForm(posted, CONSOLE_FORMS.leadCheck);
         if (Date.now() - runtime.leadRecheckedAt > 4_000) {
             runtime.leadRecheckedAt = Date.now();
             await Promise.race([checkLocalAgents(true), new Promise(done => setTimeout(done, 8_000).unref?.())]);
         }
+        const back = body.get("return");
+        if (back !== null)
+            return redirect(response, safeReturn(back));
         response.setHeader("cache-control", "no-store");
-        return respond(response, 200, "application/json", JSON.stringify({ lead: store.getChatConfig() === null ? "off" : "on", agent: runtime.localSignIn?.signedIn ?? null, command: agentSignInCommand() }));
+        return respond(response, 200, "application/json", leadState());
     }
     async function taskStatus(ctx) {
         const { url, who, response, now } = ctx;
@@ -663,7 +683,9 @@ export function createChatHandlers(runtime) {
         const body = readForm(posted, CONSOLE_FORMS.leadFollow);
         if (who.via !== "cookie")
             return refuse(response, who, 403, "Open the conversation to change automatic updates.");
-        const principal = leadPrincipal(who), session = store.activeLeadSession(who.name), thread = store.liveLeadThreadFor(who.name);
+        const principal = leadPrincipal(who), session = store.activeLeadSession(who.name);
+        // A conversation its first message started from a task or project page has no main thread yet: this act opens it.
+        const thread = principal && session && session.ceilingDigest === principal.ceilingDigest ? store.openLeadThread(who.name, principal.ceilingDigest, now).thread : null;
         if (!principal || !session || !thread || !configureLeadFollow(store, principal, session, thread, body.get("enabled") === "yes", now))
             return refuse(response, who, 409, "Conversation access changed. Start chat again.", "/chat");
         return redirect(response, safeChatReturn(body.get("return")));
@@ -875,10 +897,52 @@ export function createChatHandlers(runtime) {
         // A live mate session: the message is a mate turn — no password, the
         // session's ceremony already covered it (§1); the engine refuses on
         // its own terms and the thread shows why.
-        const leadSession = who.role === "approver" ? store.activeLeadSession(who.name) : null;
+        let leadSession = who.role === "approver" ? store.activeLeadSession(who.name) : null;
+        // Quiet page visits: a membership conversation starts with its first message, never with a page view. A page
+        // shown before one existed binds its sends to session 0; that send starts it (the same approver standing a visit
+        // used to need), and a retry or double submit of the same request lands in the conversation it started.
+        let startedHere = false;
+        const binding = body.getAll("request-session");
+        const unbound = binding.length === 0 || (binding.length === 1 && binding[0] === String(NOT_STARTED_SESSION));
+        if (who.role === "approver" && enabled.billing === "subscription" && unbound) {
+            const principal = leadPrincipal(who);
+            if (principal === null)
+                return wantsJson ? said(403, "your approver standing changed — sign in again") : refuse(response, who, 403, "your approver standing changed — sign in again", back);
+            const sentRequest = body.get("request");
+            if (sentRequest !== null && (body.getAll("request").length !== 1 || !/^[a-f0-9]{32}$/.test(sentRequest)))
+                return said(409, "This conversation changed. Reload it before sending your message.");
+            const usable = leadSession !== null && leadSession.ceilingDigest === principal.ceilingDigest && leadSession.approverGeneration === principal.generation;
+            // The conversation this very request started, if it started one: a retry or double submit lands only there.
+            const startedBy = sentRequest === null ? null : store.leadStartReceipt(who.name, sentRequest);
+            if (startedBy !== null) {
+                if (!usable || leadSession === null || leadSession.id !== startedBy.session)
+                    return said(409, "This conversation ended or changed. Reload it before sending your message.", leadSession?.id ?? null);
+                startedHere = true;
+            }
+            else if (usable && leadSession !== null) {
+                // A page that showed no conversation never sends into one it did not start.
+                if (binding.length === 1)
+                    return said(409, "This conversation changed. Reload it before sending your message.", leadSession.id);
+            }
+            else {
+                // Nothing starts for a message that would be refused anyway.
+                const message = (body.get("message") ?? "").trim();
+                if (message === "" || message.length > LEAD_MESSAGE_MAX_CHARS)
+                    return said(400, `a message is 1 to ${LEAD_MESSAGE_MAX_CHARS} characters`);
+                if (scanForSecrets(message).length > 0)
+                    return said(400, "that looks like a credential — chat never forwards or stores those");
+                const scope = chatScopeOf(focusTask, chatProject);
+                // The start and its record are one write: a retry finds it, and never starts a second conversation.
+                const started = startLeadConversation(who, principal, enabled, 0, false, now, scope, sentRequest ?? undefined);
+                leadSession = store.activeLeadSession(who.name);
+                if (leadSession === null || leadSession.id !== started)
+                    return said(409, "This conversation changed. Reload it before sending your message.");
+                startedHere = true;
+            }
+        }
         if (leadSession !== null) {
             const sentRequest = body.get("request");
-            if (sentRequest !== null && (body.getAll("request").length !== 1 || body.getAll("request-session").length !== 1 || body.get("request-session") !== String(leadSession.id))) {
+            if (sentRequest !== null && !startedHere && (body.getAll("request").length !== 1 || body.getAll("request-session").length !== 1 || body.get("request-session") !== String(leadSession.id))) {
                 return said(409, "This conversation changed. Reload it before sending your message.");
             }
             // Every send has one identity (a form without one gets it here): a message that waits is known by it.
@@ -1108,7 +1172,7 @@ export function createChatHandlers(runtime) {
             intro: HOW_IT_WORKS,
             lead: lead === null ? null : { words: `The lead uses ${lead}`, href: "/settings/lead" },
             // With no lead yet and no agent signed in, the page asks this computer again on its own.
-            recheck: store.getChatConfig() === null && agent !== undefined && !agent.done ? "/lead/status" : null,
+            recheck: store.getChatConfig() === null && agent !== undefined && !agent.done ? "/lead/check" : null,
         };
     }
     /** After the first Ready result, once (onboarding): the phone, by a chat app or the console over Tailscale. */
@@ -1136,16 +1200,18 @@ export function createChatHandlers(runtime) {
         const previous = liveTurns.get(thread);
         if (previous?.expiry)
             clearTimeout(previous.expiry);
-        const live = { steps: [], done: false, ok: false, listeners: previous?.listeners ?? new Set() };
+        const live = { steps: [], done: false, ok: false, listeners: previous?.listeners ?? new Set(), startedAt: clock().getTime(), stepAt: [] };
         liveTurns.set(thread, live);
         // A page that has this conversation open follows the reply (GET /live, its chat room).
         runtime.liveTurnStarted(thread);
-        const current = () => live.steps.at(-1) ?? (live.steps.push({ tools: [], toolCalls: [], text: "" }), live.steps.at(-1));
+        const newStep = () => { live.steps.push({ tools: [], toolCalls: [], text: "" }); live.stepAt.push(clock().getTime()); };
+        const current = () => live.steps.at(-1) ?? (newStep(), live.steps.at(-1));
         const progress = (event) => {
             if (live.done)
                 return;
+            live.turn ??= event.turn;
             if (event.kind === "step")
-                live.steps.push({ tools: [], toolCalls: [], text: "" });
+                newStep();
             else if (event.kind === "tool") {
                 current().tools.push(event.label);
                 current().toolCalls.push({ id: event.id, label: event.label, state: "running" });
@@ -1159,8 +1225,10 @@ export function createChatHandlers(runtime) {
                     }
                 }
             }
-            else if (event.kind === "text")
+            else if (event.kind === "text") {
                 current().text = event.text;
+                (live.confirmed ??= [])[live.steps.length - 1] = event.final === true;
+            }
             for (const listener of live.listeners)
                 listener();
         };
@@ -1175,6 +1243,7 @@ export function createChatHandlers(runtime) {
             return;
         live.done = true;
         live.ok = ok;
+        live.endedAt = clock().getTime();
         for (const listener of live.listeners)
             listener();
         live.expiry = setTimeout(() => { if (liveTurns.get(thread) === live)
@@ -1415,18 +1484,10 @@ export function createChatHandlers(runtime) {
             planUse: (windows?.tiles ?? []).map(one => ({ name: one.name, window: one.window, percent: one.percent, detail: one.detail, tone: one.tone })),
         };
     }
+    /** The first tasks last found for a project (docs/plans/get-side-effects.md): the background checks ask gh and
+     * git grep while the first run is open; a page shows what they found, or the generic three. */
     function firstTasksFor(repo) {
-        const at = Date.now();
-        let entry = firstTasks.get(repo);
-        if (entry === undefined || (entry.until <= at && !entry.reading)) {
-            const reading = { until: at + 10 * 60_000, found: entry?.found ?? null, reading: true };
-            firstTasks.set(repo, reading);
-            entry = reading;
-            void findFirstTasks(repo, options.firstTaskRunner ?? execRun)
-                .then(found => { reading.found = found; }, () => { })
-                .finally(() => { reading.reading = false; });
-        }
-        return entry.found ?? firstTaskSuggestions({ issues: [], todos: [] });
+        return firstTasks.get(repo)?.found ?? firstTaskSuggestions({ issues: [], todos: [] });
     }
     function approverCandidateCount(approver) {
         let count = 0;
@@ -1464,6 +1525,7 @@ export function createChatHandlers(runtime) {
         "chat.action": sharedActionReview,
         "push.key": pushKey,
         "lead.status": leadStatus,
+        "lead.check": leadCheck,
         "chat.task-status": taskStatus,
         "chat.demo.ask": demoAsk,
         "chat.demo.approve": demoAct("approve"),

package/dist/server/chrome.js

@@ -396,7 +396,7 @@ export function chromeScript() {
         `if(ev.key==="?"){toggleHelp();ev.preventDefault();return;}` +
         `if(ev.key==="j"||ev.key==="k"){rove(ev.key==="j"?1:-1,ev);return;}` +
         `if(pending==="g"){pending=null;` +
-        `var map={b:"/board",i:"/",w:"/workbench",d:"/done",q:"/board?view=order",f:"/fleet",t:"/tasks",a:"/activity",p:"/projects"};` +
+        `var map={b:"/board",i:"/",w:"/workbench",d:"/done",q:"/board?view=order",f:"/fleet",t:"/work",a:"/activity",p:"/projects"};` +
         `if(map[ev.key]){go(map[ev.key]);ev.preventDefault();}return;}` +
         `if(ev.key==="g"){pending="g";setTimeout(function(){pending=null;},800);}});` +
         `})();`);
@@ -717,7 +717,7 @@ export function workToolRows(scoped = false, _offersChat = false, offersCode = f
         ...(offersCode ? [{ key: "code", href: "/term", label: "Live", hint: "your own terminals: Claude Code, Codex or a shell" }] : []),
         { key: "inbox", href: "/inbox", label: "Inbox", hint: "questions, approvals, and repairs to act on" },
         { key: "board", href: "/board", label: "Board", hint: "lanes by state, with the order view" },
-        { key: "tasks", href: "/tasks", label: "Task list", hint: "everything, filterable by state" },
+        { key: "tasks", href: "/work", label: "Task list", hint: "everything, filterable by state" },
         { key: "recipes", href: "/recipes", label: "Recipes", hint: "choose, customize, and reuse a workflow" },
         { key: "workbench", href: "/workbench", label: "Portfolio", hint: "every project and live build in one place" },
         { key: "ledger", href: "/ledger", label: "Action ledger", hint: "who acted, what happened, and the result" },