substrate-ai 0.19.28 → 0.19.30

package/dist/{health-M0iCuP26.js → health-DKallkoo.js}

@@ -2,10 +2,13 @@ import { createLogger } from "./logger-KeHncl-f.js";
 import { DoltClient, DoltQueryError, createDatabaseAdapter$1 as createDatabaseAdapter, getLatestRun, getPipelineRunById, initSchema } from "./dist-R0W4ofKv.js";
 import { createRequire } from "module";
 import { dirname, join } from "path";
-import { existsSync, readFileSync } from "node:fs";
+import { readFile } from "fs/promises";
+import { EventEmitter } from "node:events";
+import { existsSync, promises, 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 { readFile, writeFile } from "node:fs/promises";
+import { z } from "zod";
+import { mkdir as mkdir$1, open, readFile as readFile$1, unlink, 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";
@@ -133,7 +136,7 @@ function parseDbTimestampAsUtc(ts) {
 	return new Date(ts.replace(" ", "T") + "Z");
 }
 const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
+const __dirname$1 = dirname(__filename);
 /**
 * Find the package root by walking up until we find package.json.
 * Works regardless of build output structure (tsdown bundles into
@@ -147,13 +150,13 @@ function findPackageRoot(startDir) {
 	}
 	return startDir;
 }
-const PACKAGE_ROOT = join(__dirname, "..", "..", "..");
+const PACKAGE_ROOT = join(__dirname$1, "..", "..", "..");
 /**
 * 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) {
+function resolveBmadMethodSrcPath(fromDir = __dirname$1) {
 	try {
 		const require$1 = createRequire$1(join(fromDir, "synthetic.js"));
 		const pkgJsonPath = require$1.resolve("bmad-method/package.json");
@@ -166,7 +169,7 @@ function resolveBmadMethodSrcPath(fromDir = __dirname) {
 * Read the version field from bmad-method's package.json.
 * Returns 'unknown' if not resolvable.
 */
-function resolveBmadMethodVersion(fromDir = __dirname) {
+function resolveBmadMethodVersion(fromDir = __dirname$1) {
 	try {
 		const require$1 = createRequire$1(join(fromDir, "synthetic.js"));
 		const pkgJsonPath = require$1.resolve("bmad-method/package.json");
@@ -782,7 +785,7 @@ var FileStateStore = class {
 		if (inMemory !== void 0) return inMemory;
 		if (this._basePath !== void 0) try {
 			const filePath = join$1(this._basePath, "kv-metrics.json");
-			const content = await readFile(filePath, "utf-8");
+			const content = await readFile$1(filePath, "utf-8");
 			const parsed = JSON.parse(content);
 			return parsed[runId]?.[key] ?? void 0;
 		} catch {}
@@ -797,7 +800,7 @@ var FileStateStore = class {
 			for (const [key, value] of runMap) serialized[runId][key] = value;
 		}
 		const filePath = join$1(this._basePath, "kv-metrics.json");
-		await writeFile(filePath, JSON.stringify(serialized, null, 2), "utf-8");
+		await writeFile$1(filePath, JSON.stringify(serialized, null, 2), "utf-8");
 	}
 	async getContracts(storyKey) {
 		return this._contracts.get(storyKey) ?? [];
@@ -820,7 +823,7 @@ var FileStateStore = class {
 			const serialized = {};
 			for (const [key, records] of this._contractVerifications) serialized[key] = records;
 			const filePath = join$1(this._basePath, "contract-verifications.json");
-			await writeFile(filePath, JSON.stringify(serialized, null, 2), "utf-8");
+			await writeFile$1(filePath, JSON.stringify(serialized, null, 2), "utf-8");
 		}
 	}
 	async getContractVerification(storyKey) {
@@ -1461,7 +1464,7 @@ var DoltStateStore = class DoltStateStore {
 
 //#endregion
 //#region src/modules/state/index.ts
-const logger$1 = createLogger("state:factory");
+const logger$2 = createLogger("state:factory");
 /**
 * Synchronously check whether Dolt is available and a Dolt repo exists at the
 * canonical state path under `basePath`.
@@ -1508,20 +1511,1154 @@ function createStateStore(config = {}) {
 		const repoPath = config.basePath ?? process.cwd();
 		const detection = detectDoltAvailableSync(repoPath);
 		if (detection.available) {
-			logger$1.debug(`Dolt detected, using DoltStateStore (state path: ${join$1(repoPath, ".substrate", "state")})`);
+			logger$2.debug(`Dolt detected, using DoltStateStore (state path: ${join$1(repoPath, ".substrate", "state")})`);
 			const client = new DoltClient({ repoPath });
 			return new DoltStateStore({
 				repoPath,
 				client
 			});
 		} else {
-			logger$1.debug(`Dolt not found, using FileStateStore (reason: ${detection.reason})`);
+			logger$2.debug(`Dolt not found, using FileStateStore (reason: ${detection.reason})`);
 			return new FileStateStore({ basePath: config.basePath });
 		}
 	}
 	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");
+/**
+* Read the active run ID from `.substrate/current-run-id`.
+*
+* Returns the trimmed file content, or `null` if the file is absent or empty.
+* Never throws — all I/O errors are suppressed and return `null`.
+*/
+async function readCurrentRunId(dbRoot) {
+	try {
+		const content = await readFile(join(dbRoot, ".substrate", "current-run-id"), "utf8");
+		return content.trim() || null;
+	} catch {
+		return null;
+	}
+}
+/**
+* Resolve the active run manifest for CLI commands.
+*
+* Steps:
+*   1. If `runId` is provided, use it directly.
+*   2. Otherwise, read `.substrate/current-run-id`.
+*   3. If neither yields a run ID → return `{ manifest: null, runId: null }`.
+*   4. Construct `RunManifest(resolvedRunId, runsDir)` and call `.read()` to
+*      validate the file exists and parses correctly.
+*   5. On any error (file missing, schema mismatch) → return `{ manifest: null, runId }`.
+*
+* @param dbRoot - Resolved project root (typically from `resolveMainRepoRoot`)
+* @param runId  - Optional explicit run ID; skips `current-run-id` lookup when provided
+*/
+async function resolveRunManifest(dbRoot, runId) {
+	const resolvedRunId = runId ?? await readCurrentRunId(dbRoot);
+	if (!resolvedRunId) {
+		logger$1.debug("run manifest not found — falling back to Dolt (no current-run-id)");
+		return {
+			manifest: null,
+			runId: null
+		};
+	}
+	const runsDir = join(dbRoot, ".substrate", "runs");
+	try {
+		const manifest = new RunManifest(resolvedRunId, runsDir);
+		await manifest.read();
+		return {
+			manifest,
+			runId: resolvedRunId
+		};
+	} catch {
+		logger$1.debug({ runId: resolvedRunId }, "run manifest not found — falling back to Dolt");
+		return {
+			manifest: null,
+			runId: resolvedRunId
+		};
+	}
+}
+
 //#endregion
 //#region src/cli/commands/health.ts
 const logger = createLogger("health-cmd");
@@ -1600,10 +2737,10 @@ function inspectProcessTree(opts) {
 			if (parts.length >= 3) {
 				const pid = parseInt(parts[0], 10);
 				const ppid = parseInt(parts[1], 10);
-				const stat$1 = parts[2];
+				const stat$2 = parts[2];
 				if (ppid === result.orchestrator_pid && pid !== result.orchestrator_pid) {
 					result.child_pids.push(pid);
-					if (stat$1.includes("Z")) result.zombies.push(pid);
+					if (stat$2.includes("Z")) result.zombies.push(pid);
 				}
 			}
 		}
@@ -1663,6 +2800,42 @@ function getAllDescendantPids(rootPids, execFileSyncOverride) {
 	}
 }
 /**
+* Derive health story counts from manifest `per_story_state`.
+* Maps manifest status strings to health output buckets.
+*/
+function buildHealthStoryCountsFromManifest(perStoryState) {
+	const counts = {
+		active: 0,
+		completed: 0,
+		escalated: 0,
+		pending: 0,
+		failed: 0
+	};
+	for (const entry of Object.values(perStoryState)) switch (entry.status) {
+		case "complete":
+			counts.completed++;
+			break;
+		case "escalated":
+			counts.escalated++;
+			break;
+		case "failed":
+		case "verification-failed":
+			counts.failed++;
+			break;
+		case "pending":
+		case "gated":
+			counts.pending++;
+			break;
+		case "dispatched":
+		case "in-review":
+		case "recovered":
+		default:
+			counts.active++;
+			break;
+	}
+	return counts;
+}
+/**
 * Fetch pipeline health data as a structured object without any stdout side-effects.
 * Used by runSupervisorAction to poll health without formatting overhead.
 *
@@ -1806,6 +2979,27 @@ async function getAutoHealthData(options) {
 				}
 			}
 		} catch {}
+		let manifestSupervisor;
+		let manifestStoryCounts;
+		try {
+			const { manifest: resolvedManifest } = await resolveRunManifest(dbRoot, run.id);
+			if (resolvedManifest !== null) {
+				const manifestData = await resolvedManifest.read();
+				manifestSupervisor = {
+					pid: manifestData.supervisor_pid,
+					session_id: manifestData.supervisor_session_id
+				};
+				manifestStoryCounts = buildHealthStoryCountsFromManifest(manifestData.per_story_state);
+				logger.debug({ runId: run.id }, "health: story counts and supervisor read from manifest");
+			}
+		} catch {
+			logger.debug({ runId: run.id }, "health: manifest read failed — using token_usage_json counts");
+		}
+		const finalActive = manifestStoryCounts?.active ?? active;
+		const finalCompleted = manifestStoryCounts?.completed ?? completed;
+		const finalEscalated = manifestStoryCounts?.escalated ?? escalated;
+		const finalPending = manifestStoryCounts?.pending ?? pending;
+		const finalFailed = manifestStoryCounts?.failed;
 		const substrateDirPath = join(dbRoot, ".substrate");
 		const processInfo = options._processInfoOverride ?? inspectProcessTree({
 			projectRoot,
@@ -1816,12 +3010,12 @@ async function getAutoHealthData(options) {
 		else if (processInfo.pid_file_dead === true) verdict = "STALLED";
 		else if (processInfo.zombies.length > 0) verdict = "STALLED";
 		else if (stalenessSeconds > DEFAULT_STALL_THRESHOLD_SECONDS) verdict = "STALLED";
-		else if (active > 0) verdict = "STALLED";
+		else if (finalActive > 0) verdict = "STALLED";
 		else verdict = "HEALTHY";
 		else if (run.status === "completed" || run.status === "failed" || run.status === "stopped") verdict = "NO_PIPELINE_RUNNING";
 		const warnings = [];
 		if (doltStateInfo !== void 0 && doltStateInfo.responsive === false) warnings.push("Dolt not connected — decision store queries may fail, story context will be degraded");
-		if (escalated > 0) warnings.push(`${escalated} story(ies) escalated — operator intervention may be needed`);
+		if (finalEscalated > 0) warnings.push(`${finalEscalated} story(ies) escalated — operator intervention may be needed`);
 		const healthOutput = {
 			verdict,
 			run_id: run.id,
@@ -1831,12 +3025,14 @@ async function getAutoHealthData(options) {
 			last_activity: run.updated_at ?? "",
 			process: processInfo,
 			stories: {
-				active,
-				completed,
-				escalated,
-				pending,
+				active: finalActive,
+				completed: finalCompleted,
+				escalated: finalEscalated,
+				pending: finalPending,
+				...finalFailed !== void 0 ? { failed: finalFailed } : {},
 				details: storyDetails
 			},
+			...manifestSupervisor !== void 0 ? { manifest_supervisor: manifestSupervisor } : {},
 			...doltStateInfo !== void 0 ? { dolt_state: doltStateInfo } : {},
 			...warnings.length > 0 ? { warnings } : {}
 		};
@@ -1948,5 +3144,5 @@ function registerHealthCommand(program, _version = "0.0.0", projectRoot = proces
 }
 
 //#endregion
-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, runHealthAction, validateStoryKey };
-//# sourceMappingURL=health-M0iCuP26.js.map
+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-DKallkoo.js.map