@reticlehq/server 2.14.0 → 3.2.0

package/dist/flows/gate.js

@@ -1,33 +0,0 @@
-/**
- * The completion gate — exits non-zero unless passing artifacts cover the flows affected by the changed
- * files. This is what makes verification unavoidable: an agent that edits a covered file cannot "finish"
- * without re-verifying. Flaky flows are quarantined — surfaced, never gate-blocking — because one
- * unexplained flake that blocks a merge destroys trust in the red. Pure decision; the CLI computes the
- * inputs (git diff → affected → run artifacts + flake ledger) and maps `pass` to the exit code.
- */
-export function gateDecision(input) {
-    const passing = new Set(input.passing);
-    const flaky = new Set(input.flaky ?? []);
-    const uncovered = [];
-    const quarantined = [];
-    for (const flow of input.affected) {
-        if (passing.has(flow))
-            continue;
-        if (flaky.has(flow))
-            quarantined.push(flow);
-        else
-            uncovered.push(flow);
-    }
-    // Downgrades and deleted coverage BLOCK. Flakiness is quarantined because a flake is not the agent's
-    // doing; a weakened or deleted assertion is — surfacing it without blocking would leave the gate
-    // trivially gameable, which is the exact failure exists to prevent.
-    const downgraded = [...(input.downgraded ?? [])];
-    const deleted = [...(input.deleted ?? [])];
-    return {
-        pass: 0 === uncovered.length && 0 === downgraded.length && 0 === deleted.length,
-        uncovered,
-        quarantined,
-        downgraded,
-        deleted,
-    };
-}

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

@@ -1,10 +0,0 @@
-/**
- * The self-heal state machine — load → replay → collect confident proposals → (apply ? verify+write:
- * dry). Split out of flow-tools.ts (which keeps only the FLOW_HEAL ToolDef) as a sibling of
- * flow-replay-run.ts. Never silently rewrites: only proposals that cleared HEAL_CONFIDENCE_MIN are
- * eligible, and only when apply:true; before persisting it re-verifies the success consequence still
- * fires (heal the locator, never the intent).
- */
-import { type FlowHealResult } from '@reticlehq/core';
-import type { ToolDeps } from '../tools/tools.js';
-export declare function healFlow(deps: ToolDeps, args: Record<string, unknown>): Promise<FlowHealResult>;

package/dist/flows/heal-run.js

