@petepetrash/circuit 0.1.0

package/dist/runtime/run/resume-lock.d.ts

@@ -0,0 +1,29 @@
+import { type ProcessAliveCheck } from '../fanout/run-owner-lock.js';
+/** Plain-English refusal shown when another resume already owns this run. */
+export declare const RESUME_IN_PROGRESS_MESSAGE = "Another resume is already running for this run. Wait for it to finish before resuming again.";
+/** Absolute path to a run's resume lock. */
+export declare function resumeLockPath(runDir: string): string;
+export interface ResumeLockHandle {
+    /** Release the lock. Best-effort and idempotent — safe to call more than once. */
+    release(): void;
+}
+export type AcquireResumeLockResult = {
+    readonly ok: true;
+    readonly handle: ResumeLockHandle;
+} | {
+    readonly ok: false;
+    readonly message: string;
+};
+export interface AcquireResumeLockOptions {
+    readonly now?: () => Date;
+    /** Injected so tests can drive the stale-reclaim path without real pids. */
+    readonly processAlive?: ProcessAliveCheck;
+}
+/**
+ * Acquire the resume lock for `runDir`, or refuse. On success the returned
+ * handle must be released when the resume completes (or the process exits). On
+ * refusal the caller surfaces `message` to the operator and does NOT touch the
+ * trace.
+ */
+export declare function acquireResumeLock(runDir: string, options?: AcquireResumeLockOptions): AcquireResumeLockResult;
+//# sourceMappingURL=resume-lock.d.ts.map

package/dist/runtime/run/resume-lock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resume-lock.d.ts","sourceRoot":"","sources":["../../../src/runtime/run/resume-lock.ts"],"names":[],"mappings":"AA2BA,OAAO,EAAE,KAAK,iBAAiB,EAAuB,MAAM,6BAA6B,CAAC;AAQ1F,6EAA6E;AAC7E,eAAO,MAAM,0BAA0B,iGACyD,CAAC;AAQjG,4CAA4C;AAC5C,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAErD;AAMD,MAAM,WAAW,gBAAgB;IAC/B,kFAAkF;IAClF,OAAO,IAAI,IAAI,CAAC;CACjB;AAED,MAAM,MAAM,uBAAuB,GAC/B;IAAE,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,gBAAgB,CAAA;CAAE,GACxD;IAAE,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC;AAErD,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,IAAI,CAAC;IAC1B,4EAA4E;IAC5E,QAAQ,CAAC,YAAY,CAAC,EAAE,iBAAiB,CAAC;CAC3C;AA8CD;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,MAAM,EACd,OAAO,GAAE,wBAA6B,GACrC,uBAAuB,CA2EzB"}

package/dist/runtime/run/resume-lock.js

