@reticlehq/server 3.7.0 → 3.8.1

package/dist/judgement/runs/verification-sync.d.ts

@@ -1,4 +1,5 @@
 import { type FlowFile, type FlowReplayResult } from '@reticlehq/core';
+import { type VerificationRunInput } from './artifact/build-verification-run.js';
 import { type ProjectTarget } from '../../memory/project/session-root.js';
 import type { ToolDeps } from '../../surface/tools/tool-kit.js';
 /** A replay plus the wall-clock time it took — the shape the verify handler already collects. */
@@ -11,8 +12,8 @@ export interface TimedReplay {
 /** The MCP client name `reticle verify` (the command line, CI's path) connects to a daemon as. */
 export declare const CLI_CLIENT_NAME = "reticle-cli";
 /**
- * Persist the suite's run artifact and best-effort mirror it to the cloud. Never throws into the verify
- * tool — a disk or network failure is logged and swallowed so the verdict the agent asked for is
- * unaffected. Returns the runId (for logging/tests); undefined if nothing was produced (empty suite).
+ * Who ran the command line, and why. On a CI runner it is the pipeline; anywhere else it is the
+ * person who holds the key, so the cloud credits them and the run does not read as CI.
  */
+export declare function cliRunAuthor(env: NodeJS.ProcessEnv): Pick<VerificationRunInput, 'agent' | 'trigger'>;
 export declare function persistAndSyncVerificationRun(deps: ToolDeps, timed: TimedReplay[], target: ProjectTarget): Promise<string | undefined>;

package/dist/judgement/runs/verification-sync.js

@@ -10,29 +10,42 @@
  */
 import { callerClientName } from '../../hooks/coding-agents.js';
 import { currentDrivenBy } from '../../hooks/driven-by.js';
-import { RunAgentKind, RunFramework, RunProfile, RunTrigger, asRunId, } from '@reticlehq/core';
+import { RunAgentKind, RunFramework, RunProfile, RunTrigger, RunFlowStatus, Verified, asRunId, } from '@reticlehq/core';
 import { homedir } from 'node:os';
 import { buildVerificationRun, } from './artifact/build-verification-run.js';
 import { mapReplayToFlowResult } from './artifact/replay-mapping.js';
+import { runLedger } from './run-ledger.js';
 import { defaultRunId } from './default-run-id.js';
 import { currentShotRun } from './default-run-id.js';
 import { RunStore } from './artifact/run-store.js';
 import { cloudFetch, syncRunToCloud, SyncOutcome } from '../../memory/cloud/cloud-sync.js';
 import { resolveProjectCloud } from '../../memory/cloud/cloud-config.js';
 import { log } from '../../log.js';
+import { isCiEnv } from '../../telemetry/automation-hint.js';
 import { rootForTarget } from '../../memory/project/session-root.js';
 /** The author of record when no MCP peer introduced itself — a CLI run, or a client that skipped the handshake. */
 const RETICLE_MCP_AGENT_ID = 'reticle-mcp';
 /** The MCP client name `reticle verify` (the command line, CI's path) connects to a daemon as. */
 export const CLI_CLIENT_NAME = 'reticle-cli';
 /**
- * Who ran a suite, and why. The command line is the pipeline, whichever daemon replays for it:
- * through a running daemon its runs read as a coding agent, trigger manual, credited to whoever
- * minted the key, while the path that boots its own daemon said pipeline.
+ * Who ran the command line, and why. On a CI runner it is the pipeline; anywhere else it is the
+ * person who holds the key, so the cloud credits them and the run does not read as CI.
  */
+export function cliRunAuthor(env) {
+    return isCiEnv(env)
+        ? {
+            agent: { id: CLI_CLIENT_NAME, kind: RunAgentKind.OEM_PIPELINE },
+            trigger: { kind: RunTrigger.OEM },
+        }
+        : {
+            agent: { id: CLI_CLIENT_NAME, kind: RunAgentKind.HUMAN },
+            trigger: { kind: RunTrigger.MANUAL },
+        };
+}
+/** Who ran a suite, and why: the command line by `cliRunAuthor`, any other client as a coding agent. */
 function agentAndTrigger(client) {
     return CLI_CLIENT_NAME === client
-        ? { agent: { id: client, kind: RunAgentKind.OEM_PIPELINE }, trigger: { kind: RunTrigger.OEM } }
+        ? cliRunAuthor(process.env)
         : {
             agent: { id: client ?? RETICLE_MCP_AGENT_ID, kind: RunAgentKind.CODING_AGENT },
             trigger: { kind: RunTrigger.MANUAL },
@@ -73,6 +86,13 @@ projectName) {
  * tool — a disk or network failure is logged and swallowed so the verdict the agent asked for is
  * unaffected. Returns the runId (for logging/tests); undefined if nothing was produced (empty suite).
  */
+/** A replay's verdict, decided as its run decides it: a green that proved nothing is undecided. */
+function replayVerified(replay, durationMs) {
+    const status = mapReplayToFlowResult(replay, durationMs).status;
+    if (RunFlowStatus.PASS === status)
+        return Verified.YES;
+    return RunFlowStatus.FAIL === status ? Verified.NO : Verified.UNKNOWN;
+}
 export async function persistAndSyncVerificationRun(deps, timed, target) {
     const { projectId } = target;
     if (0 === timed.length)
@@ -81,6 +101,8 @@ export async function persistAndSyncVerificationRun(deps, timed, target) {
     // it was a second row ("Passed · Flow replay · Your agent") beside the plan run it belonged to.
     if (currentDrivenBy() !== undefined)
         return undefined;
+    for (const t of timed)
+        runLedger.replayed(t.replay.name, replayVerified(t.replay, t.durationMs));
     let run;
     // The project the suite ran for, not the directory the daemon was started in. Both halves below
     // take it: the artifact `reticle_run` reads back through `sessionRoot`, and the cloud link that

package/dist/language/flows/affected-tools.js

@@ -4,6 +4,7 @@ import { loadNamedFlows, resolveChangedFiles } from '../../command/cli/cli-flow-
 import { projectDirFor } from '../../memory/project/session-root.js';
 import { sessionRoot, sessionProjectId } from '../../memory/project/session-root.js';
 import { affectedSavedFlows } from './change/flow-sources.js';
+import { RECORD_A_FLOW } from './suite/coverage.js';
 /**
  * `reticle_affected` — which saved flows must re-verify for a set of changed files.
  *
@@ -67,7 +68,7 @@ export const AFFECTED_TOOLS = [
             changed.failed
                 ? `could not read the diff for \`${String(since)}\`, so NOTHING was compared and this result proves nothing: ${changed.reason ?? 'git failed'}`
                 : 0 === flows.length
-                    ? 'no saved flows exist yet, so nothing COULD be affected — record one with reticle_record then reticle_flow_save'
+                    ? `no saved flows exist yet, so nothing COULD be affected. ${RECORD_A_FLOW}`
                     : 0 === changedFiles.length
                         ? since === undefined && 0 === files.length
                             ? 'no files were given and no `since` ref was passed, so nothing was compared — pass the files you edited, or a git ref'

package/dist/language/flows/annotate-notes/annotate.js

@@ -1,4 +1,4 @@
-import { AnnotationErrorCode, AnnotationKind, AnnotationTarget, COMPILED_PREDICATE_PREFIX, flowExpectHasConsequence, flowExpectIsPresenceOnly, PredicateKind, } from '@reticlehq/core';
+import { AnnotationErrorCode, AnnotationKind, AnnotationTarget, COMPILED_PREDICATE_PREFIX, flowExpectHasConsequence, flowExpectIsPresenceOnly, PredicateKind, SettledChannel, } from '@reticlehq/core';
 /**
  * The PURE compiler at the heart of the annotation facet. A structured annotation +
  * the current captured-step count → an AnnotateOutcome (a result envelope + the patch to apply to
@@ -39,7 +39,12 @@ function netPredicate(net) {
     if (net.count === undefined)
         return clause;
     clause.count = net.count;
-    return { kind: PredicateKind.ALL_OF, predicates: [{ kind: PredicateKind.SETTLED }, clause] };
+    // The gate waits on the NETWORK: DOM churn from an animation held a request check open until it
+    // timed out, a flaky red on a loaded machine.
+    return {
+        kind: PredicateKind.ALL_OF,
+        predicates: [{ kind: PredicateKind.SETTLED, channel: SettledChannel.NETWORK }, clause],
+    };
 }
 export function compileAnnotation(a, stepCount) {
     switch (a.kind) {
@@ -112,7 +117,7 @@ export function compileAnnotation(a, stepCount) {
             if (a.console !== undefined) {
                 return flowSuccess(a, {
                     kind: PredicateKind.CONSOLE,
-                    ...(a.console.level === undefined ? {} : { level: a.console.level }),
+                    level: a.console.level ?? 'error',
                     ...(a.console.absent === undefined ? {} : { absent: a.console.absent }),
                 });
             }

package/dist/language/flows/annotate-tools.js

@@ -85,7 +85,7 @@ export const ANNOTATE_TOOLS = [
                 .optional()
                 .describe('Treat statePath as an INVARIANT that must still hold AFTER the action settles (a blast-radius "this unrelated path must not have moved" check), not a condition to wait for. Without it a wait-until-true read passes before an over-reaching side-effect lands.'),
             dataMatches: z
-                .record(z.unknown())
+                .record(z.string(), z.unknown())
                 .optional()
                 .describe('Key/value pairs the signal payload must match (assert-signal only).'),
             net: z

package/dist/language/flows/change/affected.d.ts

@@ -16,6 +16,14 @@ export interface AffectedResult {
     /** Of the affected, which were included only because their provenance is unknown (fail-safe). */
     unknownProvenance: string[];
 }
+/**
+ * The one rule for "this changed file is that flow source": paths are compared by normalized suffix,
+ * so a repo-root-relative change (`web/src/app.ts`) matches a package-relative stamp (`src/app.ts`)
+ * and an absolute stamp, and vice-versa. Everything that asks whether a flow touches a file uses it,
+ * so "affected" and "stale" can never disagree about which files belong to a flow.
+ */
+export declare function pathsMatch(a: string, b: string): boolean;
+export declare function sourceMatchesChange(source: string, changedFiles: readonly string[]): boolean;
 /**
  * Which flows are affected by a set of changed files. Deterministic; a flow with no sources manifest is
  * always affected (fail-safe). `changedFiles` and flow sources are matched by normalized path suffix so

package/dist/language/flows/change/affected.js

@@ -5,9 +5,26 @@
  * (recorded before source stamping, or un-stampable) is `unknown` — and unknown always means affected, never
  * silently skipped: the loop fails safe toward re-verifying.
  */
-/** Normalize a path for comparison — strip a leading./ and any file:line suffix. */
+/** Normalize a path for comparison — use `/` separators, strip a leading ./ and any file:line suffix. */
 function normalize(path) {
-    return path.replace(/^\.\//, '').replace(/:\d+(:\d+)?$/, '');
+    return path
+        .replace(/\\/g, '/')
+        .replace(/^\.\//, '')
+        .replace(/:\d+(:\d+)?$/, '');
+}
+/**
+ * The one rule for "this changed file is that flow source": paths are compared by normalized suffix,
+ * so a repo-root-relative change (`web/src/app.ts`) matches a package-relative stamp (`src/app.ts`)
+ * and an absolute stamp, and vice-versa. Everything that asks whether a flow touches a file uses it,
+ * so "affected" and "stale" can never disagree about which files belong to a flow.
+ */
+export function pathsMatch(a, b) {
+    const x = normalize(a);
+    const y = normalize(b);
+    return x === y || x.endsWith(`/${y}`) || y.endsWith(`/${x}`);
+}
+export function sourceMatchesChange(source, changedFiles) {
+    return changedFiles.some((c) => pathsMatch(c, source));
 }
 /**
  * Which flows are affected by a set of changed files. Deterministic; a flow with no sources manifest is
@@ -15,11 +32,7 @@ function normalize(path) {
  * a repo-relative change matches an absolute stamp and vice-versa.
  */
 export function affectedFlows(flows, changedFiles) {
-    const changed = changedFiles.map(normalize);
-    const matchesChange = (source) => {
-        const s = normalize(source);
-        return changed.some((c) => c === s || c.endsWith(`/${s}`) || s.endsWith(`/${c}`));
-    };
+    const matchesChange = (source) => sourceMatchesChange(source, changedFiles);
     const affected = [];
     const unknownProvenance = [];
     for (const flow of flows) {

package/dist/language/flows/decision.js

@@ -1,6 +1,8 @@
 import { AnchorKind, DriftReason, isConsequenceDrift, ReplayStatus, unreachedRoutes, SuiteIsolation, } from '@reticlehq/core';
+import { replayability, Replayable } from './flow-replayable.js';
 import { classifyFlowAssertions, FlowAssertionGrade } from './flow-classify.js';
 import { SUCCESS_STEP_TOOL } from './flow-success.js';
+import { RECORD_A_FLOW } from './suite/coverage.js';
 /**
  * Turn a replay result into the autonomy DECISION envelope — the judgement a human reviewer used to
  * make, expressed so a coding agent can act on it without one. Pure: no IO, no clock.
@@ -43,7 +45,7 @@ const INTENT_BROKEN_PREFIX = 'NO LONGER TRUE: ';
  * Never an intent derived from step names: a guessed goal reads as the product owner's words and an
  * agent will act on it. The same rule as the source pointer — absence stays honest.
  */
-const NO_INTENT_ON_PASS = 'no intent declared, so this proves the steps ran, not what they were for — declare one with reticle_intent.';
+const NO_INTENT_ON_PASS = 'no intent declared, so this proves the steps ran, not what they were for — declare one with reticle_run { tool: "reticle_intent" }.';
 const NO_INTENT_ON_FAIL = 'no intent declared, so this names the mechanism, not the stakes.';
 /** `<intent> — <mechanical>`, or the mechanical sentence plus the honest absence. */
 function withIntent(mechanical, statement) {
@@ -215,7 +217,7 @@ invoked = new Map()) {
     if (flow === undefined)
         return undefined;
     if (0 === flow.steps.length) {
-        return 'the flow has no steps — it replays green whatever the app does. Record it again, or add steps with reticle_annotate.';
+        return 'the flow has no steps — it replays green whatever the app does. Record it again, or add steps with reticle_run { tool: "reticle_annotate" }.';
     }
     const c = classifyFlowAssertions(flow, invoked);
     if (c.grade !== FlowAssertionGrade.ASSERTION_FREE)
@@ -339,7 +341,7 @@ isolation) {
         ? ''
         : ` — ${String(unreached.length)} known route(s) never opened: ${unreached.join(', ')}`;
     const summary = 0 === total
-        ? 'no flows to verify — nothing was checked. Record one with reticle_record { action: "start" }, then reticle_flow_save.'
+        ? `no flows to verify — nothing was checked. ${RECORD_A_FLOW}`
         : 0 === failed
             ? 0 === unverifiable.length
                 ? `all ${total} flow${1 === total ? '' : 's'} pass`
@@ -356,18 +358,31 @@ isolation) {
     const sharedState = SuiteIsolation.SHARED_SESSION === isolation && total > 1
         ? ' — these flows shared one session and ran in order, so a pass here may rest on state an earlier flow left behind; replay with `parallel` to give each its own context'
         : '';
+    const notAsSaved = runs.flatMap(({ replay, flow }) => {
+        if (flow === undefined)
+            return [];
+        const report = replayability(flow);
+        return Replayable.YES === report.status && report.writes === undefined
+            ? []
+            : [{ flow: replay.name, ...report }];
+    });
+    const notReplayable = notAsSaved.filter((row) => Replayable.YES !== row.status);
+    const asSaved = 0 === notReplayable.length
+        ? ''
+        : ` — ${String(notReplayable.length)} of ${String(total)} flows are not replayable as saved (${notReplayable.map((row) => row.flow).join(', ')}): a drift there is the flow, not the app`;
     return {
         status,
         total,
         passed,
         failed,
-        summary: summary + silentSteps + neverOpened + disagreed + sharedState,
+        summary: summary + silentSteps + neverOpened + disagreed + sharedState + asSaved,
         failures,
         ...(isolation === undefined ? {} : { isolation }),
         ...(unverifiable.length > 0 ? { unverifiable } : {}),
         ...(coverage === undefined ? {} : { coverage }),
         ...(0 === unreached.length ? {} : { unreached }),
         ...(0 === contradictions.length ? {} : { contradictions }),
+        ...(0 === notAsSaved.length ? {} : { replayability: notAsSaved }),
     };
 }
 /**

package/dist/language/flows/fields/flow-secret-field.d.ts

@@ -24,6 +24,11 @@ export declare function anchorFieldName(anchor: FlowAnchor): string | undefined;
 export declare const REDACTED_FILL = "<redacted: supply at replay>";
 /** The arg a saved redacted fill names its variable in. Dropped before the step reaches the page. */
 export declare const SECRET_NAME_ARG = "secret";
+/**
+ * The arg a RECORDED step carries when the SDK said its target holds a secret. Recorder-internal:
+ * it decides redaction at save and never reaches the saved flow.
+ */
+export declare const SECRET_FIELD_ARG = "secretField";
 /**
  * The environment variable that supplies one redacted field.
  *
@@ -45,6 +50,10 @@ export declare const callSecretsArg: z.ZodOptional<z.ZodRecord<z.ZodString, z.Zo
  * daemon's environment.
  */
 export declare function secretValue(envKey: string, env: Record<string, string | undefined>): string | undefined;
+/** The field's own saved variable name, or its original key for legacy and invalid metadata. */
+export declare function secretKeyForFill(args: Record<string, unknown> | undefined, field: string): string | undefined;
+/** Allocate recorded fills' names while preserving legacy placeholders and existing suffixes. */
+export declare function withDistinctSecretKeys(flow: FlowFile): FlowFile;
 /** One field a flow needs supplied, and the variable that supplies it. */
 export interface UnsuppliedSecret {
     field: string;

package/dist/language/flows/fields/flow-secret-field.js

@@ -32,6 +32,11 @@ export function anchorFieldName(anchor) {
 export const REDACTED_FILL = '<redacted: supply at replay>';
 /** The arg a saved redacted fill names its variable in. Dropped before the step reaches the page. */
 export const SECRET_NAME_ARG = 'secret';
+/**
+ * The arg a RECORDED step carries when the SDK said its target holds a secret. Recorder-internal:
+ * it decides redaction at save and never reaches the saved flow.
+ */
+export const SECRET_FIELD_ARG = 'secretField';
 /** The prefix every secret's variable carries. */
 const SECRET_ENV_PREFIX = 'RETICLE_SECRET_';
 /**
@@ -50,7 +55,7 @@ export const secretEnvKey = (field) => `${SECRET_ENV_PREFIX}${field.replace(/[^a
 /** The schema of that argument, shared by every tool that replays a flow. */
 export { CALL_SECRETS_ARG };
 export const callSecretsArg = z
-    .record(z.string())
+    .record(z.string(), z.string())
     .optional()
     .describe('Redacted fields\' values, this call only, never kept: { "auth-password": "…" }');
 /**
@@ -64,6 +69,63 @@ export function secretValue(envKey, env) {
     }
     return env[envKey];
 }
+const SECRET_OCCURRENCE = /^(?:[2-9]|[1-9][0-9]+)$/;
+/** The field's own saved variable name, or its original key for legacy and invalid metadata. */
+export function secretKeyForFill(args, field) {
+    if (args?.['value'] !== REDACTED_FILL)
+        return undefined;
+    const named = args[SECRET_NAME_ARG];
+    const base = secretEnvKey(field);
+    // A flow can supply this field's occurrence, never an unrelated environment variable.
+    return 'string' === typeof named &&
+        named.startsWith(`${base}_`) &&
+        SECRET_OCCURRENCE.test(named.slice(base.length + 1))
+        ? named
+        : base;
+}
+function* secretSteps(steps) {
+    for (const step of steps) {
+        yield step;
+        if (step.steps !== undefined)
+            yield* secretSteps(step.steps);
+    }
+}
+/** Allocate recorded fills' names while preserving legacy placeholders and existing suffixes. */
+export function withDistinctSecretKeys(flow) {
+    const reserved = new Set();
+    const used = new Set();
+    for (const step of secretSteps(flow.steps)) {
+        const field = anchorFieldName(step.anchor);
+        if (field === undefined)
+            continue;
+        const key = secretKeyForFill(step.args, field);
+        if (key === undefined)
+            continue;
+        reserved.add(key);
+        if (key !== secretEnvKey(field) || step.args?.[SECRET_NAME_ARG] === undefined)
+            used.add(key);
+    }
+    const assign = (step) => {
+        let out = step;
+        const field = anchorFieldName(step.anchor);
+        if (field !== undefined &&
+            step.args?.['value'] === REDACTED_FILL &&
+            step.args[SECRET_NAME_ARG] === secretEnvKey(field)) {
+            const base = secretEnvKey(field);
+            let key = base;
+            let occurrence = 2;
+            while (used.has(key) || (key !== base && reserved.has(key))) {
+                key = `${base}_${occurrence}`;
+                occurrence += 1;
+            }
+            used.add(key);
+            if (key !== base)
+                out = { ...step, args: { ...step.args, [SECRET_NAME_ARG]: key } };
+        }
+        return step.steps === undefined ? out : { ...out, steps: step.steps.map(assign) };
+    };
+    return { ...flow, steps: flow.steps.map(assign) };
+}
 /**
  * Every credential this flow will replay as the literal placeholder.
  *
@@ -79,13 +141,13 @@ export function secretValue(envKey, env) {
 export function unsuppliedSecrets(flow, env) {
     const out = [];
     const seen = new Set();
-    for (const step of flow.steps ?? []) {
-        if (REDACTED_FILL !== step.args?.['value'])
-            continue;
+    for (const step of secretSteps(flow.steps ?? [])) {
         const field = anchorFieldName(step.anchor);
         if (field === undefined)
             continue;
-        const envKey = secretEnvKey(field);
+        const envKey = secretKeyForFill(step.args, field);
+        if (envKey === undefined)
+            continue;
         const supplied = secretValue(envKey, env);
         if (supplied !== undefined && supplied.length > 0)
             continue;

package/dist/language/flows/flow-anchor.d.ts

@@ -101,6 +101,11 @@ export declare function reresolved(anchor: FlowAnchor, refs: readonly string[]):
  * consequence did not hold.
  */
 export declare function expectElementDrift(value: string, hint: QueryEmptyHint | undefined): Drift;
+/** One look, no settling: for an anchor that may legitimately not be on the page yet. */
+export declare function queryOnce(session: FlowReplaySession, queryArgs: Record<string, unknown>): Promise<{
+    refs: string[];
+    hint?: QueryEmptyHint;
+}>;
 export declare function resolveQuery(session: FlowReplaySession, queryArgs: Record<string, unknown>, sleep: Sleep, now?: () => number): Promise<{
     refs: string[];
     hint?: QueryEmptyHint;

package/dist/language/flows/flow-anchor.js

@@ -309,6 +309,10 @@ async function settleTick(session, sleep) {
         unsubscribe?.();
     }
 }
+/** One look, no settling: for an anchor that may legitimately not be on the page yet. */
+export async function queryOnce(session, queryArgs) {
+    return readQuery(await session.command(ReticleCommand.QUERY, queryArgs));
+}
 export async function resolveQuery(session, queryArgs, sleep, now = Date.now) {
     let last = readQuery(await session.command(ReticleCommand.QUERY, queryArgs));
     const deadline = now() + ANCHOR_SETTLE_BUDGET_MS;

package/dist/language/flows/flow-cross-step.d.ts

@@ -1,4 +1,4 @@
-import type { Contradiction, FlowStepResult } from '@reticlehq/core';
+import type { Contradiction, FlowStep, FlowStepResult, Predicate } from '@reticlehq/core';
 /** Cross-step findings belong to no single step; -1 is the address the suite verdict already uses. */
 export declare const CROSS_STEP_INDEX = -1;
 /**
@@ -13,3 +13,9 @@ export declare const CROSS_STEP_INDEX = -1;
  * Exported for its own test: the subtraction is the whole rule, and it is pure.
  */
 export declare function crossStepOnly(whole: readonly Contradiction[], steps: readonly FlowStepResult[]): Contradiction[];
+/**
+ * Every consequence the flow declared, sub-steps included. The whole-span pass judges the same
+ * window the steps did, so a failure a step expected is expected here too. Without it, the per-step
+ * pass dropped the declared failure and this pass reported it again as a cross-step finding.
+ */
+export declare function declaredIn(steps: readonly FlowStep[]): Predicate[];

package/dist/language/flows/flow-cross-step.js

@@ -1,3 +1,4 @@
+import { flattenSteps } from './flow-classify.js';
 /** A contradiction's identity for de-duplication: the rule that fired, and the evidence it fired on. */
 function contradictionId(found) {
     return `${found.kind}|${found.detail}`;
@@ -19,3 +20,11 @@ export function crossStepOnly(whole, steps) {
     const seen = new Set(steps.flatMap((step) => (step.contradictions ?? []).map(contradictionId)));
     return whole.filter((found) => !seen.has(contradictionId(found)));
 }
+/**
+ * Every consequence the flow declared, sub-steps included. The whole-span pass judges the same
+ * window the steps did, so a failure a step expected is expected here too. Without it, the per-step
+ * pass dropped the declared failure and this pass reported it again as a cross-step finding.
+ */
+export function declaredIn(steps) {
+    return flattenSteps(steps).flatMap((step) => (step.expect === undefined ? [] : [step.expect]));
+}

package/dist/language/flows/flow-expect-grammar.js

@@ -11,15 +11,12 @@
  * re-save writes the canonical shape. A kind a saved flow cannot enforce is refused, not stripped
  * to an empty expect that would grade asserted-while-unchecked.
  */
-import { FlowExpectSchema, FlowPredicateSchema, READABLE_FLOW_VERSIONS, FlowErrorCode, FlowFileSchema, } from '@reticlehq/core';
+import { FlowExpectSchema, FlowPredicateSchema, READABLE_FLOW_VERSIONS, FlowErrorCode, FlowFileSchema, isPlainRecord as isRecord, } from '@reticlehq/core';
 export const FlowParseNote = {
     NOT_JSON: 'flow file is not valid JSON — fix the syntax or regenerate it with reticle_flow_save',
     MALFORMED: 'flow file is malformed — fix or regenerate it with reticle_flow_save',
     UNSUPPORTED_SHAPE: 'valid JSON, unsupported expect shape',
 };
-function isRecord(value) {
-    return 'object' === typeof value && null !== value && !Array.isArray(value);
-}
 /**
  * Flatten `signal: { name, count }` into the on-disk fields. Other channels already match FlowExpect.
  * Leave a signal object with no name alone so the schema failure can name the key.
@@ -127,15 +124,22 @@ export function coerceFlowFileExpects(raw) {
  * The issues a union rejection buries.
  *
  * `expect` accepts a predicate OR a v1 expect, and zod reports a union failure as one
- * `invalid_union` issue whose branch errors live inside `unionErrors`. The one that matters is the
+ * `invalid_union` issue whose branch errors live inside `errors`, with paths relative to the union. The one that matters is the
  * v1 branch's `unrecognized_keys` — the misspelled field. Without this the file was still correctly
  * REFUSED and the message said only "malformed", which sends the author back to hunt a
  * one-character typo we had already identified.
  */
 function flatten(issues) {
-    return issues.flatMap((issue) => 'invalid_union' === issue.code
-        ? [issue, ...flatten(issue.unionErrors.flatMap((e) => e.issues))]
-        : [issue]);
+    return issues.flatMap((issue) => {
+        if ('invalid_union' !== issue.code) {
+            return [issue];
+        }
+        const branches = issue.errors.flat().map((inner) => ({
+            ...inner,
+            path: [...issue.path, ...inner.path],
+        }));
+        return [issue, ...flatten(branches)];
+    });
 }
 export function describeFlowZodFailure(error) {
     const all = flatten(error.issues);
@@ -148,12 +152,13 @@ export function describeFlowZodFailure(error) {
      * top-level `invalid_union` says only "malformed", which is true and useless.
      */
     const named = (one) => {
-        // NOT the discriminator complaint. `invalid_union_discriminator` on `expect.kind` is the
+        // NOT the discriminator complaint. An `invalid_union` with a `discriminator` on `expect.kind` is the
         // PREDICATE branch objecting that a v1 expect has no `kind` — which is true of every v1 expect
         // ever written and tells the author nothing. The useful issue is the one from the branch they
         // were actually writing.
-        if ('invalid_union_discriminator' === one.code)
+        if ('invalid_union' === one.code && undefined !== one.discriminator) {
             return false;
+        }
         return (('steps' === one.path[0] && 'expect' === one.path[2] && one.path.length > 3) ||
             ('success' === one.path[0] && one.path.length > 1));
     };

package/dist/language/flows/flow-intent.js

@@ -12,7 +12,9 @@ import { classifyFlowAssertions } from './flow-classify.js';
  *
  * Nothing here derives an intent from step names. A flow that declares none reports that it declares
  * none — a guessed intent puts words in the product owner's mouth and an agent will act on them,
- * which is strictly worse than the honest absence.
+ * which is strictly worse than the honest absence. An auto-saved drive does carry a sentence built
+ * from its expects (`intentDerived`), so a reader can tell what it checks; it never enters the
+ * ledger, and the flow still reports that it declares no intent.
  */
 /** Namespaced so a flow-declared intent never collides with one an agent declared by hand. */
 const FLOW_INTENT_ID_PREFIX = 'flow:';
@@ -35,6 +37,9 @@ export function flowReplayVerdictId(flowName, at) {
 function intentIdOf(flow) {
     if (flow.intentId !== undefined)
         return flow.intentId;
+    // A sentence built from the steps names the flow; it is not a goal, so it declares nothing.
+    if (true === flow.intentDerived)
+        return undefined;
     // TRIMMED, not merely defined. `intent: "   "` satisfied `!== undefined` and silenced the gap, so
     // a flow whose stated goal is whitespace looked identical on disk to one somebody thought about.
     //

package/dist/language/flows/flow-journey.d.ts

@@ -58,3 +58,11 @@ export declare function establishedState(flow: FlowFile): readonly Predicate[];
  * tab on `?tab=summary` as already at `?tab=wrap`.
  */
 export declare function samePath(observed: string, expected: string): boolean;
+/**
+ * How long replay waits for the start page: the first step's budget when that is longer.
+ *
+ * A dev server that compiles a route on its first visit can take longer than the floor, and the
+ * flow then ended as unverifiable with nothing run. A step the caller let wait 15 s for its
+ * consequence can also wait 15 s for its page.
+ */
+export declare function startPathBudgetMs(flow: FlowFile): number;

package/dist/language/flows/flow-journey.js

@@ -137,3 +137,16 @@ export function samePath(observed, expected) {
     const comparable = expected.includes('?') ? observed : withoutQuery(observed);
     return trimmed(comparable) === trimmed(expected);
 }
+/** The least time replay waits for the SDK to reconnect on the start page. */
+const START_PATH_ARRIVAL_TIMEOUT_MS = 5_000;
+/**
+ * How long replay waits for the start page: the first step's budget when that is longer.
+ *
+ * A dev server that compiles a route on its first visit can take longer than the floor, and the
+ * flow then ended as unverifiable with nothing run. A step the caller let wait 15 s for its
+ * consequence can also wait 15 s for its page.
+ */
+export function startPathBudgetMs(flow) {
+    const first = flow.steps[0]?.timeoutMs ?? flow.signalTimeoutMs ?? 0;
+    return Math.max(START_PATH_ARRIVAL_TIMEOUT_MS, first);
+}

package/dist/language/flows/flow-lease.d.ts

@@ -0,0 +1,27 @@
+/**
+ * What a flow needs from the live session to run in a leased context, and what it reports when the
+ * lease never came up.
+ */
+import { type FlowReplayResult } from '@reticlehq/core';
+import type { ToolDeps } from '../../surface/tools/tool-kit.js';
+/**
+ * The URL a leased context should open: the app's ORIGIN, not the live tab's current location.
+ *
+ * The live tab drifts — every replay navigates it — so using its full URL made each lease start wherever
+ * the previous run happened to finish (observed: leases opening /deployments and failing to find the
+ * login control that only exists at the root). A lease must be a FRESH visit to a deterministic entry
+ * point; flows that need another page carry their own startPath.
+ */
+export declare function leasableAppUrl(deps: ToolDeps, sessionId: string | undefined): string | undefined;
+/**
+ * The live session's own URL — what the fixture port must be looked up by.
+ *
+ * NOT `leasableAppUrl`. That returns an ORIGIN, and the input provider finds a page by comparing
+ * full URLs, so an origin matched no page: `suiteFixtureSeed` answered `undefined` on every run and
+ * every leased flow booted cold while the code read as if it were seeded. Silent, because every
+ * refusal on that path is deliberately silent — a fixture is an optimisation, and a suite must not
+ * die when one is unavailable.
+ */
+export declare function sessionUrlOf(deps: ToolDeps, sessionId: string | undefined): string | undefined;
+/** A flow whose leased context never came up is a suite ERROR, never a silent pass. */
+export declare function leaseFailureReplay(name: string, error: string | undefined): FlowReplayResult;