toolroll 0.9.46 → 0.9.48

package/dist/browser-workspace.d.ts

@@ -2,6 +2,7 @@
  * produced by the existing trusted server renderers, never by a model-supplied
  * fragment. These projections do not authenticate, mutate or grant authority. */
 import type { TeamSnapshot } from './team-contract.js';
+import type { RunActivity } from './activity-line.js';
 import type { BrandIconId } from './brand-icons.js';
 import type { AssignmentSnapshot } from './assignment.js';
 export { browserCrewFromIndex, browserWorkActionHref } from './browser-crew.js';
@@ -26,7 +27,12 @@ export type BrowserNavigationItem = {
     href: string;
     active: boolean;
     count?: number;
+    /** What the count covers, said aloud and on hover: "3 need you in shop". */
+    countLabel?: string;
 };
+/** The Tasks badge's words: the count and the projects it covers
+ * ("3 need you in shop", "1 needs you across all your projects"). */
+export declare function needsYouLabelOf(count: number, projectName: string | null, saturated?: boolean): string;
 export type BrowserChatLink = {
     kind: 'project' | 'task';
     title: string;
@@ -53,6 +59,8 @@ export type BrowserCrewItem = {
     detail?: string;
     /** "<name> is on it.": the person's own lead took it on, by the name they gave it. */
     lead?: string;
+    /** A running task: what its agent did last, and when. */
+    activity?: RunActivity;
 };
 export type BrowserMessage = {
     id: number;
@@ -419,6 +427,13 @@ export type BrowserTaskView = {
             action: BrowserLink | null;
         } | null;
     } | null;
+    /** What the agent did last on the live run, and when; the page words it against its own clock (activity-line.ts). */
+    activity?: RunActivity | null;
+    /** The task's live stream (/t/<id>/live): change nudges and who else has it open. Absent: the page reads on its beat. */
+    live?: {
+        href: string;
+        at: string | null;
+    } | null;
     /** Stop, on the Building card: the exact live build's stop form (posts its run id). */
     stop?: {
         action: string;
@@ -1166,6 +1181,8 @@ export type BrowserHomeAgent = {
     phase: string;
     project: string | null;
     since: string;
+    /** What the agent did last, and when. */
+    activity?: RunActivity;
 };
 export type BrowserHomeCount = {
     key: 'working' | 'waiting' | 'ready' | 'done';
@@ -1277,4 +1294,4 @@ export declare function browserProjectsOf(projects: readonly {
     name: string;
     path: string;
 }[]): BrowserProject[];
-export declare function browserNavigationOf(path: string, project?: string | null, needsYou?: number): BrowserNavigationItem[];
+export declare function browserNavigationOf(path: string, project?: string | null, needsYou?: number, tasksProject?: string | null, needsYouLabel?: string): BrowserNavigationItem[];

package/dist/browser-workspace.js

@@ -1,6 +1,12 @@
 import { browserCrewFromIndex } from './browser-crew.js';
 export { browserCrewFromIndex, browserWorkActionHref } from './browser-crew.js';
 import { workIndexPage } from './work-index.js';
+/** The Tasks badge's words: the count and the projects it covers
+ * ("3 need you in shop", "1 needs you across all your projects"). */
+export function needsYouLabelOf(count, projectName, saturated = false) {
+    const where = projectName === null ? 'across all your projects' : `in ${projectName}`;
+    return `${count}${saturated ? '+' : ''} ${count === 1 && !saturated ? 'needs' : 'need'} you ${where}`;
+}
 /** Safe inside a script[type=application/json] element. JSON escaping alone
  * does not stop the HTML parser from closing that element at </script>. */
 export function serializeBrowserWorkspace(workspace) {
@@ -31,14 +37,14 @@ export function browserProjectsOf(projects) {
                 knowledgeHref: `/settings/knowledge?repo=${encodeURIComponent(project.path)}` }];
     });
 }
