@reticlehq/server 3.5.0 → 3.7.0

package/dist/index.js

@@ -1,31 +1,30 @@
-import { writeHarnessSwitch } from './memory/cloud/harness-switch.js';
-import { harnessConfigSource } from './memory/cloud/harness-config.js';
-import { fetchPlatformConfig } from './features/harness/platform-config.js';
+import { applyHarnessSwitch, harnessConfigsByRoot } from './memory/cloud/harness-config.js';
+import { coveragePercents } from './features/exhaust/ledger.js';
+import { agentWiring } from './portal/session/zero-install-first-call.js';
+import { pushIfMoved, watchAccountFiles } from './memory/impact/account-watch.js';
+import { SESSION_FILE } from './command/cli/cloud-kit.js';
 import { join } from 'node:path';
-import { existsSync, readFileSync } from 'node:fs';
 import { homedir } from 'node:os';
-import { linkedCloudPort, platformEnvPort } from './memory/cloud/cloud-config.js';
+import { linkedCloudPort, sessionCloudPort } from './memory/cloud/cloud-config.js';
+import { sessionRoot } from './memory/project/session-root.js';
 import { attachCloudSync } from './memory/cloud/sync-daemon.js';
 import { wireHooks } from './hooks/hook-commands.js';
-import { PROJECT_REGISTRY_FILE, parseProjectRegistry, projectCandidates, } from '@reticlehq/core/artifacts';
-import { discoverProjectConfigs } from './command/cli/config/config-discovery.js';
-import { artifactRootResolver, projectDirectoryFor, } from './memory/project/artifact-root-resolver.js';
+import { currentDrivenBy } from './hooks/driven-by.js';
+import { artifactRootResolver } from './memory/project/artifact-root-resolver.js';
+import { servingDirectoryOf } from './portal/session/serving-directory.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { AGENT_STOPPED_NOTICE, RETICLE_DEFAULT_PORT, bridgeWsUrl, ReticleCommand, ReticleDir, ReticleEnv, LOOPBACK_HOST, ReplayStatus, EventType, } from '@reticlehq/core';
-import { originOf } from './portal/session/session-manager.js';
-import { setBrowserMode, BrowserMode } from './telemetry/browser-mode.js';
-import { replayAndLearn } from './language/flows/flow-learning.js';
+import { AGENT_STOPPED_NOTICE, RETICLE_DEFAULT_PORT, ReticleCommand, ReticleDir, ReticleEnv, LOOPBACK_HOST, } from '@reticlehq/core';
+import { replayFromHud } from './language/flows/replay-from-hud.js';
 import { createSharedServer } from './surface/http-server.js';
 import { openLoopbackAlias } from './command/daemon/binding/loopback-alias.js';
 import { reportAppInstrumented } from './telemetry/app-instrumented.js';
 import { resolveBridgeSecurityWithAutoToken } from './portal/bridge/bridge-security.js';
 import { Bridge } from './portal/bridge/bridge.js';
-import { sdkFixForDirectory } from './command/version/sdk-fix.js';
 import { connectionSkew } from './command/version/version-nudge.js';
 import { SERVER_VERSION } from './command/version/identity/server-version.js';
 import { BaselineStore } from './memory/project/baselines.js';
 import { RecordingStore } from './language/flows/recording/tape/recordings.js';
-import { initImpact } from './memory/impact/impact-recorder.js';
+import { initImpact, impactSnapshot } from './memory/impact/impact-recorder.js';
 import { flowAuthor } from './language/flows/flow-author.js';
 import { FlowStore } from './language/flows/flows.js';
 import { buildFlowChips } from './language/flows/flow-scope.js';
@@ -40,37 +39,25 @@ import { createRunnerPort } from './judgement/runs/runner-port.js';
 import { RunStore } from './judgement/runs/artifact/run-store.js';
 import { startVerifyServer } from './judgement/runs/verify-server.js';
 import { createMcpServer } from './surface/mcp/mcp.js';
+import { instructionStateAt } from './surface/mcp/mcp-proxy.js';
 import { LEASE_ACQUIRE_TOOL } from './surface/tools/lease-tools.js';
+import { attachHudHarness, projectLinkOnly, startChatDrives } from './surface/tools/chat-drives.js';
 import { runTool } from './surface/tools/invoke-tool.js';
 import { SessionReaper, endAllSessions, MCP_DISCONNECT_SUMMARY, } from './portal/session/session-reaper.js';
 import { wireSessionScope } from './portal/session/no-session-watch.js';
 import { buildIdlePredicate, noteSetupHold } from './command/daemon/lifetime/daemon-usefulness.js';
 import { resolveToolSurface } from './surface/tools/tool-surface.js';
 import { statusPayload } from './status-payload.js';
