@reticlehq/server 3.4.0 → 3.6.0

package/dist/language/flows/replay.js

@@ -3,6 +3,7 @@ import { FlowPredicateSchema, Verified } from '@reticlehq/core';
 import { DANGEROUS_ACTION_CONFIRM_ARG, ReticleCommand, QueryBy, } from '@reticlehq/core';
 import { ReticleTool } from '@reticlehq/core';
 import { formatStepAddress } from 'open-verification';
+import { refFor } from './flow-anchor.js';
 import { asRecord, asString } from '@reticlehq/core';
 /**
  * The note attached when a testid resolves to multiple live elements (the first match is used).
@@ -12,6 +13,9 @@ import { asRecord, asString } from '@reticlehq/core';
 export function ambiguousTestidNote(value) {
     return `ambiguous testid '${value}', used first match`;
 }
+function ambiguousRoleNote(role, name) {
+    return `ambiguous ${role} named '${name}', used first match`;
+}
 /**
  * The live element refs a QUERY resolved to (empty when it failed or matched nothing). Shared by BOTH
  * replay engines (replayProgram + flow-replay's step runner) so element extraction — the core of anchor
@@ -87,6 +91,9 @@ export function pathOf(url) {
         return undefined;
     }
 }
+/** What a saved flow could not keep, and the fix. See RecordedStep.unkeptExpect. */
+export const UNKEPT_EXPECT = 'its proved `until` names something a saved flow cannot replay (a session ref such as e12): ' +
+    'name the element by testid, role and name, or text, and the check is kept';
 /**
  * Capture an act into every in-flight recording, or do nothing when none is running.
  *
@@ -96,7 +103,9 @@ export function pathOf(url) {
  */
 export function captureAct(recordings, args, res, 
 /** Where this step ran, so the ambient tape can be cut into journeys. See RecordedStep.route. */
-route) {
+route, 
+/** The session that acted: only recordings it started take the step. */
+session) {
     // NO `active()` gate. `RecordingStore.capture` opens the AMBIENT tape on its first step, and that
     // branch was unreachable from here: this returned early whenever nothing was open, and the only
     // thing that opened anything was `reticle_record { action: "start" }`. So the comment on `capture`
@@ -111,15 +120,18 @@ route) {
     // success means — the large majority of calls carry one — and dropping it produced a flow graded
     // "assertion-free: it will pass even if the feature is broken", which is the regression-suite
     // story failing at its last step. See enforceableExpect below.
-    const expect = enforceableExpect(args['until'] ?? args['predicate']);
+    const declared = args['until'] ?? args['predicate'];
+    const expect = enforceableExpect(declared);
     if (expect !== undefined)
         step.expect = expect;
+    else if (declared !== undefined)
+        step.unkeptExpect = UNKEPT_EXPECT;
     if (route !== undefined)
         step.page = route;
     const intent = asString(args['intent'])?.trim();
     if (intent !== undefined && intent.length > 0)
         step.intent = intent;
-    recordings.capture(step, route);
+    recordings.capture(step, route, session);
 }
 /**
  * Capture an act_and_wait once its verdict is known, keeping `until` as the step's expectation only
@@ -127,15 +139,15 @@ route) {
  * a regression test asserting something never once observed to hold because of the action. The
  * action itself is always recorded: it happened, and replay needs it to reach the next step.
  */
