substrate-ai 0.19.31 → 0.19.32

package/dist/{health-DUgvybiN.js → health-D--wDx-U.js}

@@ -3,15 +3,14 @@ import { DoltClient, DoltQueryError, createDatabaseAdapter$1 as createDatabaseAd
 import { createRequire } from "module";
 import { dirname, join } from "path";
 import { readFile } from "fs/promises";
-import { EventEmitter } from "node:events";
-import { existsSync, promises, readFileSync } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
 import { spawn, spawnSync } from "node:child_process";
 import { dirname as dirname$1, join as join$1, resolve as resolve$1 } from "node:path";
-import { z } from "zod";
-import { mkdir as mkdir$1, open, readFile as readFile$1, unlink, writeFile as writeFile$1 } from "node:fs/promises";
+import { readFile as readFile$1, writeFile as writeFile$1 } from "node:fs/promises";
 import { existsSync as existsSync$1 } from "fs";
 import { createRequire as createRequire$1 } from "node:module";
 import { fileURLToPath } from "node:url";
+import { RunManifest } from "@substrate-ai/sdlc";
 
 //#region rolldown:runtime
 var __create = Object.create;
@@ -136,7 +135,7 @@ function parseDbTimestampAsUtc(ts) {
 	return new Date(ts.replace(" ", "T") + "Z");
 }
 const __filename = fileURLToPath(import.meta.url);
-const __dirname$1 = dirname(__filename);
+const __dirname = dirname(__filename);
 /**
 * Find the package root by walking up until we find package.json.
 * Works regardless of build output structure (tsdown bundles into
@@ -150,13 +149,13 @@ function findPackageRoot(startDir) {
 	}
 	return startDir;
 }
-const PACKAGE_ROOT = join(__dirname$1, "..", "..", "..");
+const PACKAGE_ROOT = join(__dirname, "..", "..", "..");
 /**
 * Resolve the absolute path to the bmad-method package's src/ directory.
 * Uses createRequire so it works in ESM without import.meta.resolve polyfills.
 * Returns null if bmad-method is not installed.
 */
-function resolveBmadMethodSrcPath(fromDir = __dirname$1) {
+function resolveBmadMethodSrcPath(fromDir = __dirname) {
 	try {
 		const require$1 = createRequire$1(join(fromDir, "synthetic.js"));
 		const pkgJsonPath = require$1.resolve("bmad-method/package.json");
@@ -169,7 +168,7 @@ function resolveBmadMethodSrcPath(fromDir = __dirname$1) {
 * Read the version field from bmad-method's package.json.
 * Returns 'unknown' if not resolvable.
 */
-function resolveBmadMethodVersion(fromDir = __dirname$1) {
+function resolveBmadMethodVersion(fromDir = __dirname) {
 	try {
 		const require$1 = createRequire$1(join(fromDir, "synthetic.js"));
 		const pkgJsonPath = require$1.resolve("bmad-method/package.json");
@@ -1525,1083 +1524,6 @@ function createStateStore(config = {}) {
 	return new FileStateStore({ basePath: config.basePath });
 }
 
-//#endregion
-//#region packages/sdlc/dist/handlers/event-bridge.js
-/**
-* SDLC Event Bridge — translates factory graph executor lifecycle events into
-* SDLC orchestrator events for backward compatibility with existing consumers.
-*
-* Story 43-9: SDLC-as-Graph NDJSON Event Compatibility.
-*
-* ADR-003: This file MUST NOT import any runtime value from `@substrate-ai/factory`.
-* All coupling to the factory event bus shape is via local duck-typed interfaces.
-*/
-/**
-* Maps factory graph node IDs to SDLC phase names.
-* Node IDs not present here are silently ignored by the bridge (AC5).
-*
-* | Graph Node ID  | SDLC Phase Name |
-* |----------------|-----------------|
-* | analysis       | 'analysis'      |
-* | planning       | 'planning'      |
-* | solutioning    | 'solutioning'   |
-* | create_story   | 'create'        |
-* | dev_story      | 'dev'           |
-* | code_review    | 'review'        |
-* | start          | (ignored)       |
-* | exit           | (ignored)       |
-*/
-const SDLC_NODE_PHASE_MAP = {
-	analysis: "analysis",
-	planning: "planning",
-	solutioning: "solutioning",
-	create_story: "create",
-	dev_story: "dev",
-	code_review: "review"
-};
-/**
-* Creates an event bridge that translates factory graph executor lifecycle events
-* into SDLC orchestrator events for backward compatibility with existing consumers
-* (supervisor, CLI polling, telemetry).
-*
-* Supported translations:
-* - `graph:node-started`          → `orchestrator:story-phase-start`    (AC1)
-* - `graph:node-completed`        → `orchestrator:story-phase-complete`  (AC2)
-* - `graph:node-retried`          → (counter only — tracks review cycles)
-* - `graph:completed` (SUCCESS)   → `orchestrator:story-complete`        (AC3)
-* - `graph:goal-gate-unsatisfied` → `orchestrator:story-escalated`       (AC4)
-* - Non-SDLC node IDs             → silently ignored                     (AC5)
-*
-* @returns An object with a `teardown()` function that removes all registered
-*          graph event listeners (AC7). Must be called after story execution
-*          completes (use try/finally).
-*/
-function createSdlcEventBridge(opts) {
-	const { storyKey, pipelineRunId, sdlcBus, graphEvents } = opts;
-	let devStoryRetries = 0;
-	const onNodeStarted = (data) => {
-		const { nodeId } = data;
-		const phase = SDLC_NODE_PHASE_MAP[nodeId];
-		if (!phase) return;
-		sdlcBus.emit("orchestrator:story-phase-start", {
-			storyKey,
-			phase,
-			pipelineRunId
-		});
-	};
-	const onNodeCompleted = (data) => {
-		const { nodeId, outcome } = data;
-		const phase = SDLC_NODE_PHASE_MAP[nodeId];
-		if (!phase) return;
-		sdlcBus.emit("orchestrator:story-phase-complete", {
-			storyKey,
-			phase,
-			result: outcome,
-			pipelineRunId
-		});
-	};
-	const onNodeRetried = (data) => {
-		const { nodeId } = data;
-		if (nodeId === "dev_story") devStoryRetries++;
-	};
-	const onGraphCompleted = (data) => {
-		const { finalOutcome } = data;
-		if (finalOutcome.status === "SUCCESS") sdlcBus.emit("orchestrator:story-complete", {
-			storyKey,
-			reviewCycles: devStoryRetries
-		});
-	};
-	const onGoalGateUnsatisfied = (data) => {
-		const evt = data;
-		if (evt.nodeId === "dev_story") sdlcBus.emit("orchestrator:story-escalated", {
-			storyKey,
-			lastVerdict: evt.lastVerdict ?? "NEEDS_MAJOR_REWORK",
-			reviewCycles: evt.reviewCycles ?? devStoryRetries,
-			issues: evt.issues ?? []
-		});
-	};
-	graphEvents.on("graph:node-started", onNodeStarted);
-	graphEvents.on("graph:node-completed", onNodeCompleted);
-	graphEvents.on("graph:node-retried", onNodeRetried);
-	graphEvents.on("graph:completed", onGraphCompleted);
-	graphEvents.on("graph:goal-gate-unsatisfied", onGoalGateUnsatisfied);
-	return { teardown() {
-		graphEvents.off("graph:node-started", onNodeStarted);
-		graphEvents.off("graph:node-completed", onNodeCompleted);
-		graphEvents.off("graph:node-retried", onNodeRetried);
-		graphEvents.off("graph:completed", onGraphCompleted);
-		graphEvents.off("graph:goal-gate-unsatisfied", onGoalGateUnsatisfied);
-	} };
-}
-
-//#endregion
-//#region packages/sdlc/dist/orchestrator/graph-orchestrator.js
-const __dirname = dirname$1(fileURLToPath(import.meta.url));
-/**
-* Returns the absolute path to the bundled SDLC pipeline DOT file.
-*
-* Resolution order:
-*   1. Relative to __dirname (works in source/unbundled: __dirname = packages/sdlc/src/orchestrator/)
-*   2. Via createRequire to locate @substrate-ai/sdlc package.json, then graphs/ relative to it
-*      (works when bundled: __dirname points to dist/ but createRequire finds the real package)
-*
-* @throws {Error} if the DOT file cannot be found by any method.
-*/
-function resolveGraphPath() {
-	const candidates = [
-		join$1(__dirname, "../../graphs/sdlc-pipeline.dot"),
-		join$1(__dirname, "../graphs/sdlc-pipeline.dot"),
-		join$1(__dirname, "graphs/sdlc-pipeline.dot")
-	];
-	try {
-		const require$1 = createRequire$1(import.meta.url);
-		const sdlcPkgPath = require$1.resolve("@substrate-ai/sdlc/package.json");
-		candidates.push(join$1(dirname$1(sdlcPkgPath), "graphs", "sdlc-pipeline.dot"));
-	} catch {}
-	for (const candidate of candidates) if (existsSync(candidate)) return candidate;
-	throw new Error(`Cannot locate sdlc-pipeline.dot. Searched:\n${candidates.map((c) => `  ${c}`).join("\n")}`);
-}
-/** Thrown by `createGraphOrchestrator` when the supplied graph is structurally invalid. */
-var GraphOrchestratorInitError = class extends Error {
-	constructor(message) {
-		super(message);
-		this.name = "GraphOrchestratorInitError";
-	}
-};
-/**
-* Creates a `GraphOrchestrator` that runs one graph executor instance per
-* concurrent story slot, with conflict-group serialization and bounded concurrency.
-*
-* When `config.eventBus` is provided, a per-story SDLC event bridge is created
-* to translate factory `graph:*` events into `orchestrator:story-*` events (AC4,
-* story 43-10).
-*
-* @throws {GraphOrchestratorInitError} if `config.graph` is missing `nodes` or `edges`.
-*/
-function createGraphOrchestrator(config) {
-	if (!config.graph?.nodes || !config.graph?.edges) throw new GraphOrchestratorInitError("Invalid graph: missing nodes or edges arrays");
-	const gcPauseMs = config.gcPauseMs ?? 2e3;
-	async function runStoryGraph(storyKey, summary) {
-		const epicId = storyKey.split("-")[0] ?? "";
-		const initialContext = {
-			storyKey,
-			epicId,
-			projectRoot: config.projectRoot,
-			methodologyPack: config.methodologyPack,
-			...config.pipelineRunId !== void 0 ? {
-				runId: config.pipelineRunId,
-				pipelineRunId: config.pipelineRunId
-			} : {}
-		};
-		const factoryBus = new EventEmitter();
-		const bridge = config.eventBus != null ? createSdlcEventBridge({
-			storyKey,
-			...config.pipelineRunId !== void 0 ? { pipelineRunId: config.pipelineRunId } : {},
-			sdlcBus: config.eventBus,
-			graphEvents: factoryBus
-		}) : void 0;
-		let escalated = false;
-		factoryBus.on("graph:goal-gate-unsatisfied", () => {
-			escalated = true;
-		});
-		let result;
-		try {
-			result = await config.executor.run(config.graph, {
-				runId: `${config.runId}:${storyKey}`,
-				logsRoot: config.logsRoot,
-				handlerRegistry: config.handlerRegistry,
-				initialContext,
-				eventBus: factoryBus
-			});
-		} catch (err) {
-			const errMsg = err instanceof Error ? err.message : String(err);
-			process.stderr.write(`[graph-orchestrator] Story ${storyKey} failed: ${errMsg}\n`);
-			summary.stories[storyKey] = {
-				outcome: escalated ? "ESCALATED" : "FAILED",
-				error: errMsg
-			};
-			summary.f++;
-		} finally {
-			bridge?.teardown();
-		}
-		if (result === void 0) return;
-		if (result.status === "SUCCESS") {
-			summary.stories[storyKey] = { outcome: "SUCCESS" };
-			summary.s++;
-		} else if (escalated) {
-			summary.stories[storyKey] = { outcome: "ESCALATED" };
-			summary.f++;
-		} else {
-			const reason = result.failureReason ?? `status=${result.status}`;
-			process.stderr.write(`[graph-orchestrator] Story ${storyKey} failed: ${reason}\n`);
-			summary.stories[storyKey] = {
-				outcome: "FAILED",
-				error: reason
-			};
-			summary.f++;
-		}
-	}
-	async function runGroup(group, summary) {
-		for (const storyKey of group) {
-			await runStoryGraph(storyKey, summary);
-			if (gcPauseMs > 0) await new Promise((r) => setTimeout(r, gcPauseMs));
-		}
-	}
-	async function runBatch(groups, summary) {
-		const queue = [...groups];
-		const active = [];
-		while (queue.length > 0 || active.length > 0) {
-			while (active.length < config.maxConcurrency && queue.length > 0) {
-				const group = queue.shift();
-				const p = runGroup(group, summary).finally(() => {
-					active.splice(active.indexOf(p), 1);
-				});
-				active.push(p);
-			}
-			if (active.length > 0) await Promise.race(active);
-		}
-	}
-	return { async run(storyKeys) {
-		const grouper = config.conflictGrouper ?? ((keys) => [keys.map((k) => [k])]);
-		const batches = grouper(storyKeys);
-		const summary = {
-			s: 0,
-			f: 0,
-			stories: {}
-		};
-		for (const batchGroups of batches) await runBatch(batchGroups, summary);
-		return {
-			successCount: summary.s,
-			failureCount: summary.f,
-			totalStories: storyKeys.length,
-			stories: summary.stories
-		};
-	} };
-}
-/**
-* Patches the loaded SDLC pipeline graph to reflect runtime configuration.
-*
-* Currently maps `maxReviewCycles` → `dev_story.maxRetries` (1:1 mapping).
-* Both values represent the number of *additional* retry attempts (not total).
-*
-* Must be called after parseGraph() and before any story graph instance runs.
-*
-* @param graph  A factory Graph (Map-based nodes) duck-typed as PatchableGraph.
-* @param options  Runtime configuration to apply.
-* @throws {Error} if the graph does not contain a `dev_story` node.
-*/
-function applyConfigToGraph(graph, options) {
-	const devStoryNode = graph.nodes.get("dev_story");
-	if (!devStoryNode) throw new Error("applyConfigToGraph: graph does not contain a 'dev_story' node");
-	devStoryNode.maxRetries = options.maxReviewCycles;
-	graph.defaultMaxRetries = options.maxReviewCycles;
-}
-
-//#endregion
-//#region packages/sdlc/dist/run-model/cli-flags.js
-/**
-* Zod schema for the CLI flags persisted in the run manifest.
-*
-* All fields are optional — only flags explicitly provided on the CLI are written.
-* `halt_on` defaults to `'none'` at write time; `cost_ceiling` is omitted when not provided.
-*/
-const CliFlagsSchema = z.object({
-	stories: z.array(z.string()).optional(),
-	halt_on: z.enum([
-		"all",
-		"critical",
-		"none"
-	]).optional(),
-	cost_ceiling: z.number().positive().optional(),
-	agent: z.string().optional(),
-	skip_verification: z.boolean().optional(),
-	events: z.boolean().optional()
-});
-
-//#endregion
-//#region packages/sdlc/dist/run-model/verification-result.js
-/**
-* Schema for a single per-check verification result stored in the manifest.
-*
-* Mirrors VerificationCheckResult from packages/sdlc/src/verification/types.ts
-* without importing from that module (avoids circular dependency).
-*/
-const StoredVerificationCheckResultSchema = z.object({
-	checkName: z.string(),
-	status: z.enum([
-		"pass",
-		"warn",
-		"fail"
-	]),
-	details: z.string(),
-	duration_ms: z.number().nonnegative()
-});
-/**
-* Schema for the aggregated verification pipeline summary stored in the manifest.
-*
-* Mirrors VerificationSummary from packages/sdlc/src/verification/types.ts
-* without importing from that module (avoids circular dependency).
-*/
-const StoredVerificationSummarySchema = z.object({
-	storyKey: z.string(),
-	checks: z.array(StoredVerificationCheckResultSchema),
-	status: z.enum([
-		"pass",
-		"warn",
-		"fail"
-	]),
-	duration_ms: z.number().nonnegative()
-});
-
-//#endregion
-//#region packages/sdlc/dist/run-model/per-story-state.js
-/**
-* High-level consumer-facing status for a story in the run manifest.
-*
-* Known literals cover all states defined in Epic 52–54. The trailing
-* `z.string()` fallback (MUST remain last) accommodates states added by
-* later stories (`gated` from 53-9, `skipped` from 53-3, `recovered` from 54-1)
-* and any future extensions without breaking deserialization.
-*/
-const PerStoryStatusSchema = z.union([
-	z.literal("pending"),
-	z.literal("dispatched"),
-	z.literal("in-review"),
-	z.literal("complete"),
-	z.literal("failed"),
-	z.literal("escalated"),
-	z.literal("recovered"),
-	z.literal("verification-failed"),
-	z.literal("gated"),
-	z.literal("skipped"),
-	z.string()
-]);
-/**
-* Schema for a single per-story state entry in the run manifest.
-*
-* Field semantics:
-* - `status`: High-level consumer-facing status (state-machine value). Use this
-*   for state-machine decisions and display.
-* - `phase`: Raw orchestrator `StoryPhase` string (e.g., `'IN_DEV'`, `'IN_REVIEW'`).
-*   Informational only — do NOT compare this field in state-machine logic.
-* - `started_at`: ISO-8601 timestamp when the story entered an active phase.
-* - `completed_at`: ISO-8601 timestamp when the story reached a terminal state.
-* - `verification_result`: Verification pipeline result (populated by story 52-7).
-* - `cost_usd`: Accumulated cost in USD (populated at terminal transition).
-*/
-const PerStoryStateSchema = z.object({
-	status: PerStoryStatusSchema,
-	phase: z.string(),
-	started_at: z.string(),
-	completed_at: z.string().optional(),
-	verification_result: StoredVerificationSummarySchema.optional(),
-	cost_usd: z.number().nonnegative().optional(),
-	review_cycles: z.number().int().nonnegative().optional(),
-	dispatches: z.number().int().nonnegative().optional()
-});
-
-//#endregion
-//#region packages/sdlc/dist/run-model/recovery-history.js
-/**
-* Outcome of a recovery attempt.
-*
-* The string fallback must be last in the union so Zod evaluates the literal
-* variants first — a leading z.string() would swallow all literals. This
-* follows the v0.19.6 extensible union pattern used throughout the codebase.
-*/
-const RecoveryOutcomeSchema = z.union([
-	z.literal("retried"),
-	z.literal("escalated"),
-	z.literal("skipped"),
-	z.string()
-]);
-/**
-* A single recovery attempt recorded in the run manifest.
-*
-* `attempt_number` is 1-indexed: 1 = first retry, NOT the initial dispatch.
-* The initial dispatch of a story is never recorded as a RecoveryEntry.
-*
-* `strategy` is free-form (e.g., `'retry-with-context'`, `'re-scope'`).
-*
-* `cost_usd` is the cost of THIS single retry attempt only — NOT cumulative.
-* Cumulative per-story retry cost is tracked in `CostAccumulation.per_story`.
-*/
-const RecoveryEntrySchema = z.object({
-	story_key: z.string(),
-	attempt_number: z.number().int().nonnegative(),
-	strategy: z.string(),
-	root_cause: z.string(),
-	outcome: RecoveryOutcomeSchema,
-	cost_usd: z.number().nonnegative(),
-	timestamp: z.string()
-});
-/**
-* Accumulated retry cost data for a pipeline run.
-*
-* `per_story` maps story_key → sum of all RecoveryEntry.cost_usd for that
-* story. It does NOT include the initial dispatch cost, which is tracked in
-* `PerStoryState.cost_usd`.
-*
-* `run_total` is the sum of all RecoveryEntry.cost_usd values in the run
-* (i.e., total retry cost only, not total run cost).
-*
-* An empty `{ per_story: {}, run_total: 0 }` is the valid initial value.
-*/
-const CostAccumulationSchema = z.object({
-	per_story: z.record(z.string(), z.number().nonnegative()),
-	run_total: z.number().nonnegative()
-});
-
-//#endregion
-//#region packages/sdlc/dist/run-model/schemas.js
-/**
-* Schema for a pending supervisor proposal.
-* Uses z.union for extensible type field (follows v0.19.6 ReadinessFindingCategory pattern).
-*/
-const ProposalSchema = z.object({
-	id: z.string(),
-	created_at: z.string(),
-	description: z.string(),
-	type: z.union([
-		z.literal("retry"),
-		z.literal("fix"),
-		z.literal("escalate"),
-		z.literal("skip"),
-		z.string()
-	]),
-	story_key: z.string().optional(),
-	payload: z.record(z.string(), z.unknown()).optional()
-});
-/**
-* Zod schema for the full run manifest data.
-* Validated on every read; write validates via JSON round-trip.
-*
-* `cost_accumulation` uses `.default({ per_story: {}, run_total: 0 })` so
-* pre-Phase-D manifests that omit this field parse without error (AC7).
-*/
-const RunManifestSchema = z.object({
-	run_id: z.string(),
-	cli_flags: CliFlagsSchema.transform((v) => v),
-	story_scope: z.array(z.string()),
-	supervisor_pid: z.number().nullable(),
-	supervisor_session_id: z.string().nullable(),
-	per_story_state: z.record(z.string(), PerStoryStateSchema),
-	recovery_history: z.array(RecoveryEntrySchema),
-	cost_accumulation: CostAccumulationSchema.default({
-		per_story: {},
-		run_total: 0
-	}),
-	pending_proposals: z.array(ProposalSchema),
-	generation: z.number().int().nonnegative(),
-	created_at: z.string(),
-	updated_at: z.string()
-});
-/**
-* Error thrown when all read sources for a manifest fail.
-*
-* Includes `attempted_sources` listing each path/source tried,
-* so callers can diagnose which files were corrupt or missing.
-*/
-var ManifestReadError = class extends Error {
-	/** List of sources (file paths or source names) that were attempted. */
-	attempted_sources;
-	constructor(message, attempted_sources) {
-		super(message);
-		this.name = "ManifestReadError";
-		this.attempted_sources = attempted_sources;
-	}
-};
-
-//#endregion
-//#region packages/sdlc/dist/run-model/run-manifest.js
-/** Default base directory for run manifests. */
-function defaultBaseDir() {
-	return join$1(process.cwd(), ".substrate", "runs");
-}
-/** Build the primary manifest path for a given run ID. */
-function primaryPath(baseDir, runId) {
-	return join$1(baseDir, `${runId}.json`);
-}
-/** Build the backup path. */
-function bakPath(baseDir, runId) {
-	return join$1(baseDir, `${runId}.json.bak`);
-}
-/** Build the temporary write path. */
-function tmpPath(baseDir, runId) {
-	return join$1(baseDir, `${runId}.json.tmp`);
-}
-/**
-* Attempt to read and parse a manifest file.
-* Returns the parsed data, or null if the file is missing or fails Zod validation.
-*/
-async function tryReadFile(filePath) {
-	try {
-		const raw = await promises.readFile(filePath, "utf-8");
-		let parsed;
-		try {
-			parsed = JSON.parse(raw);
-		} catch {
-			return null;
-		}
-		const result = RunManifestSchema.safeParse(parsed);
-		if (!result.success) return null;
-		return result.data;
-	} catch {
-		return null;
-	}
-}
-/**
-* Build a minimal RunManifestData from Dolt pipeline_runs table.
-* Used in degraded-mode when all file sources fail.
-*/
-async function reconstructFromDolt(runId, adapter) {
-	try {
-		const rows = await adapter.query("SELECT id, config_json, created_at, updated_at FROM pipeline_runs WHERE id = ?", [runId]);
-		if (rows.length === 0) return null;
-		const row = rows[0];
-		let cliFlags = {};
-		if (row.config_json) try {
-			const parsed = JSON.parse(row.config_json);
-			if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) cliFlags = parsed;
-		} catch {}
-		const now = new Date().toISOString();
-		const data = {
-			run_id: runId,
-			cli_flags: cliFlags,
-			story_scope: [],
-			supervisor_pid: null,
-			supervisor_session_id: null,
-			per_story_state: {},
-			recovery_history: [],
-			cost_accumulation: {
-				per_story: {},
-				run_total: 0
-			},
-			pending_proposals: [],
-			generation: 0,
-			created_at: row.created_at ?? now,
-			updated_at: row.updated_at ?? now
-		};
-		return data;
-	} catch {
-		return null;
-	}
-}
-/**
-* Typed, atomic file-backed run manifest.
-*
-* Each instance is bound to a specific run ID and base directory.
-* Use `RunManifest.create()` to initialize a new manifest,
-* or `RunManifest.read()` to load an existing one.
-*/
-var RunManifest = class RunManifest {
-	runId;
-	baseDir;
-	/** Optional Dolt adapter for degraded-mode fallback on read. */
-	doltAdapter;
-	constructor(runId, baseDir = defaultBaseDir(), doltAdapter = null) {
-		this.runId = runId;
-		this.baseDir = baseDir;
-		this.doltAdapter = doltAdapter;
-	}
-	get primaryPath() {
-		return primaryPath(this.baseDir, this.runId);
-	}
-	get bakPath() {
-		return bakPath(this.baseDir, this.runId);
-	}
-	get tmpPath() {
-		return tmpPath(this.baseDir, this.runId);
-	}
-	/**
-	* Read this manifest from disk (multi-tier fallback).
-	*
-	* Delegates to `RunManifest.read()` with this instance's runId, baseDir,
-	* and doltAdapter. Primarily used by `SupervisorLock` (and tests that mock it).
-	*
-	* @throws ManifestReadError if all sources fail
-	*/
-	async read() {
-		return RunManifest.read(this.runId, this.baseDir, this.doltAdapter);
-	}
-	/**
-	* Atomically update specific fields in the manifest.
-	*
-	* Reads the current manifest, merges in the provided partial data (shallow
-	* merge), then writes the result atomically. Generation is incremented and
-	* `updated_at` is refreshed by `write()`.
-	*
-	* Callers should pass only the fields they intend to change. Do NOT use this
-	* to change `run_id` or `created_at` — those are immutable after creation.
-	*
-	* @throws ManifestReadError if the current manifest cannot be read
-	*/
-	async update(partial) {
-		const current = await this.read();
-		const merged = {
-			...current,
-			...partial
-		};
-		await this.write(merged);
-	}
-	/**
-	* Atomically write the manifest to disk.
-	*
-	* Sequence:
-	*   1. Auto-increment `generation`, set `updated_at`
-	*   2. Serialize to JSON and validate round-trip
-	*   3. Ensure baseDir exists (mkdir -p)
-	*   4. Write to `.tmp` via open → write → datasync → close (fsync)
-	*   5. If primary exists, copy to `.bak`
-	*   6. Rename `.tmp` → primary path
-	*/
-	async write(data) {
-		let currentGeneration = 0;
-		const existing = await tryReadFile(this.primaryPath);
-		if (existing !== null) currentGeneration = existing.generation;
-		const fullData = {
-			...data,
-			generation: currentGeneration + 1,
-			updated_at: new Date().toISOString()
-		};
-		const json = JSON.stringify(fullData, null, 2);
-		JSON.parse(json);
-		await promises.mkdir(this.baseDir, { recursive: true });
-		const tmp = this.tmpPath;
-		const fileHandle = await promises.open(tmp, "w");
-		try {
-			await fileHandle.write(json, 0, "utf-8");
-			await fileHandle.datasync();
-		} finally {
-			await fileHandle.close();
-		}
-		try {
-			await promises.copyFile(this.primaryPath, this.bakPath);
-		} catch {}
-		await promises.rename(tmp, this.primaryPath);
-	}
-	/**
-	* Return a bound `RunManifest` instance without performing any file I/O.
-	*
-	* Use `open()` when you want to call instance methods (`read()`, `patchCLIFlags()`)
-	* on an existing run without reading the manifest upfront.
-	*
-	* ```typescript
-	* await RunManifest.open(runId, runsDir).patchCLIFlags(cliFlags)
-	* ```
-	*/
-	static open(runId, baseDir = defaultBaseDir(), doltAdapter = null) {
-		return new RunManifest(runId, baseDir, doltAdapter);
-	}
-	/**
-	* Read the current manifest (or create a minimal default), merge the provided
-	* CLI flags into `cli_flags`, and write the result atomically.
-	*
-	* Non-fatal: callers should wrap in try/catch and log a warning on failure.
-	* The pipeline must not abort if manifest write fails.
-	*/
-	async patchCLIFlags(flags) {
-		let existingData;
-		try {
-			const read = await RunManifest.read(this.runId, this.baseDir, this.doltAdapter);
-			const { generation: _gen, updated_at: _ts,...rest } = read;
-			existingData = rest;
-		} catch {
-			const now = new Date().toISOString();
-			existingData = {
-				run_id: this.runId,
-				cli_flags: {},
-				story_scope: [],
-				supervisor_pid: null,
-				supervisor_session_id: null,
-				per_story_state: {},
-				recovery_history: [],
-				cost_accumulation: {
-					per_story: {},
-					run_total: 0
-				},
-				pending_proposals: [],
-				created_at: now
-			};
-		}
-		await this.write({
-			...existingData,
-			cli_flags: {
-				...existingData.cli_flags,
-				...flags
-			}
-		});
-	}
-	/**
-	* Atomically upsert the per-story lifecycle state for a single story key.
-	*
-	* Reads the current manifest (or creates a minimal default if absent),
-	* shallowly merges `updates` into `per_story_state[storyKey]`, and writes
-	* the result atomically via a single `write()` call.
-	*
-	* Fields not included in `updates` on an existing entry are preserved unchanged.
-	*
-	* Non-fatal: callers MUST wrap in `.catch((err) => logger.warn(...))`.
-	* The pipeline must never abort due to a manifest write failure.
-	*
-	* @param storyKey - Story key (e.g. '52-4')
-	* @param updates  - Partial PerStoryState fields to merge
-	*/
-	async patchStoryState(storyKey, updates) {
-		let existingData;
-		try {
-			const read = await RunManifest.read(this.runId, this.baseDir, this.doltAdapter);
-			const { generation: _gen, updated_at: _ts,...rest } = read;
-			existingData = rest;
-		} catch {
-			const now = new Date().toISOString();
-			existingData = {
-				run_id: this.runId,
-				cli_flags: {},
-				story_scope: [],
-				supervisor_pid: null,
-				supervisor_session_id: null,
-				per_story_state: {},
-				recovery_history: [],
-				cost_accumulation: {
-					per_story: {},
-					run_total: 0
-				},
-				pending_proposals: [],
-				created_at: now
-			};
-		}
-		const existing = existingData.per_story_state[storyKey];
-		const merged = {
-			status: "pending",
-			phase: "",
-			started_at: new Date().toISOString(),
-			...existing,
-			...updates
-		};
-		await this.write({
-			...existingData,
-			per_story_state: {
-				...existingData.per_story_state,
-				[storyKey]: merged
-			}
-		});
-	}
-	/**
-	* Atomically append a recovery entry and update cost accumulation.
-	*
-	* Reads the current manifest, appends `entry` to `recovery_history[]`,
-	* increments `cost_accumulation.per_story[entry.story_key]` by `entry.cost_usd`,
-	* increments `cost_accumulation.run_total` by `entry.cost_usd`, then writes
-	* atomically via a single `write()` call.
-	*
-	* Non-fatal: callers MUST wrap in `.catch((err) => logger.warn(...))`.
-	* The pipeline must never abort due to a manifest write failure.
-	*
-	* `entry.cost_usd` is the cost of this single retry attempt only (NOT cumulative).
-	* Cumulative per-story retry cost is tracked in `cost_accumulation.per_story`.
-	*
-	* @param entry - Recovery entry to append (attempt_number is 1-indexed)
-	*/
-	async appendRecoveryEntry(entry) {
-		let existingData;
-		try {
-			const read = await RunManifest.read(this.runId, this.baseDir, this.doltAdapter);
-			const { generation: _gen, updated_at: _ts,...rest } = read;
-			existingData = rest;
-		} catch {
-			const now = new Date().toISOString();
-			existingData = {
-				run_id: this.runId,
-				cli_flags: {},
-				story_scope: [],
-				supervisor_pid: null,
-				supervisor_session_id: null,
-				per_story_state: {},
-				recovery_history: [],
-				cost_accumulation: {
-					per_story: {},
-					run_total: 0
-				},
-				pending_proposals: [],
-				created_at: now
-			};
-		}
-		const prevStoryCost = existingData.cost_accumulation.per_story[entry.story_key] ?? 0;
-		const updated = {
-			...existingData,
-			recovery_history: [...existingData.recovery_history, entry],
-			cost_accumulation: {
-				per_story: {
-					...existingData.cost_accumulation.per_story,
-					[entry.story_key]: prevStoryCost + entry.cost_usd
-				},
-				run_total: existingData.cost_accumulation.run_total + entry.cost_usd
-			}
-		};
-		await this.write(updated);
-	}
-	/**
-	* Create a new manifest with `generation: 0` and write it.
-	* Returns a bound `RunManifest` instance.
-	*/
-	static async create(runId, initialData, baseDir = defaultBaseDir(), doltAdapter = null) {
-		const instance = new RunManifest(runId, baseDir, doltAdapter);
-		const now = new Date().toISOString();
-		const data = {
-			...initialData,
-			created_at: now
-		};
-		await instance.write(data);
-		return instance;
-	}
-	/**
-	* Read a manifest from disk with multi-tier fallback.
-	*
-	* Attempts sources in order:
-	*   1. Primary `.json`
-	*   2. Backup `.json.bak`  (preferred over primary if generation is higher)
-	*   3. Temporary `.json.tmp`
-	*   4. Dolt degraded reconstruction (if doltAdapter is provided)
-	*
-	* Generation tiebreak: if `.bak` has a higher `generation` than primary,
-	* `.bak` is preferred (indicates primary was overwritten mid-rename).
-	*
-	* @throws ManifestReadError if all sources fail
-	*/
-	static async read(runId, baseDir = defaultBaseDir(), doltAdapter = null) {
-		const attempted = [];
-		const primary = primaryPath(baseDir, runId);
-		const bak = bakPath(baseDir, runId);
-		const tmp = tmpPath(baseDir, runId);
-		attempted.push(primary);
-		const primaryData = await tryReadFile(primary);
-		attempted.push(bak);
-		const bakData = await tryReadFile(bak);
-		if (primaryData !== null && bakData !== null) {
-			if (bakData.generation > primaryData.generation) return bakData;
-			return primaryData;
-		}
-		if (primaryData !== null) return primaryData;
-		if (bakData !== null) return bakData;
-		attempted.push(tmp);
-		const tmpData = await tryReadFile(tmp);
-		if (tmpData !== null) return tmpData;
-		if (doltAdapter !== null) {
-			const doltSource = "dolt:pipeline_runs";
-			attempted.push(doltSource);
-			const doltData = await reconstructFromDolt(runId, doltAdapter);
-			if (doltData !== null) {
-				console.warn(`[RunManifest] Degraded mode: reconstructed run ${runId} from Dolt pipeline_runs. per_story_state and recovery_history are empty.`);
-				return doltData;
-			}
-		}
-		throw new ManifestReadError(`Failed to read manifest for run ${runId}: all sources exhausted`, attempted);
-	}
-};
-
-//#endregion
-//#region packages/sdlc/dist/run-model/supervisor-lock.js
-const defaultLogger = console;
-/**
-* Advisory lock for the supervisor process.
-*
-* Usage:
-* ```ts
-* const lock = new SupervisorLock(runId, manifest)
-* await lock.acquire(process.pid, sessionId, { force: opts.force })
-* // ... supervisor work ...
-* await lock.release()
-* ```
-*
-* The lock is automatically released on process exit if `registerExitHandlers()`
-* is called, or if the consuming code registers `process.once('exit', ...)`.
-*/
-var SupervisorLock = class {
-	runId;
-	manifest;
-	baseDir;
-	logger;
-	/** Current lock mode — null until `acquire()` succeeds. */
-	mode = null;
-	/** File handle held open to maintain the advisory lock (flock mode only). */
-	lockHandle = null;
-	constructor(runId, manifest, logger$3) {
-		this.runId = runId;
-		this.manifest = manifest;
-		this.baseDir = manifest.baseDir;
-		this.logger = logger$3 ?? defaultLogger;
-	}
-	/** Advisory lock file path (primary path). */
-	get lockPath() {
-		return join$1(this.baseDir, `${this.runId}.lock`);
-	}
-	/** PID-file path (fallback path). */
-	get pidPath() {
-		return join$1(this.baseDir, `${this.runId}.pid`);
-	}
-	/**
-	* Acquire exclusive ownership of the run.
-	*
-	* Attempts to open `.substrate/runs/{run-id}.lock` with `O_CREAT | O_EXCL`
-	* (the `'wx'` flag), which succeeds atomically only if the file does not
-	* exist. On success, writes `supervisor_pid` and `supervisor_session_id` to
-	* the manifest.
-	*
-	* On EEXIST (file exists → contended): reads the manifest's `supervisor_pid`,
-	* checks if the holder process is alive, and either throws a prescribed
-	* rejection error or evicts the holder (if `force: true`).
-	*
-	* On ENOSYS or EOPNOTSUPP (filesystem does not support exclusive open): logs
-	* a `warn`-level message and falls back to PID-file ownership.
-	*
-	* @throws Error with exact message: "Run {id} is already supervised by PID {pid}. Use --force to take over."
-	*/
-	async acquire(pid, sessionId, opts) {
-		const force = opts?.force ?? false;
-		await mkdir$1(this.baseDir, { recursive: true });
-		let fh;
-		try {
-			fh = await open(this.lockPath, "wx");
-		} catch (err) {
-			const e = err;
-			if (e.code === "ENOSYS" || e.code === "EOPNOTSUPP") {
-				this.logger.warn(`[SupervisorLock] flock not available on this filesystem (${e.code}). Falling back to PID-file for run ${this.runId}.`);
-				await this.acquireViaPidFile(pid, sessionId, opts);
-				return;
-			}
-			if (e.code === "EEXIST") {
-				let existingPid = null;
-				try {
-					const data = await this.manifest.read();
-					existingPid = data.supervisor_pid;
-				} catch {}
-				if (existingPid === null) {
-					await unlink(this.lockPath).catch(() => void 0);
-					await this.acquire(pid, sessionId, opts);
-					return;
-				}
-				const isAlive = this.isPidAlive(existingPid);
-				if (!isAlive) {
-					await unlink(this.lockPath).catch(() => void 0);
-					await this.acquire(pid, sessionId, opts);
-					return;
-				}
-				if (force) {
-					await this.forceKillOwner(existingPid);
-					await unlink(this.lockPath).catch(() => void 0);
-					await this.acquire(pid, sessionId, opts);
-					return;
-				}
-				throw new Error(`Run ${this.runId} is already supervised by PID ${existingPid}. Use --force to take over.`);
-			}
-			throw err;
-		}
-		this.lockHandle = fh;
-		this.mode = "flock";
-		try {
-			await fh.write(String(pid), 0, "utf-8");
-			await this.manifest.update({
-				supervisor_pid: pid,
-				supervisor_session_id: sessionId
-			});
-		} catch (postOpenErr) {
-			try {
-				await fh.close();
-			} catch {}
-			this.lockHandle = null;
-			this.mode = null;
-			await unlink(this.lockPath).catch(() => void 0);
-			throw postOpenErr;
-		}
-	}
-	/**
-	* Release ownership of the run.
-	*
-	* Removes the lock file (flock mode) or PID-file (fallback mode) and clears
-	* `supervisor_pid` / `supervisor_session_id` in the manifest atomically.
-	*
-	* Safe to call multiple times; subsequent calls are no-ops.
-	*/
-	async release() {
-		if (this.mode === "flock") {
-			if (this.lockHandle !== null) {
-				try {
-					await this.lockHandle.close();
-				} catch {}
-				this.lockHandle = null;
-			}
-			await unlink(this.lockPath).catch(() => void 0);
-		} else if (this.mode === "pid-file") await this.releaseViaPidFile();
-		this.mode = null;
-		await this.manifest.update({
-			supervisor_pid: null,
-			supervisor_session_id: null
-		});
-	}
-	/**
-	* Acquire ownership using a PID-file at `.substrate/runs/{run-id}.pid`.
-	*
-	* If the PID-file exists:
-	*   - Dead PID (ESRCH from `kill(pid, 0)`) → overwrite without force (AC5)
-	*   - Alive PID without force → throw prescribed rejection error (AC3)
-	*   - Alive PID with force → SIGTERM + wait, then proceed (AC4)
-	*/
-	async acquireViaPidFile(pid, sessionId, opts) {
-		const force = opts?.force ?? false;
-		let existingPid = null;
-		try {
-			const content = await readFile$1(this.pidPath, "utf-8");
-			const parsed = parseInt(content.trim(), 10);
-			if (!isNaN(parsed)) existingPid = parsed;
-		} catch (e) {
-			const err = e;
-			if (err.code !== "ENOENT") throw e;
-		}
-		if (existingPid !== null) {
-			const isAlive = this.isPidAlive(existingPid);
-			if (!isAlive) {} else if (force) await this.forceKillOwner(existingPid);
-			else throw new Error(`Run ${this.runId} is already supervised by PID ${existingPid}. Use --force to take over.`);
-		}
-		await writeFile$1(this.pidPath, String(pid), { flag: "w" });
-		await this.manifest.update({
-			supervisor_pid: pid,
-			supervisor_session_id: sessionId
-		});
-		this.mode = "pid-file";
-	}
-	async releaseViaPidFile() {
-		await unlink(this.pidPath).catch(() => void 0);
-	}
-	/**
-	* Send SIGTERM to the existing supervisor and wait up to 500ms for it to exit.
-	*
-	* @throws Error if the process is still alive after 500ms.
-	*/
-	async forceKillOwner(existingPid) {
-		process.kill(existingPid, "SIGTERM");
-		await new Promise((resolve$2) => setTimeout(resolve$2, 500));
-		const stillAlive = this.isPidAlive(existingPid);
-		if (stillAlive) throw new Error(`Existing supervisor PID ${existingPid} did not exit after SIGTERM. Kill manually and retry.`);
-	}
-	/**
-	* Test whether a PID is alive by sending signal 0.
-	*
-	* Returns true if the process exists, false if ESRCH (not found).
-	* Other errors (e.g. EPERM) are treated as "alive" to avoid false stale
-	* detections when we lack permission to signal the process.
-	*/
-	isPidAlive(pid) {
-		try {
-			process.kill(pid, 0);
-			return true;
-		} catch (e) {
-			const err = e;
-			return err.code !== "ESRCH";
-		}
-	}
-};
-
 //#endregion
 //#region src/cli/commands/manifest-read.ts
 const logger$1 = createLogger("manifest-read");
@@ -3144,5 +2066,5 @@ function registerHealthCommand(program, _version = "0.0.0", projectRoot = proces
 }
 
 //#endregion
-export { BMAD_BASELINE_TOKENS_FULL, DEFAULT_STALL_THRESHOLD_SECONDS, DoltMergeConflict, FileStateStore, RunManifest, STOP_AFTER_VALID_PHASES, STORY_KEY_PATTERN$1 as STORY_KEY_PATTERN, SUBSTRATE_OWNED_SETTINGS_KEYS, SupervisorLock, VALID_PHASES, WorkGraphRepository, __commonJS, __require, __toESM, applyConfigToGraph, buildPipelineStatusOutput, createDatabaseAdapter$1 as createDatabaseAdapter, createGraphOrchestrator, createStateStore, detectCycles, findPackageRoot, formatOutput, formatPipelineStatusHuman, formatPipelineSummary, formatTokenTelemetry, getAllDescendantPids, getAutoHealthData, getSubstrateDefaultSettings, inspectProcessTree, isOrchestratorProcessLine, parseDbTimestampAsUtc, registerHealthCommand, resolveBmadMethodSrcPath, resolveBmadMethodVersion, resolveGraphPath, resolveMainRepoRoot, resolveRunManifest, runHealthAction, validateStoryKey };
-//# sourceMappingURL=health-DUgvybiN.js.map
+export { BMAD_BASELINE_TOKENS_FULL, DEFAULT_STALL_THRESHOLD_SECONDS, DoltMergeConflict, FileStateStore, STOP_AFTER_VALID_PHASES, STORY_KEY_PATTERN$1 as STORY_KEY_PATTERN, SUBSTRATE_OWNED_SETTINGS_KEYS, VALID_PHASES, WorkGraphRepository, __commonJS, __require, __toESM, buildPipelineStatusOutput, createDatabaseAdapter$1 as createDatabaseAdapter, createStateStore, detectCycles, findPackageRoot, formatOutput, formatPipelineStatusHuman, formatPipelineSummary, formatTokenTelemetry, getAllDescendantPids, getAutoHealthData, getSubstrateDefaultSettings, inspectProcessTree, isOrchestratorProcessLine, parseDbTimestampAsUtc, registerHealthCommand, resolveBmadMethodSrcPath, resolveBmadMethodVersion, resolveMainRepoRoot, resolveRunManifest, runHealthAction, validateStoryKey };
+//# sourceMappingURL=health-D--wDx-U.js.map