-import { CdpRealInputProvider, LaunchedRealInputProvider } from './portal/input/real-input.js';
-import { cpus } from 'node:os';
-import { BrowserPool } from './portal/pool/browser-pool.js';
 import { AGENT_ALREADY_DRIVING_ELSEWHERE, shouldGreetWithLeaseNotice, } from './portal/session/lease-visibility.js';
-import { playwrightLauncher, resolveMaxContexts } from './portal/pool/playwright-launcher.js';
 import { LeaseReaper } from './portal/pool/lease-reaper.js';
-import { findProjectConfig, projectIdsAt, readJournalEnabled, readProjectId, } from './command/cli/ports/resolve/cli-port.js';
-import { hasAnyProjectConnectedBefore } from './memory/recall/prior/connection-memory.js';
-import { reticleStateHome } from './command/daemon/daemon.js';
+import { findProjectConfig, readJournalEnabled, readProjectId, } from './command/cli/ports/resolve/cli-port.js';
 import { probeLaunchableChromium } from './launch-chromium.js';
 import { attachJournal } from './wire-journal.js';
 import { reportOnboardingStep } from './telemetry/onboarding-funnel.js';
-import { AMBIENT_RECORDING } from './language/flows/recording/tape/recordings.js';
 import { readRetainPolicy } from './memory/journal/on-disk/retain-policy.js';
 import { log } from './log.js';
-import { readReaderBundle, zeroInstallScript as zeroInstallScriptFor, } from './portal/pool/zero-install.js';
-/** A human-facing one-liner for a panel replay verdict — ✓ passed / ⚠ drifted / ✗ errored. */
-function replayVerdictLine(result) {
-    if (result.status === ReplayStatus.OK)
-        return `✓ "${result.name}" passed`;
-    if (result.status === ReplayStatus.DRIFT)
-        return `⚠ "${result.name}" drifted — a step no longer matches`;
-    return `✗ "${result.name}" failed — ${result.error?.message ?? 'could not replay'}`;
-}
+import { createBrowserPool, knownProjectRoots, loadHarnessConfig, makeNetworkDetailRouter, platformEnvFor, readerConnect, resolveRealInput, sdkFixForProject, } from './start-wiring.js';
+export { replayVerdictLine } from './language/flows/replay-from-hud.js';
 // Re-exported from the contract, where the names now live: a consumer importing the server should
 // not have to know that the vocabulary moved.
 export { ReticleTool } from '@reticlehq/core';
@@ -112,181 +99,21 @@ export { findContradictions } from '@reticlehq/engine/disagreement/contradiction
 /** Default localhost port for the verify HTTP endpoint (see docs/platform-integration.md). */
 export const RETICLE_VERIFY_DEFAULT_PORT = 7331;
 export { resolveBridgeSecurity } from './portal/bridge/bridge-security.js';
