@reticlehq/server 2.3.0 → 2.5.0

package/dist/events/reconcile.js

@@ -39,7 +39,7 @@ const ZERO_DECIMAL = new Set(['JPY', 'KRW', 'VND']);
 const STATE_FIELDS = new Set(['status', 'state']);
 const ITEM_KEYS = ['items', 'results', 'data', 'records', 'rows', 'entries'];
 function isRecord(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
+    return 'object' === typeof value && value !== null && !Array.isArray(value);
 }
 /** Every object carrying an `id`, at any depth. These are the things a UI renders as rows. */
 export function entitiesIn(node, out = []) {
@@ -102,7 +102,7 @@ function wrongCurrencyMark(text, amounts, expected) {
 }
 function markBefore(text, amount, expected) {
     const at = text.indexOf(amount);
-    if (at === -1)
+    if (-1 === at)
         return undefined; // this rendering is not on screen — try the next
     // Look just before the number, where a symbol or code sits. A window, not the whole page: the
     // point is what is attached to THIS amount.
@@ -167,9 +167,9 @@ export function reconcile(bodies, pageText) {
         // number must appear with a currency marker attached. A non-money number that happens to share a
         // decimal form (a weight, a count) is rendered bare and never reaches the comparison.
         const currency = entity['currency'];
-        if (typeof currency === 'string') {
+        if ('string' === typeof currency) {
             for (const [field, value] of Object.entries(entity)) {
-                if (typeof value !== 'number' || field === 'currency')
+                if (typeof value !== 'number' || 'currency' === field)
                     continue;
                 const printed = majorForms(value, currency);
                 const wrong = wrongCurrencyMark(pageText, printed, currency);
@@ -196,7 +196,7 @@ export function reconcile(bodies, pageText) {
             const others = [...(vocabulary.get(field) ?? [])].filter((v) => v !== value);
             const shown = others.filter((v) => shows(pageText, v));
             const key = `${id}:${field}`;
-            if (shown.length === 0 || seen.has(key))
+            if (0 === shown.length || seen.has(key))
                 continue;
             seen.add(key);
             found.push({

package/dist/events/ring-buffer.js

@@ -95,7 +95,7 @@ export class RingBuffer {
                 continue;
             }
             const victim = this.#findChurnAfterHead();
-            if (victim === -1) {
+            if (-1 === victim) {
                 // Buffer genuinely full of high-signal events — fall back to FIFO so it stays bounded.
                 this.#totalBytes -= this.#eventBytes[this.#head] ?? 0;
                 this.#head += 1;

package/dist/events/stale-response.js

@@ -1,11 +1,11 @@
 import { ContradictionKind, EventType } from '@reticlehq/core';
 function pathOf(url) {
     const q = url.indexOf('?');
-    return q === -1 ? url : url.slice(0, q);
+    return -1 === q ? url : url.slice(0, q);
 }
 function queryOf(url) {
     const q = url.indexOf('?');
-    return q === -1 ? '' : url.slice(q + 1);
+    return -1 === q ? '' : url.slice(q + 1);
 }
 /**
  * Parameters that ENUMERATE a collection rather than select within it.
@@ -52,13 +52,13 @@ function flights(events) {
     const issued = new Map();
     const out = [];
     for (const event of events) {
-        const id = typeof event.data['id'] === 'string' ? event.data['id'] : undefined;
+        const id = 'string' === typeof event.data['id'] ? event.data['id'] : undefined;
         if (id === undefined)
             continue;
-        const at = typeof event.t === 'number' ? event.t : 0;
+        const at = 'number' === typeof event.t ? event.t : 0;
         if (event.type === EventType.NET_PENDING) {
-            const url = typeof event.data['url'] === 'string' ? event.data['url'] : '';
-            const method = typeof event.data['method'] === 'string' ? event.data['method'] : 'GET';
+            const url = 'string' === typeof event.data['url'] ? event.data['url'] : '';
+            const method = 'string' === typeof event.data['method'] ? event.data['method'] : 'GET';
             issued.set(id, { url, method, at });
             continue;
         }

package/dist/events/testid-near-miss.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Turning "no element matched {testid: …}" into something an agent can act on.
+ *
+ * `reticle_query` on a missing testid already returns the testids that ARE present, so a typo is one
+ * step from fixed. The same failure through a PREDICATE — `act_and_wait { until: { kind:'element',
+ * query:{ testid } } }` — said only "no element matched" and stopped, naming nothing.
+ *
+ * The near-miss machinery covered an element in the wrong STATE and a wrong NAME for a role (which
+ * even lists the names it saw). Testid — the anchor this codebase calls the gold standard — had
+ * none, and it is the one agents use most.
+ *
+ * It also just became the highest-traffic failure in the product: putting act_and_wait on the
+ * verification path means agents assert far more, so a failed element assertion is now the common
+ * case rather than the rare one.
+ */
+/**
+ * The "…but these ARE here" clause, or undefined when there is nothing useful to say.
+ *
+ * Returns the empty string when the queried testid is itself present: the miss was then about STATE,
+ * not presence, and "you asked for X; X is present" reads as a contradiction rather than a hint.
+ */
+export declare function describeTestidMiss(wanted: string, present: readonly string[]): string | undefined;

package/dist/events/testid-near-miss.js

@@ -0,0 +1,33 @@
+/**
+ * Turning "no element matched {testid: …}" into something an agent can act on.
+ *
+ * `reticle_query` on a missing testid already returns the testids that ARE present, so a typo is one
+ * step from fixed. The same failure through a PREDICATE — `act_and_wait { until: { kind:'element',
+ * query:{ testid } } }` — said only "no element matched" and stopped, naming nothing.
+ *
+ * The near-miss machinery covered an element in the wrong STATE and a wrong NAME for a role (which
+ * even lists the names it saw). Testid — the anchor this codebase calls the gold standard — had
+ * none, and it is the one agents use most.
+ *
+ * It also just became the highest-traffic failure in the product: putting act_and_wait on the
+ * verification path means agents assert far more, so a failed element assertion is now the common
+ * case rather than the rare one.
+ */
+/** Enough to recognise the one you meant; not so many that a large page floods the message. */
+const MAX_LISTED = 12;
+/**
+ * The "…but these ARE here" clause, or undefined when there is nothing useful to say.
+ *
+ * Returns the empty string when the queried testid is itself present: the miss was then about STATE,
+ * not presence, and "you asked for X; X is present" reads as a contradiction rather than a hint.
+ */
+export function describeTestidMiss(wanted, present) {
+    if (0 === present.length)
+        return undefined;
+    if (present.includes(wanted))
+        return '';
+    const shown = present.slice(0, MAX_LISTED);
+    const rest = present.length - shown.length;
+    const tail = rest > 0 ? `, and ${String(rest)} more` : '';
+    return `testids present here: ${shown.join(', ')}${tail}`;
+}

package/dist/events/unit-mismatch.js

@@ -37,7 +37,7 @@ const SCALES = [100, 1000];
  */
 const ID_PATTERN = /[A-Za-z]{2,}_[A-Za-z0-9]{2,}|[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}/g;
 function parse(raw) {
-    if (typeof raw !== 'string' || raw.length === 0)
+    if (typeof raw !== 'string' || 0 === raw.length)
         return undefined;
     try {
         return JSON.parse(raw);
@@ -53,12 +53,12 @@ function moneyByEntity(node, into) {
             moneyByEntity(item, into);
         return;
     }
-    if (typeof node !== 'object' || node === null)
+    if (typeof node !== 'object' || null === node)
         return;
     const record = node;
     // An id may arrive as a number (`{"id": 9}`) — normalised so a numeric path segment matches it.
     const raw = record['id'];
-    const id = typeof raw === 'string' ? raw : typeof raw === 'number' ? String(raw) : undefined;
+    const id = 'string' === typeof raw ? raw : 'number' === typeof raw ? String(raw) : undefined;
     if (id !== undefined) {
         for (const [key, value] of Object.entries(record)) {
             if (!MONEY_FIELDS.has(key) || typeof value !== 'number')
@@ -79,9 +79,9 @@ function idsIn(url, body) {
         if (segment.length > 0 && /^\d+$/.test(segment))
             found.add(segment);
     }
-    if (typeof body === 'object' && body !== null) {
+    if ('object' === typeof body && body !== null) {
         for (const value of Object.values(body)) {
-            if (typeof value === 'string')
+            if ('string' === typeof value)
                 for (const id of value.match(ID_PATTERN) ?? [])
                     found.add(id);
         }
@@ -90,7 +90,7 @@ function idsIn(url, body) {
 }
 /** The scale between a known value and a sent one, or undefined when they are consistent. */
 function scaleBetween(known, sent) {
-    if (sent === 0 || known === 0)
+    if (0 === sent || 0 === known)
         return undefined;
     for (const scale of SCALES) {
         // A tolerance, because the major-unit form is a rounded render of the minor one.
@@ -127,11 +127,11 @@ export function findUnitMismatches(events, prior = []) {
     for (const event of events) {
         if (event.type !== EventType.NET_REQUEST)
             continue;
-        const url = typeof event.data['url'] === 'string' ? event.data['url'] : '';
+        const url = 'string' === typeof event.data['url'] ? event.data['url'] : '';
         const requestBody = parse(event.data['requestBody']);
         // Compare BEFORE recording this call's own response, or a request that echoes its own reply
         // would compare against itself.
-        if (typeof requestBody === 'object' && requestBody !== null) {
+        if ('object' === typeof requestBody && requestBody !== null) {
             const sentFields = requestBody;
             for (const id of idsIn(url, requestBody)) {
                 const fields = known.get(id);

package/dist/flows/affected-tools.js

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import { ReticleTool } from '../tools/tool-names.js';
-import { loadNamedFlows, resolveChangedFiles } from '../cli-flow-commands.js';
+import { loadNamedFlows, resolveChangedFiles } from '../cli/cli-flow-commands.js';
 import { affectedSavedFlows } from './flow-sources.js';
 /**
  * `reticle_affected` — which saved flows must re-verify for a set of changed files.
@@ -40,13 +40,28 @@ export const AFFECTED_TOOLS = [
         },
         handler: async (deps, args) => {
             const files = Array.isArray(args['files'])
-                ? args['files'].filter((f) => typeof f === 'string')
+                ? args['files'].filter((f) => 'string' === typeof f)
                 : [];
-            const since = typeof args['since'] === 'string' ? args['since'] : undefined;
+            const since = 'string' === typeof args['since'] ? args['since'] : undefined;
             const changedFiles = await resolveChangedFiles(files, since);
             const flows = await loadNamedFlows(deps.fs, deps.reticleRoot);
             const result = affectedSavedFlows(flows, changedFiles);
-            return { changedFiles, ...result };
+            // Three different situations produced the same empty answer: no files changed, no flows saved,
+            // and a git ref that resolved to nothing. Only the first means "nothing to re-verify"; the
+            // others mean the question could not be answered, and re-running nothing on that basis is how a
+            // regression ships. Say which one it is.
+            const why = 0 === flows.length
+                ? 'no saved flows exist yet, so nothing COULD be affected — record one with reticle_record then reticle_flow_save'
+                : 0 === changedFiles.length
+                    ? since === undefined && 0 === files.length
+                        ? 'no files were given and no `since` ref was passed, so nothing was compared — pass the files you edited, or a git ref'
+                        : 'nothing changed against that input, so no saved flow needs re-verifying'
+                    : undefined;
+            return {
+                changedFiles,
+                ...result,
+                ...(why === undefined ? {} : { observed: true, note: why }),
+            };
         },
     },
 ];

package/dist/flows/affected.js

@@ -23,7 +23,7 @@ export function affectedFlows(flows, changedFiles) {
     const affected = [];
     const unknownProvenance = [];
     for (const flow of flows) {
-        if (flow.sources === undefined || flow.sources.length === 0) {
+        if (flow.sources === undefined || 0 === flow.sources.length) {
             affected.push(flow.name);
             unknownProvenance.push(flow.name);
             continue;

package/dist/flows/annotate-target.d.ts

@@ -0,0 +1 @@
+export declare function resolveAnnotateTarget(explicit: string | undefined, active: readonly string[]): string;

package/dist/flows/annotate-target.js

@@ -0,0 +1,20 @@
+/**
+ * Which recording an annotation belongs to when the call does not say.
+ *
+ * It used to be the literal name `default`, unconditionally. Reproduced on three apps: an agent that
+ * starts `reticle_record { recordingName: "my-flow" }`, acts, and then annotates without repeating
+ * the name gets `annotate_no_step` — because the steps are in "my-flow" and the annotation went
+ * looking in an empty "default". The agent's rational next move is to record MORE steps, into the
+ * wrong place.
+ *
+ * With exactly one recording in progress there is nothing to disambiguate, so that is the answer.
+ * With several, `default` stays the documented choice: silently picking one of the others would put
+ * an assertion in a flow the agent never named, which is worse than an error.
+ */
+/** The documented fallback name, matching what `reticle_record` starts when given none. */
+const DEFAULT_RECORDING = 'default';
+export function resolveAnnotateTarget(explicit, active) {
+    if (explicit !== undefined && explicit.length > 0)
+        return explicit;
+    return 1 === active.length ? (active[0] ?? DEFAULT_RECORDING) : DEFAULT_RECORDING;
+}

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.d.ts

@@ -1,11 +1,5 @@
 import { type FlowFile, type FlowReplayResult, type ReplayDecision, type SuiteVerdict } from '@reticlehq/core';
 export declare function buildDecision(result: FlowReplayResult, flow?: FlowFile): ReplayDecision;
-/**
- * Aggregate per-flow replays into one suite verdict — the autonomous loop's consolidated answer
- * after a build: did anything break, and what's the prioritized fix list. Pure: pass the already
- * decision-annotated replay results + their flows. Passing flows are counted; only failures carry
- * detail (token-cheap), each with the actionable decision so the agent fixes without re-querying.
- */
 export declare function buildSuiteVerdict(runs: ReadonlyArray<{
     replay: FlowReplayResult;
     flow?: FlowFile;