@@ -1,139 +0,0 @@
-/**
- * The self-heal state machine — load → replay → collect confident proposals → (apply ? verify+write:
- * dry). Split out of flow-tools.ts (which keeps only the FLOW_HEAL ToolDef) as a sibling of
- * flow-replay-run.ts. Never silently rewrites: only proposals that cleared HEAL_CONFIDENCE_MIN are
- * eligible, and only when apply:true; before persisting it re-verifies the success consequence still
- * fires (heal the locator, never the intent).
- */
-import { FLOW_SIGNAL_TIMEOUT_MS, HEAL_CONFIDENCE_MIN, HealStatus, ReplayStatus, } from '@reticlehq/core';
-import { asString } from '../tools/tools-helpers.js';
-import { waitForPredicate } from '../events/predicate.js';
-import { replayFlow } from './flow-replay.js';
-import { applyHealChanges, collectProposals } from './heal.js';
-import { assertSuccess, dynamicTestids, successLabel } from './flow-success.js';
-import { flowErrorMessage, sessionProjectId } from './flow-replay-run.js';
-import { flowsForSession } from './flow-store-for-session.js';
-const HEAL_MESSAGES = {
-    NOTHING: 'nothing to heal — every anchor resolved on replay',
-    HEALED: "rewrote drifted testid anchors to their nearest surviving match and re-verified the flow's success consequence still fires",
-    DRIFT_DRY: 'confident rebind(s) proposed — re-run with apply:true to write them to disk',
-    UNHEALABLE: `drift found, but no nearest match cleared the confidence floor (HEAL_CONFIDENCE_MIN=${HEAL_CONFIDENCE_MIN}); file left untouched; add a data-testid or fix the flow by hand`,
-    HEALED_UNVERIFIED: 'rewrote drifted testid anchors — but this flow declares no success consequence, so the rebind resolves a locator without proving the intent still holds. Add a success-state assertion (reticle_annotate) so future heals can be verified.',
-    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',
-};
-function toChange(proposal) {
-    return { step: proposal.step, from: proposal.from, to: proposal.to };
-}
-export async function healFlow(deps, args) {
-    const name = asString(args['flowName']) ?? '';
-    const apply = true === args['apply'];
-    const projectId = sessionProjectId(deps, asString(args['sessionId']));
-    const loaded = await flowsForSession(deps, projectId).flows.load(name, projectId);
-    if (!loaded.ok) {
-        return {
-            name,
-            status: HealStatus.ERROR,
-            applied: false,
-            proposals: [],
-            changed: [],
-            message: flowErrorMessage(loaded.code, loaded.detail),
-            error: { code: loaded.code, message: flowErrorMessage(loaded.code, loaded.detail) },
-        };
-    }
-    const session = deps.sessions.resolve(asString(args['sessionId']));
-    const steps = await replayFlow(session, loaded.value, waitForPredicate, FLOW_SIGNAL_TIMEOUT_MS, true === args['confirmDangerous']);
-    const drifted = steps.some((s) => s.drift !== undefined);
-    const failed = steps.find((s) => !s.ok && s.drift === undefined);
-    if (failed !== undefined) {
-        const message = failed.error ?? 'flow replay failed before an anchor could be healed';
-        return {
-            name,
-            status: HealStatus.ERROR,
-            applied: false,
-            proposals: [],
-            changed: [],
-            message,
-            error: { code: ReplayStatus.ERROR, message },
-        };
-    }
-    if (!drifted) {
-        return {
-            name,
-            status: HealStatus.NOTHING_TO_HEAL,
-            applied: false,
-            proposals: [],
-            changed: [],
-            message: HEAL_MESSAGES.NOTHING,
-        };
-    }
-    const proposals = collectProposals(steps);
-    if (0 === proposals.length) {
-        return {
-            name,
-            status: HealStatus.UNHEALABLE,
-            applied: false,
-            proposals: [],
-            changed: [],
-            message: HEAL_MESSAGES.UNHEALABLE,
-        };
-    }
-    if (!apply) {
-        return {
-            name,
-            status: HealStatus.DRIFT,
-            applied: false,
-            proposals,
-            changed: [],
-            message: HEAL_MESSAGES.DRIFT_DRY,
-        };
-    }
-    // Heal the locator, never the intent: verify the rebind on a healed copy before persisting. A rebound
-    // testid can resolve to a real but WRONG element that no longer triggers the success consequence.
-    const { flow: healed } = applyHealChanges(loaded.value, proposals.map(toChange));
-    if (healed.success !== undefined) {
-        // Verify from the FIRST DRIFTED step forward, not the whole flow — re-running the prefix would
-        // double-execute a non-idempotent flow (a false CONSEQUENCE_BROKEN that refuses a correct heal).
-        const firstDrift = steps.findIndex((s) => s.drift !== undefined);
-        const toVerify = firstDrift > 0 ? { ...healed, steps: healed.steps.slice(firstDrift) } : healed;
-        // Floor the success oracle at the start of the VERIFY replay so the earlier drift replay's signal
-        // cannot fake the verification.
-        const verifyFloor = session.elapsed();
-        const verifySteps = await replayFlow(session, toVerify, waitForPredicate, FLOW_SIGNAL_TIMEOUT_MS, true === args['confirmDangerous']);
-        const verifyClean = verifySteps.length > 0 && verifySteps.every((s) => s.ok && s.drift === undefined);
-        const verdict = verifyClean
-            ? await assertSuccess(session, healed.success, dynamicTestids(healed), waitForPredicate, FLOW_SIGNAL_TIMEOUT_MS, verifyFloor)
-            : { pass: false, failureReason: 'healed flow did not replay cleanly' };
-        if (!verdict.pass) {
-            return {
-                name,
-                status: HealStatus.CONSEQUENCE_BROKEN,
-                applied: false,
-                proposals,
-                changed: [],
-                message: `${HEAL_MESSAGES.CONSEQUENCE_BROKEN} (${successLabel(healed.success)}: ${verdict.failureReason ?? 'not satisfied'})`,
-            };
-        }
-    }
-    // Healing WRITES, so it must land where the load came from — a heal that read the app's flow and
-    // wrote the daemon's copy would silently fork the two.
-    const written = await flowsForSession(deps, projectId).flows.heal(name, proposals.map(toChange), projectId);
-    if (!written.ok) {
-        return {
-            name,
-            status: HealStatus.ERROR,
-            applied: false,
-            proposals,
-            changed: [],
-            message: flowErrorMessage(written.code),
-            error: { code: written.code, message: flowErrorMessage(written.code) },
-        };
-    }
-    return {
-        name,
-        status: HealStatus.HEALED,
-        applied: written.value.changed.length > 0,
-        proposals,
-        changed: written.value.changed,
-        message: loaded.value.success !== undefined ? HEAL_MESSAGES.HEALED : HEAL_MESSAGES.HEALED_UNVERIFIED,
-    };
-}

