toolroll 0.9.73 → 0.9.74

package/dist/repository-context-ui.js

@@ -1,5 +1,6 @@
 import { html, postForm } from "./html.js";
+import { framedSection } from './knowledge-ui.js';
 export function repositoryContextHtml(repo, query, result, csrf) {
     const root = `/settings/knowledge?repo=${encodeURIComponent(repo)}`;
-    return html `<section class="knowledge repository-context"><h2>Relevant code</h2><form method="get" action="/settings/knowledge"><input type="hidden" name="repo" value="${repo}"><label>Find code<input name="q" value="${query}" maxlength="1000" placeholder="A feature, file or symbol"></label><button type="submit">Search</button></form>${result === null ? '' : html `<p class="meta">${result.index.engine === 'typescript-ast' ? 'Code relationships' : 'Source search'}${result.mode === 'impact' ? ' · possible change impact' : ''}</p>${result.excerpts.length ? result.excerpts.map(one => html `<details><summary>${one.file}:${one.line}${one.symbol ? ` · ${one.symbol}` : ''}</summary><p class="meta">${one.reason}</p><pre>${one.text}</pre><a href="${root}&mode=impact&q=${encodeURIComponent(one.file)}">What this may affect</a></details>`) : html `<p>No matching source was found in this bounded search.</p>`}${result.relationships.length ? html `<details><summary>Related files</summary><ul>${result.relationships.map(one => html `<li>${one.from} → ${one.to} · ${one.kind}</li>`)}</ul></details>` : ''}<details><summary>Context details</summary><p>${result.index.status}${result.checkout ? ` · checkout ${result.checkout.head.slice(0, 8)}` : ''}</p>${result.warnings.map(one => html `<p>${one}</p>`)}</details>`}${csrf ? html `<details><summary>Refresh code index</summary>${postForm("/settings/knowledge/refresh", html `<p>Builds a local map of TypeScript and JavaScript imports. Uses no model.</p><button type="submit">Refresh index</button>`, { hidden: { repo } })}</details>` : ''}</section>`;
+    return framedSection('Relevant code', html `<form class="field-row" method="get" action="/settings/knowledge"><input type="hidden" name="repo" value="${repo}"><label>Find code<input name="q" value="${query}" maxlength="1000" placeholder="A feature, file or symbol"></label><button type="submit">Search</button></form>${result === null ? '' : html `<p class="meta">${result.index.engine === 'typescript-ast' ? 'Code relationships' : 'Source search'}${result.mode === 'impact' ? ' · possible change impact' : ''}</p>${result.excerpts.length ? result.excerpts.map(one => html `<details><summary>${one.file}:${one.line}${one.symbol ? ` · ${one.symbol}` : ''}</summary><p class="meta">${one.reason}</p><pre>${one.text}</pre><a href="${root}&mode=impact&q=${encodeURIComponent(one.file)}">What this may affect</a></details>`) : html `<p>No matching source was found in this bounded search.</p>`}${result.relationships.length ? html `<details><summary>Related files</summary><ul>${result.relationships.map(one => html `<li>${one.from} → ${one.to} · ${one.kind}</li>`)}</ul></details>` : ''}<details><summary>Context details</summary><p>${result.index.status}${result.checkout ? ` · checkout ${result.checkout.head.slice(0, 8)}` : ''}</p>${result.warnings.map(one => html `<p>${one}</p>`)}</details>`}${csrf ? html `<details><summary>Refresh code index</summary>${postForm("/settings/knowledge/refresh", html `<p>Builds a local map of TypeScript and JavaScript imports. Uses no model.</p><button type="submit">Refresh index</button>`, { hidden: { repo } })}</details>` : ''}`, 'repository-context');
 }

package/dist/run-efficiency.d.ts

@@ -8,7 +8,7 @@
  * kept 24 hours) are read once, bounded, through the descriptor-safe live reader, for step counts and observed step
  * times. No command text is ever stored here: repeats are counted, never quoted.
  */
-import type { Run, Store } from "./store.js";
+import { type Run, type Store } from "./store.js";
 import type { LiveActivityKind, LiveRecord } from "./live-records.js";
 export declare const RUN_EFFICIENCY_VERSION = 3;
 /** Budgets for one derivation: never more than the live file's own cap, and a bounded record count. */
