@reticlehq/server 2.14.0 → 3.2.0

package/dist/index.js

@@ -1,60 +1,68 @@
+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 { join } from 'node:path';
 import { existsSync, readFileSync } from 'node:fs';
 import { homedir } from 'node:os';
-import { resolveProjectCloud } from './cloud/cloud-config.js';
-import { startSyncDaemon } from './cloud/sync-daemon.js';
-import { PROJECT_REGISTRY_FILE, emptyProjectRegistry, parseProjectRegistry, projectCandidates, } from '@reticlehq/core/artifacts';
-import { discoverProjectConfigs } from './cli/config-discovery.js';
-import { projectCandidatesFrom, resolveArtifactRoot, } from './project/artifact-root.js';
+import { linkedCloudPort } from './memory/cloud/cloud-config.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 { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { AGENT_STOPPED_NOTICE, RETICLE_DEFAULT_PORT, ReticleCommand, ReticleDir, ReticleEnv, LOOPBACK_HOST, ReplayStatus, EventType, } from '@reticlehq/core';
-import { originOf } from './session/session-manager.js';
+import { originOf } from './portal/session/session-manager.js';
 import { setBrowserMode, BrowserMode } from './telemetry/browser-mode.js';
-import { replayNamedFlow } from './flows/flow-tools.js';
-import { createSharedServer } from './http-server.js';
-import { openLoopbackAlias } from './daemon/loopback-alias.js';
+import { replayAndLearn } from './language/flows/flow-learning.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 './bridge/bridge-security.js';
-import { Bridge } from './bridge/bridge.js';
-import { sdkFixForDirectory } from './version/sdk-fix.js';
-import { SERVER_VERSION } from './version/server-version.js';
-import { BaselineStore } from './project/baselines.js';
-import { RecordingStore } from './flows/recordings.js';
-import { initImpact } from './impact/impact-recorder.js';
-import { FlowStore } from './flows/flows.js';
-import { buildFlowChips } from './flows/flow-scope.js';
-import { ProjectStore } from './project/project-store.js';
-import { attachRouteLearning } from './project/learned-routes.js';
-import { AnnotationStore } from './flows/annotation-store.js';
-import { createNodeFileSystem } from './project/fs-port.js';
-import { cleanupCaptureDirectories } from './visual/capture-cleanup.js';
-import { ReticleRunner } from './runs/reticle-runner.js';
-import { createRunnerPort } from './runs/runner-port.js';
-import { RunStore } from './runs/run-store.js';
-import { startVerifyServer } from './runs/verify-server.js';
-import { createMcpServer } from './mcp/mcp.js';
-import { LEASE_ACQUIRE_TOOL } from './tools/lease-tools.js';
-import { runTool } from './tools/invoke-tool.js';
-import { SessionReaper, endAllSessions, MCP_DISCONNECT_SUMMARY } from './session/session-reaper.js';
-import { wireSessionScope } from './session/no-session-watch.js';
-import { buildIdlePredicate } from './daemon/daemon-usefulness.js';
-import { resolveToolSurface } from './tools/tool-surface.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 { 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 { FlowStore } from './language/flows/flows.js';
+import { buildFlowChips } from './language/flows/flow-scope.js';
+import { ProjectStore } from './memory/project/project-store.js';
+import { projectStoreResolver } from './memory/project/project-for-root.js';
+import { attachRouteLearning } from './memory/project/learned-routes.js';
+import { AnnotationStore } from './language/flows/stores/annotation-store.js';
+import { createNodeFileSystem } from './memory/project/fs/fs-port.js';
+import { cleanupCaptureDirectories } from './features/visual/capture-cleanup.js';
+import { ReticleRunner } from './judgement/runs/reticle-runner.js';
+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 { LEASE_ACQUIRE_TOOL } from './surface/tools/lease-tools.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 } 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 './input/real-input.js';
+import { CdpRealInputProvider, LaunchedRealInputProvider } from './portal/input/real-input.js';
 import { cpus } from 'node:os';
