@reticlehq/server 3.4.0 → 3.6.0

package/dist/features/visual/visual-tools.d.ts

@@ -1,4 +1,13 @@
-import type { ToolDef } from '../../surface/tools/tool-kit.js';
+import type { ToolDef, ToolDeps } from '../../surface/tools/tool-kit.js';
+/**
+ * One picture of the tab a chat-requested drive is driving, or undefined when there is none to take.
+ *
+ * The leased browser first, when this daemon launched the tab; then the desktop window's own capture,
+ * the same route `reticle_screenshot` takes. Without the second, a drive of a desktop app sent its
+ * steps to the chat and never a picture. Never throws: a frame is a courtesy, and a tab that has
+ * gone mid-drive must not break the drive.
+ */
+export declare function driveFrame(deps: ToolDeps, sessionId: string, jpegQuality: number): Promise<Uint8Array | undefined>;
 /**
  * Only read a capture the shell wrote. The path arrives from the PAGE, and the daemon must not
  * become a file-read oracle for whatever a compromised renderer names.

package/dist/features/visual/visual-tools.js

@@ -111,6 +111,32 @@ async function desktopCapture(deps, sessionId, fullPage) {
         return {};
     }
 }
+/**
+ * One picture of the tab a chat-requested drive is driving, or undefined when there is none to take.
+ *
+ * The leased browser first, when this daemon launched the tab; then the desktop window's own capture,
+ * the same route `reticle_screenshot` takes. Without the second, a drive of a desktop app sent its
+ * steps to the chat and never a picture. Never throws: a frame is a courtesy, and a tab that has
+ * gone mid-drive must not break the drive.
+ */
+export async function driveFrame(deps, sessionId, jpegQuality) {
+    try {
+        const leased = await deps.pool?.screenshotLease(sessionId, { jpegQuality });
+        if (leased !== undefined)
+            return leased;
+        // The window `reticle drive` opened: neither a lease nor a desktop shell, but its page is ours.
+        const url = deps.sessions.resolve(sessionId).url;
+        if (true === (await deps.realInput?.isAvailableFor(url))) {
+            const shot = await deps.realInput?.screenshot?.(url, { jpegQuality });
+            if (shot !== undefined)
+                return shot;
+        }
+        return (await desktopCapture(deps, sessionId, false)).png;
+    }
+    catch {
+        return undefined;
+    }
+}
 /**
  * Only read a capture the shell wrote. The path arrives from the PAGE, and the daemon must not
  * become a file-read oracle for whatever a compromised renderer names.
@@ -179,9 +205,20 @@ function runtimeOf(deps, sessionId) {
  * baseline that says nothing about the content below the fold, and a later diff would call it green.
  */
 async function capture(deps, sessionId, args) {
-    const provider = screenshotProvider(deps);
-    if (provider !== undefined) {
-        const session = deps.sessions.resolve(sessionId);
+    /*
+     * Only a provider driving THIS session's page. A launched provider photographs the one page it
+     * owns whatever url it is handed, so asking it about another session saved the driven tab's pixels
+     * under that session's name and answered `saved: true` (#1407). Real input asks the same question
+     * before every gesture.
+     */
+    const candidate = screenshotProvider(deps);
+    const session = candidate === undefined ? undefined : deps.sessions.resolve(sessionId);
+    const provider = candidate !== undefined &&
+        session !== undefined &&
+        (await candidate.isAvailableFor(session.url))
+        ? candidate
+        : undefined;
+    if (provider !== undefined && session !== undefined) {
         const png = await provider.screenshot(session.url, await buildOpts(deps, sessionId, args));
         // A driven browser renders the session's URL in a BROWSER — so the pixels are web even when the
         // session named is a desktop window. Scoping those under the desktop runtime would corrupt that

package/dist/hooks/driven-by.d.ts

@@ -0,0 +1,4 @@
+import type { DrivenBy } from '@reticlehq/core';
+export declare function runDrivenBy<T>(by: DrivenBy, fn: () => Promise<T>): Promise<T>;
+/** The Harness drive this call is part of, or undefined when the connected agent made it. */
+export declare function currentDrivenBy(): DrivenBy | undefined;

package/dist/hooks/driven-by.js

@@ -0,0 +1,16 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+/**
+ * Which Harness drive the current tool call belongs to, carried across every await under it.
+ *
+ * The Harness dispatches through the same tools an agent calls, so nothing in a tool's arguments can
+ * say who called it, and adding a field to every tool's schema would advertise it to every agent.
+ * The context is set once around each Harness call and read where the journal writes the action.
+ */
+const current = new AsyncLocalStorage();
+export function runDrivenBy(by, fn) {
+    return current.run(by, fn);
+}
+/** The Harness drive this call is part of, or undefined when the connected agent made it. */
+export function currentDrivenBy() {
+    return current.getStore();
+}

package/dist/hooks/hook-commands.js

@@ -21,7 +21,7 @@
  * broken gets a log line; their verdicts keep working.
  */
 import { spawn } from 'node:child_process';
-import { readFileSync, statSync } from 'node:fs';
+import { closeSync, fstatSync, openSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { HOOK_EVENT_NAMES, HookConfigSchema } from '@reticlehq/core/hooks';
 import { ReticleDir } from '@reticlehq/core';
@@ -65,18 +65,29 @@ let cached;
  */
 export function readHookConfig(reticleRoot) {
     const path = join(reticleRoot, ReticleDir.HOOKS_FILE);
-    let mtime;
+    // Open once, then stat and read the SAME descriptor: the mtime the cache keys on is the mtime of
+    // the bytes read, not of whatever the path pointed at a moment earlier.
+    let fd;
     try {
-        mtime = statSync(path).mtimeMs;
+        fd = openSync(path, 'r');
     }
     catch {
         cached = undefined;
         return {};
     }
+    try {
+        return readOpenHookConfig(fd);
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+function readOpenHookConfig(fd) {
+    const mtime = fstatSync(fd).mtimeMs;
     if (cached !== undefined && cached.at === mtime)
         return cached.config;
     try {
-        const parsed = HookConfigSchema.safeParse(JSON.parse(readFileSync(path, 'utf8')));
+        const parsed = HookConfigSchema.safeParse(JSON.parse(readFileSync(fd, 'utf8')));
         if (!parsed.success) {
             reportOnce(`config:${String(mtime)}`, `${ReticleDir.HOOKS_FILE} is not a map of event→command`);
             cached = { at: mtime, config: {} };

package/dist/hooks/tool-log.d.ts

@@ -0,0 +1,9 @@
+export declare function toolLogPath(): string | undefined;
+export declare function logToolCall(path: string, entry: {
+    tool: string;
+    args: unknown;
+    at: number;
+    ms: number;
+    result?: unknown;
+    error?: string;
+}): void;

package/dist/hooks/tool-log.js

@@ -0,0 +1,29 @@
+import { appendFileSync } from 'node:fs';
+import { currentDrivenBy } from './driven-by.js';
+/**
+ * Every tool call, its arguments and what it answered, appended to a file a person names.
+ *
+ * Off unless `RETICLE_TOOL_LOG` is set. It exists to put two drives side by side (an agent's and
+ * the Harness's) and read what each one asked and was told; `drivenBy` says which was which. Local
+ * only: nothing here leaves the machine.
+ */
+const TOOL_LOG_ENV = 'RETICLE_TOOL_LOG';
+/** A page snapshot can be large; past this a record keeps its head and says it was cut. */
+const MAX_RESULT_CHARS = 200_000;
+export function toolLogPath() {
+    const path = process.env[TOOL_LOG_ENV];
+    return path === undefined || 0 === path.trim().length ? undefined : path;
+}
+export function logToolCall(path, entry) {
+    try {
+        const text = JSON.stringify(entry.result ?? null);
+        const result = text.length > MAX_RESULT_CHARS
+            ? { truncated: text.slice(0, MAX_RESULT_CHARS) }
+            : entry.result;
+        const drivenBy = currentDrivenBy();
+        appendFileSync(path, `${JSON.stringify({ ...entry, result, ...(drivenBy === undefined ? {} : { drivenBy }) })}\n`);
+    }
+    catch {
+        /* a log that cannot be written never fails the call it describes */
+    }
+}

package/dist/index.d.ts

@@ -2,6 +2,7 @@ import type { StartOptions } from './start-options.js';
 export type { StartOptions } from './start-options.js';
 import { Bridge } from './portal/bridge/bridge.js';
 import type { RealInputProvider } from './portal/input/real-input.js';
+export { replayVerdictLine } from './language/flows/replay-from-hud.js';
 export { ReticleTool } from '@reticlehq/core';
 export { RingBuffer } from '@reticlehq/engine/window/ring-buffer.js';
 export { Bridge } from './portal/bridge/bridge.js';

package/dist/index.js

@@ -1,30 +1,34 @@
-import { writeHarnessSwitch } from './memory/cloud/harness-switch.js';
-import { harnessConfigSource } from './memory/cloud/harness-config.js';
+import { applyHarnessSwitch, harnessConfigsByRoot } from './memory/cloud/harness-config.js';
+import { coveragePercents } from './features/exhaust/ledger.js';
+import { firstRunWiring } from './portal/session/first-run-wiring.js';
 import { fetchPlatformConfig } from './features/harness/platform-config.js';
+import { 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, platformEnvPort, 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 } from './memory/project/artifact-root-resolver.js';
+import { currentDrivenBy } from './hooks/driven-by.js';
+import { artifactRootResolver, knownProjectCandidates, projectDirectoryFor, } 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 { AGENT_STOPPED_NOTICE, RETICLE_DEFAULT_PORT, bridgeWsUrl, ReticleCommand, ReticleDir, ReticleEnv, LOOPBACK_HOST, 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 { 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';
@@ -39,7 +43,9 @@ 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 { 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';
@@ -52,9 +58,7 @@ 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';
@@ -62,14 +66,7 @@ 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'}`;
-}
+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';
@@ -137,6 +134,7 @@ function createBrowserPool(headless, reader) {
         maxContexts,
         genSessionId,
         zeroInstallScript,
+        launchHeaded: playwrightLauncher({ headless: false }),
     });
 }
 /**
@@ -225,12 +223,12 @@ async function resolveRealInput(options, onNavigateError, onNetworkDetail) {
 }
 /** Start the Reticle bridge (browser WS endpoint) and, by default, the MCP stdio server. */
 /**
- * The SDK-upgrade sentence for THIS project's package.json, evaluated at each HELLO so a
- * just-edited manifest is what we name. Falls back to the framework-neutral sensor when cwd is
- * not an app.
+ * 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 sdkFixForCwd() {
-    return sdkFixForDirectory(SERVER_VERSION, process.cwd());
+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.
@@ -252,44 +250,29 @@ function sdkFixForCwd() {
  * 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];
+    return [...new Set(knownProjectCandidates().map((c) => join(c.directory, ReticleDir.ROOT)))];
 }
 /** 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);
+const loadHarnessConfig = async (root) => fetchPlatformConfig(await platformEnvFor(root)());
 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);
-    const bridge = new Bridge({ port, sdkFix: sdkFixForCwd, ...security });
+    const bridge = new Bridge({ port, sdkFix: sdkFixForProject, ...security });
     // Server-authoritative liveness: a Node-side reaper (immune to browser throttling) ends sessions
     // whose agent has gone idle, so a forgotten/crashed agent never leaves the HUD "running" forever.
     const reaper = new SessionReaper(bridge.sessions);
@@ -301,7 +284,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;
@@ -309,6 +292,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();
@@ -366,7 +350,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,
@@ -375,13 +359,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.)
@@ -400,6 +384,7 @@ export async function start(options = {}) {
             uninstallHooks();
             await cleanupCaptureDirectories();
             leaseReaper?.stop();
+            chatDrives?.stop();
             await pool?.shutdown();
             await owned?.dispose();
             await bridge.close();
@@ -414,21 +399,38 @@ 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 });
-    const bridge = new Bridge({ port, server: shared.httpServer, sdkFix: sdkFixForCwd, ...security });
+    const bridge = new Bridge({
+        port,
+        server: shared.httpServer,
+        sdkFix: sdkFixForProject,
+        ...security,
+    });
+    const repaint = (only) => {
+        for (const session of bridge.sessions.all()) {
+            const root = session.artifactRoot ?? options.reticleRoot ?? join(process.cwd(), ReticleDir.ROOT);
+            if (only === undefined || only === root)
+                session.pushImpact(() => impactSnapshot(root), true);
+        }
+    };
+    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);
@@ -470,7 +472,7 @@ export async function startDaemon(options = {}) {
     const flows = new FlowStore(fs, reticleRoot, { now });
     // 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.
      *
@@ -523,11 +525,17 @@ export async function startDaemon(options = {}) {
     // `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.
     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)));
+    // The panel's harness switch, written through to the platform so console and panel cannot disagree.
+    if (options.hudSignIn !== undefined)
+        bridge.attachSigninRequest(options.hudSignIn(() => repaint()));
+    // logout and link run in another process: repaint when their files change. See account-watch.ts.
+    const accountFiles = watchAccountFiles(() => repaint());
+    accountFiles.watch(join(homedir(), ReticleDir.ROOT, SESSION_FILE));
+    bridge.attachSessionReady((s) => accountFiles.watch(join(s.artifactRoot ?? reticleRoot, ReticleDir.CLOUD_LINK_FILE)));
+    bridge.attachHarnessRequest((on, s) => {
+        const root = s.artifactRoot ?? reticleRoot;
+        applyHarnessSwitch(configForRoot, root, on, platformEnvFor(root));
+    });
     // 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
@@ -556,26 +564,29 @@ 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,
+        firstRun: firstRunWiring({ port, cliPath: process.argv[1] ?? '' }),
         // 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;
     // Read per attach, not once: a project that gets wired while this daemon is alive should stop
     // being told to wire itself on the next agent that connects.
-    shared.attachMcp(() => createMcpServer(effectiveDeps, 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.attachMcp((peerSkew) => createMcpServer(peerSkew === undefined
+        ? effectiveDeps
+        : { ...effectiveDeps, peerSkew: connectionSkew(peerSkew) }, profile, instructionStateAt(port, bridge.sessions.count())));
+    // `reticle drive <url>` against this daemon's port, through runTool. See cli/drive/drive-attach.ts.
     shared.attachDrive((url) => runTool(LEASE_ACQUIRE_TOOL, effectiveDeps, { url }));
+    // 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,
+    }, 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`.
@@ -593,16 +604,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
@@ -672,6 +676,8 @@ export async function startDaemon(options = {}) {
             if (vh !== undefined)
                 await new Promise((resolve) => vh.server.close(() => resolve()));
             leaseReaper.stop();
+            chatDrives.stop();
+            accountFiles.close();
             await cloudSync.flush(); // not stop(): the last run written is the one nobody has yet
             await loopbackAlias.close?.();
             await pool.shutdown();
@@ -681,12 +687,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

@@ -42,10 +42,10 @@ declare const CapsuleSchema: z.ZodObject<{
     seen: z.ZodOptional<z.ZodNumber>;
     lastSeenAt: z.ZodOptional<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
-    expected: string;
-    origin: string;
     version: 1;
     id: string;
+    origin: string;
+    expected: string;
     steps: FlowStep[];
     createdAt: number;
     observed: string;
@@ -53,10 +53,10 @@ declare const CapsuleSchema: z.ZodObject<{
     seen?: number | undefined;
     lastSeenAt?: number | undefined;
 }, {
-    expected: string;
-    origin: string;
     version: 1;
     id: string;
+    origin: string;
+    expected: string;
     steps: FlowStep[];
     createdAt: number;
     observed: string;

package/dist/judgement/runs/artifact/build-verification-run.js

@@ -23,6 +23,7 @@ export function computeVerdict(input) {
         .length + input.checks.filter((c) => c.status === Verified.YES).length;
     const fails = input.flows.filter((f) => f.status === RunFlowStatus.FAIL).length +
         input.checks.filter((c) => c.status === Verified.NO).length;
+    const skippedFlows = input.flows.filter((f) => f.status === RunFlowStatus.SKIPPED).length;
     const blockingRisks = input.risks.filter((r) => r.gated).length;
     const reasons = [];
     for (const f of input.flows) {
@@ -31,6 +32,9 @@ export function computeVerdict(input) {
                 ? `flow ${f.name}: ${f.failureReason}`
                 : `flow ${f.name} failed`);
         }
+        else if (f.status === RunFlowStatus.SKIPPED && f.failureReason !== undefined) {
+            reasons.push(`flow ${f.name}: ${f.failureReason}`);
+        }
     }
     for (const c of input.checks) {
         if (c.status === Verified.NO)
@@ -47,6 +51,8 @@ export function computeVerdict(input) {
         status = VerdictStatus.PARTIAL;
     else if (fails > 0)
         status = VerdictStatus.FAIL;
+    else if (skippedFlows > 0 && passes > 0)
+        status = VerdictStatus.PARTIAL;
     else if (0 === passes) {
         // Nothing passed and nothing failed, so nothing was proved -- an empty run, or one whose every
         // flow was skipped. Reporting that as PASS is the false green this whole file exists to prevent:

package/dist/judgement/runs/artifact/replay-mapping.d.ts

@@ -5,7 +5,7 @@
  * "why" is lifted from the replay's decision envelope (or its error) into failureReason.
  */
 import { ReplayStatus, RunFlowStatus, type FlowFile, type FlowReplayResult, type RunFlowResult } from '@reticlehq/core';
-/** OK → PASS; DRIFT/ERROR → FAIL (a healed flow is produced by the heal path, not plain replay). */
+/** OK → PASS; UNVERIFIABLE → SKIPPED; DRIFT/ERROR → FAIL (a healed flow is produced by the heal path, not plain replay). */
 export declare function runFlowStatusOf(status: ReplayStatus): RunFlowStatus;
 /** Map one replay (plus its measured duration) into a RunFlowResult for the artifact's flows[]. */
 export declare function mapReplayToFlowResult(replay: FlowReplayResult, durationMs: number, flow?: FlowFile): RunFlowResult;