@@ -62,10 +62,10 @@ export declare function usageOf(run: Pick<Run, "provider" | "model" | "tokensIn"
  * others their times are partly made up (Codex reports a step when it completes, ACP agents may report late), so no
  * duration is claimed for them. */
 export declare function stepsOf(records: Iterable<LiveRecord>, truncated: string | null, measured?: boolean): RunEfficiency["steps"];
-/** Derive a finished run's How it ran from its records. */
+/** Derive a finished run's How it ran from its records, read under the run's own captured "Show commands" answer. */
 export declare function deriveRunEfficiency(run: Run & {
     usageJson?: string | null;
-}, evidenceRoot: string, now: Date): RunEfficiency;
+}, evidenceRoot: string, now: Date, commands?: boolean): RunEfficiency;
 /**
  * A finished run's How it ran: the saved one when it was derived by this version, else derived now and saved (once:
  * a row whose steps were complete or have expired is final). An unfinished run is derived but never saved.

package/dist/run-efficiency.js

@@ -1,3 +1,14 @@
+/**
+ * How a run went (docs/plans/run-efficiency.md): derived from the run's own records, display only. It never changes a
+ * completion, an approval, a charge or a check verdict, and it claims nothing its sources don't hold — an unreported
+ * number is unknown (null, shown as a dash), never zero.
+ *
+ * Sources, and what each can say: the run row (wall times, tokens, the provider's raw usage with its cache counts, the
+ * agent's turns where reported) is kept with the run; the live records (`<evidence>/live/<run>.jsonl`, display-only,
+ * kept 24 hours) are read once, bounded, through the descriptor-safe live reader, for step counts and observed step
+ * times. No command text is ever stored here: repeats are counted, never quoted.
+ */
+import { runLiveCommands } from "./store.js";
 import { closeSync, constants, fstatSync, lstatSync, openSync, readSync } from "node:fs";
 import { join } from "node:path";
 import { LIVE_RETAIN_MS, legacyLiveLogPath, liveLogPath, liveWindowRecords } from "./live.js";
