@reticlehq/server 2.14.0 → 3.2.0

package/dist/project/session-root.d.ts

@@ -1,23 +0,0 @@
-import type { ToolDeps } from '../tools/tool-kit.js';
-/**
- * The `.reticle` directory a tool call's artifacts belong in.
- *
- * Every call site that reads or writes a project artifact goes through here, and that is the whole
- * point of the function existing rather than each site asking `deps.artifactRootFor` itself. The
- * write half and the read half MUST agree: a `flow_save` that resolves to the project while
- * `verify_change` still reads the daemon's own directory would be a worse defect than the one being
- * fixed — the flow would save successfully and then be invisible to the tool that exists to replay
- * it, which reads as "no flows covered this change" rather than as an error.
- *
- * Falls back to `deps.reticleRoot` whenever resolution cannot name a project, which is exactly the
- * behaviour every call site had before the resolver existed.
- */
-export declare function sessionRoot(deps: ToolDeps, sessionId: string | undefined): string;
-/**
- * The connected session's projectId, or undefined when there is no session to ask.
- *
- * `sessions.resolve` throws when nothing is connected, when the id names no session, and when
- * several are connected and none was named. All three mean the same thing here — we cannot tell
- * which project this call is about — and none of them is a reason to fail the caller's tool.
- */
-export declare function sessionProjectId(deps: ToolDeps, sessionId: string | undefined): string | undefined;

package/dist/project/session-root.js

@@ -1,38 +0,0 @@
-/**
- * The `.reticle` directory a tool call's artifacts belong in.
- *
- * Every call site that reads or writes a project artifact goes through here, and that is the whole
- * point of the function existing rather than each site asking `deps.artifactRootFor` itself. The
- * write half and the read half MUST agree: a `flow_save` that resolves to the project while
- * `verify_change` still reads the daemon's own directory would be a worse defect than the one being
- * fixed — the flow would save successfully and then be invisible to the tool that exists to replay
- * it, which reads as "no flows covered this change" rather than as an error.
- *
- * Falls back to `deps.reticleRoot` whenever resolution cannot name a project, which is exactly the
- * behaviour every call site had before the resolver existed.
- */
-export function sessionRoot(deps, sessionId) {
-    return deps.artifactRootFor?.(sessionProjectId(deps, sessionId)).root ?? deps.reticleRoot;
-}
-/**
- * The connected session's projectId, or undefined when there is no session to ask.
- *
- * `sessions.resolve` throws when nothing is connected, when the id names no session, and when
- * several are connected and none was named. All three mean the same thing here — we cannot tell
- * which project this call is about — and none of them is a reason to fail the caller's tool.
- */
-/*
- * Exported alongside `sessionRoot`, and that is the point rather than a convenience. A caller that
- * takes the ROOT from the session and the PROJECT ID from somewhere else has resolved half an
- * address, which is the defect the comment above predicted and `loadNamedFlows` then shipped: it
- * read the id from `readProjectId(process.cwd())` while its root came from here. Both halves come
- * from this file so they cannot disagree again.
- */
-export function sessionProjectId(deps, sessionId) {
-    try {
-        return deps.sessions.resolve(sessionId).projectId;
-    }
-    catch {
-        return undefined;
-    }
-}

package/dist/runs/build-verification-run.d.ts

@@ -1,29 +0,0 @@
-/**
- * The verification-run assembler. A PURE mapping from already-produced verification results
- * (flow-replay outcomes, standalone checks, risks, evidence, repair packets) into the stable
- * ReticleVerificationRun artifact, with a deterministic verdict computed here. The clock is injected
- * (the single `createdAt` site — never Date.now in logic, per rule 7). Gathering the inputs from a
- * live session is a separate adapter concern; this file owns the shape + the verdict rules so both
- * the MCP path and the programmatic Replay/Verify API produce byte-identical verdicts.
- */
-import { type ReticleVerificationRun, type RunVerdict } from '@reticlehq/core';
-/**
- * Everything a caller supplies; schemaVersion/createdAt/verdict are filled/computed by the builder.
- * runId is a plain string here (string in) — the schema brands it to RunId on the way out (branded out),
- * so construction sites stay ergonomic while consumers get the nominal type.
- */
-export type VerificationRunInput = Omit<ReticleVerificationRun, 'schemaVersion' | 'createdAt' | 'verdict' | 'runId'> & {
-    runId: string;
-};
-/**
- * Compute the verdict deterministically from the run's flows, checks, and risks.
- * Rules (in order): a gated risk blocks → FAIL; mixed pass+fail → PARTIAL; any fail → FAIL; else PASS.
- * Confidence: nothing ran → LOW; an oracle-backed flow or any check ran → HIGH; only smoke → MEDIUM.
- */
-export declare function computeVerdict(input: VerificationRunInput): RunVerdict;
-/**
- * Assemble the final, schema-valid ReticleVerificationRun. Stamps schemaVersion + createdAt (injected
- * clock) and computes the verdict; the result is parsed through the protocol schema so a malformed
- * input can never escape as an "artifact".
- */
-export declare function buildVerificationRun(input: VerificationRunInput, now: () => number): ReticleVerificationRun;

