substrate-ai 0.2.24 → 0.2.26

package/dist/{run-CT8B9gG9.js → run-CEtHPG4I.js}

@@ -1,11 +1,11 @@
 import { createLogger } from "./logger-D2fS2ccL.js";
-import { createEventBus, createTuiApp, isTuiCapable, printNonTtyWarning } from "./event-bus-CAvDMst7.js";
+import { createEventBus, createTuiApp, isTuiCapable, printNonTtyWarning, sleep } from "./helpers-DljGJnFF.js";
 import { addTokenUsage, createDecision, createPipelineRun, createRequirement, getArtifactByTypeForRun, getArtifactsByRun, getDecisionsByCategory, getDecisionsByPhase, getDecisionsByPhaseForRun, getLatestRun, getPipelineRunById, getRunningPipelineRuns, getTokenUsageSummary, registerArtifact, updatePipelineRun, updatePipelineRunConfig, upsertDecision } from "./decisions-Dq4cAA2L.js";
 import { ESCALATION_DIAGNOSIS, OPERATIONAL_FINDING, STORY_METRICS, STORY_OUTCOME, TEST_EXPANSION_FINDING, TEST_PLAN, aggregateTokenUsageForRun, aggregateTokenUsageForStory, getStoryMetricsForRun, writeRunMetrics, writeStoryMetrics } from "./operational-CnMlvWqc.js";
 import { createRequire } from "module";
 import { dirname, join } from "path";
 import { access, readFile, readdir, stat } from "fs/promises";
-import { existsSync, mkdirSync, readFileSync } from "fs";
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "fs";
 import yaml from "js-yaml";
 import { createRequire as createRequire$1 } from "node:module";
 import { z } from "zod";
@@ -677,7 +677,9 @@ const PackManifestSchema = z.object({
 	prompts: z.record(z.string(), z.string()),
 	constraints: z.record(z.string(), z.string()),
 	templates: z.record(z.string(), z.string()),
-	conflictGroups: z.record(z.string(), z.string()).optional()
+	conflictGroups: z.record(z.string(), z.string()).optional(),
+	verifyCommand: z.union([z.string(), z.literal(false)]).optional(),
+	verifyTimeoutMs: z.number().optional()
 });
 const ConstraintSeveritySchema = z.enum([
 	"required",
@@ -1244,6 +1246,8 @@ function buildPipelineStatusOutput(run, tokenSummary, decisionsCount, storiesCou
 			}
 		}
 	} catch {}
+	const derivedStoriesCount = storiesSummary !== void 0 ? storiesSummary.completed + storiesSummary.in_progress + storiesSummary.escalated + storiesSummary.pending : storiesCount;
+	const derivedStoriesCompleted = storiesSummary !== void 0 ? storiesSummary.completed : 0;
 	return {
 		run_id: run.id,
 		current_phase: currentPhase,
@@ -1254,7 +1258,8 @@ function buildPipelineStatusOutput(run, tokenSummary, decisionsCount, storiesCou
 			cost_usd: totalCost
 		},
 		decisions_count: decisionsCount,
-		stories_count: storiesCount,
+		stories_count: derivedStoriesCount,
+		stories_completed: derivedStoriesCompleted,
 		last_activity: run.updated_at,
 		staleness_seconds: Math.round((Date.now() - parseDbTimestampAsUtc(run.updated_at).getTime()) / 1e3),
 		last_event_ts: run.updated_at,
@@ -2209,6 +2214,69 @@ const PIPELINE_EVENT_METADATA = [
 				description: "Error message."
 			}
 		]
+	},
+	{
+		type: "story:zero-diff-escalation",
+		description: "Dev-story reported COMPLETE but git diff shows no file changes (phantom completion).",
+		when: "After dev-story succeeds with zero file changes in working tree.",
+		fields: [
+			{
+				name: "ts",
+				type: "string",
+				description: "Timestamp."
+			},
+			{
+				name: "storyKey",
+				type: "string",
+				description: "Story key."
+			},
+			{
+				name: "reason",
+				type: "string",
+				description: "Always \"zero-diff-on-complete\"."
+			}
+		]
+	},
+	{
+		type: "story:build-verification-failed",
+		description: "Build verification command (default: npm run build) exited with non-zero code or timed out.",
+		when: "After dev-story and zero-diff check pass, but before code-review is dispatched.",
+		fields: [
+			{
+				name: "ts",
+				type: "string",
+				description: "Timestamp."
+			},
+			{
+				name: "storyKey",
+				type: "string",
+				description: "Story key."
+			},
+			{
+				name: "exitCode",
+				type: "number",
+				description: "Exit code from the build command (-1 for timeout)."
+			},
+			{
+				name: "output",
+				type: "string",
+				description: "Combined stdout+stderr from the build command (truncated to 2000 chars)."
+			}
+		]
+	},
+	{
+		type: "story:build-verification-passed",
+		description: "Build verification command exited with code 0 — compilation clean.",
+		when: "After dev-story completes and build verification command succeeds.",
+		fields: [{
+			name: "ts",
+			type: "string",
+			description: "Timestamp."
+		}, {
+			name: "storyKey",
+			type: "string",
+			description: "Story key."
+		}]
 	}
 ];
 /**
@@ -2969,6 +3037,7 @@ const MIN_FREE_MEMORY_BYTES = (() => {
 	return 256 * 1024 * 1024;
 })();
 const MEMORY_PRESSURE_POLL_MS = 1e4;
+let _lastKnownPressureLevel = 0;
 /**
 * Get available system memory in bytes, accounting for platform differences.
 *
@@ -2998,6 +3067,7 @@ function getAvailableMemory() {
 				timeout: 1e3,
 				encoding: "utf-8"
 			}).trim(), 10);
+			_lastKnownPressureLevel = pressureLevel;
 			if (pressureLevel >= 4) {
 				logger$16.warn({ pressureLevel }, "macOS kernel reports critical memory pressure");
 				return 0;
@@ -3025,6 +3095,7 @@ function getAvailableMemory() {
 			return freemem();
 		}
 	}
+	_lastKnownPressureLevel = 0;
 	return freemem();
 }
 var MutableDispatchHandle = class {
@@ -3430,12 +3501,28 @@ var DispatcherImpl = class {
 		if (free < MIN_FREE_MEMORY_BYTES) {
 			logger$16.warn({
 				freeMB: Math.round(free / 1024 / 1024),
-				thresholdMB: Math.round(MIN_FREE_MEMORY_BYTES / 1024 / 1024)
+				thresholdMB: Math.round(MIN_FREE_MEMORY_BYTES / 1024 / 1024),
+				pressureLevel: _lastKnownPressureLevel
 			}, "Memory pressure detected — holding dispatch queue");
 			return true;
 		}
 		return false;
 	}
+	/**
+	* Return current memory pressure state (Story 23-8, AC1).
+	*
+	* Used by the orchestrator before dispatching a story phase so it can
+	* implement backoff-retry without waiting on the dispatcher's internal queue.
+	*/
+	getMemoryState() {
+		const free = getAvailableMemory();
+		return {
+			freeMB: Math.round(free / 1024 / 1024),
+			thresholdMB: Math.round(MIN_FREE_MEMORY_BYTES / 1024 / 1024),
+			pressureLevel: _lastKnownPressureLevel,
+			isPressured: free < MIN_FREE_MEMORY_BYTES
+		};
+	}
 	_startMemoryPressureTimer() {
 		if (this._memoryPressureTimer !== null) return;
 		this._memoryPressureTimer = setInterval(() => {
@@ -3450,6 +3537,114 @@ var DispatcherImpl = class {
 		}
 	}
 };
+/** Default command for the build verification gate */
+const DEFAULT_VERIFY_COMMAND = "npm run build";
+/** Default timeout in milliseconds for the build verification gate */
+const DEFAULT_VERIFY_TIMEOUT_MS = 6e4;
+/**
+* Run the build verification gate synchronously.
+*
+* Executes the configured verifyCommand (default: "npm run build") in the
+* project root directory, capturing stdout and stderr. On success (exit 0)
+* returns { status: 'passed' }. On failure or timeout, returns a structured
+* result with status, exitCode, output, and reason.
+*
+* AC4/5: reads verifyCommand from options (or defaults to 'npm run build').
+* AC6: if verifyCommand is empty string or false, returns { status: 'skipped' }.
+* AC8: timeout is configurable via verifyTimeoutMs (default 60 s).
+*/
+function runBuildVerification(options) {
+	const { verifyCommand, verifyTimeoutMs, projectRoot } = options;
+	const cmd = verifyCommand === void 0 ? DEFAULT_VERIFY_COMMAND : verifyCommand;
+	if (!cmd) return { status: "skipped" };
+	const timeoutMs = verifyTimeoutMs ?? DEFAULT_VERIFY_TIMEOUT_MS;
+	try {
+		const stdout = execSync(cmd, {
+			cwd: projectRoot,
+			timeout: timeoutMs,
+			encoding: "utf-8"
+		});
+		return {
+			status: "passed",
+			exitCode: 0,
+			output: typeof stdout === "string" ? stdout : ""
+		};
+	} catch (err) {
+		if (err != null && typeof err === "object") {
+			const e = err;
+			const isTimeout = e.killed === true;
+			const exitCode = typeof e.status === "number" ? e.status : 1;
+			const rawStdout = e.stdout;
+			const rawStderr = e.stderr;
+			const stdoutStr = typeof rawStdout === "string" ? rawStdout : Buffer.isBuffer(rawStdout) ? rawStdout.toString("utf-8") : "";
+			const stderrStr = typeof rawStderr === "string" ? rawStderr : Buffer.isBuffer(rawStderr) ? rawStderr.toString("utf-8") : "";
+			const combinedOutput = [stdoutStr, stderrStr].filter((s) => s.length > 0).join("\n");
+			if (isTimeout) return {
+				status: "timeout",
+				exitCode: -1,
+				output: combinedOutput,
+				reason: "build-verification-timeout"
+			};
+			return {
+				status: "failed",
+				exitCode,
+				output: combinedOutput,
+				reason: "build-verification-failed"
+			};
+		}
+		return {
+			status: "failed",
+			exitCode: 1,
+			output: String(err),
+			reason: "build-verification-failed"
+		};
+	}
+}
+/**
+* Check git working tree for modified files using `git diff --name-only HEAD`
+* (unstaged + staged changes to tracked files) and `git diff --cached --name-only`
+* (staged new files not yet in HEAD). Returns a deduplicated array of file paths.
+*
+* Returns an empty array when:
+* - No files have been modified or staged
+* - Git commands fail (e.g., not in a git repo, git not installed)
+*
+* Used by the zero-diff detection gate (Story 24-1) to catch phantom completions
+* where a dev-story agent reported COMPLETE but made no actual file changes.
+*
+* @param workingDir - Directory to run git commands in (defaults to process.cwd())
+* @returns Array of changed file paths; empty when nothing changed
+*/
+function checkGitDiffFiles(workingDir = process.cwd()) {
+	const results = new Set();
+	try {
+		const unstaged = execSync("git diff --name-only HEAD", {
+			cwd: workingDir,
+			encoding: "utf-8",
+			timeout: 5e3,
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			]
+		});
+		unstaged.split("\n").map((l) => l.trim()).filter((l) => l.length > 0).forEach((f) => results.add(f));
+	} catch {}
+	try {
+		const staged = execSync("git diff --cached --name-only", {
+			cwd: workingDir,
+			encoding: "utf-8",
+			timeout: 5e3,
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			]
+		});
+		staged.split("\n").map((l) => l.trim()).filter((l) => l.length > 0).forEach((f) => results.add(f));
+	} catch {}
+	return Array.from(results);
+}
 /**
 * Create a new Dispatcher instance.
 *
@@ -5868,120 +6063,403 @@ function detectConflictGroups(storyKeys, config) {
 }
 
 //#endregion
-//#region src/modules/implementation-orchestrator/seed-methodology-context.ts
-const logger$7 = createLogger("implementation-orchestrator:seed");
-/** Max chars for the architecture summary seeded into decisions */
-const MAX_ARCH_CHARS = 6e3;
-/** Max chars per epic shard (fallback when per-story extraction returns null) */
-const MAX_EPIC_SHARD_CHARS = 12e3;
-/** Max chars for test patterns */
-const MAX_TEST_PATTERNS_CHARS = 2e3;
+//#region src/cli/commands/health.ts
+const logger$7 = createLogger("health-cmd");
+/** Default stall threshold in seconds — also used by supervisor default */
+const DEFAULT_STALL_THRESHOLD_SECONDS = 600;
 /**
-* Seed the decision store with methodology-level context from planning artifacts.
-*
-* Reads the following from `{projectRoot}/_bmad-output/planning-artifacts/`:
-* - architecture.md → solutioning/architecture decisions
-* - epics.md → implementation/epic-shard decisions (one per epic)
-* - package.json → solutioning/test-patterns decisions (framework detection)
+* Determine whether a ps output line represents the substrate pipeline orchestrator.
+* Handles invocation via:
+*   - `substrate run` (globally installed)
+*   - `substrate-ai run`
+*   - `node dist/cli/index.js run` (npm run substrate:dev)
+*   - `npx substrate run`
+*   - any node process whose command contains `run` with `--events` or `--stories`
 *
-* @param db - SQLite database instance
-* @param projectRoot - Absolute path to the target project root
-* @returns SeedResult with counts of decisions created and categories skipped
+* When `projectRoot` is provided, additionally checks that the command line
+* contains that path (via `--project-root` flag or as part of the binary/CWD path).
+* This ensures multi-project environments match the correct orchestrator.
 */