-export function browserNavigationOf(path, project = null, needsYou = 0) {
+export function browserNavigationOf(path, project = null, needsYou = 0, tasksProject = project, needsYouLabel) {
     const pathname = path.split('?')[0].split('#')[0];
     const knowledge = pathname === '/settings/knowledge' || pathname.startsWith('/settings/knowledge/');
     return [
         { label: 'Chat', href: '/chat', active: pathname === '/chat' },
-        { label: 'Tasks', href: `/work${project === null ? '' : `?project=${encodeURIComponent(project)}`}`,
+        { label: 'Tasks', href: `/work${tasksProject === null ? '' : `?project=${encodeURIComponent(tasksProject)}`}`,
             active: pathname === '/work' || pathname === '/tasks' || pathname.startsWith('/t/') || pathname.startsWith('/r/'),
-            ...(needsYou > 0 ? { count: needsYou } : {}) },
+            ...(needsYou > 0 ? { count: needsYou, ...(needsYouLabel === undefined ? {} : { countLabel: needsYouLabel }) } : {}) },
         { label: 'Flows', href: '/flows', active: pathname === '/flows' || pathname.startsWith('/flows/') },
         { label: 'Projects', href: '/projects', active: pathname === '/projects' },
         { label: 'Knowledge', href: `/settings/knowledge${project === null ? '' : `?repo=${encodeURIComponent(project)}`}`, active: knowledge },

package/dist/builder.js

@@ -60,6 +60,7 @@ import { invokeAgent } from "./invoke.js";
 import { TELEGRAM_TOKEN_ENVS } from "./names.js";
 import { OPENROUTER_ENV_KEY, auditOf, ALL_CREDENTIAL_ENV } from "./provider.js";
 import { openLiveLog } from "./live.js";
+import { withRunActivity } from "./task-activity.js";
 import { CheckProgressTracker } from "./check-progress.js";
 import { captureParkEvidence, captureTerminalDiff, captureBaseTree, evidenceRoot, handoffName, isImagePath, WORKTREE_EVIDENCE_DIR, storeHandoffArtifact, looksLikeProtocolFile, mailboxName, progressFileName, proofFileName, rubricFileName, proposalFileName, quarantineMailboxes, readMailbox, readVerifiedArtifact, scanForSecrets, redactSecretLines, storeEvidence, validateScreenshotBytes, imageDimensions, SCREENSHOT_BYTE_CAP, boundStreamHeadTail } from "./evidence.js";
 import { PROOF_LIMITS, parseProof, serializeProof, adjudicate, artifactManifestOnly, sameDiffStatFacts } from "./proof.js";
@@ -1139,7 +1140,8 @@ export async function build(store, request) {
     // The live window (arc 1): display state beside the run, never evidence.
     // Every streaming transport emits events now (peek); a file that cannot
     // open is a null, and a null never costs a build.
-    const liveLog = openLiveLog(root, request.runId);
+    // What the agent did last rides the same stream into one row (live tasks).
+    const liveLog = withRunActivity(openLiveLog(root, request.runId), store, request.runId, clock);
     // The retry base (steering fix for run 1465's proof): the SAME pinned
     // base the machine will use to capture the sealed diff (settleProof
     // below, mirroring store.firstBuilderBase's own doc). Null on a first
@@ -1329,7 +1331,7 @@ export async function build(store, request) {
             omitEnv: AGENT_ENV_DENYLIST,
             ...(agent === undefined ? {} : { runner: agent }),
             ...(request.onProviderSpawn === undefined ? {} : { onSpawn: request.onProviderSpawn }),
-            ...(liveLog === null ? {} : { onStreamEvent: (event) => liveLog.observe(event) }),
+            onStreamEvent: (event) => liveLog.observe(event),
             // The receipt (finding 8): the stream proved the prompt reached the
             // agent — settle delivery NOW, durably, whatever happens to the run
             // later. The runner latches and isolates this callback; a throw

package/dist/cli.d.ts

@@ -40,7 +40,7 @@ export type ParseResult = {
     error: string;
 };
 type Write = (line: string) => void;
-export declare const HELP = "toolroll \u2014 a control plane for unattended coding agents\n\nUsage\n  toolroll [path...]        report what is in flight\n  toolroll pulls            report what is waiting on a person\n  toolroll graph            report which work graph is already here\n  toolroll repos            list connected repositories, and how to adjust\n  toolroll repos add <path> add a project; it is in the console at once (no path: the repo you are in)\n  toolroll repos remove <path>\n                                   take it out of the console; its tasks and results stay\n  toolroll repos add-from-github <owner/name> --root <dir>\n                                   preview, then clone and connect (--yes)\n  toolroll link             put `toolroll` on your PATH\n  toolroll unlink           take it off again\n  toolroll update           update to the latest release: verified, drained, undoable\n                                   (preview first; --yes, --now, --at HH:MM, --rollback)\n  toolroll contract         the machine contract: envelope version + capabilities\n                                   (--commands dumps the declared command guide)\n  toolroll skills install --claude-code [--dir <path>]\n                                   install this binary's guides for Claude Code (preview first)\n  toolroll skills install   teach a repo's agents this queue exists (preview first)\n  toolroll skills list      the guides this exact binary serves\n  toolroll skills get <name>  print one guide (version-matched, never stale)\n  toolroll demo             a seeded throwaway sandbox \u2014 see it working in 90 seconds\n  toolroll up               app + builder for every saved project \u2014 the normal start\n  toolroll onboard          make your agent Toolroll's lead: add this repo, install its skill (--yes), offer starter flows (--starter)\n  toolroll status           running, queued, ready results, release check and plan windows\n  toolroll integrations     which integrations work, and what to do about the ones that don't (--json)\n  toolroll session          native coding sessions through the running service\n  toolroll connect          save a private connection to your central service\n  toolroll lead             named leads on the connected service\n  toolroll lead token       mint your lead agent's credential: its own work pings nobody\n  toolroll lead say \"<text>\"  (the lead) one short message in its person's chat\n  toolroll conversation     shared and private conversations on that service\n  toolroll chat --lead <id> --conversation <id>  central chat (use --local for local chat)\n\nOperating the queue \u2014 `toolroll task` prints the whole surface,\nand any queue command + --help prints it too\n  toolroll approver add <name>\n                               mint the credential that lets a person say yes\n  toolroll ready            what could be dispatched right now\n  toolroll check-progress <run>  current or final approved check progress\n  toolroll task wait <id> [--timeout <seconds>]\n                               wait for this attempt to finish or need a person\n  toolroll task add <title> queue work\n  toolroll task scope <id> --goal <text>\n                               state what success is; approval binds to it\n  toolroll task approve <id>\n                               the yes \u2014 nothing builds without one\n  toolroll claim <id> --runner <name>\n  toolroll heartbeat <lease> / release <lease> / reap\n  toolroll tick --runner <name> --token <t> --repo <path>\n                               one unattended pass over the ready set\n  toolroll flows list | show <id> | create | edit | trigger | script | card | archive\n                               set up and inspect flows (writes preview until --yes)\n  toolroll chat --as <you> --token <t>\n                               talk to the mate: one conversation across every\n                               project; it proposes, you confirm (--say \"\u2026\" for one turn)\n  toolroll serve --repo <path>  advanced: run only the console\n                               (--editor vscode with --runner: file links\n                               open in VS Code on the device you browse from)\n  toolroll watch / daemon install   advanced: run only the builder\n  toolroll reconcile        recover what the last stretch left behind\n\nWith nothing connected it reports everything it can find below the working\ndirectory. Once you connect repositories it reports those instead.\n\nOptions\n  --all         report everything discoverable, ignoring connected repos\n  --depth <n>   directory levels to descend (default: 6)\n  --hidden      include dot-directories, which are skipped by default\n  --dirty       also read each working tree for uncommitted files\n  --local       branches only: no network, no pull requests, no issues\n  --json        emit a machine-readable envelope instead of a report\n  -o <file>     also write that envelope to a file (requires --json)\n  -h, --help    show this\n\nNothing is written, installed, or configured. Every repository is read\nthrough git with --no-optional-locks, so a scan never contends for the\nindex lock with an editor you have open.\n\n--dirty is off by default because reading a working tree is unbounded\nwork: on a large or cloud-synced repo `git status` can take minutes,\nwhere listing branches takes milliseconds.\n\nlink shows what it would do and changes nothing; add --yes to apply it,\nor --to <dir> to choose where. It never uses sudo, never leaves your\nhome directory, and never touches a file it did not create.";
+export declare const HELP = "toolroll \u2014 a control plane for unattended coding agents\n\nUsage\n  toolroll [path...]        report what is in flight\n  toolroll pulls            report what is waiting on a person\n  toolroll graph            report which work graph is already here\n  toolroll repos            list connected repositories, and how to adjust\n  toolroll repos add <path> add a project; it is in the console at once (no path: the repo you are in)\n  toolroll repos remove <path>\n                                   take it out of the console; its tasks and results stay\n  toolroll repos add-from-github <owner/name> --root <dir>\n                                   preview, then clone and connect (--yes)\n  toolroll link             put `toolroll` on your PATH\n  toolroll unlink           take it off again\n  toolroll update           update to the latest release: verified, drained, undoable\n                                   (preview first; --yes, --now, --at HH:MM, --rollback)\n  toolroll contract         the machine contract: envelope version + capabilities\n                                   (--commands dumps the declared command guide)\n  toolroll skills install --claude-code [--dir <path>]\n                                   install this binary's guides for Claude Code (preview first)\n  toolroll skills install   teach a repo's agents this queue exists (preview first)\n  toolroll skills list      the guides this exact binary serves\n  toolroll skills get <name>  print one guide (version-matched, never stale)\n  toolroll demo             a seeded throwaway sandbox \u2014 see it working in 90 seconds\n  toolroll up               app + builder for every saved project \u2014 the normal start\n  toolroll onboard          make your agent Toolroll's lead: add this repo, install its skill (--yes), offer starter flows (--starter)\n  toolroll status           running, queued, ready results, release check and plan windows\n  toolroll health           recent server latency, write waits and live streams\n  toolroll integrations     which integrations work, and what to do about the ones that don't (--json)\n  toolroll session          native coding sessions through the running service\n  toolroll connect          save a private connection to your central service\n  toolroll lead             named leads on the connected service\n  toolroll lead token       mint your lead agent's credential: its own work pings nobody\n  toolroll lead say \"<text>\"  (the lead) one short message in its person's chat\n  toolroll conversation     shared and private conversations on that service\n  toolroll chat --lead <id> --conversation <id>  central chat (use --local for local chat)\n\nOperating the queue \u2014 `toolroll task` prints the whole surface,\nand any queue command + --help prints it too\n  toolroll approver add <name>\n                               mint the credential that lets a person say yes\n  toolroll ready            what could be dispatched right now\n  toolroll check-progress <run>  current or final approved check progress\n  toolroll task wait <id> [--timeout <seconds>]\n                               wait for this attempt to finish or need a person\n  toolroll task add <title> queue work\n  toolroll task scope <id> --goal <text>\n                               state what success is; approval binds to it\n  toolroll task approve <id>\n                               the yes \u2014 nothing builds without one\n  toolroll claim <id> --runner <name>\n  toolroll heartbeat <lease> / release <lease> / reap\n  toolroll tick --runner <name> --token <t> --repo <path>\n                               one unattended pass over the ready set\n  toolroll flows list | show <id> | create | edit | trigger | script | card | archive\n                               set up and inspect flows (writes preview until --yes)\n  toolroll chat --as <you> --token <t>\n                               talk to the mate: one conversation across every\n                               project; it proposes, you confirm (--say \"\u2026\" for one turn)\n  toolroll serve --repo <path>  advanced: run only the console\n                               (--editor vscode with --runner: file links\n                               open in VS Code on the device you browse from)\n  toolroll watch / daemon install   advanced: run only the builder\n  toolroll reconcile        recover what the last stretch left behind\n\nWith nothing connected it reports everything it can find below the working\ndirectory. Once you connect repositories it reports those instead.\n\nOptions\n  --all         report everything discoverable, ignoring connected repos\n  --depth <n>   directory levels to descend (default: 6)\n  --hidden      include dot-directories, which are skipped by default\n  --dirty       also read each working tree for uncommitted files\n  --local       branches only: no network, no pull requests, no issues\n  --json        emit a machine-readable envelope instead of a report\n  -o <file>     also write that envelope to a file (requires --json)\n  -h, --help    show this\n\nNothing is written, installed, or configured. Every repository is read\nthrough git with --no-optional-locks, so a scan never contends for the\nindex lock with an editor you have open.\n\n--dirty is off by default because reading a working tree is unbounded\nwork: on a large or cloud-synced repo `git status` can take minutes,\nwhere listing branches takes milliseconds.\n\nlink shows what it would do and changes nothing; add --yes to apply it,\nor --to <dir> to choose where. It never uses sudo, never leaves your\nhome directory, and never touches a file it did not create.";
 export declare function parseArgs(argv: readonly string[]): ParseResult;
 /** The commands that operate the queue rather than report on the world. */
 /** Every verb the CLI routes OUTSIDE runOperate. Exported (with

package/dist/cli.js

@@ -28,6 +28,7 @@ import { COMMAND_GUIDE, SURFACE_NOTES, SURFACE_SCHEMA_VERSION } from "./surface.
 import { runSessionCommand, SESSION_CLI_ACTIONS } from "./session-cli.js";
 import { maybeRunTeamCommand, TEAM_CLI_ACTIONS } from "./team-cli.js";
 import { maybeRunRemoteCommand } from "./remote-exec.js";
+import { runHealthCommand } from "./health-cli.js";
 import { discover, inspectAll } from "./discover.js";
 import { readPulls } from "./pulls.js";
 import { detectGraphs, chooseBackend, setupOptions, LABELS as GRAPH_LABELS, } from "./graph.js";
@@ -67,6 +68,7 @@ Usage
   toolroll up               app + builder for every saved project — the normal start
   toolroll onboard          make your agent Toolroll's lead: add this repo, install its skill (--yes), offer starter flows (--starter)
   toolroll status           running, queued, ready results, release check and plan windows
+  toolroll health           recent server latency, write waits and live streams
   toolroll integrations     which integrations work, and what to do about the ones that don't (--json)
   toolroll session          native coding sessions through the running service
   toolroll connect          save a private connection to your central service
@@ -383,6 +385,8 @@ export async function main(argv, write = line => console.log(line), mainOptions
 }
 async function dispatch(argv, write, mainOptions) {
     // A saved API token sends commands marked remote to the central server, before anything local opens.
+    if (argv[0] === 'health')
+        return runHealthCommand(argv.slice(1), write, mainOptions.team ?? mainOptions.remote);
     const central = await maybeRunRemoteCommand(argv, mainOptions.remote ?? mainOptions.team);
     if (typeof central === "number")
         return central;

package/dist/contracts/cli.d.ts

@@ -304,6 +304,93 @@ export declare const COMMAND_OUTPUTS: {
         reason: z.ZodString;
         message: z.ZodOptional<z.ZodString>;
     }, z.core.$loose>], "ok">;
+    readonly health: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        envelopeVersion: z.ZodLiteral<1>;
+        ok: z.ZodLiteral<true>;
+        command: z.ZodLiteral<"health">;
+        health: z.ZodObject<{
+            version: z.ZodLiteral<1>;
+            windowSeconds: z.ZodLiteral<300>;
+            uptimeSeconds: z.ZodNumber;
+            requests: z.ZodObject<{
+                count: z.ZodNumber;
+                p50Ms: z.ZodNullable<z.ZodNumber>;
+                p99Ms: z.ZodNullable<z.ZodNumber>;
+                maxMs: z.ZodNullable<z.ZodNumber>;
+                totalMs: z.ZodNumber;
+            }, z.core.$loose>;
+            routes: z.ZodRecord<z.ZodEnum<{
+                assets: "assets";
+                auth: "auth";
+                chat: "chat";
+                "chat-stream": "chat-stream";
+                cli: "cli";
+                console: "console";
+                decisions: "decisions";
+                "flow-stream": "flow-stream";
+                flows: "flows";
+                health: "health";
+                mcp: "mcp";
+                metrics: "metrics";
+                other: "other";
+                projects: "projects";
+                results: "results";
+                sessions: "sessions";
+                settings: "settings";
+                tasks: "tasks";
+                team: "team";
+                "team-stream": "team-stream";
+            }> & z.core.$partial, z.ZodObject<{
+                count: z.ZodNumber;
+                p50Ms: z.ZodNullable<z.ZodNumber>;
+                p99Ms: z.ZodNullable<z.ZodNumber>;
+                maxMs: z.ZodNullable<z.ZodNumber>;
+                totalMs: z.ZodNumber;
+            }, z.core.$loose>>;
+            eventLoop: z.ZodObject<{
+                count: z.ZodNumber;
+                p50Ms: z.ZodNullable<z.ZodNumber>;
+                p99Ms: z.ZodNullable<z.ZodNumber>;
+                maxMs: z.ZodNullable<z.ZodNumber>;
+                totalMs: z.ZodNumber;
+            }, z.core.$loose>;
+            writes: z.ZodObject<{
+                wait: z.ZodObject<{
+                    count: z.ZodNumber;
+                    p50Ms: z.ZodNullable<z.ZodNumber>;
+                    p99Ms: z.ZodNullable<z.ZodNumber>;
+                    maxMs: z.ZodNullable<z.ZodNumber>;
+                    totalMs: z.ZodNumber;
+                }, z.core.$loose>;
+                hold: z.ZodObject<{
+                    count: z.ZodNumber;
+                    p50Ms: z.ZodNullable<z.ZodNumber>;
+                    p99Ms: z.ZodNullable<z.ZodNumber>;
+                    maxMs: z.ZodNullable<z.ZodNumber>;
+                    totalMs: z.ZodNumber;
+                }, z.core.$loose>;
+                statement: z.ZodObject<{
+                    count: z.ZodNumber;
+                    p50Ms: z.ZodNullable<z.ZodNumber>;
+                    p99Ms: z.ZodNullable<z.ZodNumber>;
+                    maxMs: z.ZodNullable<z.ZodNumber>;
+                    totalMs: z.ZodNumber;
+                }, z.core.$loose>;
+            }, z.core.$loose>;
+            streams: z.ZodObject<{
+                open: z.ZodNumber;
+                queuedBytes: z.ZodNumber;
+                maxQueuedBytes: z.ZodNumber;
+            }, z.core.$loose>;
+            budgetRefusals: z.ZodNumber;
+        }, z.core.$loose>;
+    }, z.core.$loose>, z.ZodObject<{
+        envelopeVersion: z.ZodLiteral<1>;
+        ok: z.ZodLiteral<false>;
+        command: z.ZodLiteral<"health">;
+        reason: z.ZodString;
+        message: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>], "ok">;
     readonly integrations: z.ZodDiscriminatedUnion<[z.ZodObject<{
         envelopeVersion: z.ZodLiteral<1>;
         ok: z.ZodLiteral<true>;

package/dist/contracts/cli.js

@@ -12,6 +12,7 @@ import { z } from "zod";
 import { ENVELOPE_VERSION, envelopeJson } from "../envelope.js";
 import { parseContract } from "./contract.js";
 import { LISTED_TASK_STATES } from "./lead-tools.js";
+import { healthSnapshotSchema } from './health.js';
 const str = z.string();
 const int = z.number().int();
 const list = z.array(z.unknown());
@@ -167,6 +168,7 @@ export const COMMAND_OUTPUTS = {
     contract: contractOutput,
     scan: scanOutput,
     status: statusOutput,
+    health: answers('health', { health: healthSnapshotSchema }),
     integrations: integrationsOutput,
     ready: z.union([
         answers("ready", { count: int, tasks: rows({ id: str, title: str, state: str }) }),

package/dist/contracts/health.d.ts

@@ -0,0 +1,84 @@
+import { z } from 'zod';
+export declare const latencySummarySchema: z.ZodObject<{
+    count: z.ZodNumber;
+    p50Ms: z.ZodNullable<z.ZodNumber>;
+    p99Ms: z.ZodNullable<z.ZodNumber>;
+    maxMs: z.ZodNullable<z.ZodNumber>;
+    totalMs: z.ZodNumber;
+}, z.core.$loose>;
+export declare const healthSnapshotSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    windowSeconds: z.ZodLiteral<300>;
+    uptimeSeconds: z.ZodNumber;
+    requests: z.ZodObject<{
+        count: z.ZodNumber;
+        p50Ms: z.ZodNullable<z.ZodNumber>;
+        p99Ms: z.ZodNullable<z.ZodNumber>;
+        maxMs: z.ZodNullable<z.ZodNumber>;
+        totalMs: z.ZodNumber;
+    }, z.core.$loose>;
+    routes: z.ZodRecord<z.ZodEnum<{
+        assets: "assets";
+        auth: "auth";
+        chat: "chat";
+        "chat-stream": "chat-stream";
+        cli: "cli";
+        console: "console";
+        decisions: "decisions";
+        "flow-stream": "flow-stream";
+        flows: "flows";
+        health: "health";
+        mcp: "mcp";
+        metrics: "metrics";
+        other: "other";
+        projects: "projects";
+        results: "results";
+        sessions: "sessions";
+        settings: "settings";
+        tasks: "tasks";
+        team: "team";
+        "team-stream": "team-stream";
+    }> & z.core.$partial, z.ZodObject<{
+        count: z.ZodNumber;
+        p50Ms: z.ZodNullable<z.ZodNumber>;
+        p99Ms: z.ZodNullable<z.ZodNumber>;
+        maxMs: z.ZodNullable<z.ZodNumber>;
+        totalMs: z.ZodNumber;
+    }, z.core.$loose>>;
+    eventLoop: z.ZodObject<{
+        count: z.ZodNumber;
+        p50Ms: z.ZodNullable<z.ZodNumber>;
+        p99Ms: z.ZodNullable<z.ZodNumber>;
+        maxMs: z.ZodNullable<z.ZodNumber>;
+        totalMs: z.ZodNumber;
+    }, z.core.$loose>;
+    writes: z.ZodObject<{
+        wait: z.ZodObject<{
+            count: z.ZodNumber;
+            p50Ms: z.ZodNullable<z.ZodNumber>;
+            p99Ms: z.ZodNullable<z.ZodNumber>;
+            maxMs: z.ZodNullable<z.ZodNumber>;
+            totalMs: z.ZodNumber;
+        }, z.core.$loose>;
+        hold: z.ZodObject<{
+            count: z.ZodNumber;
+            p50Ms: z.ZodNullable<z.ZodNumber>;
+            p99Ms: z.ZodNullable<z.ZodNumber>;
+            maxMs: z.ZodNullable<z.ZodNumber>;
+            totalMs: z.ZodNumber;
+        }, z.core.$loose>;
+        statement: z.ZodObject<{
+            count: z.ZodNumber;
+            p50Ms: z.ZodNullable<z.ZodNumber>;
+            p99Ms: z.ZodNullable<z.ZodNumber>;
+            maxMs: z.ZodNullable<z.ZodNumber>;
+            totalMs: z.ZodNumber;
+        }, z.core.$loose>;
+    }, z.core.$loose>;
+    streams: z.ZodObject<{
+        open: z.ZodNumber;
+        queuedBytes: z.ZodNumber;
+        maxQueuedBytes: z.ZodNumber;
+    }, z.core.$loose>;
+    budgetRefusals: z.ZodNumber;
+}, z.core.$loose>;

package/dist/contracts/health.js

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import { ROUTE_FAMILIES } from '../server-telemetry.js';
+const count = z.number().int().nonnegative();
+const milliseconds = z.number().nonnegative();
+export const latencySummarySchema = z.looseObject({ count, p50Ms: milliseconds.nullable(), p99Ms: milliseconds.nullable(), maxMs: milliseconds.nullable(), totalMs: milliseconds });
+export const healthSnapshotSchema = z.looseObject({
+    version: z.literal(1), windowSeconds: z.literal(300), uptimeSeconds: z.number().nonnegative(),
+    requests: latencySummarySchema, routes: z.partialRecord(z.enum(ROUTE_FAMILIES), latencySummarySchema), eventLoop: latencySummarySchema,
+    writes: z.looseObject({ wait: latencySummarySchema, hold: latencySummarySchema, statement: latencySummarySchema }),
+    streams: z.looseObject({ open: count, queuedBytes: count, maxQueuedBytes: count }), budgetRefusals: count,
+});

package/dist/flow-card-task.d.ts

@@ -0,0 +1,2 @@
+import type { Store } from "./store.js";
+export declare function flowCardTaskLine(store: Store, taskId: string, repo: string, now: Date, secrets?: readonly string[]): string;

package/dist/flow-card-task.js

@@ -0,0 +1,57 @@
+/** The task behind an agent zone, read through the same status as its task page.
+ * Only saved milestone progress belongs on the card; tool calls and logs do not. */
+import { assignmentOf } from "./assignment.js";
+import { scanForSecrets } from "./evidence.js";
+import { scrubIntegrationText } from "./integrations.js";
+import { assignmentStatusFacts, taskStatusOf } from "./task-status.js";
+import { taskWorkSummaryOf } from "./work-summary.js";
+import { buildProgressOf } from "./workspace-ui.js";
+/** Redact before shortening: a cut-off credential must never slip through a scanner.
+ * Structured arguments, commands and credential assignments aren't card copy. */
+function cardReason(text, fallback, secrets) {
+    if (text === null)
+        return fallback;
+    const raw = /[{}\[\]`]|\b[\w.-]+\s*=|(?:^|\s)--[\w-]+|\b(?:arguments|tool_input|command|cmd|password|passwd|token|secret|api[_ -]?key|authorization)\s*:|\bcurl\s/i.test(text);
+    if (raw || secrets.some(secret => secret !== "" && text.includes(secret)) || scanForSecrets(text).length > 0)
+        return fallback;
+    const clean = scrubIntegrationText(text, secrets).replace(/[\p{Cf}]/gu, "").replace(/[.\s]+$/, "");
+    if (clean === "" || clean.includes("[hidden]"))
+        return fallback;
+    return clean.length > 100 ? `${clean.slice(0, 99).trimEnd()}…` : clean;
+}
+export function flowCardTaskLine(store, taskId, repo, now, secrets = []) {
+    const access = { principal: "operator", repos: [repo], dependencyRepos: [repo] };
+    const assignment = assignmentOf(store, taskId, now, access);
+    if (assignment === null)
+        return "Task unavailable";
+    const work = taskWorkSummaryOf(store, assignment.activeTaskId, now, access);
+    if (work === null)
+        return "Task unavailable";
+    const live = work.liveRunId === null ? null : store.getRun(work.liveRunId);
+    const facts = assignmentStatusFacts(assignment, { work: work.status, planning: live?.role === "planner" });
+    // The canvas reads no evidence files. Keep the machine's recorded check visible
+    // when the full receipt has no artifact root from which to read its check.
+    const check = assignment.receipt === null ? null : store.runCheckFor(assignment.receipt.runId);
+    if (facts.checks?.status === "unavailable" && check !== null)
+        facts.checks = { ...facts.checks, status: check.status, exitCode: check.exitCode };
+    const status = taskStatusOf(facts);
+    if (status.headline === "Needs you") {
+        const fallback = status.need?.action.label ?? "Open the task";
+        // The question itself is useful; routine approvals are clearer as the short action.
+        const what = status.need?.key === "answer" || status.need?.key === "other"
+            ? cardReason(status.sentence, fallback, secrets) : fallback;
+        return `Waiting on you: ${what}`;
+    }
+    if (status.headline === "Building" && live !== null) {
+        const ref = store.lookupRef(assignment.activeTaskId);
+        const checkpoint = store.latestCheckpointForRun(live.id);
+        const progress = buildProgressOf(checkpoint?.taskRef !== ref?.id ? null : checkpoint?.snapshot.milestones.map(one => ({ description: null, state: one.state, note: one.note })));
+        if (progress?.stuck != null)
+            return `Stuck: ${cardReason(progress.stuck.why, `step ${progress.step} of ${progress.total}`, secrets)}`;
+        if (progress !== null)
+            return `Building · step ${progress.step} of ${progress.total}`;
+    }
+    if (status.headline === "Failed")
+        return `Stuck: ${cardReason(status.sentence, "Open the task", secrets)}`;
+    return status.headline === "Ready for review" ? "Ready" : status.headline;
+}

package/dist/flow-live.d.ts

@@ -1,24 +1,16 @@
-import type { ServerResponse } from "node:http";
+import { type LiveRoomOptions, type LiveRooms, type LiveViewer } from "./live-bus.js";
 import type { Store } from "./store.js";
 export type FlowPresence = {
     name: string;
     cards: number[];
     editing: boolean;
 };
-export type FlowViewer = {
-    name: string;
+export type FlowViewer = LiveViewer & {
     card: number | null;
     editing: boolean;
-    response: ServerResponse;
-    valid: () => boolean;
-};
-/** What changes when anything on the canvas changes: one row, one read, kept short and opaque. */
-export declare function flowFingerprint(store: Store, flow: number): string | null;
-export type FlowRooms = {
-    /** Keep this page's stream on the flow until it closes; the first event says where the flow stands. */
-    join: (flow: number, viewer: FlowViewer) => void;
-    /** Every stream, ended (the server is closing). */
-    close: () => void;
-    size: () => number;
 };
-export declare function createFlowRooms(fingerprint: (flow: number) => string | null, tickMs?: number): FlowRooms;
+/** What changes when anything on the canvas changes: metadata only, kept short and opaque. */
+export declare function flowFingerprint(store: Store, flow: number, now?: Date): string | null;
+export type FlowRooms = LiveRooms<number, FlowViewer>;
+/** Rooms keyed by flow. With a bus, a write reaches every open page at once; without one, only the safety net. */
+export declare function createFlowRooms(fingerprint: (flow: number) => string | null, options?: LiveRoomOptions): FlowRooms;