package/dist/runs/build-verification-run.js

@@ -1,70 +0,0 @@
-/**
- * The verification-run assembler. A PURE mapping from already-produced verification results
- * (flow-replay outcomes, standalone checks, risks, evidence, repair packets) into the stable
- * ReticleVerificationRun artifact, with a deterministic verdict computed here. The clock is injected
- * (the single `createdAt` site — never Date.now in logic, per rule 7). Gathering the inputs from a
- * live session is a separate adapter concern; this file owns the shape + the verdict rules so both
- * the MCP path and the programmatic Replay/Verify API produce byte-identical verdicts.
- */
-import { ReticleVerificationRunSchema, RUN_FILE_VERSION, RunCheckStatus, RunConfidence, RunFlowStatus, VerdictStatus, } from '@reticlehq/core';
-import { redactForProfile } from './profile-redact.js';
-/**
- * Compute the verdict deterministically from the run's flows, checks, and risks.
- * Rules (in order): a gated risk blocks → FAIL; mixed pass+fail → PARTIAL; any fail → FAIL; else PASS.
- * Confidence: nothing ran → LOW; an oracle-backed flow or any check ran → HIGH; only smoke → MEDIUM.
- */
-export function computeVerdict(input) {
-    const passes = input.flows.filter((f) => f.status === RunFlowStatus.PASS || f.status === RunFlowStatus.HEALED)
-        .length + input.checks.filter((c) => c.status === RunCheckStatus.PASS).length;
-    const fails = input.flows.filter((f) => f.status === RunFlowStatus.FAIL).length +
-        input.checks.filter((c) => c.status === RunCheckStatus.FAIL).length;
-    const blockingRisks = input.risks.filter((r) => r.gated).length;
-    const reasons = [];
-    for (const f of input.flows) {
-        if (f.status === RunFlowStatus.FAIL) {
-            reasons.push(f.failureReason !== undefined
-                ? `flow ${f.name}: ${f.failureReason}`
-                : `flow ${f.name} failed`);
-        }
-    }
-    for (const c of input.checks) {
-        if (c.status === RunCheckStatus.FAIL)
-            reasons.push(`check failed: ${c.predicate}`);
-    }
-    for (const r of input.risks) {
-        if (r.gated)
-            reasons.push(`blocked: ${r.surface} risk — ${r.detail}`);
-    }
-    let status;
-    if (blockingRisks > 0)
-        status = VerdictStatus.FAIL;
-    else if (fails > 0 && passes > 0)
-        status = VerdictStatus.PARTIAL;
-    else if (fails > 0)
-        status = VerdictStatus.FAIL;
-    else
-        status = VerdictStatus.PASS;
-    const ran = input.flows.length + input.checks.length;
-    let confidence;
-    if (0 === ran)
-        confidence = RunConfidence.LOW;
-    else if (input.flows.some((f) => f.oracle !== undefined) || input.checks.length > 0)
-        confidence = RunConfidence.HIGH;
-    else
-        confidence = RunConfidence.MEDIUM;
-    return { status, reasons, confidence, blockingRisks };
-}
-/**
- * Assemble the final, schema-valid ReticleVerificationRun. Stamps schemaVersion + createdAt (injected
- * clock) and computes the verdict; the result is parsed through the protocol schema so a malformed
- * input can never escape as an "artifact".
- */
-export function buildVerificationRun(input, now) {
-    const run = {
-        schemaVersion: RUN_FILE_VERSION,
-        createdAt: now(),
-        verdict: computeVerdict(input),
-        ...input,
-    };
-    return redactForProfile(ReticleVerificationRunSchema.parse(run));
-}