-export function captureVerdictedAct(recordings, args, res, route, verified) {
+export function captureVerdictedAct(recordings, args, res, route, verified, session) {
     const { until: _until, predicate: _predicate, ...unproved } = args;
-    captureAct(recordings, Verified.YES === verified ? args : unproved, res, route);
+    captureAct(recordings, Verified.YES === verified ? args : unproved, res, route, session);
 }
 /** Fold a PASSING standalone assertion into the step it proved. See RecordingStore.attachExpect. */
-export function captureAssertion(recordings, raw) {
+export function captureAssertion(recordings, raw, session) {
     const expect = enforceableExpect(raw);
     if (expect !== undefined)
-        recordings.attachExpect(expect);
+        recordings.attachExpect(expect, session);
 }
 /**
  * A declared predicate, as a recorded expectation — or nothing.
@@ -207,6 +219,10 @@ function compileAnchorArgs(r, ref, action, actArgs) {
         };
         if (source !== undefined)
             roleArgs['source'] = source;
+        if ('number' === typeof r['nth'] && 'number' === typeof r['of']) {
+            roleArgs['nth'] = r['nth'];
+            roleArgs['of'] = r['of'];
+        }
         return { args: roleArgs, stable: true };
     }
     const component = asString(r['component']);
@@ -275,11 +291,13 @@ async function resolveRef(session, step) {
         const result = await session.command(ReticleCommand.QUERY, query);
         if (!result.ok)
             throw new Error(result.error ?? 'query failed');
-        const ref = queryRefs(result)[0];
+        const refs = queryRefs(result);
+        const meant = refFor(step, refs);
+        const ref = meant ?? refs[0];
         if (ref === undefined) {
             throw new Error(`${value} named '${String(name)}' did not resolve in current page`);
         }
-        return { ref };
+        return meant === undefined ? { ref, note: ambiguousRoleNote(value, String(name)) } : { ref };
     }
     if (by === QueryBy.COMPONENT) {
         const component = asString(step.component);

package/dist/language/flows/suite/suite-flakes.js

@@ -26,6 +26,8 @@ import { FlakeStore } from '../stores/flake-store.js';
 export async function recordSuiteFlakes(fs, reticleRoot, runs) {
     const flakes = new FlakeStore(fs, reticleRoot);
     for (const { replay } of runs) {
+        if (replay.status === ReplayStatus.UNVERIFIABLE)
+            continue;
         await flakes.record(replay.name, ReplayStatus.OK === replay.status).catch(() => undefined);
     }
     return flakes.flakyFlows().catch(() => []);

package/dist/language/flows/suite-selection.d.ts

@@ -1,17 +1,4 @@
-/**
- * Which flows a suite run replays, resolved against the store.
- *
- * Shared by the MCP tool and the `reticle verify` command so the two cannot disagree about what a
- * selection means.
- *
- * Lives beside the flow store rather than under `suite/` on purpose: it needs `flowsForSession`, and
- * from `suite/` that import made `suite` and `flows` need EACH OTHER -- a mutual pair, which the
- * reach guard forbids growing because two directories that need each other cannot be read, moved or
- * tested apart. Here it adds no edge at all: `flows` reaching itself is nothing, and `cli -> flows`
- * already existed. The pure rule lives in core (`selectFlows`); this is the part that has to read
- * the files, because a label lives in one and `list` returns only names.
- */
-import { type ProjectId } from '@reticlehq/core';
+import type { ProjectTarget } from '../../memory/project/session-root.js';
 import type { ToolDeps } from '../../surface/tools/tool-kit.js';
 /**
  * Resolve what a suite run should replay, and what it is holding back.
@@ -23,7 +10,7 @@ import type { ToolDeps } from '../../surface/tools/tool-kit.js';
  * would turn a corrupt file into missing coverage nobody is told about, and replay reports the parse
  * failure far better than a silent omission does.
  */
-export declare function resolveSuiteSelection(deps: ToolDeps, projectId: ProjectId | undefined, args: Record<string, unknown>): Promise<{
+export declare function resolveSuiteSelection(deps: ToolDeps, target: ProjectTarget, args: Record<string, unknown>): Promise<{
     run: string[];
     quarantined: string[];
     unmatched: string[];

package/dist/language/flows/suite-selection.js

@@ -11,7 +11,7 @@
  * already existed. The pure rule lives in core (`selectFlows`); this is the part that has to read
  * the files, because a label lives in one and `list` returns only names.
  */
-import { FLOW_FILE_VERSION, orderFlows, selectFlows, } from '@reticlehq/core';
+import { FLOW_FILE_VERSION, orderFlows, selectFlows } from '@reticlehq/core';
 import { flowsForSession } from './flow-store-for-session.js';
 /**
  * Resolve what a suite run should replay, and what it is holding back.
@@ -23,8 +23,9 @@ import { flowsForSession } from './flow-store-for-session.js';
  * would turn a corrupt file into missing coverage nobody is told about, and replay reports the parse
  * failure far better than a silent omission does.
  */
-export async function resolveSuiteSelection(deps, projectId, args) {
-    const store = flowsForSession(deps, projectId).flows;
+export async function resolveSuiteSelection(deps, target, args) {
+    const { projectId } = target;
+    const store = flowsForSession(deps, target).flows;
     const names = await store.list(projectId);
     const asStrings = (value) => Array.isArray(value) ? value.filter((v) => 'string' === typeof v) : [];
     const wantedNames = asStrings(args['names']);

package/dist/language/flows/verify-change-tools.js

@@ -2,7 +2,7 @@ import { z } from 'zod';
 import { sessionRoot, sessionProjectId } from '../../memory/project/session-root.js';
 import { verdictForSuite } from '../../judgement/outcome/verify-change-verdict.js';
 import { attributedFailures } from '../../judgement/outcome/attributed-failure.js';
-import { Verified } from '@reticlehq/core';
+import { Verified, isAdvisory } from '@reticlehq/core';
 import { ReticleTool } from '@reticlehq/core';
 import { asNumber, asRecord, asString } from '@reticlehq/core';
 import { workerCountSchema } from '../../surface/tools/args/numeric-bounds.js';
@@ -49,7 +49,7 @@ export const VERIFY_CHANGE_TOOLS = [
             contradictions: z
                 .array(z.unknown())
                 .optional()
-                .describe('Channels that disagreed DURING the replay. Any entry forces verified:"no" even when every flow passed — a suite that goes green over a failed write is the false green this exists to catch. OMITTED when clean; see `measured` when it could not be looked for.'),
+                .describe('Findings from channels inspected during replay. Advisory entries are reported without changing the verdict; verdict-deciding entries can turn a green suite into no or unknown. OMITTED when clean; see `measured` when it could not be looked for.'),
             untouched: z
                 .array(z.unknown())
                 .optional()
@@ -170,8 +170,9 @@ export const VERIFY_CHANGE_TOOLS = [
             // The suite went green. That is exactly when the remaining two channels are worth reading:
             // a replay that passes while a write fails is the false green this whole product is about.
             const extra = await inspectAfterReplay(deps, args, cursor);
-            if (extra.contradictions.length > 0) {
-                const kinds = extra.contradictions.map((c) => c.kind).join(', ');
+            const decidingContradictions = extra.contradictions.filter((c) => !isAdvisory(c.kind));
+            if (decidingContradictions.length > 0) {
+                const kinds = decidingContradictions.map((c) => c.kind).join(', ');
                 const earned = attributedFailures(affected, unknownProvenance).length > 0;
                 return {
                     verified: earned ? Verified.NO : Verified.UNKNOWN,
@@ -197,6 +198,7 @@ export const VERIFY_CHANGE_TOOLS = [
                     flowsRun: affected,
                     suite,
                     unknownProvenance,
+                    ...(0 === extra.contradictions.length ? {} : { contradictions: extra.contradictions }),
                     measured: extra.measured,
                 };
             }
@@ -207,6 +209,7 @@ export const VERIFY_CHANGE_TOOLS = [
                 flowsRun: affected,
                 suite,
                 unknownProvenance,
+                ...(0 === extra.contradictions.length ? {} : { contradictions: extra.contradictions }),
                 ...(extra.untouched === undefined ? {} : { untouched: extra.untouched }),
                 measured: extra.measured,
             };
@@ -243,6 +246,7 @@ async function inspectAfterReplay(deps, args, cursor) {
             currentEditEpoch: session.currentEditEpoch,
             appOrigin: session.url,
             background: session.background,
+            namedNetUrls: [],
             // The replay is the action, and the cursor is where it started.
             actionSince: cursor,
         });

package/dist/launch-chromium.d.ts

@@ -14,7 +14,7 @@
  * line there corrupts the client's stream.
  */
 import { type ChromiumLaunchOptions } from './chromium-launch-options.js';
-import { type ChromiumProbe } from './command/cli/doctor/browser/chromium-hint.js';
+import { type ChromiumPathProblem, type ChromiumProbe } from './command/cli/doctor/browser/chromium-hint.js';
 /** The installed-browser channels Playwright can drive in place of its own build. */
 export declare const ChromiumChannel: {
     readonly CHROME: "chrome";
@@ -31,6 +31,8 @@ export interface ChromiumTargetDeps {
     /** Where the bundled playwright expects its Chromium build. */
     executablePath: () => string;
     exists: (path: string) => boolean;
+    /** What stops the executable RETICLE_CHROMIUM_PATH names from launching, if anything. */
+    pathProblem: (path: string) => ChromiumPathProblem | undefined;
     platform: NodeJS.Platform;
     env: NodeJS.ProcessEnv;
     /** Run the pinned Chromium install; resolves true when it succeeded. */
@@ -38,16 +40,29 @@ export interface ChromiumTargetDeps {
     /** A progress line for a human — stderr in production. */
     announce: (line: string) => void;
 }
-/** Which browser to launch: the bundled build (no channel), an installed channel, or none at all. */
+/**
+ * Which browser to launch: the bundled build (no channel), an installed channel, the executable
+ * RETICLE_CHROMIUM_PATH names, or none at all. `unusableConfigured` is a named executable that
+ * cannot be launched, and why.
+ */
 export type ChromiumTarget = {
     found: true;
     channel?: ChromiumChannel;
+    executablePath?: string;
 } | {
     found: false;
+    unusableConfigured?: {
+        path: string;
+        problem: ChromiumPathProblem;
+    };
 };
 /**
  * Decide which browser a launch will use, installing the pinned Chromium only as the last resort.
- * Order: bundled build on disk → installed Chrome → installed Edge → install, then bundled.
+ * Order: RETICLE_CHROMIUM_PATH → bundled build on disk → installed Chrome → installed Edge →
+ * install, then bundled.
+ *
+ * A named executable ends the search either way. It is set on a machine where the usual places are
+ * empty or unusable, so falling back from a typo to a download would only hide the typo.
  */
 export declare function resolveChromiumTarget(deps: ChromiumTargetDeps): Promise<ChromiumTarget>;
 /** The subset of Playwright's `BrowserType` this file needs, so tests can pass a fake. */
@@ -67,14 +82,21 @@ export declare function announceOnce(write: (line: string) => void): (line: stri
  * turns into the pinned install command, so the user still gets the one line that fixes it.
  */
 export declare function launchChromium<B>(chromium: LaunchableChromium<B>, headless: boolean, deps?: ChromiumTargetDeps): Promise<B>;
+/** What the probes read off the machine, injected so a test can name a browser that is not there. */
+interface ProbeMachine {
+    env: NodeJS.ProcessEnv;
+    exists: (path: string) => boolean;
+    pathProblem: (path: string) => ChromiumPathProblem | undefined;
+}
 /**
  * The lease preflight's probe: "can a launch succeed?", which now includes the Chrome/Edge fallback
  * and the automatic install. Without this the preflight would refuse a lease on a machine the
  * launcher itself could serve. Falls back to the plain probe so a real refusal keeps its evidence.
  */
-export declare function probeLaunchableChromium(): Promise<ChromiumProbe>;
+export declare function probeLaunchableChromium(machine?: ProbeMachine): Promise<ChromiumProbe>;
 /**
  * `doctor`'s probe: the plain Chromium probe, plus the installed browser that stands in when the
  * bundled build is missing. Never installs — a diagnostic that downloads 150 MiB is not one.
  */
-export declare function probeChromiumWithFallback(): Promise<ChromiumProbe>;
+export declare function probeChromiumWithFallback(machine?: ProbeMachine): Promise<ChromiumProbe>;
+export {};

package/dist/launch-chromium.js

@@ -18,7 +18,7 @@ import { existsSync } from 'node:fs';
 import { createRequire } from 'node:module';
 import { dirname, join } from 'node:path';
 import { chromiumLaunchOptions } from './chromium-launch-options.js';
-import { bundledPlaywrightVersion, chromiumInstallCommand, probeChromium, } from './command/cli/doctor/browser/chromium-hint.js';
+import { bundledPlaywrightVersion, chromiumInstallCommand, chromiumPathProblem, configuredChromiumPath, configuredChromiumProbe, configuredChromiumRefusal, probeChromium, } from './command/cli/doctor/browser/chromium-hint.js';
 /** The installed-browser channels Playwright can drive in place of its own build. */
 export const ChromiumChannel = {
     CHROME: 'chrome',
@@ -72,9 +72,20 @@ const installingLine = (command) => `[reticle] No Chromium, Chrome or Edge found
 const INSTALL_FAILED_LINE = '[reticle] The Chromium install did not complete.\n';
 /**
  * Decide which browser a launch will use, installing the pinned Chromium only as the last resort.
- * Order: bundled build on disk → installed Chrome → installed Edge → install, then bundled.
+ * Order: RETICLE_CHROMIUM_PATH → bundled build on disk → installed Chrome → installed Edge →
+ * install, then bundled.
+ *
+ * A named executable ends the search either way. It is set on a machine where the usual places are
+ * empty or unusable, so falling back from a typo to a download would only hide the typo.
  */
 export async function resolveChromiumTarget(deps) {
+    const configured = configuredChromiumPath(deps.env);
+    if (configured !== undefined) {
+        const problem = deps.pathProblem(configured);
+        return problem === undefined
+            ? { found: true, executablePath: configured }
+            : { found: false, unusableConfigured: { path: configured, problem } };
+    }
     let bundled;
     try {
         bundled = deps.executablePath();
@@ -168,6 +179,7 @@ function defaultDeps(chromium) {
     return {
         executablePath: () => chromium.executablePath(),
         exists: existsSync,
+        pathProblem: (path) => chromiumPathProblem(path, process.platform),
         platform: process.platform,
         env: process.env,
         install: installPinnedChromium,
@@ -181,15 +193,30 @@ function defaultDeps(chromium) {
  */
 export async function launchChromium(chromium, headless, deps = defaultDeps(chromium)) {
     const target = await resolveChromiumTarget(deps);
-    const channel = target.found ? target.channel : undefined;
-    return chromium.launch(chromiumLaunchOptions(headless, channel));
+    // Refused here rather than launched: Playwright's error for a missing executable is the one
+    // `chromiumLaunchHint` answers with the install command, which cannot fix a wrong path.
+    if (!target.found && target.unusableConfigured !== undefined) {
+        const { path, problem } = target.unusableConfigured;
+        throw new Error(configuredChromiumRefusal(path, problem));
+    }
+    return target.found
+        ? chromium.launch(chromiumLaunchOptions(headless, target.channel, target.executablePath))
+        : chromium.launch(chromiumLaunchOptions(headless));
 }
+const THIS_MACHINE = {
+    env: process.env,
+    exists: existsSync,
+    pathProblem: (path) => chromiumPathProblem(path, process.platform),
+};
 /**
  * The lease preflight's probe: "can a launch succeed?", which now includes the Chrome/Edge fallback
  * and the automatic install. Without this the preflight would refuse a lease on a machine the
  * launcher itself could serve. Falls back to the plain probe so a real refusal keeps its evidence.
  */
-export async function probeLaunchableChromium() {
+export async function probeLaunchableChromium(machine = THIS_MACHINE) {
+    const configured = configuredChromiumProbe(machine.env, machine.pathProblem);
+    if (configured !== undefined)
+        return configured;
     try {
         const { chromium } = await import('playwright');
         const target = await resolveChromiumTarget(defaultDeps(chromium));
@@ -205,14 +232,17 @@ export async function probeLaunchableChromium() {
  * `doctor`'s probe: the plain Chromium probe, plus the installed browser that stands in when the
  * bundled build is missing. Never installs — a diagnostic that downloads 150 MiB is not one.
  */
-export async function probeChromiumWithFallback() {
+export async function probeChromiumWithFallback(machine = THIS_MACHINE) {
+    const configured = configuredChromiumProbe(machine.env, machine.pathProblem);
+    if (configured !== undefined)
+        return configured;
     const probe = await probeChromium();
     if (probe.exists)
         return probe;
     const channel = findInstalledChannel({
-        exists: existsSync,
+        exists: machine.exists,
         platform: process.platform,
-        env: process.env,
+        env: machine.env,
     });
     return channel === undefined ? probe : { ...probe, fallback: CHANNEL_LABEL[channel] };
 }

package/dist/memory/cloud/cloud-config.d.ts

@@ -78,6 +78,18 @@ export declare function resolveProjectCloud(fs: FileSystemPort, reticleRoot: str
  * needs no exported key — see `withLinkedCredential`.
  */
 export declare const linkedCloudPort: (fs: FileSystemPort, reticleRoot: string, homeDir: string, env: NodeJS.ProcessEnv) => () => Promise<CloudConfig | null>;
+/**
+ * The API key a tab's own project resolves to, so a credential is only ever used for its own tabs.
+ * A tab whose project cannot be resolved has no key.
+ */
+export declare const sessionApiKeyPort: (fs: FileSystemPort, homeDir: string, env: NodeJS.ProcessEnv, rootOf: (id: string) => string) => (sessionId: string) => Promise<string | undefined>;
+/** The platform and key a tab's own project resolves to, or undefined when it is not linked. */
+export declare const sessionCloudPort: (fs: FileSystemPort, homeDir: string, env: NodeJS.ProcessEnv, rootOf: (id: string) => string) => (sessionId: string) => Promise<CloudConfig | undefined>;
+/**
+ * The credential for pushing RUNS, or null when this project opted out with `sync.runs: false`.
+ * `reticle verify` used the port above and pushed its run and progress regardless of the opt-out.
+ */
+export declare const linkedRunsCloudPort: (fs: FileSystemPort, reticleRoot: string, homeDir: string, env: NodeJS.ProcessEnv) => () => Promise<CloudConfig | null>;
 /**
  * The environment with this project's resolved credential written into it, for the readers that
  * take an env record (the panel's model config and harness switch). Handed `process.env` alone,

package/dist/memory/cloud/cloud-config.js

@@ -182,6 +182,21 @@ export async function resolveProjectCloud(fs, reticleRoot, homeDir, env) {
  * needs no exported key — see `withLinkedCredential`.
  */
 export const linkedCloudPort = (fs, reticleRoot, homeDir, env) => async () => (await resolveProjectCloud(fs, reticleRoot, homeDir, env)).config;
+/**
+ * The API key a tab's own project resolves to, so a credential is only ever used for its own tabs.
+ * A tab whose project cannot be resolved has no key.
+ */
+export const sessionApiKeyPort = (fs, homeDir, env, rootOf) => async (sessionId) => (await sessionCloudPort(fs, homeDir, env, rootOf)(sessionId))?.apiKey;
+/** The platform and key a tab's own project resolves to, or undefined when it is not linked. */
+export const sessionCloudPort = (fs, homeDir, env, rootOf) => async (sessionId) => (await resolveProjectCloud(fs, rootOf(sessionId), homeDir, env)).config ?? undefined;
+/**
+ * The credential for pushing RUNS, or null when this project opted out with `sync.runs: false`.
+ * `reticle verify` used the port above and pushed its run and progress regardless of the opt-out.
+ */
+export const linkedRunsCloudPort = (fs, reticleRoot, homeDir, env) => async () => {
+    const cloud = await resolveProjectCloud(fs, reticleRoot, homeDir, env);
+    return cloud.policy.runs ? cloud.config : null;
+};
 /**
  * The environment with this project's resolved credential written into it, for the readers that
  * take an env record (the panel's model config and harness switch). Handed `process.env` alone,

package/dist/memory/cloud/cloud-sync.d.ts

@@ -1,13 +1,3 @@
-/**
- * Optional cloud sync for saved flows. "Logged in" here means the two cloud env vars are set (written by
- * `reticle login` later; settable by hand today): the hosted URL and an API key from the Reticle
- * dashboard. When present, a freshly-saved flow is pushed to `POST /v1/flows` so the team's regression
- * suite lives in the cloud — surviving refactors and runnable in CI. When absent, sync is a no-op and
- * everything stays 100% local (the "no phone-home" default: nothing leaves the machine unless you opt in).
- *
- * Sync is best-effort: a network failure NEVER fails the local save. The flow is already on disk; the
- * cloud copy is an enhancement, so a push error is logged and swallowed.
- */
 import { z } from 'zod';
 import { type FlowFile, type ReticleVerificationRun, type RunRecord, type VerifyProgressEvent } from '@reticlehq/core';
 /**
@@ -40,6 +30,19 @@ export declare function cloudFetch(url: string, init: {
     headers: Record<string, string>;
     body?: string;
 }, timeoutMs?: number): Promise<Response>;
+/**
+ * One sync request, status and body, under the same timeout every cloud call has. The sync daemon
+ * and `reticle sync` each called a bare `fetch`: one accepted-but-silent connection left the daemon's
+ * cycle running forever, and the dashboard stopped updating with nothing logged.
+ */
+export declare function syncRequest(url: string, init: {
+    method: string;
+    headers: Record<string, string>;
+    body?: string;
+}, timeoutMs?: number): Promise<{
+    status: number;
+    text: string;
+}>;
 export declare const SyncOutcome: {
     readonly SYNCED: "synced";
     readonly SKIPPED: "skipped";
@@ -123,20 +126,20 @@ declare const ServerVerificationSchema: z.ZodObject<{
     }>, "many">;
     summary: z.ZodString;
 }, "strip", z.ZodTypeAny, {
-    verificationId: string;
-    verdict: string | null;
     flows: {
         status: string;
         name: string;
     }[];
-    summary: string;
-}, {
     verificationId: string;
     verdict: string | null;
+    summary: string;
+}, {
     flows: {
         status: string;
         name: string;
     }[];
+    verificationId: string;
+    verdict: string | null;
     summary: string;
 }>;
 export type ServerVerification = z.infer<typeof ServerVerificationSchema>;

package/dist/memory/cloud/cloud-sync.js

@@ -8,6 +8,7 @@
  * Sync is best-effort: a network failure NEVER fails the local save. The flow is already on disk; the
  * cloud copy is an enhancement, so a push error is logged and swallowed.
  */
+import { shareableRun } from '@reticlehq/core/artifacts';
 import { z } from 'zod';
 import { VERIFY_PROGRESS_MAX_EVENTS, platformCredentialFrom, } from '@reticlehq/core';
 /**
@@ -97,6 +98,15 @@ export async function cloudFetch(url, init, timeoutMs = CLOUD_FETCH_TIMEOUT_MS)
         throw err;
     }
 }
+/**
+ * One sync request, status and body, under the same timeout every cloud call has. The sync daemon
+ * and `reticle sync` each called a bare `fetch`: one accepted-but-silent connection left the daemon's
+ * cycle running forever, and the dashboard stopped updating with nothing logged.
+ */
+export async function syncRequest(url, init, timeoutMs = CLOUD_FETCH_TIMEOUT_MS) {
+    const res = await cloudFetch(url, init, timeoutMs);
+    return { status: res.status, text: await res.text() };
+}
 export const SyncOutcome = {
     SYNCED: 'synced',
     SKIPPED: 'skipped',
@@ -143,7 +153,8 @@ export async function syncRunToCloud(run, config, fetchImpl) {
                 'content-type': 'application/json',
                 authorization: `Bearer ${config.apiKey}`,
             },
-            body: JSON.stringify(run),
+            // The prompt context leaves the machine only when the project opted in.
+            body: JSON.stringify(shareableRun(run)),
         });
         return res.ok
             ? { outcome: SyncOutcome.SYNCED, status: res.status }

package/dist/memory/cloud/harness-config.d.ts

@@ -5,8 +5,33 @@ export interface HarnessConfigView {
     harnessEntitled: boolean;
     /** Whether the platform holds a key for `provider`. Entitlement is not readiness — see the offer. */
     providerReady: boolean;
+    credits?: {
+        used: number;
+        limit: number;
+    };
 }
 export interface ConfigSource {
     read(): HarnessConfigView | undefined;
 }
-export declare function harnessConfigSource(load: () => Promise<HarnessConfigView | undefined>, now?: () => number): ConfigSource;
+export interface MutableConfigSource extends ConfigSource {
+    applyWrite(enabled: boolean): void;
+    recheck(): void;
+    subscribe(listener: () => void): () => void;
+    /** Re-read in the background, telling listeners only when the answer changed. */
+    poll(): void;
+}
+export declare function harnessConfigSource(load: () => Promise<HarnessConfigView | undefined>, now?: () => number): MutableConfigSource;
+export type ConfigsByRoot = (root: string) => MutableConfigSource;
+/**
+ * One live config source per project root, created on first ask; `onChange` hears every update.
+ *
+ * The platform read arrives as `load`, so this cache never reaches for the harness feature that
+ * performs it: the daemon, which owns both, joins them. It sat inline in `start` and `startDaemon`.
+ */
+export declare function harnessConfigsByRoot(load: (root: string) => Promise<HarnessConfigView | undefined>, onChange?: (root: string) => void): ConfigsByRoot;
+/**
+ * The HUD's harness switch, written to the platform with this project's credential. Nothing is
+ * awaited: an accepted write updates the cache at once, and a refused or failed one re-reads the
+ * platform so the switch springs back to the truth rather than staying where the user left it.
+ */
+export declare function applyHarnessSwitch(configs: ConfigsByRoot, root: string, enabled: boolean, envFor: () => Promise<Record<string, string | undefined>>): void;