package/dist/flows/heal.js

@@ -1,97 +0,0 @@
-import { AnchorKind, DriftReason, HEAL_CONFIDENCE_MIN, } from '@reticlehq/core';
-import { editDistance } from './flow-replay.js';
-/**
- * The pure proposal layer. It turns a `Drift` (with its already-
- * computed nearest testid) into a concrete, confidence-scored rebind. No new heuristics enter the
- * trust boundary: confidence is derived only from the existing case-insensitive edit distance, so
- * the "never silently rewrite a bad guess" invariant lives in a single numeric floor
- * (HEAL_CONFIDENCE_MIN). Separated from the reticle_flow_heal tool so it is unit-testable without a
- * live session or the filesystem.
- *
- * FIRST CUT: testid-anchor rebinds only, scored by string distance.
- * Future: rebind by alternate anchors (role+name, signal correlation); multi-candidate
- * ranking when several testids tie; confidence beyond string distance (DOM-position / a11y-role
- * agreement, contract-diff awareness); healing degraded (ROLE-unresolved) steps; signal-drift
- * healing (signals have no nearest-match today — intentionally nearest:null, no proposal).
- */
-/**
- * Normalize a case-insensitive edit distance to a (0,1] confidence: 1 on an exact match, decaying
- * with distance relative to the longer string's length. Always clamped to (0,1] — never 0, never
- * above 1 — so a present-but-distant testid is still legibly scored (below the floor), not dropped.
- */
-export function confidenceFor(from, to) {
-    if (from === to)
-        return 1;
-    const span = Math.max(from.length, to.length);
-    if (0 === span)
-        return 1;
-    const raw = 1 - editDistance(from, to) / span;
-    if (raw >= 1)
-        return 1;
-    if (raw <= 0)
-        return Number.EPSILON;
-    return raw;
-}
-/**
- * Pure: rewrite the named steps' testid anchors (from→to) and return the new flow plus the changes
- * that actually applied. A change whose `from` no longer matches that step's testid anchor is
- * skipped (idempotent / defensive), never throwing. Shared by the on-disk writer (FlowStore.heal)
- * and the in-memory pre-write verification in reticle_flow_heal, so both rewrite identically.
- */
-export function applyHealChanges(flow, changes) {
-    const byStep = new Map();
-    for (const change of changes)
-        byStep.set(change.step, change);
-    const applied = [];
-    const steps = flow.steps.map((step, index) => {
-        const change = byStep.get(index);
-        if (change === undefined ||
-            step.anchor.kind !== AnchorKind.TESTID ||
-            step.anchor.value !== change.from) {
-            return step;
-        }
-        applied.push(change);
-        return { ...step, anchor: { kind: AnchorKind.TESTID, value: change.to } };
-    });
-    return { flow: { ...flow, steps }, applied };
-}
-/** Internal: propose with a caller-supplied floor (enables the tunable-confidence API). */
-function proposeRebindWith(drift, step, minConfidence) {
-    if (drift.reasonKind !== DriftReason.TESTID_NOT_FOUND)
-        return undefined;
-    // Never auto-heal an ambiguous drift: when two present testids tie at the minimum distance, the
-    // `nearest` pick is arbitrary, so a rebind would be a coin-flip that can land on the wrong element
-    // and ship a bug green. Surface it (the drift still carries `nearest`) and defer to a human.
-    if (true === drift.ambiguous)
-        return undefined;
-    const to = drift.nearest;
-    if (null === to)
-        return undefined;
-    const confidence = confidenceFor(drift.anchor, to);
-    if (confidence < minConfidence)
-        return undefined;
-    return { step, from: drift.anchor, to, confidence };
-}
-/**
- * Public compat wrapper — uses HEAL_CONFIDENCE_MIN (the existing default floor).
- * Prefer collectProposals(steps, minConfidence) for new callers.
- */
-export function proposeRebind(drift, step) {
-    return proposeRebindWith(drift, step, HEAL_CONFIDENCE_MIN);
-}
-/**
- * Map step results → confident proposals (skips ok steps, signal drift, and below-floor drift).
- * Pass minConfidence to tighten (0.9 → near-certain only) or loosen (0.0 → all candidates)
- * the floor. Defaults to HEAL_CONFIDENCE_MIN (0.5) for backwards compatibility.
- */
-export function collectProposals(steps, minConfidence = HEAL_CONFIDENCE_MIN) {
-    const proposals = [];
-    for (const step of steps) {
-        if (step.drift === undefined)
-            continue;
-        const proposal = proposeRebindWith(step.drift, step.step, minConfidence);
-        if (proposal !== undefined)
-            proposals.push(proposal);
-    }
-    return proposals;
-}

