@reticlehq/server 2.0.0

package/dist/runs/reticle-runner.js

@@ -0,0 +1,56 @@
+/**
+ * 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 { 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());
+        const replays = [];
+        const flows = [];
+        for (const name of names) {
+            const start = this.#port.now();
+            const replay = await this.#port.replayFlow(name);
+            replays.push(replay);
+            flows.push(mapReplayToFlowResult(replay, this.#port.now() - start));
+        }
+        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 } } : {}),
+        };
+        return buildVerificationRun(input, () => this.#port.now());
+    }
+}
+//# sourceMappingURL=reticle-runner.js.map

package/dist/runs/reticle-runner.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reticle-runner.js","sourceRoot":"","sources":["../../src/runs/reticle-runner.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAGH,OAAO,EAAE,oBAAoB,EAA6B,MAAM,6BAA6B,CAAC;AAC9F,OAAO,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAC;AAC5D,OAAO,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AACxD,OAAO,EACL,UAAU,EACV,oBAAoB,GAGrB,MAAM,oBAAoB,CAAC;AA2B5B,MAAM,OAAO,aAAa;IACf,KAAK,CAAa;IAE3B,YAAY,IAAgB;QAC1B,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC;IACpB,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,MAAM,CAAC,IAAmB;QAC9B,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,IAAI,CAAC,MAAM,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,CAAC,CAAC;QAC3D,MAAM,OAAO,GAAG,EAAE,CAAC;QACnB,MAAM,KAAK,GAAG,EAAE,CAAC;QACjB,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;YACzB,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC;YAC/B,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;YACjD,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;YACrB,KAAK,CAAC,IAAI,CAAC,qBAAqB,CAAC,MAAM,EAAE,IAAI,CAAC,KAAK,CAAC,GAAG,EAAE,GAAG,KAAK,CAAC,CAAC,CAAC;QACtE,CAAC;QAED,MAAM,YAAY,GAAG,oBAAoB,CAAC,IAAI,CAAC,YAAY,IAAI,EAAE,CAAC,CAAC;QACnE,MAAM,KAAK,GAAG,UAAU,CAAC,YAAY,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;QACpD,MAAM,cAAc,GAAG,kBAAkB,CAAC,OAAO,CAAC,CAAC;QAEnD,MAAM,KAAK,GAAyB;YAClC,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,QAAQ,EAAE;YAC5B,UAAU,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,CAAC,EAAE,EAAE,CAAC,GAAG,GAAG,CAAC,CAAC,UAAU,EAAE,CAAC,CAAC;YAC3D,OAAO,EAAE,IAAI,CAAC,OAAO;YACrB,OAAO,EAAE,IAAI,CAAC,OAAO;YACrB,KAAK,EAAE,IAAI,CAAC,KAAK;YACjB,OAAO,EAAE,IAAI,CAAC,OAAO;YACrB,YAAY;YACZ,KAAK;YACL,MAAM,EAAE,EAAE;YACV,KAAK;YACL,QAAQ,EAAE,EAAE,aAAa,EAAE,EAAE,EAAE,gBAAgB,EAAE,EAAE,EAAE,eAAe,EAAE,EAAE,EAAE,QAAQ,EAAE,EAAE,EAAE;YACxF,GAAG,CAAC,cAAc,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,cAAc,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;SACrE,CAAC;QACF,OAAO,oBAAoB,CAAC,KAAK,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,CAAC;IAC7D,CAAC;CACF"}

package/dist/runs/risk-classify.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Risk classification — map a change set onto the risk surfaces a host must reason about before
+ * shipping generated software (the surfaces real AI-app-builder incidents cluster around: production
+ * data loss, auth/payment/RLS/secrets mistakes). Pure + heuristic: path patterns → surfaces now,
+ * refine later. A RiskPolicy marks chosen surfaces as gated, which the verdict turns into blocking
+ * risks. Every pattern is a named constant (no free strings / inline regexes scattered around).
+ */
+import { RiskSurface, RunChangeKind, type RunChangedFile, type RunRisk } from '@reticlehq/core';
+/** The risk surfaces a single path implicates (unique, stable order = RISK_PATTERNS order). */
+export declare function risksForPath(path: string): RiskSurface[];
+/** A change set Reticle was told about (the live wiring derives this from the diff). */
+export interface ChangedFileInput {
+    path: string;
+    changeKind: RunChangeKind;
+}
+/** Policy: which surfaces, if touched, block the verdict (require human confirmation). */
+export interface RiskPolicy {
+    requiresConfirmation?: RiskSurface[];
+}
+/** Tag each changed file with the surfaces it touches (for the artifact's changedFiles[]). */
+export declare function classifyChangedFiles(files: ReadonlyArray<ChangedFileInput>): RunChangedFile[];
+/**
+ * Collapse the per-file surfaces into one risk row per surface (deduped across the change set), with
+ * severity and a gated flag driven by the policy. This is what the verdict counts as blocking.
+ */
+export declare function buildRisks(changedFiles: ReadonlyArray<RunChangedFile>, policy?: RiskPolicy): RunRisk[];
+//# sourceMappingURL=risk-classify.d.ts.map