-import { BrowserPool } from './pool/browser-pool.js';
-import { AGENT_ALREADY_DRIVING_ELSEWHERE, shouldGreetWithLeaseNotice, } from './session/lease-visibility.js';
-import { playwrightLauncher, resolveMaxContexts } from './pool/playwright-launcher.js';
-import { LeaseReaper } from './pool/lease-reaper.js';
-import { readJournalEnabled, readProjectId } from './cli/cli-port.js';
-import { hasProjectConnectedBefore } from './session/connection-memory.js';
-import { reticleStateHome } from './daemon/daemon.js';
-import { probeChromium } from './cli/chromium-hint.js';
-import { makeJournalAttach } from './journal/attach-journal.js';
-import { makeSessionEnd } from './journal/session-end.js';
-import { AmbientStore } from './journal/ambient-store.js';
-import { ensureWorkspaceGitignore } from './journal/workspace-gitignore.js';
-import { pruneSessions } from './journal/retention.js';
+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 { readJournalEnabled, readProjectId } from './command/cli/ports/resolve/cli-port.js';
+import { hasProjectConnectedBefore } from './memory/recall/prior/connection-memory.js';
+import { reticleStateHome } from './command/daemon/daemon.js';
+import { probeChromium } from './command/cli/doctor/browser/chromium-hint.js';
+import { makeJournalAttach } from './memory/journal/attach-journal.js';
+import { makeSessionEnd, recordDriveRun } from './memory/journal/session-end.js';
+import { attachDriveRunFlush } from './memory/journal/drive-run-flush.js';
+import { reportOnboardingStep } from './telemetry/onboarding-funnel.js';
+import { AMBIENT_RECORDING } from './language/flows/recording/tape/recordings.js';
+import { AmbientStore } from './memory/journal/ambient-store.js';
+import { ensureWorkspaceGitignore } from './memory/journal/on-disk/workspace-gitignore.js';
+import { pruneFeedback, pruneSessions, pruneVisualDiffs, } from './memory/journal/on-disk/retention.js';
 import { log } from './log.js';
 /** A human-facing one-liner for a panel replay verdict — ✓ passed / ⚠ drifted / ✗ errored. */
 function replayVerdictLine(result) {
@@ -64,24 +72,27 @@ function replayVerdictLine(result) {
         return `⚠ "${result.name}" drifted — a step no longer matches`;
     return `✗ "${result.name}" failed — ${result.error?.message ?? 'could not replay'}`;
 }
-export { ReticleTool } from './tools/tool-names.js';
-export { RingBuffer } from './events/ring-buffer.js';
-export { Bridge } from './bridge/bridge.js';
-export { Session, SessionManager } from './session/session.js';
-export { buildSessionRecommendation } from './session/session-recommendation.js';
-export { TOOLS } from './tools/tools.js';
-export { createToolInvoker, UNKNOWN_TOOL_ERROR } from './tools/tool-invoker.js';
-export { runTool, SESSION_BOUND_TOOLS, SESSION_EXEMPT_TOOLS } from './tools/invoke-tool.js';
-export { BaselineStore, normalizeLines, diffLines } from './project/baselines.js';
-export { RecordingStore } from './flows/recordings.js';
-export { FlowStore, recordedStepToFlowStep } from './flows/flows.js';
-export { assertSuccess, successToPredicate, dynamicTestids, successLabel, } from './flows/flow-success.js';
-export { classifyFlowAssertions, FlowAssertionGrade } from './flows/flow-classify.js';
-export { buildDomainModel } from './domain/domain-model.js';
-export { ProjectStore } from './project/project-store.js';
-export { VisualStore } from './visual/visual-store.js';
-export { diffPng } from './visual/visual-diff.js';
-export { crawl } from './crawl/crawl.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';
+export { RingBuffer } from '@reticlehq/engine/window/ring-buffer.js';
+export { Bridge } from './portal/bridge/bridge.js';
+export { Session } from './portal/session/session.js';
+export { SessionManager } from './portal/session/session-manager.js';
+export { buildSessionRecommendation } from './portal/session/presence/session-recommendation.js';
+export { TOOLS } from './surface/tools/tools.js';
+export { createToolInvoker, UNKNOWN_TOOL_ERROR } from './surface/tools/tool-invoker.js';
+export { runTool, SESSION_BOUND_TOOLS, SESSION_EXEMPT_TOOLS } from './surface/tools/invoke-tool.js';
+export { BaselineStore, normalizeLines, diffLines } from './memory/project/baselines.js';
+export { RecordingStore } from './language/flows/recording/tape/recordings.js';
+export { FlowStore, recordedStepToFlowStep } from './language/flows/flows.js';
+export { assertSuccess, successToPredicate, dynamicTestids, successLabel, } from './language/flows/flow-success.js';
+export { classifyFlowAssertions, FlowAssertionGrade } from './language/flows/flow-classify.js';
+export { buildDomainModel } from './judgement/domain/domain-model.js';
+export { ProjectStore } from './memory/project/project-store.js';
+export { VisualStore } from './features/visual/visual-store.js';
+export { diffPng } from './features/visual/visual-diff.js';
+export { crawl } from './features/crawl/crawl.js';
 /**
  * The contradiction pass, and the seam a consumer adds its own rules through.
  *
@@ -89,47 +100,10 @@ export { crawl } from './crawl/crawl.js';
  * without these it would have to re-implement the fold — a second implementation of the one thing
  * this product is judged on, and the one nobody dogfoods is the one that rots.
  */
-export { findContradictions } from './events/contradictions.js';
-/**
- * The MCP server factory, so a consumer can serve the tool surface it composed.
- *
- * Without this the composition seam is unreachable from outside the package: a consumer can build the
- * list and has nothing to hand it to.
- */
-export { createMcpServer } from './mcp/mcp.js';
-export { registerContradictionFold, registeredContradictionFolds, } from './events/contradiction-folds.js';
-export { MCP_SSE_PATH, MCP_MESSAGE_PATH } from '@reticlehq/core';
-export { BrowserPool, DEFAULT_LEASE_TTL_MS } from './pool/browser-pool.js';
-export { playwrightLauncher, resolveMaxContexts } from './pool/playwright-launcher.js';
-export { appendReticleParams } from './tools/lease-tools.js';
-export { writePid, removePid, isRunning, logPath, readPid, isAlive } from './daemon/daemon.js';
-// The daemon's own liveness vocabulary, exported so a GATE can read a daemon log back and say how
-// that daemon ended. Without this the battery would re-implement the rule, and a guard that
-// re-implements what it guards is insensitive to it.
-export { classifyDaemonLife, DaemonEnd, DAEMON_HEARTBEAT_EVENT, DAEMON_HEARTBEAT_MS, } from './daemon/heartbeat.js';
-export { scrollToFind } from './input/scroll-find.js';
-export { CORE_TOOL_NAMES, TOOL_SURFACE, TOOL_PROFILE_ENV, filterTools, resolveToolSurface, } from './tools/tool-surface.js';
-export { AnnotationStore } from './flows/annotation-store.js';
-export { replayFlow, nearestTestid } from './flows/flow-replay.js';
-export { ensureReticleDir, writeContract, readContract, reticleDirPaths, flowPath, baselinePath, } from './project/reticle-dir.js';
-export { createNodeFileSystem } from './project/fs-port.js';
-// Replay/Verify API — the programmatic surface an OEM/CI pipeline drives (see docs/platform-integration.md).
-export { ReticleRunner } from './runs/reticle-runner.js';
-export { createRunnerPort, defaultRunId } from './runs/runner-port.js';
-export { buildVerificationRun, computeVerdict } from './runs/build-verification-run.js';
-export { RunStore } from './runs/run-store.js';
-export { classifyChangedFiles, buildRisks, risksForPath } from './runs/risk-classify.js';
-export { buildRepairPacket, buildRepairPackets } from './runs/repair-prompt.js';
-export { redactForProfile, REDACTED } from './runs/profile-redact.js';
-export { renderRunReport } from './runs/render-report.js';
-export { handleVerifyRequest, tokenOk, VERIFY_PATH } from './runs/verify-http.js';
-export { createVerifyRequestListener, startVerifyServer, TOKEN_HEADER, } from './runs/verify-server.js';
-export { evaluatePredicate, waitForPredicate, PredicateSchema } from './events/predicate.js';
-export { buildReactionReport } from './events/reaction.js';
-export { CdpRealInputProvider, LaunchedRealInputProvider, DriveError, performGesture, boxCenter, isPointerAction, } from './input/real-input.js';
+export { findContradictions } from '@reticlehq/engine/disagreement/contradictions.js';
 /** Default localhost port for the verify HTTP endpoint (see docs/platform-integration.md). */
 export const RETICLE_VERIFY_DEFAULT_PORT = 7331;
-export { resolveBridgeSecurity } from './bridge/bridge-security.js';
+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.
@@ -199,7 +173,15 @@ function attachJournal(bridge, deps) {
         // Stamp the project's own `.reticle` before ANY counter fires for this session. Without it every
         // verdict is recorded against wherever the daemon was started, which is how one app's evidence
         // reached a different account's production dashboard.
-        session.artifactRoot = resolveArtifactRoot(session.projectId).root;
+        // The origin is passed for the case where the page never stamped a project id: it is the only
+        // distinguishing fact left, and without it every such app shares one bucket.
+        session.artifactRoot = resolveArtifactRoot(session.projectId, originOf(session.url)).root;
+        // Here rather than on the start path, which was neither the moment we were about to write into a
+        // repository nor the root we were about to write into: it created `.reticle/` — holding nothing
+        // but the ignore file — wherever the daemon was launched, coming back every boot after the user
+        // deleted it, while the journals this ignore protects landed in another tree, uncovered.
+        if (deps.enabled)
+            void ensureWorkspaceGitignore(deps.fs, session.artifactRoot);
         journalAttach(session);
         // Seed the learned ambient map so a fresh session starts knowing which regions churn, instead of
         // re-learning from zero. Best-effort + async: a late seed still helps, a failure is silent.
@@ -211,14 +193,40 @@ function attachJournal(bridge, deps) {
         }
     });
     // Teardown: flush the journal tail to disk + persist what this session learned.