package/dist/flows/predicate-to-expect.d.ts

@@ -1,44 +0,0 @@
-/**
- * The assertion the agent MADE, in the shape a saved flow can keep.
- *
- * `reticle_act_and_wait { until }` is how agents assert — 12 of 14 calls in a day of telemetry
- * carried an `until`. `compileActStep` recorded only the ACTION, so a flow saved after an asserted
- * drive came back graded `assertion-free`: "performs actions but asserts no observable consequence —
- * it will pass even if the feature is broken." The agent had already said what success meant;
- * Reticle discarded it and then warned the agent that the flow asserts nothing.
- *
- * That is the regression-suite story failing at its last step. "Record once, verify forever" is only
- * worth anything if the recorded flow can go RED, and locally 32 of 39 saved flows cannot.
- *
- * The inverse of `successToPredicate`. Only the kinds FlowExpect can express are carried: `settled`
- * is a wait rather than a claim, and `route`/`animation`/`anyOf`/`not` have no representation at all.
- * Inventing one would write an assertion into the file that the agent never made, which is worse
- * than recording none — a flow that asserts something nobody chose is a false green with extra steps.
- */
-import type { FlowExpect } from '@reticlehq/core';
-import type { Predicate } from '../events/predicate.js';
-export declare function predicateToExpect(predicate: Predicate): FlowExpect | undefined;
-/**
- * The subset a REPLAY actually enforces.
- *
- * The rule has never changed: never write an assertion into a flow file that nothing evaluates. A
- * flow reporting `grade: "asserted"` while its assertion is read by no one is a false green, in the
- * feature whose entire purpose is preventing them.
- *
- * What changed is the SET. This kept only `element.testid` and `state`, because for a long time
- * those were the only kinds replay checked — and the note here said lifting it "requires replay to
- * evaluate them per step". Replay now does exactly that: `assertStepExpect` compiles every
- * remaining kind through `successToPredicate` and waits on it. The condition was met and the filter
- * was not updated, so the two drifted.
- *
- * That drift had a cost, and it fell on the agent. `reticle_act_and_wait { until }` IS the agent
- * saying what success means, and `net` is overwhelmingly what it says. Every one of those was
- * discarded at capture, so an agent-recorded flow reached disk assertion-free BY CONSTRUCTION and
- * `reticle_verify` then correctly called it `unverifiable` — the record → save → verify path
- * completing all the way to a run that could never be a pass. Found by driving it.
- *
- * The list below is exactly what `successToPredicate` reads, including an element located by
- * role or name. A testid is also asserted directly against the DOM by the step runner. Anything
- * it cannot compile is still dropped.
- */
-export declare function enforcedOnReplay(expect: FlowExpect | undefined): FlowExpect | undefined;

package/dist/flows/predicate-to-expect.js