package/dist/runs/context-tools.d.ts

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

package/dist/runs/context-tools.js

@@ -1,89 +0,0 @@
-import { z } from 'zod';
-import {} from '@reticlehq/core';
-import { runContextFor } from './run-context.js';
-import { openSessionIntents } from '../intent/open-intents.js';
-import { ReticleTool } from '../tools/tool-names.js';
-import { sessionIdShape } from '../tools/tool-kit.js';
-import { asString } from '../tools/tools-helpers.js';
-/**
- * What this run has established, asked for by the one party that knows when it is needed.
- *
- * Reticle holds the trajectory: the journal, the verdicts, the intent ledger. The agent holds a copy
- * in its context window, and that copy is the one that disappears — at a compaction, at the end of a
- * turn, at the handover to a sub-agent. Reticle's does not disappear at the same moment. So this is
- * not a competing memory; it is the ground truth compaction destroyed, handed back on request.
- *
- * ## Why it is PULLED
- *
- * The same content was once pushed onto every session-bound tool response. It cost +136% on a
- * verdict and was cut, because most of the time the agent still had the context and we were paying
- * on every call to duplicate what it knew. Nobody but the agent can tell when that stops being true.
- * So the agent asks, once, at the moment it knows its own memory is gone, and pays once.
- *
- * ## Why it is on the EXTENDED surface rather than the default
- *
- * The default surface is a hard COUNT — editors budget tools across every connected MCP server, so a
- * slot taken here is taken from a tool that has already earned it, and nothing on that list has been
- * demoted for this. The claim behind this tool is unmeasured, which is the same test `reticle_intent`
- * and the `reticle_capabilities` demotion were held to, and it fails that test today.
- *
- * The reachability argument is also stronger here than for most of the cold tail. The caller is,
- * by construction, an agent that has just lost its context and is re-reading the tool list it was
- * handed this turn — so `reticle_tools` (advertised on every surface) is exactly the call it is
- * already going to make, and this tool is one `reticle_run` hop behind it. A tool that is only useful
- * after a discovery step, to a caller who is already performing a discovery step, is the cheapest
- * possible thing to leave off the hot list. It moves to the default surface when a measurement says
- * the pull happens often enough to be worth a permanent slot, and not before.
- */
-/** What the run has established, and where each part of it came from. */
-const CONTEXT_OUTPUT_SCHEMA = {
-    step: z
-        .number()
-        .describe('How many actions this run has dispatched. Counted off the journal, not a counter of its own.'),
-    established: z
-        .array(z.unknown())
-        .describe('What Reticle OBSERVED, folded and capped, each `{ key, fact, source?, doc?, epoch? }`. `key` is the subject, so re-observing it supersedes rather than appends. Anything seen under a replaced document or a pre-edit epoch is already gone from this list.'),
-    proven: z
-        .array(z.unknown())
-        .describe('Claims a verdict already settled, each `{ claim, verified, source?, doc?, epoch? }`. Read this before re-driving something: re-proving it is slow, and assuming it is a false green.'),
-    remaining: z
-        .array(z.string())
-        .describe('The intents from .reticle/intent.json that no verdict has discharged. Derived from the ledger, never a guess at what you meant to do next.'),
-};
-/** The ledger and the live page state this run is folded out of. `[]`/undefined when nothing is connected. */
-async function evidenceFor(deps, sessionId) {
-    try {
-        const session = deps.sessions.resolve(sessionId);
-        return {
-            actions: await session.readJournalActions(),
-            events: await session.queryEvents({}),
-            currentDocumentId: session.currentDocumentId,
-            currentEditEpoch: session.currentEditEpoch,
-        };
-    }
-    catch {
-        // `resolve` throws when nothing is connected, when the id names no session, and when several are
-        // connected and none was named. All three mean the same thing here: there is no run to report,
-        // and an empty context is the honest answer rather than a reason to fail the call.
-        return {
-            actions: [],
-            events: [],
-            currentDocumentId: undefined,
-            currentEditEpoch: undefined,
-        };
-    }
-}
-export const CONTEXT_TOOLS = [
-    {
-        name: ReticleTool.CONTEXT,
-        description: 'What THIS run has already established, so you do not rediscover it. Call it when your own copy is gone: right after a compaction, at the top of a fresh sub-agent, or at the start of a turn you did not begin. Returns `established` (what Reticle OBSERVED, with the source file:line where one was reported), `proven` (claims a verdict already settled, so you neither re-prove them nor assume them) and `remaining` (the intents from .reticle/intent.json that nothing has discharged). It is a FOLD over the journal, never a second store, so it cannot disagree with the ledger. Bounded and superseding rather than accumulating, and anything observed under a replaced document or before your last source edit is already dropped rather than presented as current. Only what Reticle observed goes in: it never reports what you intended or believed.',
-        example: {},
-        inputSchema: { ...sessionIdShape },
-        outputSchema: CONTEXT_OUTPUT_SCHEMA,
-        handler: async (deps, args) => {
-            const sessionId = asString(args['sessionId']);
-            const evidence = await evidenceFor(deps, sessionId);
-            return runContextFor({ ...evidence, intents: await openSessionIntents(deps, sessionId) });
-        },
-    },
-];