-    bridge.attachSessionEnd(makeSessionEnd(deps));
+    bridge.attachSessionEnd(makeSessionEnd({
+        ...deps,
+        // Retention runs from teardown, and it must not delete the journal of a session that is still
+        // being written. The registry is the only thing that knows which those are.
+        liveSessionIds: () => new Set(bridge.sessions.all().map((s) => s.id)),
+    }));
+    /*
+     * And the same write, DURING the session rather than only at the end of it.
+     *
+     * Teardown was the only writer of a run artifact, so every verdict produced while a tab stayed
+     * open was invisible to cloud sync — which can only push artifacts that exist. Reported as "sync
+     * is not happening" and diagnosed as the agent forgetting to sync; there is no sync command to
+     * forget. The evidence simply was not on disk yet.
+     *
+     * Safe to call repeatedly because the run id is derived from the session, so this rewrites one
+     * artifact rather than accumulating them — a property `recordDriveRun` already had, for the
+     * unrelated reason that a reconnecting tab must not publish two overlapping rows.
+     */
     if (deps.enabled) {
-        void pruneSessions(deps.fs, deps.reticleRoot);
-        // Here rather than in `init`, because this is the moment we are actually about to write into
-        // somebody's repository — and the paths that reach it without ever running `init` (a plugin
-        // install, a hand-added client config) are exactly the ones that would otherwise leave an
-        // unexplained pile of untracked files behind. Best-effort and write-once; see the helper.
-        void ensureWorkspaceGitignore(deps.fs, deps.reticleRoot);
+        attachDriveRunFlush({
+            resolve: (sessionId) => bridge.sessions.get(sessionId),
+            write: (session) => recordDriveRun(deps, session),
+        });
+    }
+    if (deps.enabled) {
+        // Empty in the ordinary case (nothing has connected yet), but this path also runs on a daemon
+        // that is already serving sessions.
+        void pruneSessions(deps.fs, deps.reticleRoot, {
+            live: new Set(bridge.sessions.all().map((s) => s.id)),
+        });
+        // The largest thing in the workspace, and until now the only one with no delete path at all.
+        void pruneVisualDiffs(deps.fs, deps.reticleRoot);
+        // Write-only local copies of reports the outbox already carries.
+        void pruneFeedback(deps.fs, deps.reticleRoot);
     }
 }
 /**
@@ -317,39 +325,19 @@ function knownProjectRoots() {
     }
     return [...roots];
 }
-function artifactRootResolver(daemonRoot) {
-    return (projectId) => {
-        let registry = emptyProjectRegistry();
-        try {
-            const path = join(homedir(), ReticleDir.ROOT, PROJECT_REGISTRY_FILE);
-            registry = existsSync(path)
-                ? parseProjectRegistry(JSON.parse(readFileSync(path, 'utf8')))
-                : registry;
-        }
-        catch {
-            // A cache that cannot be read is an empty cache, never an error: the daemon still resolves
-            // through discovery, and falls back to its own root exactly as it did before this existed.
-        }
-        let discovery = { found: [], searched: [] };
-        try {
-            discovery = discoverProjectConfigs(process.cwd());
-        }
-        catch {
-            // Same reasoning: a diagnostic search that throws must not take a tool call with it.
-        }
-        return resolveArtifactRoot({
-            projectId,
-            candidates: projectCandidatesFrom(discovery, registry),
-            daemonRoot,
-        });
-    };
-}
 export async function start(options = {}) {
     const port = options.port ?? RETICLE_DEFAULT_PORT;
     // 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({ reticleRoot: options.reticleRoot ?? join(process.cwd(), ReticleDir.ROOT) });
+    initImpact({
+        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(() => fetchPlatformConfig(process.env)),
+    });
+    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 });
     // Server-authoritative liveness: a Node-side reaper (immune to browser throttling) ends sessions
@@ -377,10 +365,18 @@ export async function start(options = {}) {
         const reticleRoot = options.reticleRoot ?? join(process.cwd(), ReticleDir.ROOT);
         const now = options.now ?? (() => Date.now());
         const journalEnabled = readJournalEnabled(process.cwd(), process.env[ReticleEnv.JOURNAL]);
-        attachJournal(bridge, { fs, reticleRoot, enabled: journalEnabled });
         const flows = new FlowStore(fs, reticleRoot, { now });
+        attachJournal(bridge, {
+            fs,
+            reticleRoot,
+            enabled: journalEnabled,
+            // Bound HERE, where the recorder is already in hand: teardown gets the tape, not the recorder.
+            takeAmbientTape: () => recordings.stop(AMBIENT_RECORDING),
+            reportStep: reportOnboardingStep,
+            flows,
+        });
         const project = new ProjectStore(fs, reticleRoot, { now });
-        attachRouteLearning(bridge, project);
+        attachRouteLearning(bridge, projectStoreResolver(fs, project, reticleRoot, now));
         const annotations = new AnnotationStore();
         pool = createBrowserPool(options.headless ?? true);
         leaseReaper = new LeaseReaper(pool);
@@ -439,6 +435,7 @@ export async function start(options = {}) {
         ...(security.token !== undefined ? { token: security.token } : {}),
         close: async () => {
             reaper.stop();
+            uninstallHooks();
             await cleanupCaptureDirectories();
             leaseReaper?.stop();
             await pool?.shutdown();
@@ -460,7 +457,13 @@ export async function startDaemon(options = {}) {
     // 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({ reticleRoot: options.reticleRoot ?? join(process.cwd(), ReticleDir.ROOT) });
+    initImpact({
+        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(() => fetchPlatformConfig(process.env)),
+    });
     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 });
@@ -471,11 +474,11 @@ export async function startDaemon(options = {}) {
     // listen — the first status request cannot arrive until after the bind.
     let verifyHttp;
     // `reticle status` GETs this for a live, at-a-glance view of connected tabs + their health.
-    // The same diagnosis agents get on an empty `reticle_sessions`, so `reticle status` — the
-    // most-run command in the field — stops answering "sessionCount: 0" and nothing else.
+    // It carries the same diagnosis agents get on an empty `reticle_sessions`, so an empty status
+    // answers WHY rather than just "sessionCount: 0".
     // `verifyPort` rides along so a later `serve --http` can tell whether this daemon already honours
     // the requested `--http-port` instead of silently ignoring the flag (#687).
-    shared.attachStatus(() => statusPayload(bridge.sessions.count(), bridge.sessions.list(), bridge.sessions.noSessionHint(), verifyHttp?.port));
+    shared.attachStatus(() => statusPayload(bridge.sessions.count(), bridge.sessions.list(), bridge.sessions.noSessionHint(), verifyHttp?.port, bridge.sessions.noSessionLead()));
     // 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
     // "go to your terminal" notice to the panel — the human is on the browser and must not lose a typed
@@ -495,10 +498,29 @@ export async function startDaemon(options = {}) {
     const reticleRoot = options.reticleRoot ?? join(process.cwd(), ReticleDir.ROOT);
     const now = options.now ?? (() => Date.now());
     const journalEnabled = readJournalEnabled(process.cwd(), process.env[ReticleEnv.JOURNAL]);
-    attachJournal(bridge, { fs, reticleRoot, enabled: journalEnabled });
     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();
+    /*
+     * Bound AFTER the sync daemon exists, read only when a run is actually written.
+     *
+     * `attachJournal` runs before `attachCloudSync` because the journal has to be capturing before
+     * anything can connect, and reordering them so this could be a direct reference would put sync
+     * setup ahead of session capture for the sake of one callback.
+     */
+    const syncNudge = {};
+    attachJournal(bridge, {
+        fs,
+        reticleRoot,
+        enabled: journalEnabled,
+        takeAmbientTape: () => recordings.stop(AMBIENT_RECORDING),
+        reportStep: reportOnboardingStep,
+        flows,
+        onRunPersisted: () => syncNudge.run?.(),
+    });
     const project = new ProjectStore(fs, reticleRoot, { now });
