@reticlehq/server 3.5.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,20 +1,23 @@
-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, projectDirectoryFor, } 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';
@@ -25,7 +28,7 @@ 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,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';
@@ -53,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';
@@ -63,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';
@@ -138,6 +134,7 @@ function createBrowserPool(headless, reader) {
         maxContexts,
         genSessionId,
         zeroInstallScript,
+        launchHeaded: playwrightLauncher({ headless: false }),
     });
 }
 /**
@@ -253,40 +250,25 @@ function sdkFixForProject(projectId) {
  * 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);
@@ -302,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;
@@ -310,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();
@@ -367,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,
@@ -376,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.)
@@ -401,6 +384,7 @@ export async function start(options = {}) {
             uninstallHooks();
             await cleanupCaptureDirectories();
             leaseReaper?.stop();
+            chatDrives?.stop();
             await pool?.shutdown();
             await owned?.dispose();
             await bridge.close();
@@ -415,17 +399,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 +423,14 @@ export async function startDaemon(options = {}) {
         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);
@@ -476,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.
      *
@@ -529,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
@@ -562,12 +564,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,
+        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;
@@ -575,15 +579,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.
+        : { ...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`.
@@ -601,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
@@ -680,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();
@@ -689,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/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;

package/dist/judgement/runs/artifact/replay-mapping.js

@@ -6,9 +6,13 @@
  */
 import { ReplayStatus, RUN_RECORDING_MAX_BYTES, RUN_STEP_RESULTS_MAX, RUN_TEXT_MAX, RunFlowStatus, } from '@reticlehq/core';
 import { SUCCESS_STEP_TOOL } from '../../../language/flows/flow-success.js';
-/** 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 function runFlowStatusOf(status) {
-    return status === ReplayStatus.OK ? RunFlowStatus.PASS : RunFlowStatus.FAIL;
+    if (status === ReplayStatus.OK)
+        return RunFlowStatus.PASS;
+    if (status === ReplayStatus.UNVERIFIABLE)
+        return RunFlowStatus.SKIPPED;
+    return RunFlowStatus.FAIL;
 }
 const clip = (text) => text.length > RUN_TEXT_MAX ? `${text.slice(0, RUN_TEXT_MAX - 1)}…` : text;
 /** One step as synced: what it did, where, and whether it held. */
@@ -39,9 +43,12 @@ function recordingOf(flow) {
 }
 /** Map one replay (plus its measured duration) into a RunFlowResult for the artifact's flows[]. */
 export function mapReplayToFlowResult(replay, durationMs, flow) {
-    // A replay that could not start returns OK with no steps. Nothing ran, so it is SKIPPED — which
-    // every reader of a run (the verdict, the gate) already refuses to count as a pass.
-    const status = replay.unverifiable === undefined ? runFlowStatusOf(replay.status) : RunFlowStatus.SKIPPED;
+    // A replay that could not start or complete returns UNVERIFIABLE (or carries an unverifiable caveat).
+    // Nothing was verified, so it is SKIPPED — which every reader of a run (the verdict, the gate)
+    // refuses to count as a pass.
+    const status = replay.status === ReplayStatus.UNVERIFIABLE || replay.unverifiable !== undefined
+        ? RunFlowStatus.SKIPPED
+        : runFlowStatusOf(replay.status);
     const failureReason = replay.unverifiable !== undefined
         ? replay.unverifiable.reason
         : status === RunFlowStatus.FAIL
@@ -49,13 +56,16 @@ export function mapReplayToFlowResult(replay, durationMs, flow) {
                 replay.decision?.summary ??
                 replay.error?.message ??
                 'flow failed')
-            : undefined;
+            : status === RunFlowStatus.SKIPPED
+                ? 'flow could not be graded'
+                : undefined;
     // A flow with a success oracle gets a synthetic 'success' step appended by replay; surface its label
     // as the run's `oracle` so the verdict counts this flow as consequence-backed (→ HIGH confidence),
     // not a bare smoke click. Without this, an oracle-backed pass reads as MEDIUM and undersells itself.
     const oracle = replay.steps.find((s) => s.tool === SUCCESS_STEP_TOOL)?.anchor;
     return {
         name: replay.name,
+        ...(flow?.template === undefined ? {} : { template: flow.template }),
         status,
         steps: replay.steps.length,
         durationMs,

package/dist/judgement/runs/artifact/run-store.d.ts

@@ -38,7 +38,7 @@ export declare class RunStore {
      * Guards runId as a safe path segment BEFORE building the path — a runId can originate from a caller
      * (an OEM may set it), so an unsafe value must never escape .reticle/runs/ (mirrors the read guard).
      */
-    write(run: ReticleVerificationRun): Promise<void>;
+    write(given: ReticleVerificationRun): Promise<void>;
     /** Never throws. Invalid id / missing → MISSING; bad JSON or failed schema → MALFORMED. */
     read(runId: RunId): Promise<ReadRunResult>;
     /** List run ids on disk (filenames minus.json). Empty when the runs dir is absent. */