package/dist/runs/render-report.js

@@ -1,69 +0,0 @@
-/**
- * Render an ReticleVerificationRun into a legible human/agent-facing report — the "is this actually
- * useful?" moment. Pure + deterministic (no clock, no IO): the same run renders the same text, so it's
- * safe in CI and as a partner-facing artifact. Raw JSON is the contract; this is the read.
- */
-import { RunCheckStatus, RunFlowStatus, VerdictStatus, } from '@reticlehq/core';
-const VERDICT_GLYPH = {
-    [VerdictStatus.PASS]: '✓ PASS',
-    [VerdictStatus.FAIL]: '✗ FAIL',
-    [VerdictStatus.PARTIAL]: '◑ PARTIAL',
-};
-const flowGlyph = (s) => s === RunFlowStatus.PASS
-    ? '✓'
-    : s === RunFlowStatus.HEALED
-        ? '✓~'
-        : s === RunFlowStatus.SKIPPED
-            ? '–'
-            : '✗';
-function flowLine(f) {
-    const head = `  ${flowGlyph(f.status)} ${f.name} (${f.steps} steps, ${f.durationMs}ms)`;
-    return f.failureReason !== undefined ? `${head} — ${f.failureReason}` : head;
-}
-function checkLine(c) {
-    const glyph = c.status === RunCheckStatus.PASS ? '✓' : '✗';
-    return `  ${glyph} ${c.kind}: ${c.predicate}`;
-}
-function riskLine(r) {
-    return `  ⚠ ${r.surface} (${r.severity})${r.gated ? ' [GATED]' : ''} — ${r.detail}`;
-}
-/** Render the run as a plain-text report. Sections with no content are omitted. */
-export function renderRunReport(run) {
-    const out = [];
-    out.push(`Reticle verification — ${run.project.name}  [${run.profile}]`);
-    out.push(`Verdict: ${VERDICT_GLYPH[run.verdict.status]}  ·  confidence: ${run.verdict.confidence}` +
-        (run.verdict.blockingRisks > 0 ? `  ·  ${run.verdict.blockingRisks} blocking risk(s)` : ''));
-    if (run.flows.length > 0) {
-        const passed = run.flows.filter((f) => f.status === RunFlowStatus.PASS || f.status === RunFlowStatus.HEALED).length;
-        out.push('', `Flows: ${passed}/${run.flows.length} passed`);
-        for (const f of run.flows)
-            out.push(flowLine(f));
-    }
-    const failedChecks = run.checks.filter((c) => c.status === RunCheckStatus.FAIL);
-    if (run.checks.length > 0) {
-        out.push('', `Checks: ${run.checks.length - failedChecks.length}/${run.checks.length} passed`);
-        for (const c of run.checks)
-            out.push(checkLine(c));
-    }
-    if (run.risks.length > 0) {
-        out.push('', 'Risks:');
-        for (const r of run.risks)
-            out.push(riskLine(r));
-    }
-    const packets = run.repair?.failurePackets ?? [];
-    if (packets.length > 0) {
-        out.push('', 'How to fix:');
-        for (const p of packets) {
-            const where = p.sourceLocation !== undefined
-                ? ` (${p.sourceLocation.file}${p.sourceLocation.line !== undefined ? `:${p.sourceLocation.line}` : ''})`
-                : '';
-            out.push(`  → ${p.flow ?? 'check'}${where}: ${p.suggestedPrompt}`);
-        }
-    }
-    if (run.verdict.status !== VerdictStatus.PASS && run.verdict.reasons.length > 0) {
-        out.push('', 'Why it failed:');
-        for (const reason of run.verdict.reasons)
-            out.push(`  - ${reason}`);
-    }
-    return out.join('\n');
-}