-    attachRouteLearning(bridge, project);
+    attachRouteLearning(bridge, projectStoreResolver(fs, project, reticleRoot, now));
     const annotations = new AnnotationStore();
     const pool = createBrowserPool(options.headless ?? true);
     const leaseReaper = new LeaseReaper(pool);
@@ -511,15 +533,30 @@ export async function startDaemon(options = {}) {
      * process to remember. Safe for an UNLINKED project: it resolves the link on every tick and does
      * nothing until one exists, so `reticle link` takes effect without a restart.
      */
-    const cloudSync = startSyncDaemon({
+    /*
+     * Hooks, attached for the life of the daemon — the same call `start` makes, see `wireHooks`.
+     *
+     * Wired here rather than lazily on first use because the events it listens for start the moment a
+     * session attaches, and a surface that wires itself up on first need would miss exactly the
+     * events a user most wants: the ones at the start of a run.
+     */
+    wireHooks(reticleRoot, readProjectId(process.cwd()));
+    const cloudSync = attachCloudSync({
+        fs,
         reticleRoot,
-        cloud: () => resolveProjectCloud(fs, reticleRoot, homedir(), process.env),
-        // Every OTHER linked repo on this machine, not just the directory the daemon was started in.
-        // One daemon serves many projects, and pushing only its own root left the rest silently
-        // reporting nothing — indistinguishable, on the dashboard, from nobody having verified anything.
-        otherRoots: () => Promise.resolve(knownProjectRoots()),
-        cloudFor: (root) => resolveProjectCloud(fs, root, homedir(), process.env),
+        homeDir: homedir(),
+        env: process.env,
+        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.
+    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 writeHarnessSwitch(process.env, enabled));
     // 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
@@ -532,12 +569,16 @@ export async function startDaemon(options = {}) {
         sessions: bridge.sessions,
         pool,
         baselines: new BaselineStore(),
-        recordings: new RecordingStore(),
+        // The SAME store teardown reads, not a second one. A second store means the tools capture into
+        // one tape and the teardown saves from another, so every automatic flow would be empty while
+        // every check on the tape passed — the tape it checked just was not the one being driven.
+        recordings,
         annotations,
         flows,
         project,
         fs,
         reticleRoot,
+        linkedCloud: linkedCloudPort(fs, reticleRoot, homedir(), process.env),
         // The long-lived daemon needs this MORE than the standalone MCP process does, not less: it is
         // the one that outlives a single project and serves every app on the machine. Omitting it here
         // silently disabled per-session artifact resolution for every agent that attaches to a running
@@ -559,7 +600,7 @@ export async function startDaemon(options = {}) {
     // `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-attach.ts for why attaching beats refereeing the race.
+    // 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 }));
     // 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
@@ -582,7 +623,7 @@ export async function startDaemon(options = {}) {
         if (session === undefined)
             return;
         session.pushNarration(`▶ Replaying "${flowName}"…`);
-        replayNamedFlow(effectiveDeps, { flowName, sessionId })
+        replayAndLearn(effectiveDeps, { flowName, sessionId })
             .then((result) => session.pushNarration(replayVerdictLine(result)))
             .catch((error) => {
             const message = error instanceof Error ? error.message : String(error);
@@ -593,7 +634,7 @@ export async function startDaemon(options = {}) {
     // connecting session's project (a shared daemon serves many apps; each panel shows only its own
     // flows + legacy untagged ones). Each chip carries a `start` hint (the first step's testid anchor)
     // so the HUD shows a flow only on the page it can begin from — the panel re-scopes per route.
-    // The first instrumented app of this daemon run — the funnel step nothing could measure before.
+    // The first instrumented app of this daemon run.
     // Inside the existing session-ready hook rather than beside it: this fires exactly when a page
     // carrying the SDK has completed its handshake, which is the definition of "instrumented", and
     // `reportAppInstrumented` is idempotent so later sessions cost a boolean check.
@@ -666,3 +707,52 @@ 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.
+export { WebRealm } from './portal/realm/web-realm.js';
+export { conformanceClient } from './portal/realm/conformance-client.js';
+/**
+ * The MCP server factory, so a consumer can serve the tool surface it composed.
+ *
+ * Without this the composition seam is unreachable from outside the package: a consumer can build the
+ * list and has nothing to hand it to.
+ */
+export { createMcpServer } from './surface/mcp/mcp.js';
+export { registerContradictionFold, registeredContradictionFolds, } from '@reticlehq/engine/disagreement/contradiction-folds.js';
+export { MCP_SSE_PATH, MCP_MESSAGE_PATH } from '@reticlehq/core';
+export { BrowserPool, DEFAULT_LEASE_TTL_MS } from './portal/pool/browser-pool.js';
+export { playwrightLauncher, resolveMaxContexts } from './portal/pool/playwright-launcher.js';
+export { appendReticleParams } from './surface/tools/lease-tools.js';
+export { writePid, removePid, isRunning, logPath, readPid, isAlive, } from './command/daemon/daemon.js';
+// The daemon's own liveness vocabulary, exported so a GATE can read a daemon log back and say how
+// that daemon ended. Without this the battery would re-implement the rule, and a guard that
+// re-implements what it guards is insensitive to it.
+export { classifyDaemonLife, DaemonEnd, DAEMON_HEARTBEAT_EVENT, DAEMON_HEARTBEAT_MS, } from './command/daemon/lifetime/heartbeat.js';
+export { scrollToFind } from './portal/input/scroll-find.js';
+export { CORE_TOOL_NAMES, TOOL_SURFACE, TOOL_PROFILE_ENV, filterTools, resolveToolSurface, } from './surface/tools/tool-surface.js';
+export { AnnotationStore } from './language/flows/stores/annotation-store.js';
+export { replayFlow, nearestTestid } from './language/flows/flow-replay.js';
+export { ensureReticleDir, writeContract, readContract, reticleDirPaths, flowPath, baselinePath, } from './memory/project/dir/reticle-dir.js';
+export { createNodeFileSystem } from './memory/project/fs/fs-port.js';
+// Replay/Verify API — the programmatic surface an OEM/CI pipeline drives (see docs/platform-integration.md).
+export { ReticleRunner } from './judgement/runs/reticle-runner.js';
+export { createRunnerPort, defaultRunId } from './judgement/runs/runner-port.js';
+export { buildVerificationRun, computeVerdict, } from './judgement/runs/artifact/build-verification-run.js';
+export { RunStore } from './judgement/runs/artifact/run-store.js';
+export { classifyChangedFiles, buildRisks, risksForPath } from './judgement/runs/risk-classify.js';
+export { buildRepairPacket, buildRepairPackets } from './judgement/runs/repair-prompt.js';
+export { redactForProfile, REDACTED } from './judgement/runs/artifact/profile-redact.js';
+export { renderRunReport } from './judgement/runs/artifact/render-report.js';
+export { handleVerifyRequest, tokenOk, VERIFY_PATH } from './judgement/runs/verify-http.js';
+export { createVerifyRequestListener, startVerifyServer, TOKEN_HEADER, } from './judgement/runs/verify-server.js';
+export { evaluatePredicate, waitForPredicate, PredicateSchema, } from '@reticlehq/engine/question/predicate/predicate.js';
+export { buildReactionReport } from '@reticlehq/engine/question/reaction.js';
+export { CdpRealInputProvider, LaunchedRealInputProvider, DriveError, performGesture, boxCenter, isPointerAction, } from './portal/input/real-input.js';
+// Hooks, in-process half. The config half needs no export: a user writes `.reticle/hooks.json`.
+// Payload TYPES live in `@reticlehq/core/hooks`; `hook-bus.ts` has the design.
+export { onHook as onReticleEvent, emitHook, hookListenerCount } from './hooks/hook-bus.js';
+export { readHookConfig } from './hooks/hook-commands.js';

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

@@ -0,0 +1,70 @@
+import { z } from 'zod';
+import { type FlowStep } from '@reticlehq/core';
+import type { FileSystemPort } from '../../memory/project/fs/fs-port.js';
+/**
+ * Bug capsules. When an assertion fails, the evidence that explains it is in hand exactly once —
+ * at the moment of the failure. A capsule persists that moment as a *replayable artifact*: the minimal
+ * failing steps, the consequence that was supposed to hold, and the divergence that was observed instead.
+ *
+ * This is deliberately fail-to-pass shaped (SWE-bench style): a capsule reproduces a bug NOW and, once the
+ * fix lands, it is exactly a regression flow. Capsules are ordinary flow files plus evidence, so they
+ * replay through the existing machinery rather than needing a second runner.
+ */
+/**
+ * The capsule file-format version. Declared ABOVE the schema so the schema, the writer and this
+ * constant cannot disagree about the number.
+ */
+export declare const CAPSULE_VERSION = 1;
+declare const CapsuleSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    id: z.ZodString;
+    /** The flow the failure happened in, when it came from one (a bare assert has no flow). */
+    flow: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodNumber;
+    /** Why it was captured — a failed assertion, a crawl anomaly, a human review pin. */
+    origin: z.ZodString;
+    /** The consequence that was supposed to hold. */
+    expected: z.ZodString;
+    /** What was observed instead — the first-divergence sentence. */
+    observed: z.ZodString;
+    /** Minimal steps to reproduce (prefix-trimmed). */
+    steps: z.ZodArray<z.ZodType<FlowStep, z.ZodTypeDef, FlowStep>, "many">;
+}, "strip", z.ZodTypeAny, {
+    expected: string;
+    origin: string;
+    version: 1;
+    id: string;
+    steps: FlowStep[];
+    createdAt: number;
+    observed: string;
+    flow?: string | undefined;
+}, {
+    expected: string;
+    origin: string;
+    version: 1;
+    id: string;
+    steps: FlowStep[];
+    createdAt: number;
+    observed: string;
+    flow?: string | undefined;
+}>;
+export type Capsule = z.infer<typeof CapsuleSchema>;
+/** Capsule ids are filenames — refuse anything that could escape the capsules directory. */
+export declare function isValidCapsuleId(id: string): boolean;
+export declare class CapsuleStore {
+    #private;
+    constructor(fs: FileSystemPort, root: string);
+    /** Persist a capsule. Best-effort by design: capturing evidence must never fail the run that found it. */
+    save(capsule: Capsule): Promise<boolean>;
+    /** Capsule ids on disk, newest-first by id (ids are time-prefixed). Never throws. */
+    list(): Promise<string[]>;
+    /** Read one capsule; undefined when missing or malformed (never throws). */
+    read(id: string): Promise<Capsule | undefined>;
+    /** Every readable capsule, newest-first — what `reticle capsules` prints. */
+    all(): Promise<Capsule[]>;
+}
+/** Deterministic, path-safe capsule id: time-ordered so `list` sorts newest-first for free. */
+export declare function capsuleId(now: number, label: string): string;
+/** The minimal reproduction: the steps up to and including the one that failed (prefix trim). */
+export declare function minimalSteps(steps: readonly FlowStep[], failedIndex: number): FlowStep[];
+export {};