@reticlehq/server 2.4.0 → 2.6.0

package/dist/flows/annotate-tools.js

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+import { aliasParam } from '../tools/alias-args.js';
 import { AnnotationErrorCode, AnnotationSchema } from '@reticlehq/core';
 import { RECOVERY } from '../tools/error-recovery.js';
 /**
@@ -12,7 +13,7 @@ const UNKNOWN_KIND_RECOVERY = 'Annotations are structured, never free text. Pass
 import { ReticleTool } from '../tools/tool-names.js';
 import { asString } from '../tools/tools-helpers.js';
 import { compileAnnotation } from './annotate.js';
-const DEFAULT_RECORDING = 'default';
+import { resolveAnnotateTarget } from './annotate-target.js';
 /**
  * The reticle_annotate tool. A STRUCTURED annotation (the AnnotationSchema
  * discriminated union) is compiled into the live recording's per-step expect / flow dynamic[] /
@@ -48,6 +49,12 @@ export const ANNOTATE_TOOLS = [
         inputSchema: {
             // `flow` selects the recording; `name`/`signal`/`testid`/`dataMatches` are the annotation fields.
             flow: z.string().optional().describe("Named recording to annotate. Defaults to 'default'."),
+            // Every other flow tool says `flowName`, and reticle_flow_save's own description sends the
+            // agent here — so the spelling it arrives with is the one this tool did not accept.
+            flowName: z
+                .string()
+                .optional()
+                .describe('Alias for `flow` (the name every other flow tool uses).'),
             kind: z
                 .string()
                 .describe('Annotation kind: assert-signal | assert-visible | assert-state | mark-dynamic | success-state | intent.'),
@@ -114,7 +121,10 @@ export const ANNOTATE_TOOLS = [
             code: z.string().optional(),
         },
         handler: (deps, args) => {
-            const name = asString(args['flow']) ?? DEFAULT_RECORDING;
+            // The recording actually RUNNING when there is exactly one, not the literal name `default`.
+            // Reproduced on three apps: a named recording plus an unnamed annotate reported
+            // `annotate_no_step` while the steps sat in the recording the agent had started.
+            const name = resolveAnnotateTarget(asString(aliasParam(args, 'flow', ['flowName'])['flow']), deps.recordings.active());
             // Structured boundary: a free NL string / unknown kind fails the schema → UNKNOWN_KIND.
             const parsed = AnnotationSchema.safeParse(args);
             if (!parsed.success) {
@@ -134,8 +144,20 @@ export const ANNOTATE_TOOLS = [
                 });
             }
             const outcome = compileAnnotation(parsed.data, stepCount ?? 0);
-            if (!outcome.result.ok)
+            if (!outcome.result.ok) {
+                // Name what IS recording. `annotate_no_step` alone sent the agent off to record MORE steps —
+                // into the same empty recording — when the steps it already has are in another one.
+                const active = deps.recordings.active();
+                const elsewhere = active.filter((r) => r !== name && (deps.recordings.stepCount(r) ?? 0) > 0);
+                if (outcome.result.code === AnnotationErrorCode.NO_STEP_TO_ANNOTATE &&
+                    elsewhere.length > 0) {
+                    return Promise.resolve({
+                        ...outcome.result,
+                        recovery: `'${name}' has no steps yet, but ${elsewhere.map((r) => `'${r}'`).join(', ')} does. Pass \`flow\` to say which recording this belongs to, or drive an action first.`,
+                    });
+                }
                 return Promise.resolve(outcome.result);
+            }
             const patch = outcome.patch;
             if (patch !== undefined) {
                 if (patch.dynamicAdd !== undefined)

package/dist/flows/annotate.js

@@ -16,7 +16,7 @@ import { AnnotationErrorCode, AnnotationKind, AnnotationTarget, COMPILED_PREDICA
 export function compileAnnotation(a, stepCount) {
     switch (a.kind) {
         case AnnotationKind.ASSERT_SIGNAL: {
-            if (stepCount === 0)
+            if (0 === stepCount)
                 return noStep();
             const expect = { signal: a.name };
             if (a.dataMatches !== undefined)
@@ -24,12 +24,12 @@ export function compileAnnotation(a, stepCount) {
             return stepPatch(a, stepCount, expect);
         }
         case AnnotationKind.ASSERT_VISIBLE: {
-            if (stepCount === 0)
+            if (0 === stepCount)
                 return noStep();
             return stepPatch(a, stepCount, { element: { testid: a.testid } });
         }
         case AnnotationKind.ASSERT_STATE: {
-            if (stepCount === 0)
+            if (0 === stepCount)
                 return noStep();
             const state = { path: a.statePath };
             if (a.store !== undefined)
@@ -38,6 +38,11 @@ export function compileAnnotation(a, stepCount) {
                 state.equals = a.equals;
             return stepPatch(a, stepCount, { state });
         }
+        case AnnotationKind.ASSERT_NET: {
+            if (0 === stepCount)
+                return noStep();
+            return stepPatch(a, stepCount, { net: a.net });
+        }
         case AnnotationKind.MARK_DYNAMIC:
             return {
                 result: { ok: true, target: AnnotationTarget.FLOW, compiled: describeCompiled(a) },
@@ -109,6 +114,14 @@ export function describeCompiled(a) {
             return `${COMPILED_PREDICATE_PREFIX} assert ${a.testid} visible`;
         case AnnotationKind.ASSERT_STATE:
             return `${COMPILED_PREDICATE_PREFIX} assert state ${a.statePath}${a.equals !== undefined ? ` == ${JSON.stringify(a.equals)}` : ''}`;
+        case AnnotationKind.ASSERT_NET: {
+            // Say the COUNT out loud when there is one. "will assert POST /refund" and "will assert
+            // exactly 1x POST /refund" are different gates, and the confirmation is the only place the
+            // author sees which one they just attached.
+            const what = `${a.net.method ?? 'any'} ${a.net.urlContains ?? '(any url)'}`;
+            const times = a.net.count === undefined ? '' : ` exactly ${String(a.net.count)}x`;
+            return `${COMPILED_PREDICATE_PREFIX} assert${times} request ${what}`;
+        }
         case AnnotationKind.MARK_DYNAMIC:
             return `${COMPILED_PREDICATE_PREFIX} ignore ${a.testid} (dynamic)`;
         case AnnotationKind.SUCCESS_STATE:
@@ -124,7 +137,7 @@ export function describeCompiled(a) {
             }
             if (a.console !== undefined) {
                 const level = a.console.level ?? 'error';
-                return `${COMPILED_PREDICATE_PREFIX} succeed when ${a.console.absent === true ? `no console.${level}` : `console.${level}`}`;
+                return `${COMPILED_PREDICATE_PREFIX} succeed when ${true === a.console.absent ? `no console.${level}` : `console.${level}`}`;
             }
             return `${COMPILED_PREDICATE_PREFIX} succeed when ${a.testid ?? ''} visible`;
         case AnnotationKind.INTENT:

package/dist/flows/assertion-integrity.d.ts

@@ -12,7 +12,7 @@ export interface StepExpect {
     step: number;
     expect?: FlowExpect;
 }
-export interface DowngradeFinding {
+interface DowngradeFinding {
     step: number;
 }
 /**
@@ -21,3 +21,4 @@ export interface DowngradeFinding {
  * lives with the affected index.
  */
 export declare function detectDowngrades(before: readonly StepExpect[], after: readonly StepExpect[]): DowngradeFinding[];