@@ -95,7 +106,7 @@ const noSteps = (state, reason) => ({ state, reason, total: null, failed: null,
  * directory), measured once, and never more than the budget read whatever the file does meanwhile; then parsed line by
  * line. A file over the budget, in the older text format, with lines that don't read, or cut or capped while the agent
  * ran, says its steps are incomplete. Null when there is no step file at all. */
-function readRecords(evidenceRoot, runId) {
+function readRecords(evidenceRoot, runId, commands) {
     try {
         const dir = lstatSync(join(evidenceRoot, "live"));
         if (!dir.isDirectory() || dir.isSymbolicLink())
@@ -154,10 +165,10 @@ function readRecords(evidenceRoot, runId) {
         whole.length = EFFICIENCY_RECORDS;
     const keys = { inKey: false };
     // One record per line: a whole line that doesn't read is a record lost.
-    const read = liveWindowRecords({ text: whole.length === 0 ? "" : `${whole.join("\n")}\n`, format: "records" }, keys);
+    const read = liveWindowRecords({ text: whole.length === 0 ? "" : `${whole.join("\n")}\n`, format: "records" }, commands, keys);
     const lost = whole.length - read.length;
     // A finished run's last line without its newline is read like any other; one that doesn't read is a record lost.
-    const tail = unfinished.trim() === "" ? [] : liveWindowRecords({ text: `${unfinished}\n`, format: "records" }, keys);
+    const tail = unfinished.trim() === "" ? [] : liveWindowRecords({ text: `${unfinished}\n`, format: "records" }, commands, keys);
     const records = [...read, ...tail];
     const lostAll = lost + (unfinished.trim() !== "" && tail.length === 0 ? 1 : 0);
     if (records.length === 0 && text.trim() !== "")
@@ -170,10 +181,10 @@ function readRecords(evidenceRoot, runId) {
                         : null;
     return { records, truncated };
 }
-/** Derive a finished run's How it ran from its records. */
-export function deriveRunEfficiency(run, evidenceRoot, now) {
+/** Derive a finished run's How it ran from its records, read under the run's own captured "Show commands" answer. */
+export function deriveRunEfficiency(run, evidenceRoot, now, commands = false) {
     const finished = run.finishedAt;
-    const read = readRecords(evidenceRoot, run.id);
+    const read = readRecords(evidenceRoot, run.id, commands);
     const steps = read !== null && "unreadable" in read ? noSteps("truncated", read.unreadable)
         : read !== null ? stepsOf(read.records, read.truncated, run.provider === "claude")
             : finished !== null && now.getTime() - Date.parse(finished) > LIVE_RETAIN_MS ? noSteps("expired", "Step details are kept for a day after a run; this one's have expired.")
@@ -196,8 +207,9 @@ export function runEfficiencyOf(store, evidenceRoot, runId, now) {
         return null;
     const usageJson = store.handle.prepare("SELECT usage_json FROM run WHERE id = ?").get(runId)?.["usage_json"];
     const full = { ...run, usageJson: typeof usageJson === "string" ? usageJson : null };
+    const commands = runLiveCommands(store, runId);
     if (run.finishedAt === null)
-        return deriveRunEfficiency(full, evidenceRoot, now);
+        return deriveRunEfficiency(full, evidenceRoot, now, commands);
     let saved;
     try {
         saved = store.handle.prepare("SELECT parser_version, payload_json FROM run_efficiency WHERE run = ?").get(runId);
@@ -211,7 +223,7 @@ export function runEfficiencyOf(store, evidenceRoot, runId, now) {
         }
         catch { /* derived again below */ }
     }
-    const derived = deriveRunEfficiency(full, evidenceRoot, now);
+    const derived = deriveRunEfficiency(full, evidenceRoot, now, commands);
     const payload = JSON.stringify(derived);
     // A row too large for its column (it can't be: the counts are bounded) is shown, never saved.
     // Saving is a convenience: a store that can't take the row (read-only, busy) still shows what was derived.

package/dist/scout.d.ts

@@ -131,6 +131,9 @@ export declare function readReportImage(folder: string, file: string): {
 };
 /** The shorten turn's ask: the fields over their limits, and the same report again within them. */
 export declare function shortenReportBrief(over: readonly ReportProblem[], reportFile: string, structured: boolean): string;
+/** Whether a stream event shows the session writing its plan-mode plan
+ * file (~/.claude/plans/…) or handing a plan to ExitPlanMode. */
+export declare function touchesPlanFile(event: Record<string, unknown>): boolean;
 /** A cited link without its secrets: credential-shaped query values and path parts become REDACTED, a fragment
  * that carries one is dropped, and a link still showing one keeps only its origin. Unchanged when it has none. */
 export declare function scrubUrl(text: string): {

package/dist/scout.js

@@ -37,6 +37,7 @@ import { grantOf, researchToolsOf } from "./mcp-connect.js";
 import { startScoutProxy } from "./scout-net.js";
 import * as browserCheck from "./scout-browser.js";
 import { invokeAgent } from "./invoke.js";
+import { topLevelEvent } from "./stream-scope.js";
 const GIT = "git";
 const AGENT_ENV_DENYLIST = [...TELEGRAM_TOKEN_ENVS];
 const DEFAULT_SCOUT_TIMEOUT_MS = 20 * 60_000;
@@ -298,7 +299,7 @@ async function scoutWith(store, request, outputDir) {
     }
     // The live window (peek): the same transcript file the builder keeps,
     // so `toolroll peek` and the run page can watch this session too.
-    const liveLog = openLiveLog(root, request.runId, liveLogContext(store, taskRef, worktree));
+    const liveLog = openLiveLog(root, request.runId, liveLogContext(store, request.runId, taskRef, worktree, clock()));
     // Claude's report rides the terminal result event (run 2334's fix): plan
     // mode only lets the session write its own plan file. Codex has no
     // structured output and keeps the mailbox file.
@@ -706,8 +707,9 @@ export function shortenReportBrief(over, reportFile, structured) {
 }
 /** Whether a stream event shows the session writing its plan-mode plan
  * file (~/.claude/plans/…) or handing a plan to ExitPlanMode. */
-function touchesPlanFile(event) {
-    if (event["type"] !== "assistant")
+export function touchesPlanFile(event) {
+    // The session's own calls only: a subagent's (parent_tool_use_id set) is not the scout's plan (stream-scope.ts).
+    if (event["type"] !== "assistant" || !topLevelEvent(event))
         return false;
     const message = event["message"];
     if (typeof message !== "object" || message === null)

package/dist/serve.js

@@ -139,7 +139,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";
@@ -775,7 +775,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;
@@ -1139,12 +1141,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 +1160,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 +1175,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 +1188,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 +1198,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 +1216,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);
@@ -1323,7 +1335,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 +1344,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 +1358,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

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 {};

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,88 @@
+/**
+ * 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 { 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));
+            const seen = tiles.filter(tile => kept.has(tile.runId)).map(tile => [tile.runId, tile.state, tile.why, tile.endedAt]);
+            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 };
+}