package/dist/runs/replay-mapping.js

@@ -1,34 +0,0 @@
-/**
- * Pure mapping from a flow-replay outcome (the existing reticle_flow_verify machinery) into the
- * verification-run artifact's per-flow shape. DRIFT and ERROR both collapse to FAIL — from a host's
- * perspective a flow that drifted no longer behaves, so it must not read as green. The actionable
- * "why" is lifted from the replay's decision envelope (or its error) into failureReason.
- */
-import { ReplayStatus, RunFlowStatus, } from '@reticlehq/core';
-import { SUCCESS_STEP_TOOL } from '../flows/flow-success.js';
-/** OK → PASS; DRIFT/ERROR → FAIL (a healed flow is produced by the heal path, not plain replay). */
-export function runFlowStatusOf(status) {
-    return status === ReplayStatus.OK ? RunFlowStatus.PASS : RunFlowStatus.FAIL;
-}
-/** Map one replay (plus its measured duration) into a RunFlowResult for the artifact's flows[]. */
-export function mapReplayToFlowResult(replay, durationMs) {
-    const status = runFlowStatusOf(replay.status);
-    const failureReason = status === RunFlowStatus.FAIL
-        ? (replay.decision?.whatChanged ??
-            replay.decision?.summary ??
-            replay.error?.message ??
-            'flow failed')
-        : undefined;
-    // A flow with a success oracle gets a synthetic 'success' step appended by replay; surface its label
-    // as the run's `oracle` so the verdict counts this flow as consequence-backed (→ HIGH confidence),
-    // not a bare smoke click. Without this, an oracle-backed pass reads as MEDIUM and undersells itself.
-    const oracle = replay.steps.find((s) => s.tool === SUCCESS_STEP_TOOL)?.anchor;
-    return {
-        name: replay.name,
-        status,
-        steps: replay.steps.length,
-        durationMs,
-        ...(oracle !== undefined ? { oracle } : {}),
-        ...(failureReason !== undefined ? { failureReason } : {}),
-    };
-}

package/dist/runs/reticle-runner.d.ts

@@ -1,60 +0,0 @@
-/**
- * ReticleRunner — the programmatic Replay/Verify API a host platform (OEM/design partner) or CI drives
- * from its own pipeline, with no MCP stdio and no human. It reuses the existing flow-replay machinery
- * and the verification-run assembler, returning a stable ReticleVerificationRun.
- *
- * Everything it needs from the live world is injected through RunnerPort, so the core orchestration is
- * fully testable without a CDP browser. The live adapter (wrapping ToolDeps: replayNamedFlow,
- * flows.list, the drive/CDP preview boot) and the token-guarded HTTP endpoint are thin layers built on
- * top of this — the orchestration and the verdict live here so the MCP path and the API produce the
- * same artifact byte-for-byte.
- */
-import { type FlowReplayResult, type ReticleVerificationRun, type RunId, type VerifyProgressEvent } from '@reticlehq/core';
-import { type VerificationRunInput } from './build-verification-run.js';
-import { type ChangedFileInput, type RiskPolicy } from './risk-classify.js';
-/** The live capabilities ReticleRunner needs. Injected so tests pass fakes (no CDP, no session). */
-export interface RunnerPort {
-    /** Saved flow names to verify when the caller doesn't pass an explicit subset. */
-    listFlows(): Promise<string[]>;
-    /** Replay one saved flow against the live/preview app, returning the existing replay contract. */
-    replayFlow(name: string): Promise<FlowReplayResult>;
-    /** Injected clock — the single time source (no Date.now in logic, rule 7). */
-    now(): number;
-    /** Injected run-id generator (no Math.random in logic) — the live adapter supplies a branded uuid. */
-    newRunId(): RunId;
-}
-/**
- * Narration for a run in flight. Optional, and never load-bearing.
- *
- * A verification is silent for its whole duration, so anything watching from outside cannot tell a
- * run that is working from one that has died. This is the seam that makes the difference visible.
- * It reports what is HAPPENING; the artifact remains the only record of what was PROVED.
- */
-export type VerifyProgressListener = (event: VerifyProgressEvent) => void;
-/** Run metadata the caller supplies; flows + verdict are produced by verify. */
-export interface VerifyOptions {
-    names?: string[];
-    project: VerificationRunInput['project'];
-    agent: VerificationRunInput['agent'];
-    trigger: VerificationRunInput['trigger'];
-    profile: VerificationRunInput['profile'];
-    /** The change set under test — classified into risk surfaces (auth/payment/db/…). */
-    changedFiles?: ChangedFileInput[];
-    /** Which touched surfaces block the verdict (require human confirmation). */
-    policy?: RiskPolicy;
-    /**
-     * Called as each flow starts and finishes. Best-effort by contract: a listener that throws is
-     * swallowed, because a REPORTER must never be able to fail the thing it is reporting on.
-     */
-    onProgress?: VerifyProgressListener;
-}
-export declare class ReticleRunner {
-    #private;
-    constructor(port: RunnerPort);
-    /**
-     * Replay the named flows (or every saved flow), map each outcome into the artifact, and assemble a
-     * verdict. Sequential by design — flows share the one live app and parallel replay would race the
-     * DOM (the same reason reticle_flow_verify is sequential).
-     */
-    verify(opts: VerifyOptions): Promise<ReticleVerificationRun>;
-}

