@reticlehq/server 2.2.1 → 2.4.0

package/dist/flows/flake-store.js

@@ -56,4 +56,3 @@ export class FlakeStore {
             .map(([flow]) => flow);
     }
 }
-//# sourceMappingURL=flake-store.js.map

package/dist/flows/flake.d.ts

@@ -55,4 +55,3 @@ 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;
-//# sourceMappingURL=flake.d.ts.map

package/dist/flows/flake.js

@@ -33,4 +33,3 @@ export function isFlaky(record, minRuns = DEFAULT_MIN_FLAKE_RUNS) {
 export function flakeRate(record) {
     return record.runs === 0 ? 0 : record.fails / record.runs;
 }
-//# sourceMappingURL=flake.js.map

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

@@ -49,4 +49,3 @@ export interface FlowAssertionClassification {
     warning?: string;
 }
 export declare function classifyFlowAssertions(flow: FlowFile): FlowAssertionClassification;
-//# sourceMappingURL=flow-classify.d.ts.map

package/dist/flows/flow-classify.js

@@ -88,4 +88,3 @@ export function classifyFlowAssertions(flow) {
         ...(warning !== undefined ? { warning } : {}),
     };
 }
-//# sourceMappingURL=flow-classify.js.map

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

@@ -30,4 +30,3 @@ export declare function replayNamedFlow(deps: ToolDeps, args: Record<string, unk
  * documented to work headless), so a missing/unknown session degrades to the global/legacy store.
  */
 export declare function sessionProjectId(deps: ToolDeps, sessionId: string | undefined): string | undefined;
-//# sourceMappingURL=flow-replay-run.d.ts.map

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

@@ -30,11 +30,11 @@ export function flowErrorMessage(code) {
         case FlowErrorCode.INVALID_NAME:
             return 'invalid flow name — use a single safe segment (letters/digits/-/_), no path separators';
         case FlowErrorCode.NOT_FOUND:
-            return 'no such flow on disk — run reticle_flow_list to see saved flows';
+            return 'no such flow on disk — run reticle_flow{action:"list"} to see saved flows';
         case FlowErrorCode.PARSE_FAILED:
             return 'flow file is malformed — fix or regenerate it with reticle_flow_save';
         case FlowErrorCode.NO_RECORDING:
-            return 'no compiled recording by that name — record one (reticle_record_start/stop) first';
+            return 'no compiled recording by that name — record one (reticle_record{action:"start"|"stop"}) first';
     }
 }
 /** Map the wire ReplayStatus onto the persisted RunStatus (ok→pass). */
@@ -216,4 +216,3 @@ export function sessionProjectId(deps, sessionId) {
         return undefined;
     }
 }
-//# sourceMappingURL=flow-replay-run.js.map

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

@@ -1,4 +1,4 @@
-import { type CommandResult, type FlowFile, type FlowStepResult, type ReticleEvent } from '@reticlehq/core';
+import { AnchorKind, type CommandResult, 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
@@ -40,13 +40,31 @@ export declare function editDistance(a: string, b: string): number;
  */
 export declare function nearestTestid(missing: string, present: string[]): string | null;
 /** Injected sleeper so tests drive replay with a no-op clock; production waits on a real timer. */
-type Sleep = (ms: number) => Promise<void>;
+export type Sleep = (ms: number) => Promise<void>;
 /**
  * True when ≥2 present testids tie at the minimum edit distance to the missing one — `nearest` is
  * then an arbitrary lexical-tiebreak pick, so auto-healing would be a coin-flip between candidates.
  * 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<{
+    refs: string[];
+    hint?: QueryEmptyHint;
+}>;
+/** A compact, legible label for a component auto-anchor (component@file:line, or its best part). */
+export declare function componentLabel(anchor: Extract<FlowAnchor, {
+    kind: typeof AnchorKind.COMPONENT;
+}>): 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;
+}>): Record<string, unknown>;
 /**
  * Replay a loaded flow by RE-RESOLVING every step's semantic anchor against the live DOM — never
  * a stale ref. A testid anchor is re-found by reticle_query; a signal anchor waits on a predicate.
@@ -54,5 +72,3 @@ export declare function nearestIsAmbiguous(missing: string, present: string[]):
  * results. This is the "whose fault is it" contract, not a blind "command failed".
  */
 export declare function replayFlow(session: FlowReplaySession, flow: FlowFile, waitForSignal: WaitForSignal, signalTimeoutMs: number, confirmDangerous?: boolean, sleep?: Sleep): Promise<FlowStepResult[]>;