@@ -1,130 +0,0 @@
-import { PredicateKind } from '@reticlehq/core';
-/** Merge two partial expectations; later keys win only where the earlier one said nothing. */
-function merge(into, from) {
-    return { ...from, ...into };
-}
-export function predicateToExpect(predicate) {
-    switch (predicate.kind) {
-        case PredicateKind.SIGNAL: {
-            if (predicate.name === undefined)
-                return undefined;
-            const signal = { signal: predicate.name };
-            if (predicate.dataMatches !== undefined)
-                signal.signalData = predicate.dataMatches;
-            if (predicate.count !== undefined)
-                signal.signalCount = predicate.count;
-            return signal;
-        }
-        case PredicateKind.NET: {
-            const net = {};
-            if (predicate.method !== undefined)
-                net.method = predicate.method;
-            if (predicate.urlContains !== undefined)
-                net.urlContains = predicate.urlContains;
-            if (predicate.status !== undefined)
-                net.status = predicate.status;
-            if (predicate.count !== undefined)
-                net.count = predicate.count;
-            return 0 === Object.keys(net).length ? undefined : { net };
-        }
-        case PredicateKind.CONSOLE: {
-            // `contains` has no representation in FlowExpect.console (core keeps `level` and `absent`
-            // and nothing else). Copying the rest through anyway would record an assertion the agent
-            // never made: {console, level:'warn', contains:'no-op', absent:true} would save "no warn
-            // entries at all", a false red on any unrelated warning, and in the presence direction it
-            // saves a strictly weaker claim than the one chosen. This file's own rule applies: record
-            // nothing rather than something different, so the flow stays assertion-free there instead.
-            if (predicate.contains !== undefined)
-                return undefined;
-            const console_ = {};
-            if (predicate.level !== undefined)
-                console_.level = predicate.level;
-            if (predicate.absent !== undefined)
-                console_.absent = predicate.absent;
-            return 0 === Object.keys(console_).length ? undefined : { console: console_ };
-        }
-        case PredicateKind.ELEMENT: {
-            const element = {};
-            if (predicate.query.testid !== undefined)
-                element.testid = predicate.query.testid;
-            if (predicate.query.role !== undefined)
-                element.role = predicate.query.role;
-            if (predicate.query.name !== undefined)
-                element.name = predicate.query.name;
-            return 0 === Object.keys(element).length ? undefined : { element };
-        }
-        case PredicateKind.STATE: {
-            const state = { path: predicate.path };
-            if (predicate.store !== undefined)
-                state.store = predicate.store;
-            if (predicate.equals !== undefined)
-                state.equals = predicate.equals;
-            return { state };
-        }
-        case PredicateKind.ALL_OF: {
-            // `settled` members drop out on their own by returning undefined.
-            let combined;
-            for (const part of predicate.predicates) {
-                const expect = predicateToExpect(part);
-                if (expect === undefined)
-                    continue;
-                combined = combined === undefined ? expect : merge(combined, expect);
-            }
-            return combined;
-        }
-        default:
-            // settled | route | animation | anyOf | not — nothing FlowExpect can say honestly.
-            return undefined;
-    }
-}
-/**
- * The subset a REPLAY actually enforces.
- *
- * The rule has never changed: never write an assertion into a flow file that nothing evaluates. A
- * flow reporting `grade: "asserted"` while its assertion is read by no one is a false green, in the
- * feature whose entire purpose is preventing them.
- *
- * What changed is the SET. This kept only `element.testid` and `state`, because for a long time
- * those were the only kinds replay checked — and the note here said lifting it "requires replay to
- * evaluate them per step". Replay now does exactly that: `assertStepExpect` compiles every
- * remaining kind through `successToPredicate` and waits on it. The condition was met and the filter
- * was not updated, so the two drifted.
- *
- * That drift had a cost, and it fell on the agent. `reticle_act_and_wait { until }` IS the agent
- * saying what success means, and `net` is overwhelmingly what it says. Every one of those was
- * discarded at capture, so an agent-recorded flow reached disk assertion-free BY CONSTRUCTION and
- * `reticle_verify` then correctly called it `unverifiable` — the record → save → verify path
- * completing all the way to a run that could never be a pass. Found by driving it.
- *
- * The list below is exactly what `successToPredicate` reads, including an element located by
- * role or name. A testid is also asserted directly against the DOM by the step runner. Anything
- * it cannot compile is still dropped.
- */
-export function enforcedOnReplay(expect) {
-    if (expect === undefined)
-        return undefined;
-    const kept = {};
-    // The step runner asserts a testid against the live DOM before the predicate engine. Role and
-    // name are not that path: successToPredicate compiles them, and dropping them here made a
-    // recorded `until` by button name vanish so the saved flow could not go red.
-    const element = expect.element;
-    if (undefined !== element &&
-        (undefined !== element.testid || undefined !== element.role || undefined !== element.name)) {
-        kept.element = element;
-    }
-    // Everything `successToPredicate` can compile. Replay evaluates EVERY kind of expect through it
-    // (see assertStepExpect); this list is what that function actually reads.
-    if (expect.state !== undefined)
-        kept.state = expect.state;
-    if (expect.signal !== undefined)
-        kept.signal = expect.signal;
-    if (expect.signalData !== undefined)
-        kept.signalData = expect.signalData;
-    if (expect.signalCount !== undefined)
-        kept.signalCount = expect.signalCount;
-    if (expect.net !== undefined)
-        kept.net = expect.net;
-    if (expect.console !== undefined)
-        kept.console = expect.console;
-    return 0 === Object.keys(kept).length ? undefined : kept;
-}