@@ -0,0 +1,166 @@
+// Resume owner lock — the exclusive guard that lets exactly one `circuit resume`
+// touch a run folder at a time.
+//
+// The hazard (audit H5): resume has no cross-process guard. Two concurrent
+// resumes both load the trace, both compute the SAME nextSequence, and both
+// append entries stamped with it. TraceStore.load() enforces contiguous
+// sequences, so once a duplicate sequence is on disk EVERY later load() throws —
+// forever. The durable run record is unrecoverable.
+//
+// The fix mirrors the only exclusive-create primitive already in the codebase:
+// manifest-snapshot.ts opens its snapshot with `flag: 'wx'` (O_EXCL) to guard a
+// FRESH run start. O_EXCL is the filesystem's one atomic mutual-exclusion
+// primitive: exactly one racing create wins, every other gets EEXIST. Resume
+// takes the same lock at its entrypoint.
+//
+// A plain O_EXCL lock has one failure mode: a resume that crashes while holding
+// it leaves the file behind, and a naive lock would then refuse every future
+// resume — trading the concurrency brick for a crash brick. So the lock records
+// its owner's pid and reclaims a stale lock whose owner is provably gone, reusing
+// the same pid-liveness check the worktree reaper uses (`defaultProcessAlive`,
+// `process.kill(pid, 0)`). The reclaim itself is serialized behind a second
+// O_EXCL intent file so two racing reclaimers cannot both rm-and-recreate the
+// primary and both believe they own it — that double acquire is the very
+// duplicate-sequence brick this lock exists to prevent.
+import { mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { defaultProcessAlive } from '../fanout/run-owner-lock.js';
+const RESUME_LOCK_FILENAME = 'resume.lock';
+const RESUME_RECLAIM_FILENAME = 'resume.lock.reclaiming';
+// Each pass makes definite progress (acquire, refuse, or clear one stale file),
+// so this bound only guards against pathological churn from relentless racers.
+const MAX_ACQUIRE_ATTEMPTS = 8;
+/** Plain-English refusal shown when another resume already owns this run. */
+export const RESUME_IN_PROGRESS_MESSAGE = 'Another resume is already running for this run. Wait for it to finish before resuming again.';
+/** Absolute path to a run's resume lock. */
+export function resumeLockPath(runDir) {
+    return join(runDir, RESUME_LOCK_FILENAME);
+}
+function reclaimIntentPath(runDir) {
+    return join(runDir, RESUME_RECLAIM_FILENAME);
+}
+/**
+ * O_EXCL create. Returns true if we created the file, false on EEXIST. Any other
+ * error (a broken run dir, permissions) is a real failure and rethrows — a lock
+ * we cannot reason about must never masquerade as acquired.
+ */
+function createExclusive(path, payload) {
+    try {
+        writeFileSync(path, payload, { encoding: 'utf8', flag: 'wx' });
+        return true;
+    }
+    catch (error) {
+        if (error.code === 'EEXIST')
+            return false;
+        throw error;
+    }
+}
+/** The recorded owner pid, or undefined if the lock is missing or unparseable. */
+function recordedPid(path) {
+    let raw;
+    try {
+        raw = readFileSync(path, 'utf8');
+    }
+    catch {
+        return undefined;
+    }
+    let pid;
+    try {
+        pid = JSON.parse(raw).pid;
+    }
+    catch {
+        return undefined;
+    }
+    return typeof pid === 'number' ? pid : undefined;
+}
+/**
+ * True when the lock at `path` is held by a process that is still alive. A
+ * missing or corrupt lock is NOT proof of life (returns false), so a crashed
+ * owner's lock is always reclaimable — the fail-safe direction here, since a
+ * false "dead" only costs a reclaimed lock while a false "alive" would wedge
+ * every future resume.
+ */
+function heldByLiveOwner(path, processAlive) {
+    const pid = recordedPid(path);
+    return pid === undefined ? false : processAlive(pid);
+}
+/**
+ * Acquire the resume lock for `runDir`, or refuse. On success the returned
+ * handle must be released when the resume completes (or the process exits). On
+ * refusal the caller surfaces `message` to the operator and does NOT touch the
+ * trace.
+ */
+export function acquireResumeLock(runDir, options = {}) {
+    const processAlive = options.processAlive ?? defaultProcessAlive;
+    const now = options.now ?? (() => new Date());
+    const primary = resumeLockPath(runDir);
+    const intent = reclaimIntentPath(runDir);
+    const payload = () => {
+        const record = {
+            schema_version: 1,
+            pid: process.pid,
+            acquired_at: now().toISOString(),
+        };
+        return JSON.stringify(record);
+    };
+    const handle = {
+        release() {
+            try {
+                rmSync(primary, { force: true });
+            }
+            catch {
+                // A leftover lock records this now-exiting pid, so the next resume reads
+                // it as dead and reclaims it — a failed remove is never a brick. Cleanup
+                // must never throw.
+            }
+        },
+    };
+    // The run dir exists for a real resume (it holds the trace), but be defensive
+    // so a missing dir surfaces as a normal create error, not a phantom lock.
+    mkdirSync(runDir, { recursive: true });
+    for (let attempt = 0; attempt < MAX_ACQUIRE_ATTEMPTS; attempt += 1) {
+        // Fast path — the whole common case. Two resumes of a not-crashed run race
+        // here and exactly one create wins.
+        if (createExclusive(primary, payload())) {
+            return { ok: true, handle };
+        }
+        // A lock already exists. If its owner is alive, refuse — never steal a live
+        // resume's lock.
+        if (heldByLiveOwner(primary, processAlive)) {
+            return { ok: false, message: RESUME_IN_PROGRESS_MESSAGE };
+        }
+        // The primary is stale (owner crashed). Reclaim it under an O_EXCL intent
+        // lock so at most one reclaimer performs the rm-and-recreate below.
+        if (!createExclusive(intent, payload())) {
+            // Another reclaimer is mid-flight. If it is alive it wins — refuse. If its
+            // intent is itself stale (it crashed inside the tiny reclaim window), clear
+            // it and retry so the reclaim can complete.
+            if (heldByLiveOwner(intent, processAlive)) {
+                return { ok: false, message: RESUME_IN_PROGRESS_MESSAGE };
+            }
+            rmSync(intent, { force: true });
+            continue;
+        }
+        try {
+            // We alone may touch the primary now. Re-check under the intent lock: a
+            // fresh live resume takes the primary directly (not this reclaim path), so
+            // it may have replaced the stale file since our liveness check above.
+            if (heldByLiveOwner(primary, processAlive)) {
+                return { ok: false, message: RESUME_IN_PROGRESS_MESSAGE };
+            }
+            rmSync(primary, { force: true });
+            if (createExclusive(primary, payload())) {
+                return { ok: true, handle };
+            }
+            // A fresh resume grabbed the primary in the gap after our rm. Loop: the
+            // next pass reads it and refuses (alive) or reclaims it (dead).
+        }
+        finally {
+            rmSync(intent, { force: true });
+        }
+    }
+    // Exhausted retries against relentless churn: refuse rather than risk a double
+    // acquire. From the operator's view another resume is effectively in progress.
+    return { ok: false, message: RESUME_IN_PROGRESS_MESSAGE };
+}
+//# sourceMappingURL=resume-lock.js.map

package/dist/runtime/run/resume-lock.js.map

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

package/dist/runtime/run/reuse-children.d.ts

@@ -0,0 +1,24 @@
+import { RunResult } from '../../schemas/result.js';
+export interface ReusableSubRunBranch {
+    /** The prior child's run id, recorded on the reused completion entry. */
+    readonly childRunId: string;
+    /** Absolute path to the prior branch's worktree (verified to exist). */
+    readonly worktreePath: string;
+    /** The prior child's terminal result, parsed and admissible-shaped. */
+    readonly resultBody: RunResult;
+}
+export interface ReuseLookupInput {
+    /** The dead run folder the fresh run was pointed at. */
+    readonly priorRunFolder: string;
+    readonly stepId: string;
+    readonly branchId: string;
+    /** The flow this fresh branch targets; the prior child must have run it too. */
+    readonly expectedFlowRef: string;
+}
+/**
+ * Find a reusable finished sub-run branch in a prior crashed run, or undefined
+ * when none is admissible (caller then runs the child fresh). Never throws: a
+ * corrupt or missing prior trace simply means "nothing to reuse".
+ */
+export declare function lookupReusableSubRunBranch(input: ReuseLookupInput): Promise<ReusableSubRunBranch | undefined>;
+//# sourceMappingURL=reuse-children.d.ts.map

package/dist/runtime/run/reuse-children.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reuse-children.d.ts","sourceRoot":"","sources":["../../../src/runtime/run/reuse-children.ts"],"names":[],"mappings":"AAmCA,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAIpD,MAAM,WAAW,oBAAoB;IACnC,yEAAyE;IACzE,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,wEAAwE;IACxE,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,uEAAuE;IACvE,QAAQ,CAAC,UAAU,EAAE,SAAS,CAAC;CAChC;AAED,MAAM,WAAW,gBAAgB;IAC/B,wDAAwD;IACxD,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,gFAAgF;IAChF,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;CAClC;AAgBD;;;;GAIG;AACH,wBAAsB,0BAA0B,CAC9C,KAAK,EAAE,gBAAgB,GACtB,OAAO,CAAC,oBAAoB,GAAG,SAAS,CAAC,CAyD3C"}

package/dist/runtime/run/reuse-children.js

@@ -0,0 +1,107 @@
+// Reuse-children lookup for restart cheapness (`--reuse-children-from`).
+//
+// When a fresh run is pointed at a prior crashed run's folder, a sub-run fanout
+// branch can reuse that run's finished child instead of re-running the expensive
+// child flow. The lookup addresses a prior child by its STRUCTURAL address —
+// (step_id, branch_id) — which is stable across restarts because it comes from
+// the flow and the branch expansion, not from the run id. It never resumes the
+// dead run; it only reads its trace and its on-disk artifacts.
+//
+// The safety floor lives here. A child is reusable only when ALL hold:
+//   1. it ran as a `sub-run` branch (an isolating worktree), not a `relay`
+//      branch (which mutates the shared checkout — reusing only its verdict
+//      would drop the tree changes the fresh checkout does not carry);
+//   2. it ran the SAME flow this fresh branch targets — the prior result's
+//      flow_id must equal the branch's flow_ref. The structural address
+//      (step_id, branch_id) is stable across restarts but says nothing about
+//      what was built there, so without this a re-pointed flow would silently
+//      admit a child built from a different flow;
+//   3. it closed `complete` with an admissible result that still parses;
+//   4. its worktree is still a usable git worktree on disk (the dir exists and
+//      carries a `.git` entry). A `sub-run` branch does its work in this
+//      worktree, and the disjoint-merge join reads the branch's changed files
+//      from it; if the reaper removed it (or it was left a bare directory) the
+//      effect is gone, so refusing is the conservative choice across every join
+//      policy — those that decide purely from the result_body are unaffected.
+// Any miss returns undefined, and the caller runs the child fresh. Refusing is
+// always safe; it is only slower.
+//
+// What this does NOT check: the child flow's VERSION or the base commit it ran
+// against. `--reuse-children-from` is a crash-restart aid that assumes the same
+// flow at the same goal; reusing across a flow version bump or a moved base is a
+// known limitation, not a guarded invariant.
+import { existsSync, readFileSync } from 'node:fs';
+import { isAbsolute, join } from 'node:path';
+import { RunResult } from '../../schemas/result.js';
+import { TraceStore } from '../trace/trace-store.js';
+function isCompletedSubRunBranch(entry, stepId, branchId) {
+    return (entry.kind === 'fanout.branch_completed' &&
+        entry.step_id === stepId &&
+        entry.branch_id === branchId &&
+        entry.branch_kind === 'sub-run' &&
+        entry.child_outcome === 'complete');
+}
+/**
+ * Find a reusable finished sub-run branch in a prior crashed run, or undefined
+ * when none is admissible (caller then runs the child fresh). Never throws: a
+ * corrupt or missing prior trace simply means "nothing to reuse".
+ */
+export async function lookupReusableSubRunBranch(input) {
+    let entries;
+    try {
+        entries = await new TraceStore(input.priorRunFolder).load();
+    }
+    catch {
+        // A torn/corrupt prior trace is not reusable. Run fresh.
+        return undefined;
+    }
+    // Latest admissible completion for this structural address. A re-attempted
+    // branch may have several; the last one is the one that stuck.
+    let completed;
+    for (const entry of entries) {
+        if (isCompletedSubRunBranch(entry, input.stepId, input.branchId)) {
+            completed = entry;
+        }
+    }
+    if (completed === undefined)
+        return undefined;
+    // The matching start carries the worktree path (where the branch effect lives).
+    let worktreePath;
+    for (const entry of entries) {
+        if (entry.kind === 'fanout.branch_started' &&
+            entry.step_id === input.stepId &&
+            entry.branch_id === input.branchId &&
+            entry.child_run_id === completed.child_run_id) {
+            worktreePath = entry.worktree_path;
+        }
+    }
+    if (worktreePath === undefined)
+        return undefined;
+    // Safety gate: the branch effect lives in the worktree. Require a usable git
+    // worktree (the dir exists AND carries a `.git` entry), not just a leftover
+    // directory. A reaped worktree fails the dir check; a half-cleaned one fails
+    // the `.git` check. Either way, refusing and re-running is the safe direction.
+    if (!existsSync(join(worktreePath, '.git')))
+        return undefined;
+    // The branch's copied result.json lives at result_path relative to the prior
+    // run folder (the executor wrote it there with run-folder-scoped files).
+    const resultAbs = isAbsolute(completed.result_path)
+        ? completed.result_path
+        : join(input.priorRunFolder, completed.result_path);
+    let resultBody;
+    try {
+        resultBody = RunResult.parse(JSON.parse(readFileSync(resultAbs, 'utf8')));
+    }
+    catch {
+        return undefined;
+    }
+    if (resultBody.outcome !== 'complete')
+        return undefined;
+    // Identity gate: the structural address is stable across restarts but carries
+    // no flow identity, so confirm the prior child ran the same flow this branch
+    // now targets before admitting its result.
+    if (resultBody.flow_id !== input.expectedFlowRef)
+        return undefined;
+    return { childRunId: completed.child_run_id, worktreePath, resultBody };
+}
+//# sourceMappingURL=reuse-children.js.map

package/dist/runtime/run/reuse-children.js.map

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

package/dist/runtime/run/run-boundary.d.ts

@@ -0,0 +1,30 @@
+import type { CompiledFlowProgressSurface } from '../../flows/types.js';
+import type { ProgressReporter } from '../../shared/relay-runtime-types.js';
+import type { TraceEntry } from '../domain/trace.js';
+import type { ExecutableFlow } from '../manifest/executable-flow.js';
+import { RunFileStore } from '../run-files/run-file-store.js';
+import { TraceStore } from '../trace/trace-store.js';
+import { type ExternalFileReader } from './external-files.js';
+import type { ClockPort, ProgressPort, RunDirectoryPort, RunFilesPort, TraceLogPort } from './run-values.js';
+export interface OpenRunBoundaryOptions {
+    readonly runDir: string;
+    readonly isResume: boolean;
+    readonly runId: string;
+    readonly flow: ExecutableFlow;
+    readonly now?: () => Date;
+    readonly progress?: ProgressReporter;
+    readonly progressSurface?: CompiledFlowProgressSurface;
+}
+export interface RunBoundary {
+    readonly runDirectory: RunDirectoryPort;
+    readonly clock: ClockPort;
+    readonly files: RunFileStore;
+    readonly runFiles: RunFilesPort;
+    readonly trace: TraceStore;
+    readonly traceLog: TraceLogPort;
+    readonly externalFiles: ExternalFileReader;
+    readonly progress: ProgressPort;
+    readonly existingTrace: readonly TraceEntry[];
+}
+export declare function openRunBoundary(options: OpenRunBoundaryOptions): Promise<RunBoundary>;
+//# sourceMappingURL=run-boundary.d.ts.map

package/dist/runtime/run/run-boundary.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-boundary.d.ts","sourceRoot":"","sources":["../../../src/runtime/run/run-boundary.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,sBAAsB,CAAC;AAKxE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qCAAqC,CAAC;AAE5E,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC;AAGrE,OAAO,EAAE,YAAY,EAAE,MAAM,gCAAgC,CAAC;AAC9D,OAAO,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AACrD,OAAO,EAAE,KAAK,kBAAkB,EAA0B,MAAM,qBAAqB,CAAC;AACtF,OAAO,KAAK,EACV,SAAS,EACT,YAAY,EACZ,gBAAgB,EAChB,YAAY,EACZ,YAAY,EACb,MAAM,iBAAiB,CAAC;AAEzB,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAC;IAC9B,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,IAAI,CAAC;IAC1B,QAAQ,CAAC,QAAQ,CAAC,EAAE,gBAAgB,CAAC;IACrC,QAAQ,CAAC,eAAe,CAAC,EAAE,2BAA2B,CAAC;CACxD;AAED,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,YAAY,EAAE,gBAAgB,CAAC;IACxC,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC;IAC1B,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAC;IAC7B,QAAQ,CAAC,QAAQ,EAAE,YAAY,CAAC;IAChC,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAC;IAC3B,QAAQ,CAAC,QAAQ,EAAE,YAAY,CAAC;IAChC,QAAQ,CAAC,aAAa,EAAE,kBAAkB,CAAC;IAC3C,QAAQ,CAAC,QAAQ,EAAE,YAAY,CAAC;IAChC,QAAQ,CAAC,aAAa,EAAE,SAAS,UAAU,EAAE,CAAC;CAC/C;AA6CD,wBAAsB,eAAe,CAAC,OAAO,EAAE,sBAAsB,GAAG,OAAO,CAAC,WAAW,CAAC,CA+D3F"}

package/dist/runtime/run/run-boundary.js

@@ -0,0 +1,110 @@
+import { readFileSync } from 'node:fs';
+import { lstat, mkdir, readdir } from 'node:fs/promises';
+import { controlPlaneRootFromDescendant, ensureCircuitGitignore, } from '../../shared/control-plane-gitignore.js';
+import { createProgressProjector } from '../projections/progress.js';
+import { validateReportValue } from '../run-files/report-validator.js';
+import { RunFileStore } from '../run-files/run-file-store.js';
+import { TraceStore } from '../trace/trace-store.js';
+import { nodeExternalFileReader } from './external-files.js';
+async function assertFreshRunDir(runDir) {
+    let stat;
+    try {
+        stat = await lstat(runDir);
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw error;
+        await mkdir(runDir, { recursive: true });
+        stat = await lstat(runDir);
+    }
+    if (stat.isSymbolicLink()) {
+        throw new Error('runtime baseline requires a fresh run directory; existing path is a symlink');
+    }
+    if (!stat.isDirectory()) {
+        throw new Error('runtime baseline requires a fresh run directory; existing path is not a directory');
+    }
+    const entries = await readdir(runDir);
+    if (entries.length > 0) {
+        throw new Error(`runtime baseline requires a fresh run directory; existing directory is not empty (${entries.join(', ')})`);
+    }
+}
+function runFilesPortFromStore(store) {
+    return {
+        resolve: (ref) => store.resolve(ref),
+        writeJson: (ref, value) => store.writeJson(ref, value),
+        writeText: (ref, value) => store.writeText(ref, value),
+        readText: (ref) => store.readText(ref),
+        readJson: (ref) => store.readJson(ref),
+    };
+}
+function traceLogPortFromStore(store) {
+    return {
+        load: () => store.load(),
+        append: (input) => store.append(input),
+        getAll: () => store.getAll(),
+    };
+}
+export async function openRunBoundary(options) {
+    if (!options.isResume) {
+        await assertFreshRunDir(options.runDir);
+    }
+    else {
+        await mkdir(options.runDir, { recursive: true });
+    }
+    // Machine-write privacy (M3): a run creates `.circuit/runs/<id>` before any
+    // ambient harvest runs — and on hosts without continuity hooks a harvest may
+    // never run at all — so the run-open seam seeds `.circuit/.gitignore` too.
+    // It no-ops for a run directory that does not live under a `.circuit` control
+    // plane (a test's temp dir), and never clobbers a user's own ignore file.
+    const controlPlane = controlPlaneRootFromDescendant(options.runDir);
+    if (controlPlane !== undefined) {
+        ensureCircuitGitignore(controlPlane);
+    }
+    const clock = { now: options.now ?? (() => new Date()) };
+    const progressProjector = createProgressProjector({
+        progress: options.progress,
+        runDir: options.runDir,
+        runId: options.runId,
+        flow: options.flow,
+        files: {
+            readText(path) {
+                try {
+                    return readFileSync(path, 'utf8');
+                }
+                catch {
+                    return undefined;
+                }
+            },
+        },
+        ...(options.progressSurface === undefined ? {} : { progressSurface: options.progressSurface }),
+    });
+    const trace = new TraceStore(options.runDir, {
+        now: clock.now,
+        onAppend: progressProjector,
+    });
+    const existingTrace = await trace.load();
+    if (!options.isResume && existingTrace.length > 0) {
+        throw new Error('runtime baseline requires a fresh run directory');
+    }
+    if (options.isResume && existingTrace.length === 0) {
+        throw new Error('runtime resume requires an existing trace');
+    }
+    if (options.isResume && existingTrace.some((entry) => entry.kind === 'run.closed')) {
+        throw new Error('runtime resume rejected: run is already closed');
+    }
+    const files = new RunFileStore(options.runDir, validateReportValue);
+    return {
+        runDirectory: { path: options.runDir },
+        clock,
+        files,
+        runFiles: runFilesPortFromStore(files),
+        trace,
+        traceLog: traceLogPortFromStore(trace),
+        externalFiles: nodeExternalFileReader,
+        progress: {
+            ...(options.progress === undefined ? {} : { report: options.progress }),
+        },
+        existingTrace,
+    };
+}
+//# sourceMappingURL=run-boundary.js.map

package/dist/runtime/run/run-boundary.js.map

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

package/dist/runtime/run/run-close.d.ts

@@ -0,0 +1,22 @@
+import type { TerminalTarget } from '../domain/route.js';
+import type { RunClosedOutcome } from '../domain/run.js';
+import type { TraceEntry } from '../domain/trace.js';
+import { type RuntimeRunResult } from './result-writer.js';
+import type { RunContext } from './run-context.js';
+export interface GraphRunResult extends RuntimeRunResult {
+    readonly resultPath: string;
+}
+export interface GraphClosedOutcome {
+    readonly kind: 'closed';
+    readonly result: GraphRunResult;
+}
+export declare function resultSummary(outcome: RunClosedOutcome, terminalTarget?: TerminalTarget): string;
+export declare function outcomeForTerminal(target: TerminalTarget): RunClosedOutcome;
+export declare function terminalOutcomeBoundToPrimaryResult(context: RunContext, outcome: RunClosedOutcome): Promise<{
+    readonly outcome: RunClosedOutcome;
+    readonly reason: string;
+} | undefined>;
+export declare function latestAdmittedVerdict(entries: readonly TraceEntry[]): string | undefined;
+export declare function completeCloseProofGap(context: RunContext): string | undefined;
+export declare function closeRun(context: RunContext, outcome: RunClosedOutcome, terminalTarget?: TerminalTarget, reason?: string): Promise<GraphClosedOutcome>;
+//# sourceMappingURL=run-close.d.ts.map

package/dist/runtime/run/run-close.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-close.d.ts","sourceRoot":"","sources":["../../../src/runtime/run/run-close.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACzD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AACzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAGrD,OAAO,EAAE,KAAK,gBAAgB,EAAyB,MAAM,oBAAoB,CAAC;AAClF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAGnD,MAAM,WAAW,cAAe,SAAQ,gBAAgB;IACtD,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B;AAED,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAC;CACjC;AAKD,wBAAgB,aAAa,CAAC,OAAO,EAAE,gBAAgB,EAAE,cAAc,CAAC,EAAE,cAAc,GAAG,MAAM,CAGhG;AAED,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,cAAc,GAAG,gBAAgB,CAK3E;AAuDD,wBAAsB,mCAAmC,CACvD,OAAO,EAAE,UAAU,EACnB,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC;IAAE,QAAQ,CAAC,OAAO,EAAE,gBAAgB,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,CAAC,CAkCtF;AAID,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,SAAS,UAAU,EAAE,GAAG,MAAM,GAAG,SAAS,CAsBxF;AAMD,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,UAAU,GAAG,MAAM,GAAG,SAAS,CA+B7E;AAED,wBAAsB,QAAQ,CAC5B,OAAO,EAAE,UAAU,EACnB,OAAO,EAAE,gBAAgB,EACzB,cAAc,CAAC,EAAE,cAAc,EAC/B,MAAM,CAAC,EAAE,MAAM,GACd,OAAO,CAAC,kBAAkB,CAAC,CA8C7B"}