@reticlehq/server 2.2.0 → 2.3.0

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,15 +1,20 @@
 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';
-import { resolveCloudConfig, syncFlowToCloud, SyncOutcome } from '../cloud/cloud-sync.js';
+import { syncFlowToCloud, SyncOutcome } from '../cloud/cloud-sync.js';
 import { mapWithConcurrency, resolveConcurrency } from './parallel-suite.js';
 import { acquireLeasedSession } from '../tools/lease-tools.js';
+import { homedir } from 'node:os';
+import { resolveProjectCloud } from '../cloud/cloud-config.js';
 import { buildSuiteVerdict } from './decision.js';
 import { classifyFlowAssertions } from './flow-classify.js';
 import { isValidFlowName, flowPath } from '../project/reticle-dir.js';
 import { replayNamedFlow, flowErrorMessage, latestRecordedFlow, sessionProjectId, } from './flow-replay-run.js';
+import { persistAndSyncVerificationRun } from '../runs/verification-sync.js';
+import { runServerVerify } from './server-verify.js';
 import { healFlow } from './heal-run.js';
 export { replayNamedFlow } from './flow-replay-run.js';
 /**
@@ -17,11 +22,12 @@ export { replayNamedFlow } from './flow-replay-run.js';
  * set). Fire-and-forget: resolves the config, POSTs via the platform fetch, and logs the outcome. Any
  * failure is swallowed so a network hiccup never affects the local save.
  */
-async function syncSavedFlowToCloud(flow, projectId) {
-    const config = resolveCloudConfig(process.env);
-    if (config === null)
-        return; // not logged in → stays local
-    const result = await syncFlowToCloud(flow, config, projectId, (url, init) => fetch(url, init));
+async function syncSavedFlowToCloud(deps, flow, projectId) {
+    // Per-project cloud: sync a saved flow only when cloud is attached AND flow sync is enabled.
+    const cloud = await resolveProjectCloud(deps.fs, deps.reticleRoot, homedir(), process.env);
+    if (cloud.config === null || !cloud.policy.flows)
+        return; // not attached / flows disabled → local only
+    const result = await syncFlowToCloud(flow, cloud.config, projectId, (url, init) => fetch(url, init));
     if (result.outcome !== SyncOutcome.SYNCED) {
         log('cloud-flow-sync-failed', { flow: flow.name, status: result.status, error: result.error });
     }
@@ -66,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()
@@ -166,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()
@@ -195,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()
@@ -226,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()
@@ -269,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
@@ -292,13 +298,26 @@ 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']);
             // "Replay all" means all of THIS app's flows (+ legacy), not every project's on a shared daemon.
+            const projectId = sessionProjectId(deps, sessionId);
             const requested = Array.isArray(args['names'])
                 ? args['names'].filter((n) => typeof n === 'string')
-                : await deps.flows.list(sessionProjectId(deps, sessionId));
+                : await deps.flows.list(projectId);
+            // verify:server — hand the whole suite to the hosted runner; it records the verification itself.
+            const cloud = await resolveProjectCloud(deps.fs, deps.reticleRoot, homedir(), process.env);
+            const server = await runServerVerify(deps, cloud, sessionId, requested);
+            if (server !== null)
+                return server;
             // PARALLEL: flows race the DOM only when they share ONE tab. Given the lease pool, each
             // flow gets its own isolated context, so a large suite finishes in interactive time. Opt-in via
             // `parallel`; a missing prerequisite (no pool, unknown app URL) falls back to the sequential path
@@ -333,12 +352,32 @@ export const FLOW_TOOLS = [
                 })));
             }
             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 });
+                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);
             }
-            return buildSuiteVerdict(runs);
+            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);
+            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;
         },
     },
     {
@@ -389,7 +428,7 @@ export const FLOW_TOOLS = [
                 return { error: flowErrorMessage(res.code), code: res.code };
             // If logged into Reticle Cloud, mirror the saved flow to the team's regression suite. Best-effort
             // and non-blocking: the flow is already on disk, so a sync failure never fails the save.
-            void syncSavedFlowToCloud(flow, session.projectId);
+            void syncSavedFlowToCloud(deps, flow, session.projectId);
             // Return the SaveSummary as-is ({ name, stepCount, degraded, empty }) — the outputSchema
             // declares `name`, so the old `flowName` key was silently stripped by schema-strict clients.
             return res.value;
@@ -407,7 +446,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()
@@ -430,4 +469,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

package/dist/flows/recordings.d.ts

@@ -43,4 +43,3 @@ export declare class RecordingStore {
     active(): string[];
 }
 export {};
-//# sourceMappingURL=recordings.d.ts.map

package/dist/flows/recordings.js

@@ -40,4 +40,3 @@ export class RecordingStore {
         return [...this.#active.keys()];
     }
 }
-//# sourceMappingURL=recordings.js.map

package/dist/flows/replay.d.ts

@@ -33,4 +33,3 @@ interface ReplayStepResult {
 /** Re-execute every step of a compiled program in order, stopping at the first failure. */
 export declare function replayProgram(session: Session, program: CompiledProgram, confirmDangerous?: boolean): Promise<ReplayStepResult[]>;
 export {};
-//# sourceMappingURL=replay.d.ts.map