package/dist/flows/recording-backtrack.js

@@ -1,73 +0,0 @@
-/**
- * A recorded flow that backtracks across pages cannot replay.
- *
- * The recorder stores clicks, not navigations. A drive that opens a product and then returns to
- * search saves both clicks; replay lands on the product page and looks for a control that only
- * exists on search. That shape is visible from the route list with no change to the flow file, so
- * stop/save can warn instead of writing a flow that fails on the next click.
- */
-import { EventType } from '@reticlehq/core';
-import { routePathOf } from '../events/predicate-route.js';
-function asString(value) {
-    return 'string' === typeof value ? value : undefined;
-}
-/**
- * The page a recording step sat on, comparable across path routers and hash routers.
- *
- * A startPath is stored as pathname+hash (`/#/search`); a ROUTE_CHANGE carries them separately.
- * Without this, every hash-router page compares as `/` and a backtrack is invisible.
- */
-export function recordingRouteOf(pathname, hash = '') {
-    const hashIdx = pathname.indexOf('#/');
-    if (hashIdx >= 0) {
-        return routePathOf(pathname.slice(0, hashIdx) || '/', pathname.slice(hashIdx));
-    }
-    const fragment = hash.startsWith('#') ? hash : 0 === hash.length ? '' : `#${hash}`;
-    if (fragment.startsWith('#/'))
-        return routePathOf(0 === pathname.length ? '/' : pathname, fragment);
-    return pathname;
-}
-function collapseConsecutive(routes) {
-    const out = [];
-    for (const route of routes) {
-        if (0 === route.length)
-            continue;
-        if (out.at(-1) === route)
-            continue;
-        out.push(route);
-    }
-    return out;
-}
-/**
- * Warn when the journey left a page and came back. Linear A→B→C is silent: that still cannot
- * replay either if a later click needs a previous page, but the reported failure is specifically
- * the backtrack, and inventing a warning for every multi-page drive would teach agents to ignore it.
- */
-export function recordingBacktrackWarning(routes) {
-    const path = collapseConsecutive(routes);
-    const seen = new Set();
-    for (const route of path) {
-        if (seen.has(route)) {
-            return (`this recording returned to ${route} after leaving it — replay has no navigation steps, so ` +
-                'the next click looks for a control that only exists on a page the tab is no longer on. ' +
-                `Journey: ${path.join(' → ')}. Split into one flow per page, or record the control that navigates back.`);
-        }
-        seen.add(route);
-    }
-    return undefined;
-}
-/** Ordered pages the recording sat on, startPath first, consecutive stays collapsed. */
-export function routesFromRecording(startPath, events) {
-    const raw = [];
-    if (undefined !== startPath)
-        raw.push(recordingRouteOf(startPath));
-    for (const event of events) {
-        if (EventType.ROUTE_CHANGE !== event.type)
-            continue;
-        const pathname = asString(event.data['pathname']) ?? asString(event.data['to']);
-        if (undefined === pathname)
-            continue;
-        raw.push(recordingRouteOf(pathname, asString(event.data['hash']) ?? ''));
-    }
-    return collapseConsecutive(raw);
-}

package/dist/flows/recordings.d.ts