-export {};
-//# sourceMappingURL=flow-replay.d.ts.map

package/dist/flows/flow-replay.js

@@ -1,6 +1,7 @@
 import { AnchorKind, DriftReason, EventType, ReticleCommand, QueryBy, } from '@reticlehq/core';
 import { asRecord, asString } from '../tools/tools-helpers.js';
 import { replayActionArgs, ambiguousTestidNote, queryRefs } from './replay.js';
+import { runRoleStep, runComponentStep } from './flow-step-runners.js';
 import { ReticleTool } from '../tools/tool-names.js';
 /**
  * A single ASCII-ish edit distance (case-insensitive). Small inputs (testids), so O(n*m) is fine.
@@ -124,7 +125,7 @@ function testidDrift(value, hint) {
  * 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.
  */
-async function resolveQuery(session, queryArgs, sleep) {
+export async function resolveQuery(session, queryArgs, sleep) {
     let last = readQuery(await session.command(ReticleCommand.QUERY, queryArgs));
     for (let attempt = 1; last.refs.length === 0 && attempt < ANCHOR_SETTLE_ATTEMPTS; attempt += 1) {
         await sleep(ANCHOR_SETTLE_DELAY_MS);
@@ -196,7 +197,7 @@ function summarizeConsequence(events) {
     return parts.length > 0 ? parts.join('; ') : undefined;
 }
 /** A compact, legible label for a component auto-anchor (component@file:line, or its best part). */
-function componentLabel(anchor) {
+export function componentLabel(anchor) {
     if (anchor.source !== undefined) {
         const base = anchor.source.file.split('/').pop() ?? anchor.source.file;
         const loc = `${base}:${anchor.source.line}`;
@@ -215,7 +216,7 @@ function anchorLabel(anchor) {
     return anchor.name ?? anchor.role;
 }
 /** QUERY args for a component auto-anchor — source (precise) + component name (coarse) as given. */
-function componentQueryArgs(anchor) {
+export function componentQueryArgs(anchor) {
     const args = { by: QueryBy.COMPONENT };
     if (anchor.component !== undefined)
         args['component'] = anchor.component;
@@ -223,45 +224,6 @@ function componentQueryArgs(anchor) {
         args['source'] = anchor.source;
     return args;
 }
-/** Run one component-anchored step: re-resolve via QUERY by:'component', ACT on the live ref, else drift. */
-async function runComponentStep(session, step, index, anchor, confirmDangerous, sleep) {
-    const label = componentLabel(anchor);
-    const { refs } = await resolveQuery(session, componentQueryArgs(anchor), sleep);
-    if (refs.length === 0) {
-        return {
-            step: index,
-            tool: step.tool,
-            anchor: label,
-            ok: false,
-            drift: {
-                reasonKind: DriftReason.COMPONENT_NOT_FOUND,
-                reason: `component anchor "${label}" not found`,
-                anchor: label,
-                nearest: null,
-            },
-        };
-    }
-    const ref = refs[0] ?? '';
-    // Attribute the step's effects to the step. Without this window they arrive with no actionId and are
-    // learned as ambient churn on the very regions the flow exercises.
-    session.beginAction?.(ReticleTool.FLOW_REPLAY, { ref, action: step.action ?? '' });
-    let act;
-    try {
-        act = await session.command(ReticleCommand.ACT, {
-            ref,
-            action: step.action ?? '',
-            args: replayActionArgs(step.args, confirmDangerous),
-        });
-    }
-    finally {
-        // Close on every exit so a throwing step cannot leak the window onto the next step's events.
-        session.finishAction?.();
-    }
-    const result = { step: index, tool: step.tool, anchor: label, ok: act.ok };
-    if (!act.ok)
-        result.error = act.error ?? 'command failed';
-    return result;
-}
 /** Run one testid-anchored step: re-resolve via QUERY, then ACT on the live ref, else drift. */
 async function runTestidStep(session, step, index, value, dynamic, confirmDangerous, sleep) {
     const { refs, hint } = await resolveTestid(session, value, sleep);
@@ -393,6 +355,11 @@ export async function replayFlow(session, flow, waitForSignal, signalTimeoutMs,
         else if (step.anchor.kind === AnchorKind.COMPONENT) {
             result = await runComponentStep(session, step, index, step.anchor, confirmDangerous, sleep);
         }
+        else if (step.anchor.kind === AnchorKind.ROLE && step.anchor.name !== undefined) {
+            // A NAMED role anchor addresses one element. The nameless one is the degraded placeholder and
+            // keeps its old path, where it fails legibly rather than querying a role as if it were a testid.
+            result = await runRoleStep(session, step, index, step.anchor, confirmDangerous, sleep);
+        }
         else {
             result = await runTestidStep(session, step, index, label, dynamic, confirmDangerous, sleep);
         }
@@ -422,4 +389,3 @@ export async function replayFlow(session, flow, waitForSignal, signalTimeoutMs,
     }
     return results;
 }
-//# sourceMappingURL=flow-replay.js.map

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

@@ -20,4 +20,3 @@ interface FlowReportInput {
 }
 export declare function buildFlowReport(input: FlowReportInput): string;
 export {};
-//# sourceMappingURL=flow-report.d.ts.map

package/dist/flows/flow-report.js

@@ -104,4 +104,3 @@ export function buildFlowReport(input) {
     out.push('');
     return out.join('\n');
 }
-//# sourceMappingURL=flow-report.js.map

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

@@ -22,4 +22,3 @@ export declare function flowInProjectScope(flowProjectId: string | undefined, se
  * flows starting from a non-testid anchor get a chip with no `start` (shown on every page).
  */
 export declare function buildFlowChips(flows: readonly FlowFile[], sessionProjectId: string | undefined): FlowChip[];
-//# sourceMappingURL=flow-scope.d.ts.map

package/dist/flows/flow-scope.js

@@ -31,4 +31,3 @@ export function buildFlowChips(flows, sessionProjectId) {
     }
     return chips;
 }
-//# sourceMappingURL=flow-scope.js.map

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

@@ -17,4 +17,3 @@ export interface NamedFlow {
 export declare function toFlowSources(flows: readonly NamedFlow[]): FlowSources[];
 /** Which saved flows a set of changed files affects — the derivation + index in one call. */
 export declare function affectedSavedFlows(flows: readonly NamedFlow[], changedFiles: readonly string[]): AffectedResult;
-//# sourceMappingURL=flow-sources.d.ts.map

package/dist/flows/flow-sources.js

@@ -30,4 +30,3 @@ export function toFlowSources(flows) {
 export function affectedSavedFlows(flows, changedFiles) {
     return affectedFlows(toFlowSources(flows), changedFiles);
 }
-//# sourceMappingURL=flow-sources.js.map

package/dist/flows/flow-step-runners.d.ts

@@ -0,0 +1,23 @@
+/**
+ * How one anchored step is turned into a live action.
+ *
+ * Split out of flow-replay.ts when adding the role+name runner pushed that file past the size cap.
+ * These three share one shape — resolve an anchor to a ref, then dispatch — and the sharing is the
+ * point: the action window must open and close identically no matter which anchor found the element,
+ * or a step's events land in the wrong window depending on how it was addressed.
+ */
+import { AnchorKind, type FlowAnchor, type FlowStep, type FlowStepResult } from '@reticlehq/core';
+import type { FlowReplaySession, Sleep } from './flow-replay.js';
+/** Run one role+name-anchored step: re-resolve via QUERY by:'role', ACT on the live ref, else drift. */
+export declare function runRoleStep(session: FlowReplaySession, step: FlowStep, index: number, anchor: Extract<FlowAnchor, {
+    kind: typeof AnchorKind.ROLE;
+}>, confirmDangerous: boolean, sleep: Sleep): Promise<FlowStepResult>;
+/**
+ * Dispatch one already-resolved step. Shared so every anchor kind runs the action the same way —
+ * including the action window, whose open/close must not depend on which anchor found the element.
+ */
+export declare function actOnResolvedRef(session: FlowReplaySession, step: FlowStep, index: number, label: string, ref: string, confirmDangerous: boolean): Promise<FlowStepResult>;
+/** Run one component-anchored step: re-resolve via QUERY by:'component', ACT on the live ref, else drift. */
+export declare function runComponentStep(session: FlowReplaySession, step: FlowStep, index: number, anchor: Extract<FlowAnchor, {
+    kind: typeof AnchorKind.COMPONENT;
+}>, confirmDangerous: boolean, sleep: Sleep): Promise<FlowStepResult>;

package/dist/flows/flow-step-runners.js

@@ -0,0 +1,102 @@
+/**
+ * How one anchored step is turned into a live action.
+ *
+ * Split out of flow-replay.ts when adding the role+name runner pushed that file past the size cap.
+ * These three share one shape — resolve an anchor to a ref, then dispatch — and the sharing is the
+ * point: the action window must open and close identically no matter which anchor found the element,
+ * or a step's events land in the wrong window depending on how it was addressed.
+ */
+import { AnchorKind, DriftReason, QueryBy, ReticleCommand, } from '@reticlehq/core';
+import { ReticleTool } from '../tools/tool-names.js';
+import { replayActionArgs } from './replay.js';
+import { componentLabel, componentQueryArgs, resolveQuery } from './flow-replay.js';
+/** Query args for a NAMED role anchor — the handle that identifies an instance, not a JSX site. */
+function roleQueryArgs(anchor) {
+    return {
+        by: QueryBy.ROLE,
+        value: anchor.role,
+        ...(anchor.name === undefined ? {} : { name: anchor.name }),
+    };
+}
+/** Run one role+name-anchored step: re-resolve via QUERY by:'role', ACT on the live ref, else drift. */
+export async function runRoleStep(session, step, index, anchor, confirmDangerous, sleep) {
+    const label = `${anchor.role} "${String(anchor.name)}"`;
+    const { refs } = await resolveQuery(session, roleQueryArgs(anchor), sleep);
+    const ref = refs[0];
+    if (ref === undefined) {
+        return {
+            step: index,
+            tool: step.tool,
+            anchor: label,
+            ok: false,
+            drift: {
+                reasonKind: DriftReason.COMPONENT_NOT_FOUND,
+                reason: `role anchor ${label} not found`,
+                anchor: label,
+                nearest: null,
+            },
+        };
+    }
+    return await actOnResolvedRef(session, step, index, label, ref, confirmDangerous);
+}
+/**
+ * Dispatch one already-resolved step. Shared so every anchor kind runs the action the same way —
+ * including the action window, whose open/close must not depend on which anchor found the element.
+ */
+export async function actOnResolvedRef(session, step, index, label, ref, confirmDangerous) {
+    session.beginAction?.(ReticleTool.FLOW_REPLAY, { ref, action: step.action ?? '' });
+    let act;
+    try {
+        act = await session.command(ReticleCommand.ACT, {
+            ref,
+            action: step.action ?? '',
+            args: replayActionArgs(step.args, confirmDangerous),
+        });
+    }
+    finally {
+        session.finishAction?.();
+    }
+    const result = { step: index, tool: step.tool, anchor: label, ok: act.ok };
+    if (!act.ok)
+        result.error = act.error ?? 'command failed';
+    return result;
+}
+/** Run one component-anchored step: re-resolve via QUERY by:'component', ACT on the live ref, else drift. */
+export async function runComponentStep(session, step, index, anchor, confirmDangerous, sleep) {
+    const label = componentLabel(anchor);
+    const { refs } = await resolveQuery(session, componentQueryArgs(anchor), sleep);
+    if (refs.length === 0) {
+        return {
+            step: index,
+            tool: step.tool,
+            anchor: label,
+            ok: false,
+            drift: {
+                reasonKind: DriftReason.COMPONENT_NOT_FOUND,
+                reason: `component anchor "${label}" not found`,
+                anchor: label,
+                nearest: null,
+            },
+        };
+    }
+    const ref = refs[0] ?? '';
+    // Attribute the step's effects to the step. Without this window they arrive with no actionId and are
+    // learned as ambient churn on the very regions the flow exercises.
+    session.beginAction?.(ReticleTool.FLOW_REPLAY, { ref, action: step.action ?? '' });
+    let act;
+    try {
+        act = await session.command(ReticleCommand.ACT, {
+            ref,
+            action: step.action ?? '',
+            args: replayActionArgs(step.args, confirmDangerous),
+        });
+    }
+    finally {
+        // Close on every exit so a throwing step cannot leak the window onto the next step's events.
+        session.finishAction?.();
+    }
+    const result = { step: index, tool: step.tool, anchor: label, ok: act.ok };
+    if (!act.ok)
+        result.error = act.error ?? 'command failed';
+    return result;
+}

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

@@ -30,4 +30,3 @@ export declare function successToPredicate(success: FlowExpect, dynamic: Readonl
  * the injected timeout. Never reads the wall clock.
  */
 export declare function assertSuccess(session: FlowReplaySession, success: FlowExpect | undefined, dynamic: ReadonlySet<string>, waitForSignal: WaitForSignal, timeoutMs: number, since?: number): Promise<EvalResult>;
-//# sourceMappingURL=flow-success.d.ts.map

package/dist/flows/flow-success.js

@@ -128,4 +128,3 @@ export async function assertSuccess(session, success, dynamic, waitForSignal, ti
     // a prior replay/run (or, in heal, by the pre-heal drift replay) cannot fake a pass.
     return waitForSignal(session, predicate, timeoutMs, since);
 }
-//# sourceMappingURL=flow-success.js.map

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

@@ -13,4 +13,3 @@ export declare function leasableAppUrl(deps: ToolDeps, sessionId: string | undef
 /** 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;
 export declare const FLOW_TOOLS: ToolDef[];
-//# sourceMappingURL=flow-tools.d.ts.map

package/dist/flows/flow-tools.js

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import { FlowErrorCode, RecordedSaveError, ReplayStatus, } from '@reticlehq/core';
+import { FlakeStore } from './flake-store.js';
 import { ReticleTool } from '../tools/tool-names.js';
 import { asNumber, asString } from '../tools/tools-helpers.js';
 import { log } from '../log.js';
@@ -71,7 +72,7 @@ export const FLOW_TOOLS = [
         inputSchema: {
             flowName: z
                 .string()
-                .describe('Name for the flow file (saved to .reticle/flows/<flowName>.json). Use again in reticle_flow_load/reticle_flow_replay.'),
+                .describe('Name for the flow file (saved to .reticle/flows/<flowName>.json). Use again in reticle_flow{action:"load"} / reticle_flow_replay.'),
             sessionId: z
                 .string()
                 .optional()
@@ -171,7 +172,7 @@ export const FLOW_TOOLS = [
         inputSchema: {
             flowName: z
                 .string()
-                .describe('Flow file name (without .json extension) from reticle_flow_list.'),
+                .describe('Flow file name (without .json extension) from reticle_flow{action:"list"}.'),
             sessionId: z
                 .string()
                 .optional()
@@ -200,7 +201,7 @@ export const FLOW_TOOLS = [
         inputSchema: {
             flowName: z
                 .string()
-                .describe('Flow file name (without .json extension) from reticle_flow_list.'),
+                .describe('Flow file name (without .json extension) from reticle_flow{action:"list"}.'),
             sessionId: z
                 .string()
                 .optional()
@@ -231,7 +232,7 @@ export const FLOW_TOOLS = [
         inputSchema: {
             flowName: z
                 .string()
-                .describe('Flow file name (without .json extension) from reticle_flow_list.'),
+                .describe('Flow file name (without .json extension) from reticle_flow{action:"list"}.'),
             confirmDangerous: z
                 .boolean()
                 .optional()
@@ -274,7 +275,7 @@ export const FLOW_TOOLS = [
         description: 'Replay EVERY saved flow (or a given subset) and return ONE consolidated suite verdict — the ' +
             'autonomous regression check to run after a build/change. Deterministic (no LLM per flow). ' +
             'Returns { status: pass|fail, total, passed, failed, summary, failures:[{ flow, verdict, ' +
-            'whatChanged, whereInSource, nextAction }] } — passing flows are counted, only failures carry ' +
+            'whatChanged, whereInSource, nextAction }] } plus `flaky` (flows seen to pass AND fail on unchanged code) — passing flows are counted, only failures carry ' +
             'detail (the actionable fix). One call replaces N hand-driven replays.',
         inputSchema: {
             names: z
@@ -297,6 +298,13 @@ export const FLOW_TOOLS = [
             failed: z.number(),
             summary: z.string(),
             failures: z.array(z.unknown()),
+            flaky: z
+                .array(z.string())
+                .optional()
+                .describe('Flows that have both passed and failed on UNCHANGED code — intermittent, not regressions. Omitted when none are known.'),
+            // Session-EXEMPT, so it does not inherit `sessionEnvelopeShape` — declare the one-shot human
+            // feedback ask here or a validating profile strips it off the suite verdict.
+            feedback_prompt: z.unknown().optional(),
         },
         handler: async (deps, args) => {
             const sessionId = asString(args['sessionId']);
@@ -337,24 +345,47 @@ export const FLOW_TOOLS = [
                         await lease.release().catch(() => undefined);
                     }
                 });
-                return buildSuiteVerdict(outcomes.map((o, i) => ({
-                    replay: o.ok && o.value !== undefined
-                        ? o.value
-                        : leaseFailureReplay(requested[i] ?? '', o.error),
-                })));
+                const parallelRuns = await Promise.all(outcomes.map(async (o, i) => {
+                    const name = requested[i] ?? '';
+                    const replay = o.ok && o.value !== undefined ? o.value : leaseFailureReplay(name, o.error);
+                    const loaded = await deps.flows.load(name, projectId).catch(() => null);
+                    const flow = loaded !== null && loaded.ok ? loaded.value : undefined;
+                    return flow === undefined ? { replay } : { replay, flow };
+                }));
+                return buildSuiteVerdict(parallelRuns);
             }
+            // The flow FILE travels with each replay so the verdict can tell a green that verified
+            // something from a green that could never have gone red. Without it the suite reported "all 1
+            // flow pass" for a flow with no steps at all.
             const runs = [];
             const timed = [];
+            // The flake ledger the CLI gate already keeps — see FlakeStore. It was only ever written by
+            // `reticle flow` on the command line, so an AGENT running this tool a hundred times learned
+            // nothing about which flows are intermittent. Same product, same ledger, two surfaces, and the
+            // one an agent uses was the blind half.
+            const flakes = new FlakeStore(deps.fs, deps.reticleRoot);
             // Sequential default: every flow replays against the same live session, so they must not overlap.
             for (const flowName of requested) {
                 const start = deps.now();
                 const replay = await replayNamedFlow(deps, { flowName, sessionId });
-                runs.push({ replay });
+                const loaded = await deps.flows.load(flowName, projectId).catch(() => null);
+                const flow = loaded !== null && loaded.ok ? loaded.value : undefined;
+                runs.push(flow === undefined ? { replay } : { replay, flow });
                 timed.push({ replay, durationMs: deps.now() - start });
             }
+            // Accrue this run's outcomes, then report what the ledger knows. Best-effort on both halves: a
+            // flake ledger is memory, not a gate, and it must never turn a working verify into an error.
+            for (const { replay } of runs) {
+                await flakes.record(replay.name, replay.status === ReplayStatus.OK).catch(() => undefined);
+            }
+            const flaky = await flakes.flakyFlows().catch(() => []);
             // Emit the consolidated run artifact (Runs tab) + best-effort cloud push. Never blocks the verdict.
             await persistAndSyncVerificationRun(deps, timed, projectId);
-            return buildSuiteVerdict(runs);
+            const verdict = buildSuiteVerdict(runs);
+            // A flow that has both passed and failed on UNCHANGED code is a different thing from a
+            // regression, and an agent that cannot tell them apart either chases a ghost or ignores a real
+            // break. Present only when the ledger has seen enough runs to say so.
+            return flaky.length > 0 ? { ...verdict, flaky } : verdict;
         },
     },
     {
@@ -423,7 +454,7 @@ export const FLOW_TOOLS = [
             'untouched). Returns { name, status: healed|drift|unhealable|consequence_broken|' +
             'nothing_to_heal|error, applied, proposals[], changed[], message }.',
         inputSchema: {
-            flowName: z.string().describe('Flow file name to heal (from reticle_flow_list).'),
+            flowName: z.string().describe('Flow file name to heal (from reticle_flow{action:"list"}).'),
             apply: z.boolean().optional(),
             confirmDangerous: z
                 .boolean()
@@ -446,4 +477,3 @@ export const FLOW_TOOLS = [
         handler: (deps, args) => healFlow(deps, args).then(({ name, ...rest }) => ({ flowName: name, ...rest })),
     },
 ];
-//# sourceMappingURL=flow-tools.js.map

package/dist/flows/flows.d.ts

@@ -1,5 +1,5 @@
 import { FlowErrorCode } from '@reticlehq/core';
-import type { FlowExpect, FlowFile, FlowStep, HealChange } from '@reticlehq/core';
+import type { FlowAnchor, FlowExpect, FlowFile, FlowStep, HealChange } from '@reticlehq/core';
 import type { CompiledProgram, RecordedStep } from './recordings.js';
 import type { FileSystemPort } from '../project/fs-port.js';
 /** A monotonic clock injected for createdAt — never call Date.now inside the store (rule 7). */
@@ -14,6 +14,11 @@ export type FlowResult<T> = {
     ok: false;
     code: FlowErrorCode;
 };
+/** Pick the on-disk anchor for a normalized step: testid > component(auto) > degraded role. */
+export declare function anchorForStep(args: Record<string, unknown>): {
+    anchor: FlowAnchor;
+    degraded: boolean;
+};
 /**
  * Pure: map one normalized RecordedStep → FlowStep with a semantic anchor (+ degraded marker).
  * A ref-only (stable:false) step is recorded with a best-effort anchor and degraded:true —
@@ -95,4 +100,3 @@ export declare class FlowStore {
     remove(name: string, projectId?: string): Promise<FlowResult<void>>;
 }
 export {};
-//# sourceMappingURL=flows.d.ts.map

package/dist/flows/flows.js

@@ -50,7 +50,7 @@ function componentAnchor(src) {
     return anchor;
 }
 /** Pick the on-disk anchor for a normalized step: testid > component(auto) > degraded role. */
-function anchorForStep(args) {
+export function anchorForStep(args) {
     const by = asString(args['by']);
     const value = asString(args['value']);
     if (by === QueryBy.TESTID && value !== undefined) {
@@ -63,6 +63,20 @@ function anchorForStep(args) {
             anchor.source = source;
         return { anchor, degraded: false };
     }
+    // Role + NAME is a real anchor, not a degraded placeholder.
+    //
+    // The vocabulary has always described `{ kind:'role', role, name }` as an addressable anchor, and
+    // nothing ever produced one — the only ROLE anchor written to disk was the degraded placeholder
+    // that means "add a data-testid". So a step the recorder anchored by accessible name arrived here
+    // and had that name thrown away, which is precisely the anchor that distinguishes one row's
+    // control from another's when a shared JSX source location cannot.
+    if (by === QueryBy.ROLE && value !== undefined) {
+        const name = asString(args['name']);
+        if (name !== undefined && name.length > 0) {
+            // The schema carries role + name only; provenance lives on the step, not the anchor.
+            return { anchor: { kind: AnchorKind.ROLE, role: value, name }, degraded: false };
+        }
+    }
     if (by === QueryBy.COMPONENT) {
         const anchor = componentAnchor(args);
         if (anchor !== null)
@@ -369,4 +383,3 @@ export class FlowStore {
         return { ok: true, value: undefined };
     }
 }
-//# sourceMappingURL=flows.js.map

package/dist/flows/gate.d.ts

@@ -36,4 +36,3 @@ export interface GateResult {
     deleted: string[];
 }
 export declare function gateDecision(input: GateInput): GateResult;
-//# sourceMappingURL=gate.d.ts.map

package/dist/flows/gate.js

@@ -31,4 +31,3 @@ export function gateDecision(input) {
         deleted,
     };
 }
-//# sourceMappingURL=gate.js.map

package/dist/flows/git-changed.d.ts

@@ -6,4 +6,3 @@ export declare function parseGitFiles(output: string): string[];
  * than throwing — the caller degrades to "no changes" and the gate simply passes, never crashes CI.
  */
 export declare function changedFilesSince(ref: string, cwd: string): Promise<string[]>;
-//# sourceMappingURL=git-changed.d.ts.map

package/dist/flows/git-changed.js

@@ -22,4 +22,3 @@ export async function changedFilesSince(ref, cwd) {
         return [];
     }
 }
-//# sourceMappingURL=git-changed.js.map

package/dist/flows/heal-run.d.ts

@@ -16,4 +16,3 @@ export declare const HEAL_MESSAGES: {
     readonly CONSEQUENCE_BROKEN: "rebind resolves the drifted locator to a surviving element, but the healed flow no longer satisfies its success consequence — refusing to write (a heal that loses the intent would ship a green-but-dead test). Fix by hand and verify";
 };
 export declare function healFlow(deps: ToolDeps, args: Record<string, unknown>): Promise<FlowHealResult>;
-//# sourceMappingURL=heal-run.d.ts.map

package/dist/flows/heal-run.js

@@ -134,4 +134,3 @@ export async function healFlow(deps, args) {
         message: loaded.value.success !== undefined ? HEAL_MESSAGES.HEALED : HEAL_MESSAGES.HEALED_UNVERIFIED,
     };
 }
-//# sourceMappingURL=heal-run.js.map

package/dist/flows/heal.d.ts

@@ -40,4 +40,3 @@ export declare function proposeRebind(drift: Drift, step: number): HealProposal
  * the floor. Defaults to HEAL_CONFIDENCE_MIN (0.5) for backwards compatibility.
  */
 export declare function collectProposals(steps: FlowStepResult[], minConfidence?: number): HealProposal[];
-//# sourceMappingURL=heal.d.ts.map

package/dist/flows/heal.js

@@ -95,4 +95,3 @@ export function collectProposals(steps, minConfidence = HEAL_CONFIDENCE_MIN) {
     }
     return proposals;
 }
-//# sourceMappingURL=heal.js.map

package/dist/flows/parallel-suite.d.ts

@@ -24,4 +24,3 @@ export declare function mapWithConcurrency<I, T>(items: readonly I[], limit: num
  * and never below 1. Explicit `requested` (the tool's `parallel` arg) wins when it is a sane number.
  */
 export declare function resolveConcurrency(flowCount: number, poolCapacity: number, requested?: number): number;
-//# sourceMappingURL=parallel-suite.d.ts.map

package/dist/flows/parallel-suite.js

@@ -48,4 +48,3 @@ export function resolveConcurrency(flowCount, poolCapacity, requested) {
         return ceiling;
     return Math.max(1, Math.min(Math.floor(requested), ceiling));
 }
-//# sourceMappingURL=parallel-suite.js.map