-/**
- * Build the shared browser pool (one headless Chromium, N capped isolated leased contexts). Lazy —
- * no Chromium launches until the first lease — so creating it is free even when never used.
- */
-/** Where the zero-install reader connects: this daemon's own bridge, with its pairing token. */
-function readerConnect(port, token) {
-    return { url: bridgeWsUrl(port), ...(token === undefined ? {} : { token }) };
-}
-function createBrowserPool(headless, reader) {
-    const maxContexts = resolveMaxContexts(process.env[ReticleEnv.MAX_CONTEXTS], cpus().length);
-    const genSessionId = () => `lease-${'function' === typeof globalThis.crypto?.randomUUID
-        ? globalThis.crypto.randomUUID()
-        : String(Date.now())}`;
-    // Built on first use and kept: the page that needs it is one whose app never connected.
-    let script;
-    const zeroInstallScript = () => {
-        if (script === undefined) {
-            const bundle = readReaderBundle();
-            script = bundle === undefined ? null : zeroInstallScriptFor(bundle, reader);
-        }
-        return script ?? undefined;
-    };
-    return new BrowserPool(playwrightLauncher({ headless }), {
-        maxContexts,
-        genSessionId,
-        zeroInstallScript,
-    });
-}
-/**
- * Route CDP-authoritative network detail onto the driven session's journal.
- *
- * The page and the SDK session share an origin, so a NET_DETAIL is pushed to the matching connected
- * session. Shared by both entry points: `startDaemon` previously omitted it entirely, so on the path
- * users actually take, CDP network detail was collected and then dropped on the floor.
- */
-function makeNetworkDetailRouter(bridge, driveUrl) {
-    const driveOrigin = originOf(driveUrl ?? '');
-    return (detail) => {
-        // Route by the DOCUMENT that issued the request, not by the request's own origin.
-        //
-        // Matching the request's origin only works for same-origin calls. An app on one origin calling an
-        // API on another — most API calls — produced a detail matching no session, and it was dropped
-        // without a trace. The drive-URL fallback papered over it on the launched path and did nothing on
-        // the CDP-attach path, where driveUrl is undefined and the fallback compares against ''.
-        const pageOrigin = originOf(detail.pageUrl ?? '');
-        const requestOrigin = originOf(detail.url);
-        for (const session of bridge.sessions.all()) {
-            const origin = originOf(session.url);
-            // originOf returns `string | undefined`, NEVER '' — so the old `!== ''` guards were dead, and a
-            // bare `origin === requestOrigin` matched `undefined === undefined` when BOTH the session URL and
-            // the detail URL were unparseable. That routed a NET_DETAIL (with its response headers, incl.
-            // set-cookie) onto an unrelated session. Require a DEFINED origin; undefined operands then simply
-            // fail to match any of the three candidates.
-            const matches = origin !== undefined &&
-                (origin === pageOrigin || origin === requestOrigin || origin === driveOrigin);
-            if (matches) {
-                session.pushEvent({
-                    t: 0,
-                    type: EventType.NET_DETAIL,
-                    sessionId: session.id,
-                    data: { ...detail },
-                });
-            }
-        }
-    };
-}
-/**
- * Resolve the drive/real-input provider from options — shared by start and startDaemon so the
- * precedence (driveUrl launch+own → CDP attach → none) and the storageState/injectConnect plumbing
- * live in ONE place. `onNavigateError` is the entrypoint's own cleanup (close the bridge/shared server)
- * so a failed launch never leaks a WS port. A past divergence between the two paths let daemon mode
- * run with a different setup — this removes that risk.
- */
-async function resolveRealInput(options, onNavigateError, onNetworkDetail) {
-    const driveUrl = options.driveUrl;
-    if (driveUrl !== undefined && driveUrl.length > 0) {
-        const headless = options.headless ?? true;
-        // The one place that knows. Everything downstream reads it rather than re-deriving it, and a
-        // daemon that launches nothing keeps the default (ATTACHED) rather than guessing.
-        setBrowserMode(headless ? BrowserMode.HEADLESS : BrowserMode.HEADED);
-        const injectConnect = options.injectConnect;
-        const storageState = options.storageState;
-        const factory = options.realInputFactory ??
-            ((opts) => new LaunchedRealInputProvider({
-                driveUrl: opts.driveUrl,
-                headless: opts.headless,
-                ...(injectConnect !== undefined ? { injectConnect } : {}),
-                ...(storageState !== undefined ? { storageState } : {}),
-                ...(onNetworkDetail !== undefined ? { onNetworkDetail } : {}),
-            }));
-        const launched = factory({ driveUrl, headless });
-        try {
-            await launched.navigate();
-        }
-        catch (error) {
-            await onNavigateError(); // no leaked WS port on a failed start
-            throw error;
-        }
-        return { realInput: launched, owned: launched };
-    }
-    const cdpUrl = options.cdpUrl ?? process.env[ReticleEnv.CDP_URL];
-    if (cdpUrl !== undefined && cdpUrl.length > 0) {
-        // Same network sink as the launched path. Whether Reticle opened the browser or attached to one
-        // someone else opened has no bearing on whether it can read that browser's network.
-        const cdp = new CdpRealInputProvider({
-            cdpUrl,
-            ...(onNetworkDetail !== undefined ? { onNetworkDetail } : {}),
-        });
-        return { realInput: cdp, owned: cdp };
-    }
-    return {};
-}
 /** Start the Reticle bridge (browser WS endpoint) and, by default, the MCP stdio server. */