package/dist/runs/risk-classify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"risk-classify.d.ts","sourceRoot":"","sources":["../../src/runs/risk-classify.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAEL,WAAW,EACX,aAAa,EACb,KAAK,cAAc,EACnB,KAAK,OAAO,EACb,MAAM,iBAAiB,CAAC;AAmCzB,+FAA+F;AAC/F,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,EAAE,CAExD;AAED,wFAAwF;AACxF,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,aAAa,CAAC;CAC3B;AAED,0FAA0F;AAC1F,MAAM,WAAW,UAAU;IACzB,oBAAoB,CAAC,EAAE,WAAW,EAAE,CAAC;CACtC;AAED,8FAA8F;AAC9F,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,aAAa,CAAC,gBAAgB,CAAC,GAAG,cAAc,EAAE,CAE7F;AAED;;;GAGG;AACH,wBAAgB,UAAU,CACxB,YAAY,EAAE,aAAa,CAAC,cAAc,CAAC,EAC3C,MAAM,GAAE,UAAe,GACtB,OAAO,EAAE,CAuBX"}

package/dist/runs/risk-classify.js

@@ -0,0 +1,76 @@
+/**
+ * Risk classification — map a change set onto the risk surfaces a host must reason about before
+ * shipping generated software (the surfaces real AI-app-builder incidents cluster around: production
+ * data loss, auth/payment/RLS/secrets mistakes). Pure + heuristic: path patterns → surfaces now,
+ * refine later. A RiskPolicy marks chosen surfaces as gated, which the verdict turns into blocking
+ * risks. Every pattern is a named constant (no free strings / inline regexes scattered around).
+ */
+import { RiskSeverity, RiskSurface, RunChangeKind, } from '@reticlehq/core';
+/** Path heuristics per surface. Order is irrelevant — a path may match several surfaces. */
+const RISK_PATTERNS = [
+    {
+        surface: RiskSurface.AUTH,
+        pattern: /(\bauth\b|login|logout|sign-?in|sign-?up|session|oauth|jwt|password)/i,
+    },
+    {
+        surface: RiskSurface.PAYMENT,
+        pattern: /(payment|checkout|stripe|billing|invoice|charge|subscription)/i,
+    },
+    {
+        surface: RiskSurface.DB,
+        pattern: /(schema\.|prisma|drizzle|\bdb\b|database|\.sql$|repository)/i,
+    },
+    { surface: RiskSurface.MIGRATION, pattern: /(migration|migrate)/i },
+    { surface: RiskSurface.RLS, pattern: /(\brls\b|row-?level|policy\.sql|policies)/i },
+    { surface: RiskSurface.SECRETS, pattern: /(\.env|secret|api[-_]?key|credential|\btoken\b)/i },
+    { surface: RiskSurface.DESTRUCTIVE, pattern: /(delete|destroy|\bdrop\b|truncate|purge|wipe)/i },
+    { surface: RiskSurface.EXTERNAL, pattern: /(webhook|external|third-?party|integration)/i },
+];
+/** Severity per surface — the "how bad if this is wrong" floor. */
+const SURFACE_SEVERITY = {
+    [RiskSurface.AUTH]: RiskSeverity.HIGH,
+    [RiskSurface.PAYMENT]: RiskSeverity.CRITICAL,
+    [RiskSurface.DB]: RiskSeverity.HIGH,
+    [RiskSurface.MIGRATION]: RiskSeverity.HIGH,
+    [RiskSurface.RLS]: RiskSeverity.CRITICAL,
+    [RiskSurface.SECRETS]: RiskSeverity.CRITICAL,
+    [RiskSurface.DESTRUCTIVE]: RiskSeverity.HIGH,
+    [RiskSurface.EXTERNAL]: RiskSeverity.MEDIUM,
+};
+/** The risk surfaces a single path implicates (unique, stable order = RISK_PATTERNS order). */
+export function risksForPath(path) {
+    return RISK_PATTERNS.filter((r) => r.pattern.test(path)).map((r) => r.surface);
+}
+/** Tag each changed file with the surfaces it touches (for the artifact's changedFiles[]). */
+export function classifyChangedFiles(files) {
+    return files.map((f) => ({ path: f.path, changeKind: f.changeKind, risk: risksForPath(f.path) }));
+}
+/**
+ * Collapse the per-file surfaces into one risk row per surface (deduped across the change set), with
+ * severity and a gated flag driven by the policy. This is what the verdict counts as blocking.
+ */
+export function buildRisks(changedFiles, policy = {}) {
+    const gatedSet = new Set(policy.requiresConfirmation ?? []);
+    const filesBySurface = new Map();
+    for (const file of changedFiles) {
+        for (const surface of file.risk) {
+            const list = filesBySurface.get(surface) ?? [];
+            list.push(file.path);
+            filesBySurface.set(surface, list);
+        }
+    }
+    const risks = [];
+    for (const { surface } of RISK_PATTERNS) {
+        const files = filesBySurface.get(surface);
+        if (files === undefined || files.length === 0)
+            continue;
+        risks.push({
+            surface,
+            severity: SURFACE_SEVERITY[surface],
+            detail: `${files.length} changed file(s) touch the ${surface} surface (e.g. ${files[0]})`,
+            gated: gatedSet.has(surface),
+        });
+    }
+    return risks;
+}
+//# sourceMappingURL=risk-classify.js.map