package/dist/runs/reticle-runner.js

@@ -1,95 +0,0 @@
-/**
- * ReticleRunner — the programmatic Replay/Verify API a host platform (OEM/design partner) or CI drives
- * from its own pipeline, with no MCP stdio and no human. It reuses the existing flow-replay machinery
- * and the verification-run assembler, returning a stable ReticleVerificationRun.
- *
- * Everything it needs from the live world is injected through RunnerPort, so the core orchestration is
- * fully testable without a CDP browser. The live adapter (wrapping ToolDeps: replayNamedFlow,
- * flows.list, the drive/CDP preview boot) and the token-guarded HTTP endpoint are thin layers built on
- * top of this — the orchestration and the verdict live here so the MCP path and the API produce the
- * same artifact byte-for-byte.
- */
-import { reportRunTelemetry } from '../telemetry/run-telemetry.js';
-import { boundFlowName, RunFlowStatus, VerifyPhase, } from '@reticlehq/core';
-import { buildVerificationRun } from './build-verification-run.js';
-import { mapReplayToFlowResult } from './replay-mapping.js';
-import { buildRepairPackets } from './repair-prompt.js';
-import { buildRisks, classifyChangedFiles, } from './risk-classify.js';
-export class ReticleRunner {
-    #port;
-    constructor(port) {
-        this.#port = port;
-    }
-    /**
-     * Replay the named flows (or every saved flow), map each outcome into the artifact, and assemble a
-     * verdict. Sequential by design — flows share the one live app and parallel replay would race the
-     * DOM (the same reason reticle_flow_verify is sequential).
-     */
-    async verify(opts) {
-        const names = opts.names ?? (await this.#port.listFlows());
-        /*
-         * Emitting NEVER throws into the run. A dashboard, a log or an editor is watching, and none of
-         * them is worth failing a verification for — so a listener that blows up is dropped here rather
-         * than unwinding a suite somebody is waiting on.
-         */
-        const emit = (event) => {
-            try {
-                opts.onProgress?.(event);
-            }
-            catch {
-                /* a reporter cannot fail the thing it reports on */
-            }
-        };
-        const total = names.length;
-        // Announced BEFORE the loop: "step 3" without "of 12" does not answer the only question a
-        // person watching is actually asking, which is whether to keep waiting.
-        emit({ phase: VerifyPhase.FLOWS_FOUND, total, at: this.#port.now() });
-        const replays = [];
-        const flows = [];
-        for (const [index, name] of names.entries()) {
-            const start = this.#port.now();
-            emit({
-                phase: VerifyPhase.FLOW_STARTED,
-                index,
-                total,
-                name: boundFlowName(name),
-                at: start,
-            });
-            const replay = await this.#port.replayFlow(name);
-            replays.push(replay);
-            const mapped = mapReplayToFlowResult(replay, this.#port.now() - start);
-            flows.push(mapped);
-            emit({
-                phase: VerifyPhase.FLOW_FINISHED,
-                index,
-                total,
-                name: boundFlowName(name),
-                // A convenience for colouring a row while the run is live. The VERDICT is computed from the
-                // graded artifact below and never from this.
-                ok: mapped.status === RunFlowStatus.PASS,
-                at: this.#port.now(),
-            });
-        }
-        emit({ phase: VerifyPhase.GRADING, total, at: this.#port.now() });
-        const changedFiles = classifyChangedFiles(opts.changedFiles ?? []);
-        const risks = buildRisks(changedFiles, opts.policy);
-        const failurePackets = buildRepairPackets(replays);
-        const input = {
-            runId: this.#port.newRunId(),
-            durationMs: flows.reduce((sum, f) => sum + f.durationMs, 0),
-            profile: opts.profile,
-            project: opts.project,
-            agent: opts.agent,
-            trigger: opts.trigger,
-            changedFiles,
-            flows,
-            checks: [],
-            risks,
-            evidence: { consoleErrors: [], networkAnomalies: [], stateAssertions: [], timeline: [] },
-            ...(failurePackets.length > 0 ? { repair: { failurePackets } } : {}),
-        };
-        const run = buildVerificationRun(input, () => this.#port.now());
-        reportRunTelemetry(run);
-        return run;
-    }
-}

package/dist/runs/run-store.d.ts

@@ -1,54 +0,0 @@
-/**
- * Persistence for verification-run artifacts at .reticle/runs/<runId>.json. Mirrors ProjectStore:
- * injected FileSystemPort, never-throws read, path-segment guard on the runId (the tool-arg attack
- * surface). One artifact per file (unlike project.json's single rolling file) so a host can attach an
- * individual run to a deploy. The run is already clock-stamped by buildVerificationRun, so the store
- * needs no clock.
- */
-import { RunReadError, type ReticleVerificationRun, type RunId } from '@reticlehq/core';
-import type { FileSystemPort } from '../project/fs-port.js';
-/** Never-throws read result (mirrors ReadProjectResult). */
-export type ReadRunResult = {
-    ok: true;
-    run: ReticleVerificationRun;
-} | {
-    ok: false;
-    reason: RunReadError;
-};
-/** Optional retention overrides (defaults to the protocol caps). Injectable so tests prune fast. */
-interface RunStoreOptions {
-    retention?: number;
-    slack?: number;
-    /**
-     * Called after a run artifact is safely on disk. Used to wake cloud sync so a finished
-     * verification reaches the dashboard promptly instead of waiting for the next timer tick.
-     *
-     * A callback rather than a dependency on the sync daemon: the store's job is durability, and a
-     * store that imported the cloud would make "write a run" fail whenever the cloud did. It is
-     * invoked AFTER the rename, so nothing can observe a run that is not yet readable, and it must
-     * never throw — see the call site.
-     */
-    onWrote?: () => void;
-}
-export declare class RunStore {
-    #private;
-    constructor(fs: FileSystemPort, root: string, opts?: RunStoreOptions);
-    /**
-     * Write one run artifact. Creates .reticle/runs/ first; byte-stable (fixed indent + trailing newline).
-     * Guards runId as a safe path segment BEFORE building the path — a runId can originate from a caller
-     * (an OEM may set it), so an unsafe value must never escape .reticle/runs/ (mirrors the read guard).
-     */
-    write(run: ReticleVerificationRun): Promise<void>;
-    /** Never throws. Invalid id / missing → MISSING; bad JSON or failed schema → MALFORMED. */
-    read(runId: RunId): Promise<ReadRunResult>;
-    /** List run ids on disk (filenames minus.json). Empty when the runs dir is absent. */
-    list(): Promise<RunId[]>;
-    /** The most-recent run by createdAt (undefined when none). Powers reticle_run_export's default. */
-    latest(): Promise<ReticleVerificationRun | undefined>;
-    /**
-     * The two most-recent runs by createdAt as `[previous, current]` (oldest-first), or undefined when
-     * fewer than two readable runs exist. Powers reticle_run_export's `format:"diff"` (run-to-run deltas).
-     */
-    latestTwo(): Promise<[ReticleVerificationRun, ReticleVerificationRun] | undefined>;
-}
-export {};