@@ -1,63 +0,0 @@
-import type { FlowExpect } from '@reticlehq/core';
-/** One captured agent action, normalized for replay. */
-export interface RecordedStep {
-    /** ReticleTool.ACT | ReticleTool.ACT_SEQUENCE */
-    tool: string;
-    /** Normalized args: refs replaced by { by:'testid', value } where resolvable. */
-    args: Record<string, unknown>;
-    /** false if any ref could not be normalized to a testid (replay only valid in-session). */
-    stable: boolean;
-    /** Optional post-condition annotation carried into the on-disk flow's expect. */
-    expect?: FlowExpect;
-}
-interface ActiveRecording {
-    cursor: number;
-    steps: RecordedStep[];
-    /** The route the journey began on. See CompiledProgram.startPath. */
-    startPath?: string;
-}
-/** A finished, replayable program compiled from a recording. */
-export interface CompiledProgram {
-    name: string;
-    version: number;
-    steps: RecordedStep[];
-    startPath?: string;
-    /**
-     * Pages the recording sat on, in order, consecutive stays collapsed. In-memory only — not written
-     * to the flow file. Lets save warn about a backtrack (a journey that cannot replay) without a
-     * format change.
-     */
-    routes?: string[];
-}
-/**
- * Tracks in-flight recordings (name -> { buffer cursor at record_start, captured steps })
- * and the last compiled program per name (for reticle_replay).
- */
-export declare class RecordingStore {
-    #private;
-    start(name: string, cursor: number, startPath?: string): void;
-    isRecording(name: string): boolean;
-    /**
-     * Number of steps captured so far in the named ACTIVE recording (0 if it
-     * exists but is empty, undefined if there is no active recording by that name). Lets the annotate
-     * compiler target the LAST captured step without exposing the mutable step array.
-     */
-    stepCount(name: string): number | undefined;
-    /** Append a captured step to every active recording (steps belong to all in-flight spans). */
-    capture(step: RecordedStep): void;
-    /** Returns the active recording (cursor + steps) and clears it, or undefined if not recording. */
-    stop(name: string): ActiveRecording | undefined;
-    saveCompiled(program: CompiledProgram): void;
-    getCompiled(name: string): CompiledProgram | undefined;
-    active(): string[];
-    /**
-     * Names of recordings that have been STOPPED and compiled.
-     *
-     * The mirror of `active()`, and needed for the same defaulting: after `reticle_record stop` a
-     * recording is no longer active, so resolving "the obvious one" from `active()` finds nothing.
-     * Saving it then demanded the exact name back from the caller, which is a thing to remember for
-     * no reason when exactly one recording exists.
-     */
-    compiled(): string[];
-}
-export {};

package/dist/flows/recordings.js

@@ -1,57 +0,0 @@
-/**
- * Tracks in-flight recordings (name -> { buffer cursor at record_start, captured steps })
- * and the last compiled program per name (for reticle_replay).
- */
-export class RecordingStore {
-    #active = new Map();
-    #compiled = new Map();
-    start(name, cursor, startPath) {
-        this.#active.set(name, {
-            cursor,
-            steps: [],
-            ...(startPath === undefined ? {} : { startPath }),
-        });
-    }
-    isRecording(name) {
-        return this.#active.has(name);
-    }
-    /**
-     * Number of steps captured so far in the named ACTIVE recording (0 if it
-     * exists but is empty, undefined if there is no active recording by that name). Lets the annotate
-     * compiler target the LAST captured step without exposing the mutable step array.
-     */
-    stepCount(name) {
-        return this.#active.get(name)?.steps.length;
-    }
-    /** Append a captured step to every active recording (steps belong to all in-flight spans). */
-    capture(step) {
-        for (const rec of this.#active.values())
-            rec.steps.push(step);
-    }
-    /** Returns the active recording (cursor + steps) and clears it, or undefined if not recording. */
-    stop(name) {
-        const rec = this.#active.get(name);
-        this.#active.delete(name);
-        return rec;
-    }
-    saveCompiled(program) {
-        this.#compiled.set(program.name, program);
-    }
-    getCompiled(name) {
-        return this.#compiled.get(name);
-    }
-    active() {
-        return [...this.#active.keys()];
-    }
-    /**
-     * Names of recordings that have been STOPPED and compiled.
-     *
-     * The mirror of `active()`, and needed for the same defaulting: after `reticle_record stop` a
-     * recording is no longer active, so resolving "the obvious one" from `active()` finds nothing.
-     * Saving it then demanded the exact name back from the caller, which is a thing to remember for
-     * no reason when exactly one recording exists.
-     */
-    compiled() {
-        return [...this.#compiled.keys()];
-    }
-}