+export {};

package/dist/flows/assertion-tiers-store.d.ts

@@ -1,74 +1,10 @@
-import { z } from 'zod';
 import type { FileSystemPort } from '../project/fs-port.js';
 import type { StepExpect } from './assertion-integrity.js';
-/**
- * The anti-reward-hacking baseline. Detecting an assertion DOWNGRADE requires knowing what the
- * flow asserted the last time it PASSED — otherwise a weakened flow simply looks like a flow that always
- * asserted little. Flows are git-checked and agent-editable, so we cannot trust the file itself as its own
- * history.
- *
- * So: on every passing replay we record that flow's per-step assertion shape here, and the gate diffs the
- * current file against it. Recorded only on PASS, deliberately — a failing run must never become the
- * baseline a later weakening is measured against.
- *
- * Loads never throw: a missing/corrupt ledger degrades to "no baseline", which means no downgrade can be
- * claimed. Failing OPEN is right here — accusing an agent of gaming the gate on the strength of an
- * unreadable file would be worse than missing one downgrade.
- */
-export declare const AssertionTiersFileSchema: z.ZodObject<{
-    version: z.ZodLiteral<1>;
-    flows: z.ZodRecord<z.ZodString, z.ZodObject<{
-        steps: z.ZodArray<z.ZodObject<{
-            step: z.ZodNumber;
-            expect: z.ZodOptional<z.ZodUnknown>;
-        }, "strip", z.ZodTypeAny, {
-            step: number;
-            expect?: unknown;
-        }, {
-            step: number;
-            expect?: unknown;
-        }>, "many">;
-        /** Source files this flow covered when it last passed — lets the gate scope DELETION findings to
-         * the files that actually changed, instead of flagging every intentionally-removed flow. */
-        sources: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
-    }, "strip", z.ZodTypeAny, {
-        steps: {
-            step: number;
-            expect?: unknown;
-        }[];
-        sources: string[];
-    }, {
-        steps: {
-            step: number;
-            expect?: unknown;
-        }[];
-        sources?: string[] | undefined;
-    }>>;
-}, "strip", z.ZodTypeAny, {
-    version: 1;
-    flows: Record<string, {
-        steps: {
-            step: number;
-            expect?: unknown;
-        }[];
-        sources: string[];
-    }>;
-}, {
-    version: 1;
-    flows: Record<string, {
-        steps: {
-            step: number;
-            expect?: unknown;
-        }[];
-        sources?: string[] | undefined;
-    }>;
-}>;
-export interface FlowBaseline {
+interface FlowBaseline {
     steps: StepExpect[];
     sources: string[];
 }
-export type FlowTiers = Record<string, FlowBaseline>;
-export declare const ASSERTION_TIERS_VERSION = 1;
+type FlowTiers = Record<string, FlowBaseline>;
 export declare class AssertionTiersStore {
     #private;
     constructor(fs: FileSystemPort, root: string);
@@ -77,3 +13,4 @@ export declare class AssertionTiersStore {
     /** Record one flow's assertion shape + covered sources after it PASSED. Never breaks a replay. */
     recordPassing(name: string, steps: readonly StepExpect[], sources?: readonly string[]): Promise<void>;
 }
+export {};

package/dist/flows/assertion-tiers-store.js

@@ -16,7 +16,7 @@ import { withFileLock } from '../project/file-lock.js';
  * claimed. Failing OPEN is right here — accusing an agent of gaming the gate on the strength of an
  * unreadable file would be worse than missing one downgrade.
  */
-export const AssertionTiersFileSchema = z.object({
+const AssertionTiersFileSchema = z.object({
     version: z.literal(1),
     flows: z.record(z.object({
         steps: z.array(z.object({ step: z.number(), expect: z.unknown().optional() })),
@@ -25,7 +25,7 @@ export const AssertionTiersFileSchema = z.object({
         sources: z.array(z.string()).default([]),
     })),
 });
-export const ASSERTION_TIERS_VERSION = 1;
+const ASSERTION_TIERS_VERSION = 1;
 export class AssertionTiersStore {
     #fs;
     #path;

package/dist/flows/attributed-failure.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Which failing flows can support a verdict ABOUT THE CHANGED FILES.
+ *
+ * `affectedSavedFlows` deliberately re-runs any flow whose covered sources it cannot determine —
+ * over-running beats silently skipping — and reports those names in `unknownProvenance`. The verdict
+ * then ignored that and answered NO whenever anything failed, producing the observed
+ *
+ *   verified: "no", because "1 of 1 covering flows failed
+ *                            (1 of them re-run only because Reticle cannot tell which sources they cover)"
+ *
+ * — a negative claim about `src/App.tsx` whose own explanation admits the evidence is not tied to it.
+ *
+ * This tool already refuses the mirror-image error: an uncovered change is UNKNOWN, never a green,
+ * because "nothing ran, so nothing was proved". A red nothing earned is the same mistake reversed.
+ */
+/** Failing flows minus the ones that only ran because their provenance is unknown. */
+export declare function attributedFailures(failingFlows: readonly string[], unknownProvenance: readonly string[]): string[];

package/dist/flows/attributed-failure.js

@@ -0,0 +1,20 @@
+/**
+ * Which failing flows can support a verdict ABOUT THE CHANGED FILES.
+ *
+ * `affectedSavedFlows` deliberately re-runs any flow whose covered sources it cannot determine —
+ * over-running beats silently skipping — and reports those names in `unknownProvenance`. The verdict
+ * then ignored that and answered NO whenever anything failed, producing the observed
+ *
+ *   verified: "no", because "1 of 1 covering flows failed
+ *                            (1 of them re-run only because Reticle cannot tell which sources they cover)"
+ *
+ * — a negative claim about `src/App.tsx` whose own explanation admits the evidence is not tied to it.
+ *
+ * This tool already refuses the mirror-image error: an uncovered change is UNKNOWN, never a green,
+ * because "nothing ran, so nothing was proved". A red nothing earned is the same mistake reversed.
+ */
+/** Failing flows minus the ones that only ran because their provenance is unknown. */
+export function attributedFailures(failingFlows, unknownProvenance) {
+    const unattributable = new Set(unknownProvenance);
+    return failingFlows.filter((flow) => !unattributable.has(flow));
+}

package/dist/flows/buddy-status.d.ts

@@ -6,7 +6,7 @@
  * nominal" needs no detail; a deviation needs its name, because a status line that says only "1 deviation"
  * forces the human to go digging, which is exactly the work the buddy exists to remove.
  */
-export interface BuddyStatusInput {
+interface BuddyStatusInput {
     /** Every saved flow. */
     total: number;
     /** Flows with a passing artifact. */
@@ -22,3 +22,4 @@ export interface BuddyStatusInput {
  * `✗ 2 deviations: checkout, billing · 39 nominal · 1 flaky quarantined`
  */
 export declare function formatBuddyStatus(input: BuddyStatusInput): string;
+export {};

package/dist/flows/buddy-status.js

@@ -16,13 +16,13 @@ const MAX_NAMED = 2;
 export function formatBuddyStatus(input) {
     const parts = [];
     const deviations = input.deviations.length;
-    if (deviations === 0) {
+    if (0 === deviations) {
         parts.push(`✓ ${String(input.passing)}/${String(input.total)} flows nominal`);
     }
     else {
         const named = input.deviations.slice(0, MAX_NAMED).join(', ');
         const rest = deviations - Math.min(MAX_NAMED, deviations);
-        parts.push(`✗ ${String(deviations)} deviation${deviations === 1 ? '' : 's'}: ${named}${rest > 0 ? ` +${String(rest)} more` : ''}`);
+        parts.push(`✗ ${String(deviations)} deviation${1 === deviations ? '' : 's'}: ${named}${rest > 0 ? ` +${String(rest)} more` : ''}`);
         parts.push(`${String(input.passing)} nominal`);
     }
     if (input.quarantined.length > 0) {

package/dist/flows/coverage.d.ts

@@ -4,12 +4,12 @@
  * (contract testids/signals/flows) actually touched by passing verification, so "everything" is honest
  * about what everything means. Pure set math; the deviation report + gate carry the number.
  */
-export interface DeclaredSurface {
+interface DeclaredSurface {
     testids: readonly string[];
     signals: readonly string[];
     flows: readonly string[];
 }
-export interface CoverageDimension {
+interface CoverageDimension {
     total: number;
     covered: number;
     /** Percent covered, rounded; 100 when nothing is declared (vacuously complete). */
@@ -25,3 +25,4 @@ export interface Coverage {
     overallPct: number;
 }
 export declare function computeCoverage(declared: DeclaredSurface, exercised: DeclaredSurface): Coverage;
+export {};

package/dist/flows/coverage.js

@@ -7,7 +7,7 @@
 function dimension(declared, exercised) {
     const uncovered = declared.filter((d) => !exercised.has(d));
     const covered = declared.length - uncovered.length;
-    const pct = declared.length === 0 ? 100 : Math.round((covered / declared.length) * 100);
+    const pct = 0 === declared.length ? 100 : Math.round((covered / declared.length) * 100);
     return { total: declared.length, covered, pct, uncovered };
 }
 export function computeCoverage(declared, exercised) {
@@ -16,6 +16,6 @@ export function computeCoverage(declared, exercised) {
     const flows = dimension(declared.flows, new Set(exercised.flows));
     const total = testids.total + signals.total + flows.total;
     const covered = testids.covered + signals.covered + flows.covered;
-    const overallPct = total === 0 ? 100 : Math.round((covered / total) * 100);
+    const overallPct = 0 === total ? 100 : Math.round((covered / total) * 100);
     return { testids, signals, flows, overallPct };
 }

package/dist/flows/decision.js

@@ -35,7 +35,7 @@ export function buildDecision(result, flow) {
         // Green — but is it green-for-the-right-reason? A flow that asserts no consequence can pass while
         // broken, so the honest next action is to add one.
         const grade = flow !== undefined ? classifyFlowAssertions(flow) : undefined;
-        const verifiesOutcome = grade?.hasConsequenceAssertion === true;
+        const verifiesOutcome = true === grade?.hasConsequenceAssertion;
         const intent = flow?.intent;
         return {
             verdict: 'pass',
@@ -103,7 +103,7 @@ function suiteVerdictOf(status) {
 function unverifiableReason(flow) {
     if (flow === undefined)
         return undefined;
-    if (flow.steps.length === 0) {
+    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.';
     }
     const c = classifyFlowAssertions(flow);
@@ -129,6 +129,14 @@ export function buildSuiteVerdict(runs) {
         }
         const decision = replay.decision ?? buildDecision(replay, flow);
         const row = { flow: replay.name, verdict: suiteVerdictOf(replay.status) };
+        // Zero step results PLUS an error is the signature of a replay that never STARTED — the flow file
+        // failed to load (before the session is even resolved), or its leased context never came up. A
+        // flow that ran and failed always carries its failing step; a flow with no steps replays OK and
+        // never reaches here. Both arrive as ReplayStatus.ERROR, so without this the suite cannot tell
+        // "the app broke" from "Reticle could not run this" — and the bug metric reported the second as
+        // the first, 8 times in one sweep.
+        if (0 === replay.steps.length && replay.error !== undefined)
+            row.couldNotRun = true;
         if (decision.whatChanged !== undefined)
             row.whatChanged = decision.whatChanged;
         if (decision.whereInSource !== undefined)
@@ -139,15 +147,22 @@ export function buildSuiteVerdict(runs) {
     const total = runs.length;
     const failed = failures.length;
     // A real failure outranks an unverifiable flow: a broken flow is worse news than an empty one.
-    const status = failed > 0 ? 'fail' : unverifiable.length > 0 ? 'unverifiable' : 'pass';
-    const cannotFail = unverifiable.length === 0
+    // An EMPTY suite is unverifiable for the same reason a flow that asserts nothing is — it is the
+    // purest green that cannot go red. It used to report `pass` with the summary "all 0 flows pass",
+    // which meant `reticle verify` went green on every project that had not written a flow yet, and on
+    // any project where the flows directory failed to resolve. Found by the adversarial MCP sweep; it
+    // was the only invented answer in 994 calls.
+    const status = failed > 0 ? 'fail' : unverifiable.length > 0 || 0 === total ? 'unverifiable' : 'pass';
+    const cannotFail = 0 === unverifiable.length
         ? ''
         : ` — ${String(unverifiable.length)} verified nothing (${unverifiable.map((u) => u.flow).join(', ')})`;
-    const summary = failed === 0
-        ? unverifiable.length === 0
-            ? `all ${total} flow${total === 1 ? '' : 's'} pass`
-            : `${String(passed)}/${String(total)} flows verified${cannotFail}`
-        : `${passed}/${total} flows pass — ${failed} need attention: ${failures.map((f) => f.flow).join(', ')}${cannotFail}`;
+    const summary = 0 === total
+        ? 'no flows to verify — nothing was checked. Record one with reticle_record { action: "start" }, then reticle_flow_save.'
+        : 0 === failed
+            ? 0 === unverifiable.length
+                ? `all ${total} flow${1 === total ? '' : 's'} pass`
+                : `${String(passed)}/${String(total)} flows verified${cannotFail}`
+            : `${passed}/${total} flows pass — ${failed} need attention: ${failures.map((f) => f.flow).join(', ')}${cannotFail}`;
     return {
         status,
         total,

package/dist/flows/empty-flow.d.ts

@@ -0,0 +1,6 @@
+interface EmptyFlowRefusal {
+    error: string;
+    recovery: string;
+}
+export declare function emptyFlowRefusal(stepCount: number, name: string): EmptyFlowRefusal | undefined;
+export {};

package/dist/flows/empty-flow.js

@@ -0,0 +1,24 @@
+/**
+ * Refuse to save a flow with no steps.
+ *
+ * It used to succeed: `flow_save` returned `{ stepCount: 0, grade: "assertion-free" }` with no error,
+ * `flow_list` then showed one more flow, and `flow_verify` called it `unverifiable` — forever. The
+ * agent believes it saved a regression test; what it wrote is a permanent suite entry that can never
+ * go green or red.
+ *
+ * Zero steps is not a degraded flow, it is the absence of one. And the refusal matters most on the
+ * stacks where the recorder is known to capture nothing, because there the empty save is the only
+ * signal the agent would ever get that something went wrong.
+ */
+import { ReticleTool } from '../tools/tool-names.js';
+export function emptyFlowRefusal(stepCount, name) {
+    if (stepCount > 0)
+        return undefined;
+    return {
+        error: `'${name}' has no steps, so there is nothing to save — a flow with no steps can never pass or fail, and would sit in the suite reporting "unverifiable" forever`,
+        recovery: `Nothing was captured between ${ReticleTool.RECORD} { action: "start" } and { action: "stop" }. ` +
+            `Drive at least one action with ${ReticleTool.ACT} or ${ReticleTool.ACT_AND_WAIT} while the ` +
+            `recording is open, then save. If you DID act and this still says zero, the recorder captured ` +
+            `nothing for this stack — report it with ${ReticleTool.FEEDBACK}.`,
+    };
+}

package/dist/flows/flake-store.d.ts

@@ -1,6 +1,5 @@
 import type { FileSystemPort } from '../project/fs-port.js';
 import { type FlakeLedger } from './flake.js';
-export declare const FLAKE_FILE_VERSION = 1;
 /**
  * Persists the per-flow flake ledger at `.reticle/flake.json`. Local single-project memory (stays OSS —
  * OSS-VS-SERVER). Loads never throw: missing/malformed/wrong-version degrades to an empty ledger, so

package/dist/flows/flake-store.js

@@ -1,7 +1,7 @@
 import { dirname } from 'node:path';
 import { reticleDirPaths } from '../project/reticle-dir.js';
 import { FlakeFileSchema, emptyRecord, isFlaky, recordOutcome } from './flake.js';
-export const FLAKE_FILE_VERSION = 1;
+const FLAKE_FILE_VERSION = 1;
 /**
  * Persists the per-flow flake ledger at `.reticle/flake.json`. Local single-project memory (stays OSS —
  * OSS-VS-SERVER). Loads never throw: missing/malformed/wrong-version degrades to an empty ledger, so

package/dist/flows/flake.d.ts

@@ -5,7 +5,7 @@ import { z } from 'zod';
  * (excluded from gate-blocking) and surfaced for repair, never silently blocking. The caller accrues an
  * outcome ONLY for unchanged-code replays (a fail after a code change is a legitimate red, not flake).
  */
-export declare const FlakeRecordSchema: z.ZodObject<{
+declare const FlakeRecordSchema: z.ZodObject<{
     runs: z.ZodNumber;
     fails: z.ZodNumber;
 }, "strip", z.ZodTypeAny, {
@@ -55,3 +55,4 @@ export declare function recordOutcome(record: FlakeRecord, passed: boolean): Fla
 export declare function isFlaky(record: FlakeRecord, minRuns?: number): boolean;
 /** Observed intermittent-failure rate (0 when too few runs to judge). */
 export declare function flakeRate(record: FlakeRecord): number;
+export {};

package/dist/flows/flake.js

@@ -5,7 +5,7 @@ import { z } from 'zod';
  * (excluded from gate-blocking) and surfaced for repair, never silently blocking. The caller accrues an
  * outcome ONLY for unchanged-code replays (a fail after a code change is a legitimate red, not flake).
  */
-export const FlakeRecordSchema = z.object({
+const FlakeRecordSchema = z.object({
     runs: z.number().int().min(0),
     fails: z.number().int().min(0),
 });
@@ -31,5 +31,5 @@ export function isFlaky(record, minRuns = DEFAULT_MIN_FLAKE_RUNS) {
 }
 /** Observed intermittent-failure rate (0 when too few runs to judge). */
 export function flakeRate(record) {
-    return record.runs === 0 ? 0 : record.fails / record.runs;
+    return 0 === record.runs ? 0 : record.fails / record.runs;
 }

package/dist/flows/flow-classify.js

@@ -33,6 +33,18 @@ const INTENT_WITHOUT_OUTCOME_WARNING = 'This flow declares a business intent but
 // Consequence vs presence-only classification lives in @reticlehq/core (one source for all graders).
 const expectIsConsequence = flowExpectHasConsequence;
 const expectIsWeak = flowExpectIsPresenceOnly;
+/**
+ * A step expect counts the same as a flow-level one, because replay now evaluates the same set.
+ *
+ * This was briefly narrowed to `state` only — correctly, at the time: replay checked element presence
+ * and state and nothing else, so grading a step signal/net as a consequence produced a flow that
+ * reported `grade: "asserted"` and could not go red. `assertStepExpect` closed that by compiling
+ * every step expect through the same `successToPredicate` the flow-level path uses, so the narrow
+ * rule is no longer true and would now UNDER-grade real assertions.
+ *
+ * The invariant to keep: this function and what replay enforces must move together. If one ever
+ * describes more than the other, the difference is a false green or a lost verification.
+ */
 /** Walk steps + act_sequence sub-steps so an expect on either level is counted. */
 function flattenSteps(steps) {
     const out = [];

package/dist/flows/flow-replay-run.js

@@ -64,7 +64,7 @@ async function recordReplayRun(deps, name, status, driftSteps, durationMs, proje
     });
     // Per-project cloud: push memory outcomes only when cloud is attached AND memory sync is enabled.
     const cloud = await resolveProjectCloud(deps.fs, deps.reticleRoot, homedir(), process.env);
-    if (cloud.config === null || !cloud.policy.memory)
+    if (null === cloud.config || !cloud.policy.memory)
         return; // not attached / memory disabled → local only
     const result = await syncRunRecordToCloud({ kind: RunKind.FLOW_REPLAY, name, status: runStatus, at: deps.now(), durationMs }, projectId, cloud.config, (url, init) => fetch(url, init));
     if (result.outcome !== SyncOutcome.SYNCED) {
@@ -82,7 +82,7 @@ async function recordReplayRun(deps, name, status, driftSteps, durationMs, proje
  */
 export function startPathMismatchHint(flow, session) {
     const startPath = flow.startPath;
-    if (startPath === undefined || startPath.length === 0)
+    if (startPath === undefined || 0 === startPath.length)
         return undefined;
     const routes = session.eventsSince(0).filter((e) => e.type === EventType.ROUTE_CHANGE);
     const last = routes.at(-1);
@@ -127,7 +127,7 @@ export async function replayNamedFlow(deps, args) {
     // Floor the success oracle at the start of THIS replay so a stale signal from a prior run
     // in the same session can't fake a pass.
     const replayFloor = session.elapsed();
-    const steps = await replayFlow(session, loaded.value, waitForPredicate, FLOW_SIGNAL_TIMEOUT_MS, args['confirmDangerous'] === true);
+    const steps = await replayFlow(session, loaded.value, waitForPredicate, FLOW_SIGNAL_TIMEOUT_MS, true === args['confirmDangerous']);
     // "green means intent satisfied": when every step ran clean, assert the flow's success
     // end-condition as a real consequence. A signal/net success that never fires FAILS the replay
     // even though all locators resolved — the regression a healed-but-wrong locator ships green.
@@ -188,7 +188,7 @@ export async function replayNamedFlow(deps, args) {
 async function computeReplayDeviation(deps, session, floor) {
     try {
         const segments = computeSegments(session.eventsSince(floor));
-        if (segments.length === 0)
+        if (0 === segments.length)
             return undefined;
         return await reportAndAccumulate(new EnvelopeStore(deps.fs, deps.reticleRoot), segments);
     }

package/dist/flows/flow-replay.d.ts

@@ -1,4 +1,4 @@
-import { AnchorKind, type CommandResult, type FlowAnchor, type FlowFile, type FlowStepResult, type ReticleEvent, type QueryEmptyHint } from '@reticlehq/core';
+import { AnchorKind, type CommandResult, type Drift, type FlowAnchor, type FlowFile, type FlowStepResult, type ReticleEvent, type QueryEmptyHint } from '@reticlehq/core';
 import type { EvalResult, Predicate } from '../events/predicate.js';
 /**
  * The session surface flow-replay needs: QUERY to re-resolve a testid anchor against the live
@@ -47,13 +47,9 @@ export type Sleep = (ms: number) => Promise<void>;
  * Such a drift is surfaced (with a nearest) but never auto-healed.
  */
 export declare function nearestIsAmbiguous(missing: string, present: string[]): boolean;
-/**
- * Re-resolve any QUERY against the live DOM, tolerating an in-flight render: QUERY, and while it
- * returns zero refs, sleep and retry up to ANCHOR_SETTLE_ATTEMPTS. Returns as soon as refs appear,
- * so a present anchor costs one query; a genuinely missing one costs the full (bounded) settle and
- * then drifts. The last result's near-miss hint is returned for the drift record.
- */
-export declare function resolveQuery(session: FlowReplaySession, queryArgs: Record<string, unknown>, sleep: Sleep): Promise<{
+/** Build the legible-drift record for a testid anchor that resolved to zero live elements. */
+export declare function testidDrift(value: string, hint: QueryEmptyHint | undefined): Drift;
+export declare function resolveQuery(session: FlowReplaySession, queryArgs: Record<string, unknown>, sleep: Sleep, now?: () => number): Promise<{
     refs: string[];
     hint?: QueryEmptyHint;
 }>;
@@ -61,6 +57,8 @@ export declare function resolveQuery(session: FlowReplaySession, queryArgs: Reco
 export declare function componentLabel(anchor: Extract<FlowAnchor, {
     kind: typeof AnchorKind.COMPONENT;
 }>): string;
+/** The value of a step's primary anchor, for labelling the result row. */
+export declare function anchorLabel(anchor: FlowAnchor): string;
 /** QUERY args for a component auto-anchor — source (precise) + component name (coarse) as given. */
 export declare function componentQueryArgs(anchor: Extract<FlowAnchor, {
     kind: typeof AnchorKind.COMPONENT;