@reticlehq/server 2.2.1 → 2.3.0

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']);
@@ -345,6 +353,11 @@ 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();
@@ -352,9 +365,19 @@ export const FLOW_TOOLS = [
                 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);
+            }
+            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 +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()
@@ -446,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

package/dist/flows/replay.js

@@ -64,6 +64,24 @@ export function compileActStep(args, res) {
             testidArgs['source'] = source;
         return { tool: ReticleTool.ACT, stable: true, args: testidArgs };
     }
+    // Role + NAME before component: a component/source anchor names the JSX site, so every row's copy
+    // of the same control collapses onto it. The accessible name separates them, and it is also the
+    // only stable anchor an app with no testids has. Measured: three rows' checkboxes compiled to one
+    // identical component anchor and replayed onto a single element.
+    const role = asString(r['role']);
+    const name = asString(r['name']);
+    if (role !== undefined && name !== undefined) {
+        const roleArgs = {
+            by: QueryBy.ROLE,
+            value: role,
+            name,
+            action,
+            args: actArgs,
+        };
+        if (source !== undefined)
+            roleArgs['source'] = source;
+        return { tool: ReticleTool.ACT, stable: true, args: roleArgs };
+    }
     const component = asString(r['component']);
     if (component !== undefined || source !== undefined) {
         const componentArgs = { by: QueryBy.COMPONENT, action, args: actArgs };
@@ -99,7 +117,16 @@ export function compileSequenceStep(args, res) {
     });
     return { tool: ReticleTool.ACT_SEQUENCE, stable, args: { steps: subSteps } };
 }
-/** Resolve a recorded sub-step's element to a live ref via testid query, else fall back to its stored ref. */
+/**
+ * Resolve a recorded step's element to a live ref, by whichever anchor the compiler chose.
+ *
+ * Every anchor the compiler can EMIT must be resolvable here. It could not be: `compileActStep`
+ * emits `by: component` steps (and marks them `stable: true`), and this function only understood
+ * `testid` — so every component-anchored step failed with "no testid or ref to resolve", and the
+ * `stable` flag on it was a claim the replayer could not honour. Measured on a console with 5 steps:
+ * the 2 with testids replayed, the 3 without were unreplayable, and the flow reported ok:false at
+ * the first of them.
+ */
 async function resolveRef(session, step) {
     const by = asString(step.by);
     const value = asString(step.value);
@@ -113,9 +140,50 @@ async function resolveRef(session, step) {
             throw new Error(`testid '${value}' did not resolve in current page`);
         return refs.length > 1 ? { ref, note: ambiguousTestidNote(value) } : { ref };
     }
+    // Role + accessible NAME: the anchor that distinguishes one row's control from another's, which
+    // neither a testid-less app nor a shared JSX source location can do.
+    if (by === QueryBy.ROLE && value !== undefined) {
+        const name = asString(step.name);
+        const query = { by, value, ...(name === undefined ? {} : { name }) };
+        const result = await session.command(ReticleCommand.QUERY, query);
+        if (!result.ok)
+            throw new Error(result.error ?? 'query failed');
+        const ref = queryRefs(result)[0];
+        if (ref === undefined) {
+            throw new Error(`${value} named '${String(name)}' did not resolve in current page`);
+        }
+        return { ref };
+    }
+    if (by === QueryBy.COMPONENT) {
+        const component = asString(step.component);
+        const source = step.source;
+        const query = {
+            by,
+            ...(component === undefined ? {} : { component, value: component }),
+            ...(source === undefined ? {} : { source }),
+        };
+        const result = await session.command(ReticleCommand.QUERY, query);
+        if (!result.ok)
+            throw new Error(result.error ?? 'query failed');
+        const refs = queryRefs(result);
+        const ref = refs[0];
+        if (ref === undefined) {
+            throw new Error(`component '${String(component)}' did not resolve in current page`);
+        }
+        // A source location identifies a JSX SITE, not an instance: one `<input>` inside a row renders
+        // once per row and every one of them shares this anchor. Saying so is the difference between a
+        // replay that repeated itself and a replay that reports it might have.
+        return refs.length > 1
+            ? {
+                ref,
+                note: `component anchor matched ${String(refs.length)} elements — replayed the first`,
+            }
+            : { ref };
+    }
     const ref = asString(step.ref);
-    if (ref === undefined || ref.length === 0)
-        throw new Error('step has no testid or ref to resolve');
+    if (ref === undefined || ref.length === 0) {
+        throw new Error('step has no resolvable anchor (testid, role+name, component) and no ref');
+    }
     return { ref, note: 'replayed by stale ref (not portable across sessions)' };
 }
 /** Re-execute every step of a compiled program in order, stopping at the first failure. */
@@ -190,4 +258,3 @@ function buildResult(tool, ok, error, notes) {
         base.note = notes.join('; ');
     return base;
 }
-//# sourceMappingURL=replay.js.map

package/dist/flows/server-verify.d.ts

@@ -13,4 +13,3 @@ import { type ServerVerification } from '../cloud/cloud-sync.js';
 export declare function toSuiteVerdict(report: ServerVerification): SuiteVerdict;
 /** Run the suite on the hosted runner, or null to signal the caller should replay locally. */
 export declare function runServerVerify(deps: ToolDeps, cloud: ProjectCloud, sessionId: string | undefined, flows: string[]): Promise<SuiteVerdict | null>;
-//# sourceMappingURL=server-verify.d.ts.map

package/dist/flows/server-verify.js

@@ -40,4 +40,3 @@ export async function runServerVerify(deps, cloud, sessionId, flows) {
         return null;
     return toSuiteVerdict(report);
 }
-//# sourceMappingURL=server-verify.js.map

package/dist/flows/verify-change-tools.d.ts

@@ -0,0 +1,2 @@
+import type { ToolDef } from '../tools/tools.js';
+export declare const VERIFY_CHANGE_TOOLS: ToolDef[];