package/dist/runs/risk-classify.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"risk-classify.js","sourceRoot":"","sources":["../../src/runs/risk-classify.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,40 @@
+/**
+ * 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;
+}
+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>;
+}
+export {};
+//# sourceMappingURL=run-store.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"run-store.d.ts","sourceRoot":"","sources":["../../src/runs/run-store.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAKL,YAAY,EACZ,KAAK,sBAAsB,EAC3B,KAAK,KAAK,EACX,MAAM,iBAAiB,CAAC;AACzB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAO5D,4DAA4D;AAC5D,MAAM,MAAM,aAAa,GACrB;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,GAAG,EAAE,sBAAsB,CAAA;CAAE,GACzC;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,YAAY,CAAA;CAAE,CAAC;AAExC,oGAAoG;AACpG,UAAU,eAAe;IACvB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,qBAAa,QAAQ;;gBAMP,EAAE,EAAE,cAAc,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,GAAE,eAAoB;IAOxE;;;;OAIG;IACG,KAAK,CAAC,GAAG,EAAE,sBAAsB,GAAG,OAAO,CAAC,IAAI,CAAC;IAgCvD,2FAA2F;IACrF,IAAI,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,CAAC,aAAa,CAAC;IA2BhD,uFAAuF;IACjF,IAAI,IAAI,OAAO,CAAC,KAAK,EAAE,CAAC;IAc9B,mGAAmG;IAC7F,MAAM,IAAI,OAAO,CAAC,sBAAsB,GAAG,SAAS,CAAC;CAW5D"}

package/dist/runs/run-store.js

@@ -0,0 +1,118 @@
+/**
+ * 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 { asRunId, ReticleVerificationRunSchema, RUN_RETENTION, RUN_RETENTION_SLACK, RunReadError, } from '@reticlehq/core';
+import { reticleDirPaths, isValidRunId, runPath } from '../project/reticle-dir.js';
+const JSON_INDENT = 2;
+const JSON_EXT = '.json';
+const TMP_EXT = '.tmp';
+export class RunStore {
+    #fs;
+    #root;
+    #retention;
+    #slack;
+    constructor(fs, root, opts = {}) {
+        this.#fs = fs;
+        this.#root = root;
+        this.#retention = opts.retention ?? RUN_RETENTION;
+        this.#slack = opts.slack ?? RUN_RETENTION_SLACK;
+    }
+    /**
+     * 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).
+     */
+    async write(run) {
+        if (!isValidRunId(run.runId)) {
+            throw new Error(`refusing to write run with unsafe runId: ${JSON.stringify(run.runId)}`);
+        }
+        await this.#fs.mkdir(reticleDirPaths(this.#root).runs);
+        // Atomic publish: write a temp file then rename, so a crash mid-write never leaves a half-written
+        // artifact (a partial .json would otherwise read back as MALFORMED).
+        const path = runPath(this.#root, run.runId);
+        const tmp = `${path}${TMP_EXT}`;
+        await this.#fs.writeFile(tmp, `${JSON.stringify(run, null, JSON_INDENT)}\n`);
+        await this.#fs.rename(tmp, path);
+        await this.#pruneOld();
+    }
+    /**
+     * Keep .reticle/runs/ bounded. Only acts once the count exceeds RUN_RETENTION + SLACK, then deletes the
+     * oldest (by createdAt) back down to RUN_RETENTION — so the read-all is amortized, not per-write.
+     */
+    async #pruneOld() {
+        const ids = await this.list();
+        if (ids.length <= this.#retention + this.#slack)
+            return;
+        const stamped = [];
+        for (const id of ids) {
+            const result = await this.read(id);
+            stamped.push({ id, at: result.ok ? result.run.createdAt : 0 });
+        }
+        stamped.sort((a, b) => a.at - b.at);
+        for (const { id } of stamped.slice(0, stamped.length - this.#retention)) {
+            await this.#fs.rm(runPath(this.#root, id));
+        }
+    }
+    /** Never throws. Invalid id / missing → MISSING; bad JSON or failed schema → MALFORMED. */
+    async read(runId) {
+        if (!isValidRunId(runId))
+            return { ok: false, reason: RunReadError.MISSING };
+        const path = runPath(this.#root, runId);
+        if (!(await this.#fs.exists(path)))
+            return { ok: false, reason: RunReadError.MISSING };
+        let text;
+        try {
+            text = await this.#fs.readFile(path);
+        }
+        catch (error) {
+            return {
+                ok: false,
+                reason: this.#fs.isNotFound(error) ? RunReadError.MISSING : RunReadError.MALFORMED,
+            };
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(text);
+        }
+        catch {
+            return { ok: false, reason: RunReadError.MALFORMED };
+        }
+        const result = ReticleVerificationRunSchema.safeParse(parsed);
+        if (!result.success)
+            return { ok: false, reason: RunReadError.MALFORMED };
+        return { ok: true, run: result.data };
+    }
+    /** List run ids on disk (filenames minus .json). Empty when the runs dir is absent. */
+    async list() {
+        const dir = reticleDirPaths(this.#root).runs;
+        if (!(await this.#fs.exists(dir)))
+            return [];
+        let entries;
+        try {
+            entries = await this.#fs.readdir(dir);
+        }
+        catch {
+            return [];
+        }
+        return entries
+            .filter((e) => e.endsWith(JSON_EXT))
+            .map((e) => asRunId(e.slice(0, -JSON_EXT.length)));
+    }
+    /** The most-recent run by createdAt (undefined when none). Powers reticle_run_export's default. */
+    async latest() {
+        const ids = await this.list();
+        let best;
+        for (const id of ids) {
+            const result = await this.read(id);
+            if (result.ok && (best === undefined || result.run.createdAt > best.createdAt)) {
+                best = result.run;
+            }
+        }
+        return best;
+    }
+}
+//# sourceMappingURL=run-store.js.map

package/dist/runs/run-store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-store.js","sourceRoot":"","sources":["../../src/runs/run-store.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,10 @@
+import type { ToolDef } from '../tools/tools.js';
+/**
+ * The verification-run export tool. `reticle_run_export` reads a persisted ReticleVerificationRun artifact
+ * from .reticle/runs/ — the stable verdict a host platform (OEM/design partner) or CI consumes. With a
+ * runId it returns that run; without one it returns the most recent. With format:"report" it returns a
+ * legible ✓/✗ text report instead of raw JSON. The RunStore is built inline from the injected fs +
+ * reticleRoot (it is stateless), so this needs no new ToolDeps wiring.
+ */
+export declare const RUN_TOOLS: ToolDef[];
+//# sourceMappingURL=run-tools.d.ts.map

package/dist/runs/run-tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-tools.d.ts","sourceRoot":"","sources":["../../src/runs/run-tools.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,OAAO,EAAY,MAAM,mBAAmB,CAAC;AAI3D;;;;;;GAMG;AACH,eAAO,MAAM,SAAS,EAAE,OAAO,EAqD9B,CAAC"}

package/dist/runs/run-tools.js

@@ -0,0 +1,69 @@
+import { z } from 'zod';
+import { RunReadError } from '@reticlehq/core';
+import { ReticleTool } from '../tools/tool-names.js';
+import { asString } from '../tools/tools-helpers.js';
+import { sessionIdShape } from '../tools/tool-kit.js';
+import { isValidRunId } from '../project/reticle-dir.js';
+import { RunStore } from './run-store.js';
+import { renderRunReport } from './render-report.js';
+/**
+ * The verification-run export tool. `reticle_run_export` reads a persisted ReticleVerificationRun artifact
+ * from .reticle/runs/ — the stable verdict a host platform (OEM/design partner) or CI consumes. With a
+ * runId it returns that run; without one it returns the most recent. With format:"report" it returns a
+ * legible ✓/✗ text report instead of raw JSON. The RunStore is built inline from the injected fs +
+ * reticleRoot (it is stateless), so this needs no new ToolDeps wiring.
+ */
+export const RUN_TOOLS = [
+    {
+        name: ReticleTool.RUN_EXPORT,
+        description: 'Export a verification-run artifact (the OEM/CI-consumable verdict) from .reticle/runs/. With { runId } returns that specific run; without it returns the most recent. With { format: "report" } returns a legible ✓/✗ text summary (flows, checks, risks, repair, why-it-failed) instead of the raw run. Returns { run } | { report } or { error, reason } when none exists.',
+        inputSchema: {
+            runId: z
+                .string()
+                .optional()
+                .describe('The run id to export. Omit to return the most recent run.'),
+            format: z
+                .enum(['json', 'report'])
+                .optional()
+                .describe('json (default) returns the full run; report returns a legible text summary.'),
+            ...sessionIdShape,
+        },
+        outputSchema: {
+            run: z.unknown().optional(),
+            report: z.string().optional(),
+            error: z.string().optional(),
+        },
+        handler: async (deps, args) => {
+            const store = new RunStore(deps.fs, deps.reticleRoot);
+            const runId = asString(args['runId']);
+            let run;
+            if (runId !== undefined) {
+                if (!isValidRunId(runId)) {
+                    return { error: `no run '${runId}' in .reticle/runs/`, reason: RunReadError.MISSING };
+                }
+                const read = await store.read(runId);
+                if (!read.ok) {
+                    return {
+                        error: read.reason === RunReadError.MISSING
+                            ? `no run '${runId}' in .reticle/runs/`
+                            : `run '${runId}' is malformed`,
+                        reason: read.reason,
+                    };
+                }
+                run = read.run;
+            }
+            else {
+                const latest = await store.latest();
+                if (latest === undefined) {
+                    return {
+                        error: 'no verification runs yet — produce one with the verify flow first',
+                        reason: RunReadError.MISSING,
+                    };
+                }
+                run = latest;
+            }
+            return asString(args['format']) === 'report' ? { report: renderRunReport(run) } : { run };
+        },
+    },
+];
+//# sourceMappingURL=run-tools.js.map

package/dist/runs/run-tools.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-tools.js","sourceRoot":"","sources":["../../src/runs/run-tools.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,YAAY,EAA+B,MAAM,iBAAiB,CAAC;AAC5E,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,EAAE,QAAQ,EAAE,MAAM,2BAA2B,CAAC;AACrD,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AACtD,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAEzD,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC1C,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAErD;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,SAAS,GAAc;IAClC;QACE,IAAI,EAAE,WAAW,CAAC,UAAU;QAC5B,WAAW,EACT,8WAA8W;QAChX,WAAW,EAAE;YACX,KAAK,EAAE,CAAC;iBACL,MAAM,EAAE;iBACR,QAAQ,EAAE;iBACV,QAAQ,CAAC,2DAA2D,CAAC;YACxE,MAAM,EAAE,CAAC;iBACN,IAAI,CAAC,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;iBACxB,QAAQ,EAAE;iBACV,QAAQ,CAAC,6EAA6E,CAAC;YAC1F,GAAG,cAAc;SAClB;QACD,YAAY,EAAE;YACZ,GAAG,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE;YAC3B,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;YAC7B,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;SAC7B;QACD,OAAO,EAAE,KAAK,EAAE,IAAc,EAAE,IAA6B,EAAE,EAAE;YAC/D,MAAM,KAAK,GAAG,IAAI,QAAQ,CAAC,IAAI,CAAC,EAAE,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC;YACtD,MAAM,KAAK,GAAG,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;YACtC,IAAI,GAA2B,CAAC;YAChC,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;gBACxB,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,EAAE,CAAC;oBACzB,OAAO,EAAE,KAAK,EAAE,WAAW,KAAK,qBAAqB,EAAE,MAAM,EAAE,YAAY,CAAC,OAAO,EAAE,CAAC;gBACxF,CAAC;gBACD,MAAM,IAAI,GAAG,MAAM,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;gBACrC,IAAI,CAAC,IAAI,CAAC,EAAE,EAAE,CAAC;oBACb,OAAO;wBACL,KAAK,EACH,IAAI,CAAC,MAAM,KAAK,YAAY,CAAC,OAAO;4BAClC,CAAC,CAAC,WAAW,KAAK,qBAAqB;4BACvC,CAAC,CAAC,QAAQ,KAAK,gBAAgB;wBACnC,MAAM,EAAE,IAAI,CAAC,MAAM;qBACpB,CAAC;gBACJ,CAAC;gBACD,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC;YACjB,CAAC;iBAAM,CAAC;gBACN,MAAM,MAAM,GAAG,MAAM,KAAK,CAAC,MAAM,EAAE,CAAC;gBACpC,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;oBACzB,OAAO;wBACL,KAAK,EAAE,mEAAmE;wBAC1E,MAAM,EAAE,YAAY,CAAC,OAAO;qBAC7B,CAAC;gBACJ,CAAC;gBACD,GAAG,GAAG,MAAM,CAAC;YACf,CAAC;YACD,OAAO,QAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,KAAK,QAAQ,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,eAAe,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC;QAC5F,CAAC;KACF;CACF,CAAC"}

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

@@ -0,0 +1,14 @@
+/**
+ * The live adapter: build a RunnerPort from the real ToolDeps so ReticleRunner drives actual flow
+ * replays against the connected app. Thin glue — it wires deps.flows.list, replayNamedFlow, deps.now,
+ * and a uuid generator. The ReticleRunner core (tested with a fake port) holds all the orchestration and
+ * verdict logic, so this layer carries no decisions.
+ */
+import { type RunId } from '@reticlehq/core';
+import type { ToolDeps } from '../tools/tools.js';
+import type { RunnerPort } from './reticle-runner.js';
+/** The default run-id generator — a branded uuid. Isolated so it can be swapped/tested independently. */
+export declare function defaultRunId(): RunId;
+/** Wire a RunnerPort to the live session. Pass sessionId to disambiguate when several tabs are open. */
+export declare function createRunnerPort(deps: ToolDeps, sessionId?: string): RunnerPort;
+//# sourceMappingURL=runner-port.d.ts.map

package/dist/runs/runner-port.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runner-port.d.ts","sourceRoot":"","sources":["../../src/runs/runner-port.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,EAAW,KAAK,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAEtD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAClD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAEtD,yGAAyG;AACzG,wBAAgB,YAAY,IAAI,KAAK,CAEpC;AAED,wGAAwG;AACxG,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,QAAQ,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,UAAU,CAW/E"}

package/dist/runs/runner-port.js

@@ -0,0 +1,23 @@
+/**
+ * The live adapter: build a RunnerPort from the real ToolDeps so ReticleRunner drives actual flow
+ * replays against the connected app. Thin glue — it wires deps.flows.list, replayNamedFlow, deps.now,
+ * and a uuid generator. The ReticleRunner core (tested with a fake port) holds all the orchestration and
+ * verdict logic, so this layer carries no decisions.
+ */
+import { randomUUID } from 'node:crypto';
+import { asRunId } from '@reticlehq/core';
+import { replayNamedFlow } from '../flows/flow-tools.js';
+/** The default run-id generator — a branded uuid. Isolated so it can be swapped/tested independently. */
+export function defaultRunId() {
+    return asRunId(randomUUID());
+}
+/** Wire a RunnerPort to the live session. Pass sessionId to disambiguate when several tabs are open. */
+export function createRunnerPort(deps, sessionId) {
+    return {
+        listFlows: () => deps.flows.list(),
+        replayFlow: (name) => replayNamedFlow(deps, sessionId !== undefined ? { flowName: name, sessionId } : { flowName: name }),
+        now: () => deps.now(),
+        newRunId: defaultRunId,
+    };
+}
+//# sourceMappingURL=runner-port.js.map

package/dist/runs/runner-port.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"runner-port.js","sourceRoot":"","sources":["../../src/runs/runner-port.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AACzC,OAAO,EAAE,OAAO,EAAc,MAAM,iBAAiB,CAAC;AACtD,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAIzD,yGAAyG;AACzG,MAAM,UAAU,YAAY;IAC1B,OAAO,OAAO,CAAC,UAAU,EAAE,CAAC,CAAC;AAC/B,CAAC;AAED,wGAAwG;AACxG,MAAM,UAAU,gBAAgB,CAAC,IAAc,EAAE,SAAkB;IACjE,OAAO;QACL,SAAS,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE;QAClC,UAAU,EAAE,CAAC,IAAI,EAAE,EAAE,CACnB,eAAe,CACb,IAAI,EACJ,SAAS,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,IAAI,EAAE,SAAS,EAAE,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,IAAI,EAAE,CAC7E;QACH,GAAG,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,GAAG,EAAE;QACrB,QAAQ,EAAE,YAAY;KACvB,CAAC;AACJ,CAAC"}

package/dist/runs/verify-http.d.ts

@@ -0,0 +1,34 @@
+/**
+ * The token-guarded HTTP verify endpoint — how a host platform (OEM/design partner) or CI drives a
+ * verdict from its own pipeline, with no MCP stdio and no human. The request handler is PURE (takes a
+ * parsed request, returns a status + body), so it is fully testable without binding a socket; a thin
+ * node:http adapter wires it to the wire. Localhost-bound by design; a configured token adds defence
+ * in depth (timing-safe compared). An optional persist hook writes the run via RunStore.
+ */
+import { type ReticleVerificationRun } from '@reticlehq/core';
+import type { ReticleRunner } from './reticle-runner.js';
+/** The POST route a partner pipeline calls to get a verdict. */
+export declare const VERIFY_PATH = "/verify";
+/** Constant-time token check. Empty expected token ⇒ open (localhost-only deployments). */
+export declare function tokenOk(provided: string | undefined, expected: string): boolean;
+/** The parsed request the pure handler operates on (decoupled from node:http). */
+export interface VerifyHttpRequest {
+    method: string;
+    path: string;
+    token?: string;
+    body: unknown;
+}
+export interface VerifyHttpResponse {
+    status: number;
+    body: {
+        run: ReticleVerificationRun;
+    } | {
+        error: string;
+    };
+}
+/**
+ * Pure verify handler. Routes/guards, parses the body, runs the verify, optionally persists the run,
+ * and returns a status + body. No sockets, no globals — a test calls it directly.
+ */
+export declare function handleVerifyRequest(req: VerifyHttpRequest, runner: ReticleRunner, expectedToken: string, persist?: (run: ReticleVerificationRun) => Promise<void>): Promise<VerifyHttpResponse>;
+//# sourceMappingURL=verify-http.d.ts.map

package/dist/runs/verify-http.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verify-http.d.ts","sourceRoot":"","sources":["../../src/runs/verify-http.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAIH,OAAO,EAML,KAAK,sBAAsB,EAC5B,MAAM,iBAAiB,CAAC;AACzB,OAAO,KAAK,EAAE,aAAa,EAAiB,MAAM,qBAAqB,CAAC;AAExE,gEAAgE;AAChE,eAAO,MAAM,WAAW,YAAY,CAAC;AA4DrC,2FAA2F;AAC3F,wBAAgB,OAAO,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAM/E;AAED,kFAAkF;AAClF,MAAM,WAAW,iBAAiB;IAChC,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,OAAO,CAAC;CACf;AAED,MAAM,WAAW,kBAAkB;IACjC,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE;QAAE,GAAG,EAAE,sBAAsB,CAAA;KAAE,GAAG;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;CAC3D;AAED;;;GAGG;AACH,wBAAsB,mBAAmB,CACvC,GAAG,EAAE,iBAAiB,EACtB,MAAM,EAAE,aAAa,EACrB,aAAa,EAAE,MAAM,EACrB,OAAO,CAAC,EAAE,CAAC,GAAG,EAAE,sBAAsB,KAAK,OAAO,CAAC,IAAI,CAAC,GACvD,OAAO,CAAC,kBAAkB,CAAC,CAe7B"}

package/dist/runs/verify-http.js

@@ -0,0 +1,102 @@
+/**
+ * The token-guarded HTTP verify endpoint — how a host platform (OEM/design partner) or CI drives a
+ * verdict from its own pipeline, with no MCP stdio and no human. The request handler is PURE (takes a
+ * parsed request, returns a status + body), so it is fully testable without binding a socket; a thin
+ * node:http adapter wires it to the wire. Localhost-bound by design; a configured token adds defence
+ * in depth (timing-safe compared). An optional persist hook writes the run via RunStore.
+ */
+import { timingSafeEqual } from 'node:crypto';
+import { z } from 'zod';
+import { RunAgentKind, RunEnv, RunFramework, RunProfile, RunTrigger, } from '@reticlehq/core';
+/** The POST route a partner pipeline calls to get a verdict. */
+export const VERIFY_PATH = '/verify';
+/** Lenient request body — every field optional; sane defaults are filled by toVerifyOptions. */
+const VerifyRequestSchema = z.object({
+    names: z.array(z.string()).optional(),
+    project: z
+        .object({
+        name: z.string().optional(),
+        framework: z.nativeEnum(RunFramework).optional(),
+        commit: z.string().optional(),
+        env: z.nativeEnum(RunEnv).optional(),
+        previewUrl: z.string().optional(),
+    })
+        .optional(),
+    agent: z
+        .object({
+        id: z.string().optional(),
+        kind: z.nativeEnum(RunAgentKind).optional(),
+        model: z.string().optional(),
+    })
+        .optional(),
+    trigger: z
+        .object({
+        kind: z.nativeEnum(RunTrigger).optional(),
+        diffRef: z.string().optional(),
+        note: z.string().optional(),
+    })
+        .optional(),
+    profile: z.nativeEnum(RunProfile).optional(),
+});
+/** Map a parsed request into VerifyOptions, defaulting the required pipeline fields. */
+function toVerifyOptions(body) {
+    const project = {
+        name: body.project?.name ?? 'app',
+        framework: body.project?.framework ?? RunFramework.OTHER,
+        ...(body.project?.commit !== undefined ? { commit: body.project.commit } : {}),
+        ...(body.project?.env !== undefined ? { env: body.project.env } : {}),
+        ...(body.project?.previewUrl !== undefined ? { previewUrl: body.project.previewUrl } : {}),
+    };
+    const agent = {
+        id: body.agent?.id ?? 'oem-pipeline',
+        kind: body.agent?.kind ?? RunAgentKind.OEM_PIPELINE,
+        ...(body.agent?.model !== undefined ? { model: body.agent.model } : {}),
+    };
+    const trigger = {
+        kind: body.trigger?.kind ?? RunTrigger.OEM,
+        ...(body.trigger?.diffRef !== undefined ? { diffRef: body.trigger.diffRef } : {}),
+        ...(body.trigger?.note !== undefined ? { note: body.trigger.note } : {}),
+    };
+    return {
+        ...(body.names !== undefined ? { names: body.names } : {}),
+        project,
+        agent,
+        trigger,
+        profile: body.profile ?? RunProfile.PROD_PREVIEW,
+    };
+}
+/** Constant-time token check. Empty expected token ⇒ open (localhost-only deployments). */
+export function tokenOk(provided, expected) {
+    if (expected.length === 0)
+        return true;
+    if (provided === undefined)
+        return false;
+    const a = Buffer.from(provided);
+    const b = Buffer.from(expected);
+    return a.length === b.length && timingSafeEqual(a, b);
+}
+/**
+ * Pure verify handler. Routes/guards, parses the body, runs the verify, optionally persists the run,
+ * and returns a status + body. No sockets, no globals — a test calls it directly.
+ */
+export async function handleVerifyRequest(req, runner, expectedToken, persist) {
+    if (req.path !== VERIFY_PATH)
+        return { status: 404, body: { error: 'not found' } };
+    if (req.method !== 'POST')
+        return { status: 405, body: { error: 'method not allowed' } };
+    if (!tokenOk(req.token, expectedToken))
+        return { status: 401, body: { error: 'unauthorized' } };
+    const parsed = VerifyRequestSchema.safeParse(req.body ?? {});
+    if (!parsed.success)
+        return { status: 400, body: { error: 'invalid request body' } };
+    try {
+        const run = await runner.verify(toVerifyOptions(parsed.data));
+        if (persist !== undefined)
+            await persist(run);
+        return { status: 200, body: { run } };
+    }
+    catch {
+        return { status: 500, body: { error: 'verify failed' } };
+    }
+}
+//# sourceMappingURL=verify-http.js.map