-/**
- * The SDK-upgrade sentence for the package.json of the project the page announced, evaluated at
- * each HELLO so a just-edited manifest is what we name. The daemon's cwd only when that project's
- * directory is unknown, and the framework-neutral sensor when that is not an app either (#1135).
- */
-function sdkFixForProject(projectId) {
-    return sdkFixForDirectory(SERVER_VERSION, projectDirectoryFor(projectId) ?? process.cwd());
-}
-/**
- * Resolve a session's artifact root, from everything this machine knows about where projects live.
- *
- * Built once per daemon and closed over by every tool call. The two sources are read lazily and
- * cheaply on each call rather than snapshotted at startup: `init` can run in another terminal while
- * this daemon is up, and a resolution that used a startup snapshot would keep answering with a map
- * from before the project the agent is now driving existed.
- */
-/**
- * Every `.reticle` root on this machine that sync should consider, from the same two sources the
- * artifact resolver uses.
- *
- * Read on every call rather than snapshotted, for the same reason: `reticle link` can run in
- * another terminal while this daemon is up, and a startup snapshot would keep that repo silent
- * until somebody restarted a process they have no reason to suspect.
- *
- * Returns directories that MIGHT be linked; the caller resolves each and skips the ones that are
- * not. Deciding that here would mean reading every cloud.json on every tick.
- */
-function knownProjectRoots() {
-    const roots = new Set();
-    try {
-        const path = join(homedir(), ReticleDir.ROOT, PROJECT_REGISTRY_FILE);
-        if (existsSync(path)) {
-            const registry = parseProjectRegistry(JSON.parse(readFileSync(path, 'utf8')));
-            for (const candidate of projectCandidates(registry))
-                roots.add(join(candidate.directory, ReticleDir.ROOT));
-        }
-    }
-    catch {
-        // A registry that cannot be read is an empty one — never a reason to stop syncing.
-    }
-    try {
-        for (const config of discoverProjectConfigs(process.cwd()).found)
-            roots.add(join(config.directory, ReticleDir.ROOT));
-    }
-    catch {
-        // Same: a diagnostic walk that throws must not take the sync loop with it.
-    }
-    return [...roots];
-}
-/** This project's platform credential (stored, else the env key), as the env the platform readers take. */
-const platformEnvFor = (root) => platformEnvPort(createNodeFileSystem(), root ?? join(process.cwd(), ReticleDir.ROOT), homedir(), process.env);
 export async function start(options = {}) {
     const port = options.port ?? RETICLE_DEFAULT_PORT;
+    const configForRoot = harnessConfigsByRoot(loadHarnessConfig);
     // Open the user's impact record before anything can connect. Not inside the MCP branch: a daemon
     // serving a browser with no agent attached still has a HUD to answer, and a report that reads
     // "nothing recorded yet" over a month of history on disk is the worst version of this feature.
     initImpact({
+        sdkVersion: SERVER_VERSION,
         reticleRoot: options.reticleRoot ?? join(process.cwd(), ReticleDir.ROOT),
         // The daemon owns both sides of this seam, so it is the layer that may join them: the cache
         // lives in cloud memory, the platform read lives in the harness feature, and neither is allowed
         // to reach for the other.
-        config: harnessConfigSource(async () => fetchPlatformConfig(await platformEnvFor(options.reticleRoot)())),
+        configForRoot,
+        coverageForRoot: (root) => () => coveragePercents(root),
     });
     const uninstallHooks = wireHooks(options.reticleRoot ?? join(process.cwd(), ReticleDir.ROOT), readProjectId(process.cwd()));
     const security = await resolveBridgeSecurityWithAutoToken(options);
@@ -302,7 +129,7 @@ export async function start(options = {}) {
         bridge.sessions.setDefaultScope({ projectId: activeProjectId });
     }
     const baselines = new BaselineStore();
-    const recordings = new RecordingStore();
+    const recordings = new RecordingStore(() => currentDrivenBy() !== undefined);
     // drive precedence: driveUrl (launch+own a browser) → CDP (attach) → none.
     let pool;
     let leaseReaper;
@@ -310,6 +137,7 @@ export async function start(options = {}) {
     // page and the SDK session share an origin, so a NET_DETAIL is pushed to the matching connected session.
     const routeNetworkDetail = makeNetworkDetailRouter(bridge, options.driveUrl);
     const { realInput, owned } = await resolveRealInput(options, () => bridge.close(), routeNetworkDetail);
+    let chatDrives;
     if (options.mcp !== false) {
         // cwd/Date.now are confined to start — never inside reticle-dir.ts's pure logic (rule 7).
         const fs = createNodeFileSystem();
@@ -326,7 +154,7 @@ export async function start(options = {}) {
             enabled: journalEnabled,
             retain,
             // Bound HERE, where the recorder is already in hand: teardown gets the tape, not the recorder.
-            takeAmbientTape: () => recordings.stop(AMBIENT_RECORDING),
+            takeAmbientTape: (sessionId) => recordings.takeAmbient(sessionId),
             reportStep: reportOnboardingStep,
             flows,
             author: flowAuthor,
@@ -367,7 +195,7 @@ export async function start(options = {}) {
             fs,
             reticleRoot,
             linkedCloud: linkedCloudPort(fs, reticleRoot, homedir(), process.env),
-            artifactRootFor: artifactRootResolver(reticleRoot),
+            artifactRootFor: artifactRootResolver(reticleRoot, { servingDirectory: servingDirectoryOf }),
             now,
             bridgePort: port,
             browserProbe: probeLaunchableChromium,
@@ -376,13 +204,13 @@ export async function start(options = {}) {
             ...(activeProjectId === undefined ? {} : { projectId: activeProjectId }),
         };
         const profile = resolveToolSurface(options.toolProfile);
-        const server = createMcpServer(realInput !== undefined ? { ...deps, realInput } : deps, profile, 
-        // A session live RIGHT NOW is stronger evidence than the durable memory, which can be empty or
-        // stale for a project the plugin wired without writing `.reticle.json` (see connection-memory.ts's
-        // KNOWN LIMIT). Without this OR, that project's `initialize` led with the first-install steps
-        // while a real session was already connected — see #1138.
-        bridge.sessions.count() > 0 ||
-            hasAnyProjectConnectedBefore(reticleStateHome(), port, projectIdsAt(process.cwd())));
+        const toolDeps = realInput !== undefined ? { ...deps, realInput } : deps;
+        // The platform chat sees this app too: `reticle drive` in a window runs here, not in a daemon.
+        chatDrives = startChatDrives(toolDeps, bridge.sessions, fs, {
+            sessionCloud: sessionCloudPort(fs, homedir(), process.env, (id) => sessionRoot(toolDeps, id)),
+            version: SERVER_VERSION,
+        }, log);
+        const server = createMcpServer(toolDeps, profile, instructionStateAt(port, bridge.sessions.count()));
         // When the agent (the MCP client) disconnects cleanly, end every active session at once so the
         // HUD doesn't linger. (If the agent instead KILLS this process, the WS dies and the browser
         // self-ends via SESSION_LIFECYCLE.BRIDGE_LOST_MS — see transport.ts.)
@@ -401,6 +229,7 @@ export async function start(options = {}) {
             uninstallHooks();
             await cleanupCaptureDirectories();
             leaseReaper?.stop();
+            chatDrives?.stop();
             await pool?.shutdown();
             await owned?.dispose();
             await bridge.close();
@@ -415,17 +244,21 @@ export async function start(options = {}) {
  */
 export async function startDaemon(options = {}) {
     const port = options.port ?? RETICLE_DEFAULT_PORT;
+    let pushHarnessConfig = () => undefined;
+    const configForRoot = harnessConfigsByRoot(loadHarnessConfig, (root) => pushHarnessConfig(root));
     // The SAME line as in `start`, because these are two entry points that each wire their own world
     // and the daemon is the one that actually serves people. Wired only in `start`, the impact record
     // was never opened in the process the HUD talks to: tool calls still recorded (the dispatch
     // chokepoint opens it lazily), but a tab that connected before the first tool call was pushed
     // nothing, so the report read "nothing recorded yet" over a file with history in it.
     initImpact({
+        sdkVersion: SERVER_VERSION,
         reticleRoot: options.reticleRoot ?? join(process.cwd(), ReticleDir.ROOT),
         // The daemon owns both sides of this seam, so it is the layer that may join them: the cache
         // lives in cloud memory, the platform read lives in the harness feature, and neither is allowed
         // to reach for the other.
-        config: harnessConfigSource(async () => fetchPlatformConfig(await platformEnvFor(options.reticleRoot)())),
+        configForRoot,
+        coverageForRoot: (root) => () => coveragePercents(root),
     });
     const security = await resolveBridgeSecurityWithAutoToken(options);
     const shared = createSharedServer(security.token === undefined ? {} : { token: security.token });
@@ -435,6 +268,14 @@ export async function startDaemon(options = {}) {
         sdkFix: sdkFixForProject,
         ...security,
     });
+    const repaint = (only, ifChanged = false) => {
+        for (const session of bridge.sessions.all()) {
+            const root = session.artifactRoot ?? options.reticleRoot ?? join(process.cwd(), ReticleDir.ROOT);
+            if ((only ?? root) === root)
+                pushIfMoved(session, () => impactSnapshot(root), ifChanged);
+        }
+    };
+    pushHarnessConfig = repaint;
     // The daemon owns listen (below), so the real bind error is reported there; absorb bridge.ready's
     // mirror rejection so a port collision can't surface as an unhandled promise rejection.
     void bridge.ready.catch(() => undefined);
@@ -450,7 +291,7 @@ export async function startDaemon(options = {}) {
         // `init` holds the daemon it is waiting on, so the idle rule cannot shut it down mid-wait.
         if (held)
             noteSetupHold(Date.now());
-        return statusPayload(bridge.sessions.count(), bridge.sessions.list(), bridge.sessions.noSessionHint(), verifyHttp?.port, bridge.sessions.noSessionLead());
+        return statusPayload(bridge.sessions.count(), bridge.sessions.list(), bridge.sessions.noSessionHint(), verifyHttp?.port, bridge.sessions.noSessionLead(), bridge.sessions.all());
     });
     // Agent-independent presence: the daemon outlives any single agent, so when the LAST agent's MCP
     // connection drops (it stopped, or is waiting on the human), end every session and push a clear
@@ -473,10 +314,11 @@ export async function startDaemon(options = {}) {
     const retain = readRetainPolicy(findProjectConfig(process.cwd()));
     // See the sibling path: `retain.sessions: 0` stops the capture too, not only the sweep.
     const journalEnabled = readJournalEnabled(process.cwd(), process.env[ReticleEnv.JOURNAL]) && 0 < retain.sessions;
-    const flows = new FlowStore(fs, reticleRoot, { now });
+    // A saved flow wakes sync like a landed run: see FlowStore's `onWrote`.
+    const flows = new FlowStore(fs, reticleRoot, { now }, { onWrote: () => syncNudge.run?.() });
     // Built here rather than inside `deps` below, so teardown can save what a drive recorded. Both
     // paths pass the same pair — `daemon-parity.test.ts` is what keeps them from drifting apart.
-    const recordings = new RecordingStore();
+    const recordings = new RecordingStore(() => currentDrivenBy() !== undefined);
     /*
      * Bound AFTER the sync daemon exists, read only when a run is actually written.
      *
@@ -485,12 +327,12 @@ export async function startDaemon(options = {}) {
      * setup ahead of session capture for the sake of one callback.
      */
     const syncNudge = {};
-    attachJournal(bridge, {
+    const endLiveSessions = attachJournal(bridge, {
         fs,
         reticleRoot,
         enabled: journalEnabled,
         retain,
-        takeAmbientTape: () => recordings.stop(AMBIENT_RECORDING),
+        takeAmbientTape: (sessionId) => recordings.takeAmbient(sessionId),
         reportStep: reportOnboardingStep,
         flows,
         author: flowAuthor,
@@ -526,14 +368,15 @@ export async function startDaemon(options = {}) {
         otherRoots: knownProjectRoots,
     });
     syncNudge.run = () => cloudSync.nudge();
-    // `syncNow`, not `nudge`: a nudge schedules a cycle soon, which is right for "a run landed" and
-    // wrong for a button somebody is watching. Never awaited.
+    // `syncNow`, not `nudge` (a cycle soon): somebody is watching the button. Never awaited.
     bridge.attachSyncRequest(() => void cloudSync.syncNow());
-    // The panel's harness switch. Written through to the platform rather than kept locally, so the
-    // console and the panel cannot disagree about a setting they both offer. Nothing is awaited and a
-    // failure is not surfaced: the next snapshot re-reads the platform, so a lost write shows up as
-    // the switch springing back, which is the truthful outcome.
-    bridge.attachHarnessRequest((enabled) => void platformEnvFor(reticleRoot)().then((env) => writeHarnessSwitch(env, enabled)));
+    if (options.hudSignIn !== undefined)
+        bridge.attachSigninRequest(options.hudSignIn(repaint, projectLinkOnly(options.hudLink)));
+    // Logout and link run in another process: repaint when their files change, the rest on a timer.
+    const accountFiles = watchAccountFiles(repaint, undefined, () => repaint(undefined, true));
+    accountFiles.watch(join(homedir(), ReticleDir.ROOT, SESSION_FILE));
+    bridge.attachSessionReady((s) => accountFiles.watch(join(s.artifactRoot ?? reticleRoot, ReticleDir.CLOUD_LINK_FILE)));
+    attachHudHarness(bridge, { deps: () => deps, root: reticleRoot, repaint: () => repaint() }, (r, on) => applyHarnessSwitch(configForRoot, r, on, platformEnvFor(r)), options.hudLink);
     // Scope auto-selection to the active project (from .reticle.json) so a stray tab from another app is
     // never picked when the agent omits a sessionId. Explicit per-call scope/sessionId still overrides.
     // Scope + the no-session diagnosis: "no browser session connected" is the error that ends most
@@ -542,6 +385,7 @@ export async function startDaemon(options = {}) {
     // server for a wired project (see no-session-watch.ts), and it opens it through the pool — the same
     // path reticle_lease takes, in this process, binding nothing.
     wireSessionScope(bridge.sessions, readProjectId(process.cwd()), port, (sessionId) => pool.wasReapedLease(sessionId), (url) => pool.acquire(url));
+    const leaseUrl = (url) => runTool(LEASE_ACQUIRE_TOOL, effectiveDeps, { url });
     const deps = {
         sessions: bridge.sessions,
         pool,
@@ -562,12 +406,14 @@ export async function startDaemon(options = {}) {
         // daemon — the common case — so flows were listed, loaded and healed against wherever the
         // daemon happened to be launched. Wired in only one of the two places, a resolver is a resolver
         // that does not run.
-        artifactRootFor: artifactRootResolver(reticleRoot),
+        artifactRootFor: artifactRootResolver(reticleRoot, { servingDirectory: servingDirectoryOf }),
         now,
         bridgePort: port,
         browserProbe: probeLaunchableChromium,
+        ...agentWiring(port, bridge.sessions, leaseUrl),
         // A finished verification should not sit behind a one-minute timer — see ToolDeps.onRunPersisted.
         onRunPersisted: () => cloudSync.nudge(),
+        syncNow: () => cloudSync.syncNow(),
     };
     const profile = resolveToolSurface(options.toolProfile);
     const effectiveDeps = realInput !== undefined ? { ...deps, realInput } : deps;
@@ -575,15 +421,14 @@ export async function startDaemon(options = {}) {
     // being told to wire itself on the next agent that connects.
     shared.attachMcp((peerSkew) => createMcpServer(peerSkew === undefined
         ? effectiveDeps
-        : { ...effectiveDeps, peerSkew: connectionSkew(peerSkew) }, profile, 
-    // See the sibling call in `start`: a live session outweighs empty/stale durable memory (#1138).
-    bridge.sessions.count() > 0 ||
-        hasAnyProjectConnectedBefore(reticleStateHome(), port, projectIdsAt(process.cwd()))));
-    // `reticle drive <url>` when this daemon already owns the port: it asks HERE instead of trying to
-    // bind a port we are holding, and gets the same pooled context an agent's reticle_lease returns —
-    // through runTool, so it is counted and reported like any other call rather than being a second,
-    // invisible dispatch path. See cli/drive/drive-attach.ts for why attaching beats refereeing the race.
-    shared.attachDrive((url) => runTool(LEASE_ACQUIRE_TOOL, effectiveDeps, { url }));
+        : { ...effectiveDeps, peerSkew: connectionSkew(peerSkew) }, profile, instructionStateAt(port, bridge.sessions.count())));
+    shared.attachDrive(leaseUrl); // `reticle drive <url>` — see cli/drive/drive-attach.ts.
+    // The platform chat's apps and drives, run here. See chat-drives.ts.
+    const chatDrives = startChatDrives(effectiveDeps, bridge.sessions, fs, {
+        sessionCloud: sessionCloudPort(fs, homedir(), process.env, (id) => sessionRoot(effectiveDeps, id)),
+        version: SERVER_VERSION,
+        unsynced: () => cloudSync.unsyncedRoots(),
+    }, log);
     // Optional OEM/CI verify endpoint: a host platform POSTs to /verify and gets an ReticleVerificationRun,
     // driving the same flow-replay machinery the agent uses — no MCP stdio, no human. Each verdict is
     // persisted via RunStore. Localhost-bound + token-guarded. Off unless `reticle serve --http`.
@@ -601,16 +446,9 @@ export async function startDaemon(options = {}) {
     // verdict into the same activity log they watch the agent in. The page animates via the normal
     // replay path, so they see it re-drive and the ✓/⚠/✗ land.
     bridge.attachReplay((sessionId, flowName) => {
-        const session = bridge.sessions.get(sessionId);
-        if (session === undefined)
+        if (bridge.sessions.get(sessionId) === undefined)
             return;
-        session.pushNarration(`▶ Replaying "${flowName}"…`);
-        replayAndLearn(effectiveDeps, { flowName, sessionId })
-            .then((result) => session.pushNarration(replayVerdictLine(result)))
-            .catch((error) => {
-            const message = error instanceof Error ? error.message : String(error);
-            session.pushNarration(`✗ Replay "${flowName}" failed — ${message}`);
-        });
+        void replayFromHud(effectiveDeps, (id) => bridge.sessions.get(id), sessionId, flowName);
     });
     // On connect, hand the panel the replayable flows so it can render the ▶ list. Scoped to the
     // connecting session's project (a shared daemon serves many apps; each panel shows only its own
@@ -680,6 +518,9 @@ export async function startDaemon(options = {}) {
             if (vh !== undefined)
                 await new Promise((resolve) => vh.server.close(() => resolve()));
             leaseReaper.stop();
+            chatDrives.stop();
+            accountFiles.close();
+            await endLiveSessions(); // first: an open tab's teardown writes the flow this flush sends
             await cloudSync.flush(); // not stop(): the last run written is the one nobody has yet
             await loopbackAlias.close?.();
             await pool.shutdown();
@@ -689,12 +530,8 @@ export async function startDaemon(options = {}) {
         },
     };
 }
-// The OpenVerification binding, exported so a conformance run can be driven from outside this package.
-//
-// It was written and then not reachable: `conformanceClient` takes a `WebRealm`, a `WebRealm`
-// takes a live `Session`, and a `Session` exists only inside a running daemon. A runner that
-// cannot import it cannot score anything, which would have made the whole conformance chain
-// complete and unusable.
+// The OpenVerification binding, exported so a conformance run can be driven from outside this
+// package: a `WebRealm` needs a live `Session`, which exists only inside a running daemon.
 export { WebRealm } from './portal/realm/web-realm.js';
 export { conformanceClient } from './portal/realm/conformance-client.js';
 /**

package/dist/judgement/capsule/capsule-store.d.ts

@@ -45,9 +45,9 @@ declare const CapsuleSchema: z.ZodObject<{
     version: 1;
     id: string;
     origin: string;
+    createdAt: number;
     expected: string;
     steps: FlowStep[];
-    createdAt: number;
     observed: string;
     flow?: string | undefined;
     seen?: number | undefined;
@@ -56,9 +56,9 @@ declare const CapsuleSchema: z.ZodObject<{
     version: 1;
     id: string;
     origin: string;
+    createdAt: number;
     expected: string;
     steps: FlowStep[];
-    createdAt: number;
     observed: string;
     flow?: string | undefined;
     seen?: number | undefined;

package/dist/judgement/capsule/causal-summary.d.ts

@@ -40,10 +40,24 @@ export interface CausalSummary {
         headline?: string;
     };
     consoleErrors: number;
+    /** The first console error's text, capped — so a count is never the only thing an agent can read. */
+    firstConsoleError?: string;
+    /**
+     * The app's requests in this window as `METHOD /path STATUS` (`pending` when unanswered), capped.
+     * Origin and query string are left out: the line is for recognising the call, and the full record is
+     * one `reticle_observe { since }` away. Present only when there were any.
+     */
+    requests?: string[];
     statePathsChanged: string[];
     storageKeysChanged: string[];
     /** Before→after for each changed store path — the diffs, not just the names. Values capped. */
     stateDiffs: StateDiff[];
+    /**
+     * How many store diffs were left out of `stateDiffs` because they moved only a cache's own
+     * bookkeeping (fetchStatus, isStale, dataUpdatedAt — see engine's state-bookkeeping rule). Present
+     * only when there were any: a trim is never silent. Predicates still see every transition.
+     */
+    ignoredBookkeeping?: number;
     /**
      * How long the store took to stop moving: last state change − first, in ms. Present only when more
      * than one path changed, because with a single change there is no interval to describe.
@@ -126,6 +140,6 @@ interface SummaryContext {
  */
 export declare const MAX_SUMMARY_ENTRIES = 20;
 /** The lists that are capped, named so `elided` can say which one lost entries. */
-type CappedList = 'statePathsChanged' | 'storageKeysChanged' | 'stateDiffs' | 'storageDiffs' | 'signals' | 'fieldsChanged';
+type CappedList = 'requests' | 'statePathsChanged' | 'storageKeysChanged' | 'stateDiffs' | 'storageDiffs' | 'signals' | 'fieldsChanged';
 export declare function causalSummary(events: readonly ReticleEvent[], context?: SummaryContext): CausalSummary;
 export {};