-function seedMethodologyContext(db, projectRoot) {
+function isOrchestratorProcessLine(line, projectRoot) {
+	if (line.includes("grep")) return false;
+	let isOrchestrator = false;
+	if (line.includes("substrate run")) isOrchestrator = true;
+	else if (line.includes("substrate-ai run")) isOrchestrator = true;
+	else if (line.includes("index.js run")) isOrchestrator = true;
+	else if (line.includes("node") && /\srun(\s|$)/.test(line) && (line.includes("--events") || line.includes("--stories"))) isOrchestrator = true;
+	if (!isOrchestrator) return false;
+	if (projectRoot !== void 0) return line.includes(projectRoot);
+	return true;
+}
+function inspectProcessTree(opts) {
+	const { projectRoot, substrateDirPath, execFileSync: execFileSyncOverride, readFileSync: readFileSyncOverride } = opts ?? {};
 	const result = {
-		decisionsCreated: 0,
-		skippedCategories: []
+		orchestrator_pid: null,
+		child_pids: [],
+		zombies: []
 	};
 	try {
-		const archCount = seedArchitecture(db, projectRoot);
-		if (archCount === -1) result.skippedCategories.push("architecture");
-		else result.decisionsCreated += archCount;
-		const epicCount = seedEpicShards(db, projectRoot);
-		if (epicCount === -1) result.skippedCategories.push("epic-shard");
-		else result.decisionsCreated += epicCount;
-		const testCount = seedTestPatterns(db, projectRoot);
-		if (testCount === -1) result.skippedCategories.push("test-patterns");
-		else result.decisionsCreated += testCount;
-		logger$7.info({
-			decisionsCreated: result.decisionsCreated,
-			skippedCategories: result.skippedCategories
-		}, "Methodology context seeding complete");
-	} catch (err) {
-		logger$7.warn({ error: err instanceof Error ? err.message : String(err) }, "Methodology context seeding failed (non-fatal)");
-	}
-	return result;
-}
-/**
-* Seed architecture constraints from architecture.md.
-* Extracts key sections (tech stack, ADRs, component overview) as separate decisions.
-* Returns number of decisions created, or -1 if skipped (already seeded).
-*/
-function seedArchitecture(db, projectRoot) {
-	const existing = getDecisionsByPhase(db, "solutioning");
-	if (existing.some((d) => d.category === "architecture")) return -1;
-	const archPath = findArtifact(projectRoot, [
-		"_bmad-output/planning-artifacts/architecture.md",
-		"_bmad-output/architecture/architecture.md",
-		"_bmad-output/architecture.md"
-	]);
-	if (archPath === void 0) return 0;
-	const content = readFileSync$1(archPath, "utf-8");
-	if (content.length === 0) return 0;
-	const sections = extractArchSections(content);
-	let count = 0;
-	for (const section of sections) {
-		createDecision(db, {
-			pipeline_run_id: null,
-			phase: "solutioning",
-			category: "architecture",
-			key: section.key,
-			value: section.value.slice(0, MAX_ARCH_CHARS),
-			rationale: "Seeded from planning artifacts at orchestrator startup"
-		});
-		count++;
-	}
-	if (count === 0) {
-		createDecision(db, {
-			pipeline_run_id: null,
-			phase: "solutioning",
-			category: "architecture",
-			key: "full",
-			value: content.slice(0, MAX_ARCH_CHARS),
-			rationale: "Seeded from planning artifacts at orchestrator startup (full file)"
+		let psOutput;
+		if (execFileSyncOverride !== void 0) psOutput = execFileSyncOverride("ps", ["-eo", "pid,ppid,stat,command"], {
+			encoding: "utf-8",
+			timeout: 5e3
 		});
-		count = 1;
-	}
-	logger$7.debug({ count }, "Seeded architecture decisions");
-	return count;
+		else {
+			const { execFileSync } = __require("node:child_process");
+			psOutput = execFileSync("ps", ["-eo", "pid,ppid,stat,command"], {
+				encoding: "utf-8",
+				timeout: 5e3
+			});
+		}
+		const lines = psOutput.split("\n");
+		if (substrateDirPath !== void 0) try {
+			const readFileSyncFn = readFileSyncOverride ?? ((path$1, encoding) => readFileSync$1(path$1, encoding));
+			const pidContent = readFileSyncFn(join(substrateDirPath, "orchestrator.pid"), "utf-8");
+			const pid = parseInt(pidContent.trim(), 10);
+			if (!isNaN(pid) && pid > 0) {
+				const isAlive = lines.some((line) => {
+					const parts = line.trim().split(/\s+/);
+					if (parts.length < 3) return false;
+					return parseInt(parts[0], 10) === pid && !parts[2].includes("Z");
+				});
+				if (isAlive) result.orchestrator_pid = pid;
+			}
+		} catch {}
+		if (result.orchestrator_pid === null) {
+			for (const line of lines) if (isOrchestratorProcessLine(line, projectRoot)) {
+				const match = line.trim().match(/^(\d+)/);
+				if (match) {
+					result.orchestrator_pid = parseInt(match[1], 10);
+					break;
+				}
+			}
+		}
+		if (result.orchestrator_pid !== null) for (const line of lines) {
+			const parts = line.trim().split(/\s+/);
+			if (parts.length >= 3) {
+				const pid = parseInt(parts[0], 10);
+				const ppid = parseInt(parts[1], 10);
+				const stat$2 = parts[2];
+				if (ppid === result.orchestrator_pid && pid !== result.orchestrator_pid) {
+					result.child_pids.push(pid);
+					if (stat$2.includes("Z")) result.zombies.push(pid);
+				}
+			}
+		}
+	} catch {}
+	return result;
 }
 /**
-* Seed epic shards from epics.md.
-* Parses each epic section and creates an implementation/epic-shard decision.
-*
-* Uses content-hash comparison (AC1, AC2, AC6):
-* - Computes SHA-256 of the epics file and compares to the stored `epic-shard-hash` decision.
-* - If hashes match: skip re-seeding (unchanged file).
-* - If hash differs or no hash stored: delete existing epic-shard decisions and re-seed.
+* Collect all descendant PIDs of the given root PIDs by walking the process
+* tree recursively. This ensures that grandchildren of the orchestrator
+* (e.g. node subprocesses spawned by `claude -p`) are also killed during
+* stall recovery, leaving no orphan processes.
 *
-* Returns number of decisions created, or -1 if skipped (hash unchanged).
+* Returns only the descendants — the root PIDs themselves are NOT included.
 */
-function seedEpicShards(db, projectRoot) {
-	const epicsPath = findArtifact(projectRoot, ["_bmad-output/planning-artifacts/epics.md", "_bmad-output/epics.md"]);
-	if (epicsPath === void 0) return 0;
-	const content = readFileSync$1(epicsPath, "utf-8");
-	if (content.length === 0) return 0;
-	const currentHash = createHash("sha256").update(content).digest("hex");
-	const implementationDecisions = getDecisionsByPhase(db, "implementation");
-	const storedHashDecision = implementationDecisions.find((d) => d.category === "epic-shard-hash" && d.key === "epics-file");
-	const storedHash = storedHashDecision?.value;
-	if (storedHash === currentHash) {
-		logger$7.debug({ hash: currentHash }, "Epic shards up-to-date (hash unchanged) — skipping re-seed");
-		return -1;
-	}
-	if (implementationDecisions.some((d) => d.category === "epic-shard")) {
-		logger$7.debug({
-			storedHash,
+function getAllDescendantPids(rootPids, execFileSyncOverride) {
+	if (rootPids.length === 0) return [];
+	try {
+		let psOutput;
+		if (execFileSyncOverride !== void 0) psOutput = execFileSyncOverride("ps", ["-eo", "pid,ppid"], {
+			encoding: "utf-8",
+			timeout: 5e3
+		});
+		else {
+			const { execFileSync } = __require("node:child_process");
+			psOutput = execFileSync("ps", ["-eo", "pid,ppid"], {
+				encoding: "utf-8",
+				timeout: 5e3
+			});
+		}
+		const childrenOf = new Map();
+		for (const line of psOutput.split("\n")) {
+			const parts = line.trim().split(/\s+/);
+			if (parts.length >= 2) {
+				const pid = parseInt(parts[0], 10);
+				const ppid = parseInt(parts[1], 10);
+				if (!isNaN(pid) && !isNaN(ppid) && pid > 0) {
+					if (!childrenOf.has(ppid)) childrenOf.set(ppid, []);
+					childrenOf.get(ppid).push(pid);
+				}
+			}
+		}
+		const descendants = [];
+		const seen = new Set(rootPids);
+		const queue = [...rootPids];
+		while (queue.length > 0) {
+			const current = queue.shift();
+			const children = childrenOf.get(current) ?? [];
+			for (const child of children) if (!seen.has(child)) {
+				seen.add(child);
+				descendants.push(child);
+				queue.push(child);
+			}
+		}
+		return descendants;
+	} catch {
+		return [];
+	}
+}
+/**
+* Fetch pipeline health data as a structured object without any stdout side-effects.
+* Used by runSupervisorAction to poll health without formatting overhead.
+*
+* Returns a NO_PIPELINE_RUNNING health object for all graceful "no data" cases
+* (missing DB, missing run, terminal run status). Throws only on unexpected errors.
+*/
+async function getAutoHealthData(options) {
+	const { runId, projectRoot } = options;
+	const dbRoot = await resolveMainRepoRoot(projectRoot);
+	const dbPath = join(dbRoot, ".substrate", "substrate.db");
+	const NO_PIPELINE = {
+		verdict: "NO_PIPELINE_RUNNING",
+		run_id: null,
+		status: null,
+		current_phase: null,
+		staleness_seconds: 0,
+		last_activity: "",
+		process: {
+			orchestrator_pid: null,
+			child_pids: [],
+			zombies: []
+		},
+		stories: {
+			active: 0,
+			completed: 0,
+			escalated: 0,
+			details: {}
+		}
+	};
+	if (!existsSync$1(dbPath)) return NO_PIPELINE;
+	const dbWrapper = new DatabaseWrapper(dbPath);
+	try {
+		dbWrapper.open();
+		const db = dbWrapper.db;
+		let run;
+		if (runId !== void 0) run = getPipelineRunById(db, runId);
+		else run = getLatestRun(db);
+		if (run === void 0) return NO_PIPELINE;
+		const updatedAt = parseDbTimestampAsUtc(run.updated_at);
+		const stalenessSeconds = Math.round((Date.now() - updatedAt.getTime()) / 1e3);
+		let storyDetails = {};
+		let active = 0;
+		let completed = 0;
+		let escalated = 0;
+		let pending = 0;
+		try {
+			if (run.token_usage_json) {
+				const state = JSON.parse(run.token_usage_json);
+				if (state.stories) for (const [key, s] of Object.entries(state.stories)) {
+					storyDetails[key] = {
+						phase: s.phase,
+						review_cycles: s.reviewCycles
+					};
+					if (s.phase === "COMPLETE") completed++;
+					else if (s.phase === "ESCALATED") escalated++;
+					else if (s.phase === "PENDING") pending++;
+					else active++;
+				}
+			}
+		} catch {}
+		const substrateDirPath = join(dbRoot, ".substrate");
+		const processInfo = inspectProcessTree({
+			projectRoot,
+			substrateDirPath
+		});
+		let verdict = "NO_PIPELINE_RUNNING";
+		if (run.status === "running") if (processInfo.zombies.length > 0) verdict = "STALLED";
+		else if (processInfo.orchestrator_pid !== null && processInfo.child_pids.length > 0 && stalenessSeconds > DEFAULT_STALL_THRESHOLD_SECONDS) verdict = "HEALTHY";
+		else if (stalenessSeconds > DEFAULT_STALL_THRESHOLD_SECONDS) verdict = "STALLED";
+		else if (processInfo.orchestrator_pid !== null && processInfo.child_pids.length === 0 && active > 0) verdict = "STALLED";
+		else verdict = "HEALTHY";
+		else if (run.status === "completed" || run.status === "failed" || run.status === "stopped") verdict = "NO_PIPELINE_RUNNING";
+		return {
+			verdict,
+			run_id: run.id,
+			status: run.status,
+			current_phase: run.current_phase,
+			staleness_seconds: stalenessSeconds,
+			last_activity: run.updated_at,
+			process: processInfo,
+			stories: {
+				active,
+				completed,
+				escalated,
+				pending,
+				details: storyDetails
+			}
+		};
+	} finally {
+		try {
+			dbWrapper.close();
+		} catch {}
+	}
+}
+async function runHealthAction(options) {
+	const { outputFormat } = options;
+	try {
+		const health = await getAutoHealthData(options);
+		if (outputFormat === "json") process.stdout.write(formatOutput(health, "json", true) + "\n");
+		else {
+			const verdictLabel = health.verdict === "HEALTHY" ? "HEALTHY" : health.verdict === "STALLED" ? "STALLED" : "NO PIPELINE RUNNING";
+			process.stdout.write(`\nPipeline Health: ${verdictLabel}\n`);
+			if (health.run_id !== null) {
+				process.stdout.write(`  Run:          ${health.run_id}\n`);
+				process.stdout.write(`  Status:       ${health.status}\n`);
+				process.stdout.write(`  Phase:        ${health.current_phase ?? "N/A"}\n`);
+				process.stdout.write(`  Last Active:  ${health.last_activity} (${health.staleness_seconds}s ago)\n`);
+				const processInfo = health.process;
+				if (processInfo.orchestrator_pid !== null) {
+					process.stdout.write(`  Orchestrator: PID ${processInfo.orchestrator_pid}\n`);
+					process.stdout.write(`  Children:     ${processInfo.child_pids.length} active`);
+					if (processInfo.zombies.length > 0) process.stdout.write(` (${processInfo.zombies.length} ZOMBIE)`);
+					process.stdout.write("\n");
+				} else process.stdout.write("  Orchestrator: not running\n");
+				const storyDetails = health.stories.details;
+				if (Object.keys(storyDetails).length > 0) {
+					process.stdout.write("\n  Stories:\n");
+					for (const [key, s] of Object.entries(storyDetails)) process.stdout.write(`    ${key}: ${s.phase} (${s.review_cycles} review cycles)\n`);
+					process.stdout.write(`\n  Summary: ${health.stories.active} active, ${health.stories.completed} completed, ${health.stories.escalated} escalated\n`);
+				}
+			}
+		}
+		return 0;
+	} catch (err) {
+		const msg = err instanceof Error ? err.message : String(err);
+		if (outputFormat === "json") process.stdout.write(formatOutput(null, "json", false, msg) + "\n");
+		else process.stderr.write(`Error: ${msg}\n`);
+		logger$7.error({ err }, "health action failed");
+		return 1;
+	}
+}
+function registerHealthCommand(program, _version = "0.0.0", projectRoot = process.cwd()) {
+	program.command("health").description("Check pipeline health: process status, stall detection, and verdict").option("--run-id <id>", "Pipeline run ID to query (defaults to latest)").option("--project-root <path>", "Project root directory", projectRoot).option("--output-format <format>", "Output format: human (default) or json", "human").action(async (opts) => {
+		const outputFormat = opts.outputFormat === "json" ? "json" : "human";
+		const exitCode = await runHealthAction({
+			outputFormat,
+			runId: opts.runId,
+			projectRoot: opts.projectRoot
+		});
+		process.exitCode = exitCode;
+	});
+}
+
+//#endregion
+//#region src/modules/implementation-orchestrator/seed-methodology-context.ts
+const logger$6 = createLogger("implementation-orchestrator:seed");
+/** Max chars for the architecture summary seeded into decisions */
+const MAX_ARCH_CHARS = 6e3;
+/** Max chars per epic shard (fallback when per-story extraction returns null) */
+const MAX_EPIC_SHARD_CHARS = 12e3;
+/** Max chars for test patterns */
+const MAX_TEST_PATTERNS_CHARS = 2e3;
+/**
+* Seed the decision store with methodology-level context from planning artifacts.
+*
+* Reads the following from `{projectRoot}/_bmad-output/planning-artifacts/`:
+* - architecture.md → solutioning/architecture decisions
+* - epics.md → implementation/epic-shard decisions (one per epic)
+* - package.json → solutioning/test-patterns decisions (framework detection)
+*
+* @param db - SQLite database instance
+* @param projectRoot - Absolute path to the target project root
+* @returns SeedResult with counts of decisions created and categories skipped
+*/
+function seedMethodologyContext(db, projectRoot) {
+	const result = {
+		decisionsCreated: 0,
+		skippedCategories: []
+	};
+	try {
+		const archCount = seedArchitecture(db, projectRoot);
+		if (archCount === -1) result.skippedCategories.push("architecture");
+		else result.decisionsCreated += archCount;
+		const epicCount = seedEpicShards(db, projectRoot);
+		if (epicCount === -1) result.skippedCategories.push("epic-shard");
+		else result.decisionsCreated += epicCount;
+		const testCount = seedTestPatterns(db, projectRoot);
+		if (testCount === -1) result.skippedCategories.push("test-patterns");
+		else result.decisionsCreated += testCount;
+		logger$6.info({
+			decisionsCreated: result.decisionsCreated,
+			skippedCategories: result.skippedCategories
+		}, "Methodology context seeding complete");
+	} catch (err) {
+		logger$6.warn({ error: err instanceof Error ? err.message : String(err) }, "Methodology context seeding failed (non-fatal)");
+	}
+	return result;
+}
+/**
+* Seed architecture constraints from architecture.md.
+* Extracts key sections (tech stack, ADRs, component overview) as separate decisions.
+* Returns number of decisions created, or -1 if skipped (already seeded).
+*/
+function seedArchitecture(db, projectRoot) {
+	const existing = getDecisionsByPhase(db, "solutioning");
+	if (existing.some((d) => d.category === "architecture")) return -1;
+	const archPath = findArtifact(projectRoot, [
+		"_bmad-output/planning-artifacts/architecture.md",
+		"_bmad-output/architecture/architecture.md",
+		"_bmad-output/architecture.md"
+	]);
+	if (archPath === void 0) return 0;
+	const content = readFileSync$1(archPath, "utf-8");
+	if (content.length === 0) return 0;
+	const sections = extractArchSections(content);
+	let count = 0;
+	for (const section of sections) {
+		createDecision(db, {
+			pipeline_run_id: null,
+			phase: "solutioning",
+			category: "architecture",
+			key: section.key,
+			value: section.value.slice(0, MAX_ARCH_CHARS),
+			rationale: "Seeded from planning artifacts at orchestrator startup"
+		});
+		count++;
+	}
+	if (count === 0) {
+		createDecision(db, {
+			pipeline_run_id: null,
+			phase: "solutioning",
+			category: "architecture",
+			key: "full",
+			value: content.slice(0, MAX_ARCH_CHARS),
+			rationale: "Seeded from planning artifacts at orchestrator startup (full file)"
+		});
+		count = 1;
+	}
+	logger$6.debug({ count }, "Seeded architecture decisions");
+	return count;
+}
+/**
+* Seed epic shards from epics.md.
+* Parses each epic section and creates an implementation/epic-shard decision.
+*
+* Uses content-hash comparison (AC1, AC2, AC6):
+* - Computes SHA-256 of the epics file and compares to the stored `epic-shard-hash` decision.
+* - If hashes match: skip re-seeding (unchanged file).
+* - If hash differs or no hash stored: delete existing epic-shard decisions and re-seed.
+*
+* Returns number of decisions created, or -1 if skipped (hash unchanged).
+*/
+function seedEpicShards(db, projectRoot) {
+	const epicsPath = findArtifact(projectRoot, ["_bmad-output/planning-artifacts/epics.md", "_bmad-output/epics.md"]);
+	if (epicsPath === void 0) return 0;
+	const content = readFileSync$1(epicsPath, "utf-8");
+	if (content.length === 0) return 0;
+	const currentHash = createHash("sha256").update(content).digest("hex");
+	const implementationDecisions = getDecisionsByPhase(db, "implementation");
+	const storedHashDecision = implementationDecisions.find((d) => d.category === "epic-shard-hash" && d.key === "epics-file");
+	const storedHash = storedHashDecision?.value;
+	if (storedHash === currentHash) {
+		logger$6.debug({ hash: currentHash }, "Epic shards up-to-date (hash unchanged) — skipping re-seed");
+		return -1;
+	}
+	if (implementationDecisions.some((d) => d.category === "epic-shard")) {
+		logger$6.debug({
+			storedHash,
 			currentHash
 		}, "Epics file changed — deleting stale epic-shard decisions");
 		db.prepare("DELETE FROM decisions WHERE phase = 'implementation' AND category = 'epic-shard'").run();
@@ -6008,7 +6486,7 @@ function seedEpicShards(db, projectRoot) {
 		value: currentHash,
 		rationale: "SHA-256 hash of epics file content for change detection"
 	});
-	logger$7.debug({
+	logger$6.debug({
 		count,
 		hash: currentHash
 	}, "Seeded epic shard decisions");
@@ -6032,7 +6510,7 @@ function seedTestPatterns(db, projectRoot) {
 		value: patterns.slice(0, MAX_TEST_PATTERNS_CHARS),
 		rationale: "Detected from project configuration at orchestrator startup"
 	});
-	logger$7.debug("Seeded test patterns decision");
+	logger$6.debug("Seeded test patterns decision");
 	return 1;
 }
 /**
@@ -6235,13 +6713,19 @@ function createImplementationOrchestrator(deps) {
 	let _lastProgressTs = Date.now();
 	let _heartbeatTimer = null;
 	const HEARTBEAT_INTERVAL_MS = 3e4;
-	const WATCHDOG_TIMEOUT_MS = 6e5;
+	const DEFAULT_STALL_THRESHOLD_MS = 6e5;
+	const DEV_STORY_STALL_THRESHOLD_MS = 9e5;
 	const _stalledStories = new Set();
 	const _storiesWithStall = new Set();
 	const _phaseStartMs = new Map();
 	const _phaseEndMs = new Map();
 	const _storyDispatches = new Map();
 	let _maxConcurrentActual = 0;
+	const MEMORY_PRESSURE_BACKOFF_MS = [
+		3e4,
+		6e4,
+		12e4
+	];
 	function startPhase(storyKey, phase) {
 		if (!_phaseStartMs.has(storyKey)) _phaseStartMs.set(storyKey, new Map());
 		_phaseStartMs.get(storyKey).set(phase, Date.now());
@@ -6426,6 +6910,9 @@ function createImplementationOrchestrator(deps) {
 		_lastProgressTs = Date.now();
 		_stalledStories.clear();
 	}
+	function getStallThresholdMs(phase) {
+		return phase === "IN_DEV" ? DEV_STORY_STALL_THRESHOLD_MS : DEFAULT_STALL_THRESHOLD_MS;
+	}
 	function startHeartbeat() {
 		if (_heartbeatTimer !== null) return;
 		_heartbeatTimer = setInterval(() => {
@@ -6444,24 +6931,49 @@ function createImplementationOrchestrator(deps) {
 				queuedDispatches: queued
 			});
 			const elapsed = Date.now() - _lastProgressTs;
-			if (elapsed >= WATCHDOG_TIMEOUT_MS) {
-				for (const [key, s] of _stories) if (s.phase !== "PENDING" && s.phase !== "COMPLETE" && s.phase !== "ESCALATED") {
-					if (_stalledStories.has(key)) continue;
-					_stalledStories.add(key);
-					_storiesWithStall.add(key);
-					logger$20.warn({
-						storyKey: key,
-						phase: s.phase,
-						elapsedMs: elapsed
-					}, "Watchdog: possible stall detected");
-					eventBus.emit("orchestrator:stall", {
-						runId: config.pipelineRunId ?? "",
+			let childPids = [];
+			let childActive = false;
+			let processInspected = false;
+			for (const [key, s] of _stories) {
+				if (s.phase === "PENDING" || s.phase === "COMPLETE" || s.phase === "ESCALATED") continue;
+				const threshold = getStallThresholdMs(s.phase);
+				if (elapsed < threshold) continue;
+				if (_stalledStories.has(key)) continue;
+				if (!processInspected) {
+					processInspected = true;
+					try {
+						const processInfo = inspectProcessTree();
+						childPids = processInfo.child_pids;
+						const nonZombieChildren = processInfo.child_pids.filter((pid) => !processInfo.zombies.includes(pid));
+						childActive = nonZombieChildren.length > 0;
+					} catch {}
+				}
+				if (childActive) {
+					_lastProgressTs = Date.now();
+					logger$20.debug({
 						storyKey: key,
 						phase: s.phase,
-						elapsedMs: elapsed,
-						childPid: null
-					});
+						childPids
+					}, "Staleness exceeded but child processes are active — suppressing stall");
+					break;
 				}
+				_stalledStories.add(key);
+				_storiesWithStall.add(key);
+				logger$20.warn({
+					storyKey: key,
+					phase: s.phase,
+					elapsedMs: elapsed,
+					childPids,
+					childActive
+				}, "Watchdog: possible stall detected");
+				eventBus.emit("orchestrator:stall", {
+					runId: config.pipelineRunId ?? "",
+					storyKey: key,
+					phase: s.phase,
+					elapsedMs: elapsed,
+					childPids,
+					childActive
+				});
 			}
 		}, HEARTBEAT_INTERVAL_MS);
 		if (_heartbeatTimer && typeof _heartbeatTimer === "object" && "unref" in _heartbeatTimer) _heartbeatTimer.unref();
@@ -6479,6 +6991,32 @@ function createImplementationOrchestrator(deps) {
 		if (_paused && _pauseGate !== null) await _pauseGate.promise;
 	}
 	/**
+	* Check memory pressure before dispatching a story phase (Story 23-8, AC1).
+	*
+	* When the dispatcher reports memory pressure, this helper waits using
+	* exponential backoff (30 s, 60 s, 120 s) and re-checks after each interval.
+	* If memory is still pressured after all intervals, returns false so the
+	* caller can escalate the story with reason 'memory_pressure_exhausted'.
+	*
+	* If memory is OK (or clears during a wait), returns true immediately.
+	*/
+	async function checkMemoryPressure(storyKey) {
+		for (let attempt = 0; attempt < MEMORY_PRESSURE_BACKOFF_MS.length; attempt++) {
+			const memState = dispatcher.getMemoryState();
+			if (!memState.isPressured) return true;
+			logger$20.warn({
+				storyKey,
+				freeMB: memState.freeMB,
+				thresholdMB: memState.thresholdMB,
+				pressureLevel: memState.pressureLevel,
+				attempt: attempt + 1,
+				maxAttempts: MEMORY_PRESSURE_BACKOFF_MS.length
+			}, "Memory pressure before story dispatch — backing off");
+			await sleep(MEMORY_PRESSURE_BACKOFF_MS[attempt] ?? 0);
+		}
+		return !dispatcher.getMemoryState().isPressured;
+	}
+	/**
 	* Run the full pipeline for a single story key.
 	*
 	* Sequence: create-story → dev-story → code-review (with retry/rework up
@@ -6487,6 +7025,28 @@ function createImplementationOrchestrator(deps) {
 	*/
 	async function processStory(storyKey) {
 		logger$20.info("Processing story", { storyKey });
+		{
+			const memoryOk = await checkMemoryPressure(storyKey);
+			if (!memoryOk) {
+				logger$20.warn({ storyKey }, "Memory pressure exhausted — escalating story without dispatch");
+				_stories.set(storyKey, {
+					phase: "ESCALATED",
+					reviewCycles: 0,
+					error: "memory_pressure_exhausted",
+					startedAt: new Date().toISOString(),
+					completedAt: new Date().toISOString()
+				});
+				writeStoryMetricsBestEffort(storyKey, "escalated", 0);
+				emitEscalation({
+					storyKey,
+					lastVerdict: "memory_pressure_exhausted",
+					reviewCycles: 0,
+					issues: [`Memory pressure exhausted after ${MEMORY_PRESSURE_BACKOFF_MS.length} backoff attempts`]
+				});
+				persistState();
+				return;
+			}
+		}
 		await waitIfPaused();
 		if (_state !== "RUNNING") return;
 		startPhase(storyKey, "create-story");
@@ -6640,6 +7200,7 @@ function createImplementationOrchestrator(deps) {
 		persistState();
 		let devFilesModified = [];
 		const batchFileGroups = [];
+		let devStoryWasSuccess = false;
 		try {
 			let storyContentForAnalysis = "";
 			try {
@@ -6748,6 +7309,7 @@ function createImplementationOrchestrator(deps) {
 						batchIndex: batch.batchIndex,
 						error: batchResult.error
 					}, "Batch dev-story reported failure — continuing with partial files");
+					else devStoryWasSuccess = true;
 					eventBus.emit("orchestrator:story-phase-complete", {
 						storyKey,
 						phase: "IN_DEV",
@@ -6776,7 +7338,8 @@ function createImplementationOrchestrator(deps) {
 					result: devResult
 				});
 				persistState();
-				if (devResult.result === "failed") logger$20.warn("Dev-story reported failure, proceeding to code review", {
+				if (devResult.result === "success") devStoryWasSuccess = true;
+				else logger$20.warn("Dev-story reported failure, proceeding to code review", {
 					storyKey,
 					error: devResult.error,
 					filesModified: devFilesModified.length
@@ -6800,7 +7363,70 @@ function createImplementationOrchestrator(deps) {
 			persistState();
 			return;
 		}
+		if (devStoryWasSuccess) {
+			const changedFiles = checkGitDiffFiles(projectRoot ?? process.cwd());
+			if (changedFiles.length === 0) {
+				logger$20.warn({ storyKey }, "Zero-diff detected after COMPLETE dev-story — no file changes in git working tree");
+				eventBus.emit("orchestrator:zero-diff-escalation", {
+					storyKey,
+					reason: "zero-diff-on-complete"
+				});
+				endPhase(storyKey, "dev-story");
+				updateStory(storyKey, {
+					phase: "ESCALATED",
+					error: "zero-diff-on-complete",
+					completedAt: new Date().toISOString()
+				});
+				writeStoryMetricsBestEffort(storyKey, "escalated", 0);
+				emitEscalation({
+					storyKey,
+					lastVerdict: "zero-diff-on-complete",
+					reviewCycles: 0,
+					issues: ["dev-story completed with COMPLETE verdict but no file changes detected in git diff"]
+				});
+				persistState();
+				return;
+			}
+		}
 		endPhase(storyKey, "dev-story");
+		{
+			const buildVerifyResult = runBuildVerification({
+				verifyCommand: pack.manifest.verifyCommand,
+				verifyTimeoutMs: pack.manifest.verifyTimeoutMs,
+				projectRoot: projectRoot ?? process.cwd()
+			});
+			if (buildVerifyResult.status === "passed") {
+				eventBus.emit("story:build-verification-passed", { storyKey });
+				logger$20.info({ storyKey }, "Build verification passed");
+			} else if (buildVerifyResult.status === "failed" || buildVerifyResult.status === "timeout") {
+				const truncatedOutput = (buildVerifyResult.output ?? "").slice(0, 2e3);
+				const reason = buildVerifyResult.reason ?? "build-verification-failed";
+				eventBus.emit("story:build-verification-failed", {
+					storyKey,
+					exitCode: buildVerifyResult.exitCode ?? 1,
+					output: truncatedOutput
+				});
+				logger$20.warn({
+					storyKey,
+					reason,
+					exitCode: buildVerifyResult.exitCode
+				}, "Build verification failed — escalating story");
+				updateStory(storyKey, {
+					phase: "ESCALATED",
+					error: reason,
+					completedAt: new Date().toISOString()
+				});
+				writeStoryMetricsBestEffort(storyKey, "escalated", 0);
+				emitEscalation({
+					storyKey,
+					lastVerdict: reason,
+					reviewCycles: 0,
+					issues: [truncatedOutput]
+				});
+				persistState();
+				return;
+			}
+		}
 		let reviewCycles = 0;
 		let keepReviewing = true;
 		let timeoutRetried = false;
@@ -7304,9 +7930,18 @@ function createImplementationOrchestrator(deps) {
 	}
 	/**
 	* Process a conflict group: run stories sequentially within the group.
+	*
+	* After each story completes (any outcome), a GC hint is issued and a short
+	* pause inserted so the Node.js process can reclaim memory before the next
+	* story dispatch (Story 23-8, AC2).
 	*/
 	async function processConflictGroup(group) {
-		for (const storyKey of group) await processStory(storyKey);
+		for (const storyKey of group) {
+			await processStory(storyKey);
+			globalThis.gc?.();
+			const gcPauseMs = config.gcPauseMs ?? 2e3;
+			await sleep(gcPauseMs);
+		}
 	}
 	/**
 	* Promise pool: run up to maxConcurrency groups at a time.
@@ -8091,7 +8726,7 @@ const CritiqueOutputSchema = z.object({
 
 //#endregion
 //#region src/modules/phase-orchestrator/critique-loop.ts
-const logger$6 = createLogger("critique-loop");
+const logger$5 = createLogger("critique-loop");
 /**
 * Maps a phase name to the critique prompt template name.
 * Falls back to `critique-${phase}` for unknown phases.
@@ -8145,7 +8780,7 @@ async function runCritiqueLoop(artifact, phaseId, runId, phase, deps, options =
 			critiquePrompt = critiqueTemplate.replace("{{artifact_content}}", currentArtifact).replace("{{project_context}}", projectContext);
 		} catch (err) {
 			const message = err instanceof Error ? err.message : String(err);
-			logger$6.warn({
+			logger$5.warn({
 				phaseId,
 				promptName: critiquePromptName,
 				err: message
@@ -8173,7 +8808,7 @@ async function runCritiqueLoop(artifact, phaseId, runId, phase, deps, options =
 			critiqueTokens.output += result.tokenEstimate.output;
 			if (result.status !== "completed" || result.parsed === null) {
 				const errMsg = result.parseError ?? `Critique dispatch ended with status '${result.status}'`;
-				logger$6.warn({
+				logger$5.warn({
 					phaseId,
 					iteration: i + 1,
 					err: errMsg
@@ -8192,7 +8827,7 @@ async function runCritiqueLoop(artifact, phaseId, runId, phase, deps, options =
 			lastCritiqueOutput = critiqueOutput;
 		} catch (err) {
 			const message = err instanceof Error ? err.message : String(err);
-			logger$6.warn({
+			logger$5.warn({
 				phaseId,
 				iteration: i + 1,
 				err: message
@@ -8232,14 +8867,14 @@ async function runCritiqueLoop(artifact, phaseId, runId, phase, deps, options =
 			});
 		} catch (err) {
 			const message = err instanceof Error ? err.message : String(err);
-			logger$6.warn({
+			logger$5.warn({
 				phaseId,
 				iteration: i + 1,
 				err: message
 			}, "Critique loop: failed to store critique decision — continuing");
 		}
 		if (critiqueOutput.verdict === "pass") {
-			logger$6.info({
+			logger$5.info({
 				phaseId,
 				iteration: i + 1
 			}, "Critique loop: artifact passed critique — loop complete");
@@ -8252,7 +8887,7 @@ async function runCritiqueLoop(artifact, phaseId, runId, phase, deps, options =
 				totalMs: Date.now() - startMs
 			};
 		}
-		logger$6.info({
+		logger$5.info({
 			phaseId,
 			iteration: i + 1,
 			issueCount: critiqueOutput.issue_count
@@ -8265,7 +8900,7 @@ async function runCritiqueLoop(artifact, phaseId, runId, phase, deps, options =
 				refinePrompt = refineTemplate.replace("{{original_artifact}}", currentArtifact).replace("{{critique_issues}}", issuesText).replace("{{phase_context}}", phaseContext);
 			} catch (err) {
 				const message = err instanceof Error ? err.message : String(err);
-				logger$6.warn({
+				logger$5.warn({
 					phaseId,
 					iteration: i + 1,
 					err: message
@@ -8286,7 +8921,7 @@ async function runCritiqueLoop(artifact, phaseId, runId, phase, deps, options =
 					const originalLength = currentArtifact.length;
 					const refinedLength = refineResult.output.length;
 					const delta = refinedLength - originalLength;
-					logger$6.info({
+					logger$5.info({
 						phaseId,
 						iteration: i + 1,
 						originalLength,
@@ -8295,7 +8930,7 @@ async function runCritiqueLoop(artifact, phaseId, runId, phase, deps, options =
 					}, "Critique loop: refinement complete");
 					currentArtifact = refineResult.output;
 				} else {
-					logger$6.warn({
+					logger$5.warn({
 						phaseId,
 						iteration: i + 1,
 						status: refineResult.status
@@ -8304,7 +8939,7 @@ async function runCritiqueLoop(artifact, phaseId, runId, phase, deps, options =
 				}
 			} catch (err) {
 				const message = err instanceof Error ? err.message : String(err);
-				logger$6.warn({
+				logger$5.warn({
 					phaseId,
 					iteration: i + 1,
 					err: message
@@ -8315,12 +8950,12 @@ async function runCritiqueLoop(artifact, phaseId, runId, phase, deps, options =
 	}
 	const remainingIssues = lastCritiqueOutput?.issues ?? [];
 	if (remainingIssues.length > 0) {
-		logger$6.warn({
+		logger$5.warn({
 			phaseId,
 			maxIterations,
 			issueCount: remainingIssues.length
 		}, "Critique loop: max iterations reached with unresolved issues");
-		for (const issue of remainingIssues) logger$6.warn({
+		for (const issue of remainingIssues) logger$5.warn({
 			phaseId,
 			severity: issue.severity,
 			category: issue.category,
@@ -8339,7 +8974,7 @@ async function runCritiqueLoop(artifact, phaseId, runId, phase, deps, options =
 
 //#endregion
 //#region src/modules/phase-orchestrator/elicitation-selector.ts
-const logger$5 = createLogger("elicitation-selector");
+const logger$4 = createLogger("elicitation-selector");
 /**
 * Affinity scores (0.0–1.0) for each category per content type.
 *
@@ -8461,10 +9096,10 @@ function loadElicitationMethods() {
 	try {
 		const content = readFileSync(csvPath, "utf-8");
 		const methods = parseMethodsCsv(content);
-		logger$5.debug({ count: methods.length }, "Loaded elicitation methods");
+		logger$4.debug({ count: methods.length }, "Loaded elicitation methods");
 		return methods;
 	} catch (err) {
-		logger$5.warn({
+		logger$4.warn({
 			csvPath,
 			err
 		}, "Failed to load elicitation methods CSV");
@@ -8784,7 +9419,7 @@ const ElicitationOutputSchema = z.object({
 
 //#endregion
 //#region src/modules/phase-orchestrator/step-runner.ts
-const logger$4 = createLogger("step-runner");
+const logger$3 = createLogger("step-runner");
 /**
 * Format an array of decision records into a markdown section for injection.
 *
@@ -8891,7 +9526,7 @@ async function runSteps(steps, deps, runId, phase, params) {
 		if (estimatedTokens > budgetTokens) {
 			const decisionRefs = step.context.filter((ref) => ref.source.startsWith("decision:"));
 			if (decisionRefs.length > 0) {
-				logger$4.warn({
+				logger$3.warn({
 					step: step.name,
 					estimatedTokens,
 					budgetTokens
@@ -8918,7 +9553,7 @@ async function runSteps(steps, deps, runId, phase, params) {
 				}
 				prompt = summarizedPrompt;
 				estimatedTokens = Math.ceil(prompt.length / 4);
-				if (estimatedTokens <= budgetTokens) logger$4.info({
+				if (estimatedTokens <= budgetTokens) logger$3.info({
 					step: step.name,
 					estimatedTokens,
 					budgetTokens
@@ -9099,7 +9734,7 @@ async function runSteps(steps, deps, runId, phase, params) {
 			const critiqueResult = await runCritiqueLoop(artifactContent, phase, runId, phase, deps);
 			totalInput += critiqueResult.critiqueTokens.input + critiqueResult.refinementTokens.input;
 			totalOutput += critiqueResult.critiqueTokens.output + critiqueResult.refinementTokens.output;
-			logger$4.info({
+			logger$3.info({
 				step: step.name,
 				verdict: critiqueResult.verdict,
 				iterations: critiqueResult.iterations,
@@ -9107,7 +9742,7 @@ async function runSteps(steps, deps, runId, phase, params) {
 			}, "Step critique loop complete");
 		} catch (critiqueErr) {
 			const critiqueMsg = critiqueErr instanceof Error ? critiqueErr.message : String(critiqueErr);
-			logger$4.warn({
+			logger$3.warn({
 				step: step.name,
 				err: critiqueMsg
 			}, "Step critique loop threw an error — continuing without critique");
@@ -9117,7 +9752,7 @@ async function runSteps(steps, deps, runId, phase, params) {
 			const contentType = deriveContentType(phase, step.name);
 			const selectedMethods = selectMethods({ content_type: contentType }, usedElicitationMethods);
 			if (selectedMethods.length > 0) {
-				logger$4.info({
+				logger$3.info({
 					step: step.name,
 					methods: selectedMethods.map((m) => m.name),
 					contentType
@@ -9156,13 +9791,13 @@ async function runSteps(steps, deps, runId, phase, params) {
 								key: `${phase}-round-${roundIndex}-insights`,
 								value: elicitParsed.insights
 							});
-							logger$4.info({
+							logger$3.info({
 								step: step.name,
 								method: method.name,
 								roundIndex
 							}, "Elicitation insights stored in decision store");
 						}
-					} else logger$4.warn({
+					} else logger$3.warn({
 						step: step.name,
 						method: method.name,
 						status: elicitResult.status
@@ -9178,7 +9813,7 @@ async function runSteps(steps, deps, runId, phase, params) {
 			}
 		} catch (elicitErr) {
 			const elicitMsg = elicitErr instanceof Error ? elicitErr.message : String(elicitErr);
-			logger$4.warn({
+			logger$3.warn({
 				step: step.name,
 				err: elicitMsg
 			}, "Step elicitation threw an error — continuing without elicitation");
@@ -9546,7 +10181,7 @@ async function runAnalysisPhase(deps, params) {
 
 //#endregion
 //#region src/modules/phase-orchestrator/phases/planning.ts
-const logger$3 = createLogger("planning-phase");
+const logger$2 = createLogger("planning-phase");
 /** Maximum total prompt length in tokens (3,500 tokens × 4 chars/token = 14,000 chars) */
 const MAX_PROMPT_TOKENS = 3500;
 const MAX_PROMPT_CHARS = MAX_PROMPT_TOKENS * 4;
@@ -9773,7 +10408,7 @@ async function runPlanningMultiStep(deps, params) {
 			const techConstraintDecisions = allAnalysisDecisions.filter((d) => d.category === "technology-constraints");
 			const violation = detectTechStackViolation(techStack, techConstraintDecisions);
 			if (violation) {
-				logger$3.warn({ violation }, "Tech stack constraint violation detected — retrying step 3 with correction");
+				logger$2.warn({ violation }, "Tech stack constraint violation detected — retrying step 3 with correction");
 				const correctionPrefix = `CRITICAL CORRECTION: Your previous output was rejected because it violates the stated technology constraints.\n\nViolation: ${violation}\n\nYou MUST NOT use TypeScript, JavaScript, or Node.js for ANY backend service. Choose from Go, Kotlin/JVM, or Rust as stated in the technology constraints.\n\nRe-generate your output with a compliant tech stack. Everything else (NFRs, domain model, out-of-scope) can remain the same.\n\n---\n\n`;
 				const step3Template = await deps.pack.getPrompt("planning-step-3-nfrs");
 				const stepOutputs = new Map();
@@ -9800,10 +10435,10 @@ async function runPlanningMultiStep(deps, params) {
 					const retryTechStack = retryParsed.tech_stack;
 					const retryViolation = retryTechStack ? detectTechStackViolation(retryTechStack, techConstraintDecisions) : null;
 					if (!retryViolation) {
-						logger$3.info("Retry produced compliant tech stack — using corrected output");
+						logger$2.info("Retry produced compliant tech stack — using corrected output");
 						nfrsOutput = retryParsed;
-					} else logger$3.warn({ retryViolation }, "Retry still violates constraints — using original output");
-				} else logger$3.warn("Retry dispatch failed — using original output");
+					} else logger$2.warn({ retryViolation }, "Retry still violates constraints — using original output");
+				} else logger$2.warn("Retry dispatch failed — using original output");
 			}
 		}
 		const frs = frsOutput.functional_requirements;
@@ -10090,7 +10725,7 @@ const ReadinessOutputSchema = z.object({
 
 //#endregion
 //#region src/modules/phase-orchestrator/phases/solutioning.ts
-const logger$2 = createLogger("solutioning");
+const logger$1 = createLogger("solutioning");
 /** Base token budget for architecture generation (covers template + requirements) */
 const BASE_ARCH_PROMPT_TOKENS = 3e3;
 /** Base token budget for story generation (covers template + requirements + architecture) */
@@ -10499,7 +11134,7 @@ async function runReadinessCheck(deps, runId) {
 		input: tokenEstimate.input,
 		output: tokenEstimate.output
 	};
-	logger$2.info({
+	logger$1.info({
 		runId,
 		durationMs: dispatchResult.durationMs,
 		tokens: tokenEstimate
@@ -10760,7 +11395,7 @@ async function runSolutioningPhase(deps, params) {
 		let archResult;
 		if (existingArchArtifact) {
 			const existingDecisions = getDecisionsByPhaseForRun(deps.db, params.runId, "solutioning").filter((d) => d.category === "architecture");
-			logger$2.info({
+			logger$1.info({
 				runId: params.runId,
 				artifactId: existingArchArtifact.id,
 				decisionCount: existingDecisions.length
@@ -10791,7 +11426,7 @@ async function runSolutioningPhase(deps, params) {
 				output: totalOutput
 			}
 		};
-		logger$2.info({
+		logger$1.info({
 			runId: params.runId,
 			decisionCount: archResult.decisions.length,
 			mode: hasSteps ? "multi-step" : "single-dispatch"
@@ -10813,7 +11448,7 @@ async function runSolutioningPhase(deps, params) {
 		totalInput += readinessResult.tokenUsage.input;
 		totalOutput += readinessResult.tokenUsage.output;
 		if (readinessResult.verdict === "error") {
-			logger$2.error({
+			logger$1.error({
 				runId: params.runId,
 				error: readinessResult.error
 			}, "Readiness check agent failed");
@@ -10829,7 +11464,7 @@ async function runSolutioningPhase(deps, params) {
 				}
 			};
 		}
-		logger$2.info({
+		logger$1.info({
 			runId: params.runId,
 			verdict: readinessResult.verdict,
 			coverageScore: readinessResult.coverageScore,
@@ -10845,7 +11480,7 @@ async function runSolutioningPhase(deps, params) {
 				key: `finding-${i + 1}`,
 				value: JSON.stringify(finding)
 			});
-			logger$2.error({
+			logger$1.error({
 				runId: params.runId,
 				verdict: "NOT_READY",
 				coverageScore: readinessResult.coverageScore,
@@ -10911,7 +11546,7 @@ async function runSolutioningPhase(deps, params) {
 					"",
 					"Please generate additional or revised stories to specifically address each blocker above."
 				].join("\n");
-				logger$2.info({
+				logger$1.info({
 					runId: params.runId,
 					blockerCount: blockers.length
 				}, "Readiness NEEDS_WORK with blockers — retrying story generation with gap analysis");
@@ -10950,7 +11585,7 @@ async function runSolutioningPhase(deps, params) {
 				};
 				if (retryReadiness.verdict === "NOT_READY" || retryReadiness.verdict === "NEEDS_WORK") {
 					const retryBlockers = retryReadiness.findings.filter((f) => f.severity === "blocker");
-					logger$2.error({
+					logger$1.error({
 						runId: params.runId,
 						verdict: retryReadiness.verdict,
 						retryBlockers: retryBlockers.length
@@ -10974,7 +11609,7 @@ async function runSolutioningPhase(deps, params) {
 				}
 				const retryStories = retryResult.epics.reduce((sum, epic) => sum + epic.stories.length, 0);
 				const minorFindings$1 = retryReadiness.findings.filter((f) => f.severity === "minor");
-				if (minorFindings$1.length > 0) logger$2.warn({
+				if (minorFindings$1.length > 0) logger$1.warn({
 					runId: params.runId,
 					minorFindings: minorFindings$1
 				}, "Readiness READY with minor findings after retry");
@@ -11003,7 +11638,7 @@ async function runSolutioningPhase(deps, params) {
 				};
 			}
 			const majorFindings = readinessResult.findings.filter((f) => f.severity === "major");
-			logger$2.warn({
+			logger$1.warn({
 				runId: params.runId,
 				majorCount: majorFindings.length,
 				findings: readinessResult.findings
@@ -11019,7 +11654,7 @@ async function runSolutioningPhase(deps, params) {
 		const minorFindings = readinessResult.findings.filter((f) => f.severity === "minor");
 		if (minorFindings.length > 0) {
 			const verdictLabel = readinessResult.verdict === "READY" ? "READY" : "NEEDS_WORK (no blockers)";
-			logger$2.warn({
+			logger$1.warn({
 				runId: params.runId,
 				verdict: readinessResult.verdict,
 				minorFindings
@@ -11316,381 +11951,119 @@ function buildResearchSteps() {
 			{
 				field: "technical_findings",
 				category: "research",
-				key: "technical_findings"
-			}
-		],
-		elicitate: true
-	}, {
-		name: "research-step-2-synthesis",
-		taskType: "research-synthesis",
-		outputSchema: ResearchSynthesisOutputSchema,
-		context: [{
-			placeholder: "concept",
-			source: "param:concept"
-		}, {
-			placeholder: "raw_findings",
-			source: "step:research-step-1-discovery"
-		}],
-		persist: [
-			{
-				field: "market_context",
-				category: "research",
-				key: "market_context"
-			},
-			{
-				field: "competitive_landscape",
-				category: "research",
-				key: "competitive_landscape"
-			},
-			{
-				field: "technical_feasibility",
-				category: "research",
-				key: "technical_feasibility"
-			},
-			{
-				field: "risk_flags",
-				category: "research",
-				key: "risk_flags"
-			},
-			{
-				field: "opportunity_signals",
-				category: "research",
-				key: "opportunity_signals"
-			}
-		],
-		registerArtifact: {
-			type: "research-findings",
-			path: "decision-store://research/research-findings",
-			summarize: (parsed) => {
-				const risks = Array.isArray(parsed.risk_flags) ? parsed.risk_flags : void 0;
-				const opportunities = Array.isArray(parsed.opportunity_signals) ? parsed.opportunity_signals : void 0;
-				const count = (risks?.length ?? 0) + (opportunities?.length ?? 0);
-				return count > 0 ? `${count} research insights captured (risks + opportunities)` : "Research synthesis complete";
-			}
-		},
-		critique: true
-	}];
-}
-/**
-* Execute the research phase of the BMAD pipeline.
-*
-* Runs 2 sequential steps covering discovery and synthesis.
-* Each step builds on prior step decisions via the decision store.
-*
-* On success, a 'research-findings' artifact is registered and research decisions
-* are available to subsequent phases via `decision:research.*`.
-*
-* @param deps - Shared phase dependencies (db, pack, contextCompiler, dispatcher)
-* @param params - Phase parameters (runId, concept)
-* @returns ResearchResult with success/failure status and token usage
-*/
-async function runResearchPhase(deps, params) {
-	const { runId } = params;
-	const zeroTokenUsage = {
-		input: 0,
-		output: 0
-	};
-	try {
-		const steps = buildResearchSteps();
-		const result = await runSteps(steps, deps, runId, "research", { concept: params.concept });
-		if (!result.success) return {
-			result: "failed",
-			error: result.error ?? "research_multi_step_failed",
-			details: result.error ?? "Research multi-step execution failed",
-			tokenUsage: result.tokenUsage
-		};
-		const lastStep = result.steps[result.steps.length - 1];
-		const artifactId = lastStep?.artifactId;
-		if (!artifactId) {
-			const artifact = registerArtifact(deps.db, {
-				pipeline_run_id: runId,
-				phase: "research",
-				type: "research-findings",
-				path: "decision-store://research/research-findings",
-				summary: "Research phase completed"
-			});
-			return {
-				result: "success",
-				artifact_id: artifact.id,
-				tokenUsage: result.tokenUsage
-			};
-		}
-		return {
-			result: "success",
-			artifact_id: artifactId,
-			tokenUsage: result.tokenUsage
-		};
-	} catch (err) {
-		const message = err instanceof Error ? err.message : String(err);
-		return {
-			result: "failed",
-			error: message,
-			tokenUsage: zeroTokenUsage
-		};
-	}
-}
-
-//#endregion
-//#region src/cli/commands/health.ts
-const logger$1 = createLogger("health-cmd");
-/** Default stall threshold in seconds — also used by supervisor default */
-const DEFAULT_STALL_THRESHOLD_SECONDS = 600;
-/**
-* Determine whether a ps output line represents the substrate pipeline orchestrator.
-* Handles invocation via:
-*   - `substrate run` (globally installed)
-*   - `substrate-ai run`
-*   - `node dist/cli/index.js run` (npm run substrate:dev)
-*   - `npx substrate run`
-*   - any node process whose command contains `run` with `--events` or `--stories`
-*
-* When `projectRoot` is provided, additionally checks that the command line
-* contains that path (via `--project-root` flag or as part of the binary/CWD path).
-* This ensures multi-project environments match the correct orchestrator.
-*/
-function isOrchestratorProcessLine(line, projectRoot) {
-	if (line.includes("grep")) return false;
-	let isOrchestrator = false;
-	if (line.includes("substrate run")) isOrchestrator = true;
-	else if (line.includes("substrate-ai run")) isOrchestrator = true;
-	else if (line.includes("index.js run")) isOrchestrator = true;
-	else if (line.includes("node") && /\srun(\s|$)/.test(line) && (line.includes("--events") || line.includes("--stories"))) isOrchestrator = true;
-	if (!isOrchestrator) return false;
-	if (projectRoot !== void 0) return line.includes(projectRoot);
-	return true;
-}
-function inspectProcessTree(opts) {
-	const { projectRoot, execFileSync: execFileSyncOverride } = opts ?? {};
-	const result = {
-		orchestrator_pid: null,
-		child_pids: [],
-		zombies: []
-	};
-	try {
-		let psOutput;
-		if (execFileSyncOverride !== void 0) psOutput = execFileSyncOverride("ps", ["-eo", "pid,ppid,stat,command"], {
-			encoding: "utf-8",
-			timeout: 5e3
-		});
-		else {
-			const { execFileSync } = __require("node:child_process");
-			psOutput = execFileSync("ps", ["-eo", "pid,ppid,stat,command"], {
-				encoding: "utf-8",
-				timeout: 5e3
-			});
-		}
-		const lines = psOutput.split("\n");
-		for (const line of lines) if (isOrchestratorProcessLine(line, projectRoot)) {
-			const match = line.trim().match(/^(\d+)/);
-			if (match) {
-				result.orchestrator_pid = parseInt(match[1], 10);
-				break;
-			}
-		}
-		if (result.orchestrator_pid !== null) for (const line of lines) {
-			const parts = line.trim().split(/\s+/);
-			if (parts.length >= 3) {
-				const pid = parseInt(parts[0], 10);
-				const ppid = parseInt(parts[1], 10);
-				const stat$2 = parts[2];
-				if (ppid === result.orchestrator_pid && pid !== result.orchestrator_pid) {
-					result.child_pids.push(pid);
-					if (stat$2.includes("Z")) result.zombies.push(pid);
-				}
-			}
-		}
-	} catch {}
-	return result;
-}
-/**
-* Collect all descendant PIDs of the given root PIDs by walking the process
-* tree recursively. This ensures that grandchildren of the orchestrator
-* (e.g. node subprocesses spawned by `claude -p`) are also killed during
-* stall recovery, leaving no orphan processes.
-*
-* Returns only the descendants — the root PIDs themselves are NOT included.
-*/
-function getAllDescendantPids(rootPids, execFileSyncOverride) {
-	if (rootPids.length === 0) return [];
-	try {
-		let psOutput;
-		if (execFileSyncOverride !== void 0) psOutput = execFileSyncOverride("ps", ["-eo", "pid,ppid"], {
-			encoding: "utf-8",
-			timeout: 5e3
-		});
-		else {
-			const { execFileSync } = __require("node:child_process");
-			psOutput = execFileSync("ps", ["-eo", "pid,ppid"], {
-				encoding: "utf-8",
-				timeout: 5e3
-			});
-		}
-		const childrenOf = new Map();
-		for (const line of psOutput.split("\n")) {
-			const parts = line.trim().split(/\s+/);
-			if (parts.length >= 2) {
-				const pid = parseInt(parts[0], 10);
-				const ppid = parseInt(parts[1], 10);
-				if (!isNaN(pid) && !isNaN(ppid) && pid > 0) {
-					if (!childrenOf.has(ppid)) childrenOf.set(ppid, []);
-					childrenOf.get(ppid).push(pid);
-				}
+				key: "technical_findings"
 			}
-		}
-		const descendants = [];
-		const seen = new Set(rootPids);
-		const queue = [...rootPids];
-		while (queue.length > 0) {
-			const current = queue.shift();
-			const children = childrenOf.get(current) ?? [];
-			for (const child of children) if (!seen.has(child)) {
-				seen.add(child);
-				descendants.push(child);
-				queue.push(child);
+		],
+		elicitate: true
+	}, {
+		name: "research-step-2-synthesis",
+		taskType: "research-synthesis",
+		outputSchema: ResearchSynthesisOutputSchema,
+		context: [{
+			placeholder: "concept",
+			source: "param:concept"
+		}, {
+			placeholder: "raw_findings",
+			source: "step:research-step-1-discovery"
+		}],
+		persist: [
+			{
+				field: "market_context",
+				category: "research",
+				key: "market_context"
+			},
+			{
+				field: "competitive_landscape",
+				category: "research",
+				key: "competitive_landscape"
+			},
+			{
+				field: "technical_feasibility",
+				category: "research",
+				key: "technical_feasibility"
+			},
+			{
+				field: "risk_flags",
+				category: "research",
+				key: "risk_flags"
+			},
+			{
+				field: "opportunity_signals",
+				category: "research",
+				key: "opportunity_signals"
 			}
-		}
-		return descendants;
-	} catch {
-		return [];
-	}
+		],
+		registerArtifact: {
+			type: "research-findings",
+			path: "decision-store://research/research-findings",
+			summarize: (parsed) => {
+				const risks = Array.isArray(parsed.risk_flags) ? parsed.risk_flags : void 0;
+				const opportunities = Array.isArray(parsed.opportunity_signals) ? parsed.opportunity_signals : void 0;
+				const count = (risks?.length ?? 0) + (opportunities?.length ?? 0);
+				return count > 0 ? `${count} research insights captured (risks + opportunities)` : "Research synthesis complete";
+			}
+		},
+		critique: true
+	}];
 }
 /**
-* Fetch pipeline health data as a structured object without any stdout side-effects.
-* Used by runSupervisorAction to poll health without formatting overhead.
+* Execute the research phase of the BMAD pipeline.
 *
-* Returns a NO_PIPELINE_RUNNING health object for all graceful "no data" cases
-* (missing DB, missing run, terminal run status). Throws only on unexpected errors.
+* Runs 2 sequential steps covering discovery and synthesis.
+* Each step builds on prior step decisions via the decision store.
+*
+* On success, a 'research-findings' artifact is registered and research decisions
+* are available to subsequent phases via `decision:research.*`.
+*
+* @param deps - Shared phase dependencies (db, pack, contextCompiler, dispatcher)
+* @param params - Phase parameters (runId, concept)
+* @returns ResearchResult with success/failure status and token usage
 */
-async function getAutoHealthData(options) {
-	const { runId, projectRoot } = options;
-	const dbRoot = await resolveMainRepoRoot(projectRoot);
-	const dbPath = join(dbRoot, ".substrate", "substrate.db");
-	const NO_PIPELINE = {
-		verdict: "NO_PIPELINE_RUNNING",
-		run_id: null,
-		status: null,
-		current_phase: null,
-		staleness_seconds: 0,
-		last_activity: "",
-		process: {
-			orchestrator_pid: null,
-			child_pids: [],
-			zombies: []
-		},
-		stories: {
-			active: 0,
-			completed: 0,
-			escalated: 0,
-			details: {}
-		}
+async function runResearchPhase(deps, params) {
+	const { runId } = params;
+	const zeroTokenUsage = {
+		input: 0,
+		output: 0
 	};
-	if (!existsSync(dbPath)) return NO_PIPELINE;
-	const dbWrapper = new DatabaseWrapper(dbPath);
 	try {
-		dbWrapper.open();
-		const db = dbWrapper.db;
-		let run;
-		if (runId !== void 0) run = getPipelineRunById(db, runId);
-		else run = getLatestRun(db);
-		if (run === void 0) return NO_PIPELINE;
-		const updatedAt = parseDbTimestampAsUtc(run.updated_at);
-		const stalenessSeconds = Math.round((Date.now() - updatedAt.getTime()) / 1e3);
-		let storyDetails = {};
-		let active = 0;
-		let completed = 0;
-		let escalated = 0;
-		try {
-			if (run.token_usage_json) {
-				const state = JSON.parse(run.token_usage_json);
-				if (state.stories) for (const [key, s] of Object.entries(state.stories)) {
-					storyDetails[key] = {
-						phase: s.phase,
-						review_cycles: s.reviewCycles
-					};
-					if (s.phase === "COMPLETE") completed++;
-					else if (s.phase === "ESCALATED") escalated++;
-					else if (s.phase !== "PENDING") active++;
-				}
-			}
-		} catch {}
-		const processInfo = inspectProcessTree({ projectRoot });
-		let verdict = "NO_PIPELINE_RUNNING";
-		if (run.status === "running") if (processInfo.orchestrator_pid === null && active === 0 && completed > 0) verdict = "NO_PIPELINE_RUNNING";
-		else if (processInfo.zombies.length > 0) verdict = "STALLED";
-		else if (processInfo.orchestrator_pid !== null && processInfo.child_pids.length > 0 && stalenessSeconds > DEFAULT_STALL_THRESHOLD_SECONDS) verdict = "HEALTHY";
-		else if (stalenessSeconds > DEFAULT_STALL_THRESHOLD_SECONDS) verdict = "STALLED";
-		else if (processInfo.orchestrator_pid !== null && processInfo.child_pids.length === 0 && active > 0) verdict = "STALLED";
-		else verdict = "HEALTHY";
-		else if (run.status === "completed" || run.status === "failed" || run.status === "stopped") verdict = "NO_PIPELINE_RUNNING";
-		return {
-			verdict,
-			run_id: run.id,
-			status: run.status,
-			current_phase: run.current_phase,
-			staleness_seconds: stalenessSeconds,
-			last_activity: run.updated_at,
-			process: processInfo,
-			stories: {
-				active,
-				completed,
-				escalated,
-				details: storyDetails
-			}
+		const steps = buildResearchSteps();
+		const result = await runSteps(steps, deps, runId, "research", { concept: params.concept });
+		if (!result.success) return {
+			result: "failed",
+			error: result.error ?? "research_multi_step_failed",
+			details: result.error ?? "Research multi-step execution failed",
+			tokenUsage: result.tokenUsage
 		};
-	} finally {
-		try {
-			dbWrapper.close();
-		} catch {}
-	}
-}
-async function runHealthAction(options) {
-	const { outputFormat } = options;
-	try {
-		const health = await getAutoHealthData(options);
-		if (outputFormat === "json") process.stdout.write(formatOutput(health, "json", true) + "\n");
-		else {
-			const verdictLabel = health.verdict === "HEALTHY" ? "HEALTHY" : health.verdict === "STALLED" ? "STALLED" : "NO PIPELINE RUNNING";
-			process.stdout.write(`\nPipeline Health: ${verdictLabel}\n`);
-			if (health.run_id !== null) {
-				process.stdout.write(`  Run:          ${health.run_id}\n`);
-				process.stdout.write(`  Status:       ${health.status}\n`);
-				process.stdout.write(`  Phase:        ${health.current_phase ?? "N/A"}\n`);
-				process.stdout.write(`  Last Active:  ${health.last_activity} (${health.staleness_seconds}s ago)\n`);
-				const processInfo = health.process;
-				if (processInfo.orchestrator_pid !== null) {
-					process.stdout.write(`  Orchestrator: PID ${processInfo.orchestrator_pid}\n`);
-					process.stdout.write(`  Children:     ${processInfo.child_pids.length} active`);
-					if (processInfo.zombies.length > 0) process.stdout.write(` (${processInfo.zombies.length} ZOMBIE)`);
-					process.stdout.write("\n");
-				} else process.stdout.write("  Orchestrator: not running\n");
-				const storyDetails = health.stories.details;
-				if (Object.keys(storyDetails).length > 0) {
-					process.stdout.write("\n  Stories:\n");
-					for (const [key, s] of Object.entries(storyDetails)) process.stdout.write(`    ${key}: ${s.phase} (${s.review_cycles} review cycles)\n`);
-					process.stdout.write(`\n  Summary: ${health.stories.active} active, ${health.stories.completed} completed, ${health.stories.escalated} escalated\n`);
-				}
-			}
+		const lastStep = result.steps[result.steps.length - 1];
+		const artifactId = lastStep?.artifactId;
+		if (!artifactId) {
+			const artifact = registerArtifact(deps.db, {
+				pipeline_run_id: runId,
+				phase: "research",
+				type: "research-findings",
+				path: "decision-store://research/research-findings",
+				summary: "Research phase completed"
+			});
+			return {
+				result: "success",
+				artifact_id: artifact.id,
+				tokenUsage: result.tokenUsage
+			};
 		}
-		return 0;
+		return {
+			result: "success",
+			artifact_id: artifactId,
+			tokenUsage: result.tokenUsage
+		};
 	} catch (err) {
-		const msg = err instanceof Error ? err.message : String(err);
-		if (outputFormat === "json") process.stdout.write(formatOutput(null, "json", false, msg) + "\n");
-		else process.stderr.write(`Error: ${msg}\n`);
-		logger$1.error({ err }, "health action failed");
-		return 1;
+		const message = err instanceof Error ? err.message : String(err);
+		return {
+			result: "failed",
+			error: message,
+			tokenUsage: zeroTokenUsage
+		};
 	}
 }
-function registerHealthCommand(program, _version = "0.0.0", projectRoot = process.cwd()) {
-	program.command("health").description("Check pipeline health: process status, stall detection, and verdict").option("--run-id <id>", "Pipeline run ID to query (defaults to latest)").option("--project-root <path>", "Project root directory", projectRoot).option("--output-format <format>", "Output format: human (default) or json", "human").action(async (opts) => {
-		const outputFormat = opts.outputFormat === "json" ? "json" : "human";
-		const exitCode = await runHealthAction({
-			outputFormat,
-			runId: opts.runId,
-			projectRoot: opts.projectRoot
-		});
-		process.exitCode = exitCode;
-	});
-}
 
 //#endregion
 //#region src/cli/commands/run.ts
@@ -11755,6 +12128,25 @@ async function runRunAction(options) {
 	const dbRoot = await resolveMainRepoRoot(projectRoot);
 	const dbDir = join(dbRoot, ".substrate");
 	const dbPath = join(dbDir, "substrate.db");
+	mkdirSync(dbDir, { recursive: true });
+	const pidFilePath = join(dbDir, "orchestrator.pid");
+	try {
+		writeFileSync(pidFilePath, String(process.pid), "utf-8");
+		const cleanupPidFile = () => {
+			try {
+				unlinkSync(pidFilePath);
+			} catch {}
+		};
+		process.on("exit", cleanupPidFile);
+		process.once("SIGTERM", () => {
+			cleanupPidFile();
+			process.exit(0);
+		});
+		process.once("SIGINT", () => {
+			cleanupPidFile();
+			process.exit(130);
+		});
+	} catch {}
 	if (startPhase !== void 0) return runFullPipeline({
 		packName,
 		packPath,
@@ -12110,7 +12502,32 @@ async function runRunAction(options) {
 					story_key: payload.storyKey,
 					phase: payload.phase,
 					elapsed_ms: payload.elapsedMs,
-					child_pid: payload.childPid
+					child_pids: payload.childPids,
+					child_active: payload.childActive
+				});
+			});
+			eventBus.on("orchestrator:zero-diff-escalation", (payload) => {
+				ndjsonEmitter.emit({
+					type: "story:zero-diff-escalation",
+					ts: new Date().toISOString(),
+					storyKey: payload.storyKey,
+					reason: payload.reason
+				});
+			});
+			eventBus.on("story:build-verification-passed", (payload) => {
+				ndjsonEmitter.emit({
+					type: "story:build-verification-passed",
+					ts: new Date().toISOString(),
+					storyKey: payload.storyKey
+				});
+			});
+			eventBus.on("story:build-verification-failed", (payload) => {
+				ndjsonEmitter.emit({
+					type: "story:build-verification-failed",
+					ts: new Date().toISOString(),
+					storyKey: payload.storyKey,
+					exitCode: payload.exitCode,
+					output: payload.output
 				});
 			});
 		}
@@ -12567,4 +12984,4 @@ function registerRunCommand(program, _version = "0.0.0", projectRoot = process.c
 
 //#endregion
 export { DatabaseWrapper, SUBSTRATE_OWNED_SETTINGS_KEYS, VALID_PHASES, buildPipelineStatusOutput, createContextCompiler, createDispatcher, createImplementationOrchestrator, createPackLoader, createPhaseOrchestrator, createStopAfterGate, findPackageRoot, formatOutput, formatPhaseCompletionSummary, formatPipelineStatusHuman, formatPipelineSummary, formatTokenTelemetry, getAllDescendantPids, getAutoHealthData, getSubstrateDefaultSettings, registerHealthCommand, registerRunCommand, resolveBmadMethodSrcPath, resolveBmadMethodVersion, resolveMainRepoRoot, runAnalysisPhase, runMigrations, runPlanningPhase, runRunAction, runSolutioningPhase, validateStopAfterFromConflict };
-//# sourceMappingURL=run-CT8B9gG9.js.map
+//# sourceMappingURL=run-CEtHPG4I.js.map