substrate-ai 0.6.8 → 0.7.0

package/dist/health-Dnx-FGva.js

@@ -0,0 +1,3247 @@
+import { createLogger } from "./logger-D2fS2ccL.js";
+import { getLatestRun, getPipelineRunById } from "./decisions-DhAA2HG2.js";
+import { createRequire } from "module";
+import { dirname, join } from "path";
+import { existsSync } from "fs";
+import { createRequire as createRequire$1 } from "node:module";
+import { execFile, spawn, spawnSync } from "node:child_process";
+import { dirname as dirname$1, join as join$1, resolve as resolve$1 } from "node:path";
+import { existsSync as existsSync$1, readFileSync as readFileSync$1 } from "node:fs";
+import { access, mkdir, readFile, writeFile } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function() {
+	return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+//#endregion
+//#region src/utils/git-root.ts
+/**
+* Resolve the main git repository root, even from a linked worktree.
+*
+* In the main worktree, `--git-common-dir` returns `.git` (relative).
+* In a linked worktree, it returns the absolute path to the main `.git` dir.
+* Either way, `dirname()` of the resolved absolute path yields the repo root.
+*
+* Falls back to `cwd` if not in a git repo or git is unavailable.
+*/
+async function resolveMainRepoRoot(cwd = process.cwd()) {
+	return new Promise((res) => {
+		let stdout = "";
+		const proc = spawn("git", ["rev-parse", "--git-common-dir"], {
+			cwd,
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			]
+		});
+		if (proc.stdout !== null) proc.stdout.on("data", (chunk) => {
+			stdout += chunk.toString("utf-8");
+		});
+		proc.on("error", () => {
+			res(cwd);
+		});
+		proc.on("close", (code) => {
+			if (code !== 0) {
+				res(cwd);
+				return;
+			}
+			const commonDir = stdout.trim();
+			if (!commonDir) {
+				res(cwd);
+				return;
+			}
+			const absCommonDir = resolve$1(cwd, commonDir);
+			res(dirname$1(absCommonDir));
+		});
+	});
+}
+
+//#endregion
+//#region src/persistence/dolt-adapter.ts
+var DoltDatabaseAdapter = class {
+	_client;
+	/**
+	* Create a DoltDatabaseAdapter wrapping the supplied DoltClient.
+	* The caller should construct the client with the correct `repoPath`
+	* before passing it here; `connect()` is called lazily by DoltClient.
+	*/
+	constructor(client) {
+		this._client = client;
+	}
+	/**
+	* Execute a SQL query and return all result rows as typed objects.
+	*
+	* Delegates to `DoltClient.query<T>()` which supports both mysql2
+	* pool mode and CLI fallback.
+	*/
+	async query(sql, params) {
+		return this._client.query(sql, params);
+	}
+	/**
+	* Execute a SQL statement with no return value (DDL or DML).
+	*
+	* Delegates to `DoltClient.query()` and discards the result rows.
+	*/
+	async exec(sql) {
+		await this._client.query(sql, void 0);
+	}
+	/**
+	* Execute a function within an explicit SQL transaction.
+	*
+	* Issues `BEGIN` before the function and `COMMIT` on success or
+	* `ROLLBACK` on error.  Works in both mysql2 pool mode (where
+	* transactions are natively supported) and CLI mode (where Dolt
+	* supports multi-statement sessions via CALL DOLT_CHECKOUT).
+	*/
+	async transaction(fn) {
+		await this._client.query("BEGIN", void 0);
+		try {
+			const result = await fn(this);
+			await this._client.query("COMMIT", void 0);
+			return result;
+		} catch (err) {
+			await this._client.query("ROLLBACK", void 0);
+			throw err;
+		}
+	}
+	/**
+	* Close the underlying DoltClient connection pool.
+	*/
+	async close() {
+		await this._client.close();
+	}
+	/**
+	* Query story keys from the `ready_stories` SQL view.
+	*
+	* Returns story keys whose status is `planned` or `ready` and whose
+	* hard dependencies are all `complete` in the work graph.
+	*
+	* On any SQL error (e.g., view not yet created by story 31-1 schema,
+	* or empty stories table), returns `[]` so the caller falls through to
+	* the legacy discovery chain.
+	*/
+	async queryReadyStories() {
+		try {
+			const rows = await this._client.query("SELECT `key` FROM ready_stories ORDER BY `key` ASC", void 0);
+			return rows.map((r) => r.key);
+		} catch {
+			return [];
+		}
+	}
+};
+
+//#endregion
+//#region src/persistence/memory-adapter.ts
+var InMemoryDatabaseAdapter = class {
+	_tables = new Map();
+	async query(sql, params) {
+		const rows = this._execute(sql.trim(), params);
+		return rows;
+	}
+	async exec(sql) {
+		this._execute(sql.trim(), void 0);
+	}
+	async transaction(fn) {
+		const snapshot = new Map();
+		for (const [name, rows] of this._tables) snapshot.set(name, rows.map((r) => ({ ...r })));
+		try {
+			const result = await fn(this);
+			return result;
+		} catch (err) {
+			this._tables = snapshot;
+			throw err;
+		}
+	}
+	async close() {
+		this._tables.clear();
+	}
+	/**
+	* Work graph not supported in InMemoryDatabaseAdapter.
+	* Returns `[]` to signal the caller to use the legacy discovery path.
+	*/
+	async queryReadyStories() {
+		return [];
+	}
+	_execute(sql, params) {
+		const resolved = this._substituteParams(sql, params);
+		const upper = resolved.trimStart().toUpperCase();
+		if (/^CREATE\s+TABLE/i.test(upper)) return this._createTable(resolved);
+		if (/^DROP\s+TABLE/i.test(upper)) return this._dropTable(resolved);
+		if (/^CREATE\s+(?:OR\s+REPLACE\s+)?VIEW/i.test(upper)) return [];
+		if (/^INSERT\s+(?:IGNORE\s+)?INTO/i.test(upper)) return this._insert(resolved, /^INSERT\s+IGNORE\s+INTO/i.test(upper));
+		if (/^SELECT/i.test(upper)) return this._select(resolved);
+		if (/^UPDATE/i.test(upper)) return this._update(resolved);
+		if (/^DELETE\s+FROM/i.test(upper)) return this._delete(resolved);
+		return [];
+	}
+	/**
+	* Replace each `?` placeholder with an escaped literal value.
+	*/
+	_substituteParams(sql, params) {
+		if (!params || params.length === 0) return sql;
+		let idx = 0;
+		return sql.replace(/\?/g, () => {
+			const val = params[idx++];
+			if (val === null || val === void 0) return "NULL";
+			if (typeof val === "number") return String(val);
+			if (typeof val === "boolean") return val ? "1" : "0";
+			return `'${String(val).replace(/'/g, "''")}'`;
+		});
+	}
+	_createTable(sql) {
+		const m = /CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?(\w+)/i.exec(sql);
+		if (m) {
+			const name = m[1];
+			if (!this._tables.has(name)) this._tables.set(name, []);
+		}
+		return [];
+	}
+	_dropTable(sql) {
+		const m = /DROP\s+TABLE\s+(?:IF\s+EXISTS\s+)?(\w+)/i.exec(sql);
+		if (m) this._tables.delete(m[1]);
+		return [];
+	}
+	_insert(sql, _ignoreConflicts = false) {
+		const m = /INSERT\s+(?:IGNORE\s+)?INTO\s+(\w+)\s*\(([^)]+)\)\s*VALUES\s*\((.+)\)\s*$/is.exec(sql);
+		if (!m) return [];
+		const tableName = m[1];
+		const cols = m[2].split(",").map((c) => c.trim());
+		const valStr = m[3];
+		const vals = this._parseValueList(valStr);
+		const row = {};
+		for (let i = 0; i < cols.length; i++) row[cols[i]] = vals[i] ?? null;
+		if (!this._tables.has(tableName)) this._tables.set(tableName, []);
+		this._tables.get(tableName).push(row);
+		return [];
+	}
+	_select(sql) {
+		if (!/FROM/i.test(sql)) {
+			const m$1 = /SELECT\s+(.+)$/is.exec(sql);
+			if (!m$1) return [];
+			return [this._evalSelectExprs(m$1[1].trim())];
+		}
+		const stripped = sql.replace(/\s+ORDER\s+BY\s+.+?(?=\s+LIMIT\s|\s*$)/is, "").replace(/\s+LIMIT\s+\d+\s*$/is, "");
+		const m = /SELECT\s+(.+?)\s+FROM\s+(\w+)(?:\s+WHERE\s+(.+))?$/is.exec(stripped);
+		if (!m) return [];
+		const colsStr = m[1].trim();
+		const tableName = m[2];
+		const whereStr = m[3];
+		const table = this._tables.get(tableName) ?? [];
+		let rows = table.map((r) => ({ ...r }));
+		if (whereStr) rows = rows.filter((row) => this._matchWhere(whereStr.trim(), row));
+		if (colsStr === "*") return rows;
+		if (/\b(?:SUM|COALESCE|COUNT|AVG|MIN|MAX)\s*\(/i.test(colsStr)) return [this._evalAggregate(colsStr, rows)];
+		return rows.map((row) => this._projectCols(colsStr, row));
+	}
+	_update(sql) {
+		const m = /UPDATE\s+(\w+)\s+SET\s+(.+?)(?:\s+WHERE\s+(.+))?$/is.exec(sql);
+		if (!m) return [];
+		const tableName = m[1];
+		const setStr = m[2];
+		const whereStr = m[3];
+		const table = this._tables.get(tableName);
+		if (!table) return [];
+		const assignments = this._parseAssignments(setStr);
+		for (const row of table) if (!whereStr || this._matchWhere(whereStr.trim(), row)) for (const [col, val] of assignments) row[col] = val;
+		return [];
+	}
+	_delete(sql) {
+		const m = /DELETE\s+FROM\s+(\w+)(?:\s+WHERE\s+(.+))?$/is.exec(sql);
+		if (!m) return [];
+		const tableName = m[1];
+		const whereStr = m[2];
+		const table = this._tables.get(tableName);
+		if (!table) return [];
+		if (!whereStr) {
+			this._tables.set(tableName, []);
+			return [];
+		}
+		const kept = table.filter((row) => !this._matchWhere(whereStr.trim(), row));
+		this._tables.set(tableName, kept);
+		return [];
+	}
+	/**
+	* Evaluate a simple WHERE clause against a row.
+	* Supports: `col = val` conditions joined by AND.
+	*/
+	_matchWhere(whereClause, row) {
+		const conditions = whereClause.split(/\s+AND\s+/i);
+		for (const condition of conditions) {
+			const trimmed = condition.trim();
+			const strM = /^(\w+)\s*=\s*'(.*)'$/is.exec(trimmed);
+			if (strM) {
+				const colVal = String(row[strM[1]] ?? "");
+				const literal = strM[2].replace(/''/g, "'");
+				if (colVal !== literal) return false;
+				continue;
+			}
+			const numM = /^(\w+)\s*=\s*(-?\d+(?:\.\d+)?)$/.exec(trimmed);
+			if (numM) {
+				if (Number(row[numM[1]]) !== parseFloat(numM[2])) return false;
+				continue;
+			}
+			const nullM = /^(\w+)\s+IS\s+NULL$/i.exec(trimmed);
+			if (nullM) {
+				if (row[nullM[1]] !== null && row[nullM[1]] !== void 0) return false;
+				continue;
+			}
+			const notNullM = /^(\w+)\s+IS\s+NOT\s+NULL$/i.exec(trimmed);
+			if (notNullM) {
+				if (row[notNullM[1]] === null || row[notNullM[1]] === void 0) return false;
+				continue;
+			}
+			const likeM = /^(\w+)\s+LIKE\s+'(.*)'$/is.exec(trimmed);
+			if (likeM) {
+				const colVal = row[likeM[1]];
+				if (colVal === null || colVal === void 0) return false;
+				const pattern = likeM[2].replace(/''/g, "'");
+				const escaped = pattern.replace(/[.*+?^${}()|[\]\\]/g, (ch) => ch === "%" || ch === "_" ? ch : "\\" + ch);
+				const regex = new RegExp("^" + escaped.replace(/%/g, ".*").replace(/_/g, ".") + "$", "s");
+				if (!regex.test(String(colVal))) return false;
+				continue;
+			}
+		}
+		return true;
+	}
+	_projectCols(colsStr, row) {
+		const result = {};
+		const cols = this._splitTopLevelCommas(colsStr);
+		for (const col of cols) {
+			const aliasM = /^(.+?)\s+AS\s+(\w+)$/i.exec(col);
+			if (aliasM) result[aliasM[2]] = this._evalExprAgainstRow(aliasM[1].trim(), row);
+			else result[col] = row[col];
+		}
+		return result;
+	}
+	_evalSelectExprs(exprs) {
+		const result = {};
+		const parts = this._splitTopLevelCommas(exprs);
+		for (const part of parts) {
+			const aliasM = /^(.+?)\s+AS\s+(\w+)$/i.exec(part);
+			if (aliasM) result[aliasM[2]] = this._evalLiteral(aliasM[1].trim());
+			else result[part] = this._evalLiteral(part);
+		}
+		return result;
+	}
+	_evalLiteral(expr) {
+		const trimmed = expr.trim();
+		if (trimmed.toUpperCase() === "NULL") return null;
+		if (/^'.*'$/.test(trimmed)) return trimmed.slice(1, -1).replace(/''/g, "'");
+		if (/^-?\d+$/.test(trimmed)) return parseInt(trimmed, 10);
+		if (/^-?\d+\.\d+$/.test(trimmed)) return parseFloat(trimmed);
+		return trimmed;
+	}
+	_evalExprAgainstRow(expr, row) {
+		const literal = this._evalLiteral(expr);
+		if (typeof literal !== "string") return literal;
+		if (/^\w+$/.test(expr) && expr in row) return row[expr];
+		return literal;
+	}
+	/**
+	* Split a string by commas that are NOT inside parentheses.
+	* E.g. "COALESCE(SUM(x), 0) as a, y" → ["COALESCE(SUM(x), 0) as a", "y"]
+	*/
+	_splitTopLevelCommas(str) {
+		const parts = [];
+		let current = "";
+		let depth = 0;
+		let inStr = false;
+		for (let i = 0; i < str.length; i++) {
+			const ch = str[i];
+			if (ch === "'" && !inStr) {
+				inStr = true;
+				current += ch;
+			} else if (ch === "'" && inStr) if (str[i + 1] === "'") {
+				current += "''";
+				i++;
+			} else {
+				inStr = false;
+				current += ch;
+			}
+			else if (!inStr && ch === "(") {
+				depth++;
+				current += ch;
+			} else if (!inStr && ch === ")") {
+				depth--;
+				current += ch;
+			} else if (!inStr && ch === "," && depth === 0) {
+				parts.push(current.trim());
+				current = "";
+			} else current += ch;
+		}
+		if (current.trim() !== "") parts.push(current.trim());
+		return parts;
+	}
+	/**
+	* Evaluate aggregate SELECT expressions (SUM, COALESCE, COUNT) across
+	* a set of filtered rows, returning a single result row.
+	*/
+	_evalAggregate(colsStr, rows) {
+		const result = {};
+		const cols = this._splitTopLevelCommas(colsStr);
+		for (const col of cols) {
+			const aliasM = /^(.+?)\s+AS\s+(\w+)$/i.exec(col);
+			const expr = aliasM ? aliasM[1].trim() : col.trim();
+			const alias = aliasM ? aliasM[2] : col.trim();
+			result[alias] = this._evalAggregateExpr(expr, rows);
+		}
+		return result;
+	}
+	/**
+	* Evaluate a single aggregate expression against a set of rows.
+	* Supports: SUM(col), COALESCE(expr, default), COUNT(*).
+	*/
+	_evalAggregateExpr(expr, rows) {
+		const trimmed = expr.trim();
+		const coalesceM = /^COALESCE\((.+)\)$/i.exec(trimmed);
+		if (coalesceM) {
+			const args = this._splitTopLevelCommas(coalesceM[1]);
+			for (const arg of args) {
+				const val = this._evalAggregateExpr(arg.trim(), rows);
+				if (val !== null && val !== void 0) return val;
+			}
+			return null;
+		}
+		const sumM = /^SUM\((\w+)\)$/i.exec(trimmed);
+		if (sumM) {
+			const col = sumM[1];
+			if (rows.length === 0) return null;
+			let total = 0;
+			for (const row of rows) total += Number(row[col] ?? 0);
+			return total;
+		}
+		if (/^COUNT\(\*\)$/i.test(trimmed)) return rows.length;
+		const countM = /^COUNT\((\w+)\)$/i.exec(trimmed);
+		if (countM) {
+			const col = countM[1];
+			return rows.filter((r) => r[col] !== null && r[col] !== void 0).length;
+		}
+		return this._evalLiteral(trimmed);
+	}
+	/**
+	* Parse a comma-separated list of SQL literal values.
+	* Handles: NULL, numbers, single-quoted strings.
+	* Simple split by comma (assumes no commas inside string values).
+	*/
+	_parseValueList(valStr) {
+		const tokens = [];
+		let current = "";
+		let inStr = false;
+		for (let i = 0; i < valStr.length; i++) {
+			const ch = valStr[i];
+			if (ch === "'" && !inStr) {
+				inStr = true;
+				current += ch;
+			} else if (ch === "'" && inStr) if (valStr[i + 1] === "'") {
+				current += "''";
+				i++;
+			} else {
+				inStr = false;
+				current += ch;
+			}
+			else if (ch === "," && !inStr) {
+				tokens.push(current.trim());
+				current = "";
+			} else current += ch;
+		}
+		if (current.trim() !== "") tokens.push(current.trim());
+		return tokens.map((t) => this._evalLiteral(t));
+	}
+	/**
+	* Parse `col1 = val1, col2 = val2` assignments into an array of [col, val] pairs.
+	*/
+	_parseAssignments(setStr) {
+		const assignments = [];
+		const parts = [];
+		let current = "";
+		let inStr = false;
+		for (let i = 0; i < setStr.length; i++) {
+			const ch = setStr[i];
+			if (ch === "'" && !inStr) {
+				inStr = true;
+				current += ch;
+			} else if (ch === "'" && inStr) if (setStr[i + 1] === "'") {
+				current += "''";
+				i++;
+			} else {
+				inStr = false;
+				current += ch;
+			}
+			else if (ch === "," && !inStr) {
+				parts.push(current.trim());
+				current = "";
+			} else current += ch;
+		}
+		if (current.trim() !== "") parts.push(current.trim());
+		for (const part of parts) {
+			const eqIdx = part.indexOf("=");
+			if (eqIdx === -1) continue;
+			const col = part.slice(0, eqIdx).trim();
+			const valStr = part.slice(eqIdx + 1).trim();
+			assignments.push([col, this._evalLiteral(valStr)]);
+		}
+		return assignments;
+	}
+};
+
+//#endregion
+//#region src/modules/state/errors.ts
+/**
+* Typed error classes for the Dolt state store.
+*/
+var StateStoreError = class extends Error {
+	code;
+	constructor(code, message) {
+		super(message);
+		this.name = "StateStoreError";
+		this.code = code;
+	}
+};
+var DoltQueryError = class extends StateStoreError {
+	sql;
+	detail;
+	constructor(sql, detail) {
+		super("DOLT_QUERY_ERROR", `Dolt query failed: ${detail}`);
+		this.name = "DoltQueryError";
+		this.sql = sql;
+		this.detail = detail;
+	}
+};
+var DoltMergeConflictError = class extends StateStoreError {
+	table;
+	conflictingKeys;
+	rowKey;
+	ourValue;
+	theirValue;
+	constructor(table, conflictingKeys, options) {
+		super("DOLT_MERGE_CONFLICT", `Merge conflict in table '${table}' on keys: ${conflictingKeys.join(", ")}`);
+		this.name = "DoltMergeConflictError";
+		this.table = table;
+		this.conflictingKeys = conflictingKeys;
+		if (options) {
+			this.rowKey = options.rowKey;
+			this.ourValue = options.ourValue;
+			this.theirValue = options.theirValue;
+		}
+	}
+};
+/** Alias for DoltMergeConflictError — used by orchestrator branch lifecycle. */
+const DoltMergeConflict = DoltMergeConflictError;
+
+//#endregion
+//#region src/modules/state/dolt-client.ts
+/**
+* Promise-wrapper around execFile that always resolves to { stdout, stderr }.
+* Using an explicit wrapper rather than promisify() avoids the util.promisify.custom
+* symbol complexity when mocking in tests.
+*/
+function runExecFile(cmd, args, opts) {
+	return new Promise((resolve$2, reject) => {
+		execFile(cmd, args, opts, (err, stdout, stderr) => {
+			if (err) reject(err);
+			else resolve$2({
+				stdout,
+				stderr
+			});
+		});
+	});
+}
+const log$1 = createLogger("modules:state:dolt");
+var DoltClient = class {
+	repoPath;
+	socketPath;
+	_pool = null;
+	_useCliMode = false;
+	_connected = false;
+	/** Promise-chain mutex that serializes all CLI operations to prevent concurrent noms manifest access */
+	_cliMutex = Promise.resolve();
+	constructor(options) {
+		this.repoPath = options.repoPath;
+		this.socketPath = options.socketPath ?? `${options.repoPath}/.dolt/dolt.sock`;
+	}
+	async connect() {
+		try {
+			await access(this.socketPath);
+			const mysql = await import("mysql2/promise");
+			this._pool = mysql.createPool({
+				socketPath: this.socketPath,
+				user: "root",
+				database: "doltdb",
+				waitForConnections: true,
+				connectionLimit: 5
+			});
+			this._useCliMode = false;
+			log$1.debug("Connected via unix socket: %s", this.socketPath);
+		} catch {
+			this._useCliMode = true;
+			log$1.debug("Unix socket not available, using CLI fallback for %s", this.repoPath);
+		}
+		this._connected = true;
+	}
+	async query(sql, params, branch) {
+		if (!this._connected) await this.connect();
+		if (this._useCliMode) return this._queryCli(sql, params, branch);
+		return this._queryPool(sql, params, branch);
+	}
+	async _queryPool(sql, params, branch) {
+		try {
+			if (branch !== void 0 && branch !== "main") {
+				const conn = await this._pool.getConnection();
+				try {
+					await conn.execute(`USE \`substrate/${branch}\``);
+					const [rows$1] = await conn.execute(sql, params);
+					return rows$1;
+				} finally {
+					conn.release();
+				}
+			}
+			const [rows] = await this._pool.execute(sql, params);
+			return rows;
+		} catch (err) {
+			const detail = err instanceof Error ? err.message : String(err);
+			throw new DoltQueryError(sql, detail);
+		}
+	}
+	/**
+	* Acquire an exclusive CLI lock. Dolt CLI takes an exclusive lock on the noms
+	* manifest, so concurrent `dolt sql -q` / `dolt <subcommand>` processes
+	* produce "cannot update manifest: database is read only" errors.
+	* Serialize all CLI operations through a single promise chain.
+	*/
+	_withCliLock(fn) {
+		const prev = this._cliMutex;
+		let release;
+		this._cliMutex = new Promise((resolve$2) => {
+			release = resolve$2;
+		});
+		return prev.then(fn).finally(() => release());
+	}
+	async _queryCli(sql, params, branch) {
+		let resolvedSql = sql;
+		if (params && params.length > 0) {
+			let i = 0;
+			resolvedSql = sql.replace(/\?/g, () => {
+				const val = params[i++];
+				if (val === null || val === void 0) return "NULL";
+				if (typeof val === "number") return String(val);
+				return `'${String(val).replace(/'/g, "''")}'`;
+			});
+		}
+		const finalSql = resolvedSql;
+		return this._withCliLock(async () => {
+			try {
+				const branchPrefix = branch ? `CALL DOLT_CHECKOUT('${branch.replace(/'/g, "''")}'); ` : "";
+				const args = [
+					"sql",
+					"-q",
+					branchPrefix + finalSql,
+					"--result-format",
+					"json"
+				];
+				const { stdout } = await runExecFile("dolt", args, { cwd: this.repoPath });
+				const lines = (stdout || "").trim().split("\n").filter(Boolean);
+				const lastLine = lines.length > 0 ? lines[lines.length - 1] : "{\"rows\":[]}";
+				const parsed = JSON.parse(lastLine);
+				return parsed.rows ?? [];
+			} catch (err) {
+				const detail = err instanceof Error ? err.message : String(err);
+				throw new DoltQueryError(finalSql, detail);
+			}
+		});
+	}
+	/**
+	* Execute a raw Dolt CLI command (e.g. `dolt diff main...story/26-1 --stat`)
+	* and return the stdout as a string.
+	*
+	* This is distinct from `query()` which runs SQL. Use `exec()` for Dolt
+	* sub-commands like `diff`, `log`, `branch`, etc.
+	*/
+	async exec(command) {
+		const parts = command.trim().split(/\s+/);
+		const cmdArgs = parts[0] === "dolt" ? parts.slice(1) : parts;
+		return this.execArgs(cmdArgs);
+	}
+	/**
+	* Execute a Dolt CLI command with pre-split arguments.
+	*
+	* Use this instead of `exec()` when arguments contain spaces (e.g. commit
+	* messages) to avoid whitespace-splitting issues.
+	*/
+	async execArgs(args) {
+		return this._withCliLock(async () => {
+			try {
+				const { stdout } = await runExecFile("dolt", args, { cwd: this.repoPath });
+				return stdout;
+			} catch (err) {
+				const detail = err instanceof Error ? err.message : String(err);
+				throw new DoltQueryError(args.join(" "), detail);
+			}
+		});
+	}
+	async close() {
+		if (this._pool) {
+			await this._pool.end();
+			this._pool = null;
+		}
+		this._connected = false;
+	}
+};
+function createDoltClient(options) {
+	return new DoltClient(options);
+}
+
+//#endregion
+//#region src/persistence/adapter.ts
+const logger$2 = createLogger("persistence:adapter");
+/** Type guard: check if a DatabaseAdapter also implements SyncAdapter. */
+function isSyncAdapter(adapter) {
+	return typeof adapter.querySync === "function";
+}
+/**
+* Synchronously check whether Dolt is installed on PATH and a Dolt repo
+* exists at the canonical state path under `basePath`.
+*/
+function isDoltAvailable(basePath) {
+	const result = spawnSync("dolt", ["version"], { stdio: "ignore" });
+	if (result.error != null || result.status !== 0) return false;
+	const stateDoltDir = join$1(basePath, ".substrate", "state", ".dolt");
+	return existsSync$1(stateDoltDir);
+}
+/**
+* Create a `DatabaseAdapter` for the specified (or auto-detected) backend.
+*
+* @param config - Optional configuration. Defaults to `{ backend: 'auto' }`.
+* @returns A `DatabaseAdapter` instance ready for use.
+*/
+function createDatabaseAdapter(config = { backend: "auto" }) {
+	const backend = config.backend ?? "auto";
+	const basePath = config.basePath ?? process.cwd();
+	const doltRepoPath = join$1(basePath, ".substrate", "state");
+	if (backend === "dolt") {
+		logger$2.debug("Using DoltDatabaseAdapter (explicit config)");
+		const client = new DoltClient({ repoPath: doltRepoPath });
+		return new DoltDatabaseAdapter(client);
+	}
+	if (backend === "memory") {
+		logger$2.debug("Using InMemoryDatabaseAdapter (explicit config)");
+		return new InMemoryDatabaseAdapter();
+	}
+	if (isDoltAvailable(basePath)) {
+		logger$2.debug("Dolt detected, using DoltDatabaseAdapter");
+		const client = new DoltClient({ repoPath: doltRepoPath });
+		return new DoltDatabaseAdapter(client);
+	}
+	logger$2.debug("Dolt not available, using InMemoryDatabaseAdapter");
+	return new InMemoryDatabaseAdapter();
+}
+
+//#endregion
+//#region src/persistence/schema.ts
+/**
+* Initialize all persistence tables on the given adapter.
+* Idempotent — safe to call multiple times.
+*/
+async function initSchema(adapter) {
+	await adapter.exec(`
+    CREATE TABLE IF NOT EXISTS sessions (
+      id                VARCHAR(255) PRIMARY KEY,
+      name              TEXT,
+      graph_file        TEXT NOT NULL,
+      status            VARCHAR(32) NOT NULL DEFAULT 'active',
+      budget_usd        DOUBLE,
+      total_cost_usd    DOUBLE NOT NULL DEFAULT 0.0,
+      planning_cost_usd DOUBLE NOT NULL DEFAULT 0.0,
+      config_snapshot   TEXT,
+      base_branch       TEXT NOT NULL DEFAULT 'main',
+      plan_source       TEXT,
+      planning_agent    TEXT,
+      planning_costs_count_against_budget INTEGER NOT NULL DEFAULT 0,
+      created_at        DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+      updated_at        DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+    )
+  `);
+	await adapter.exec(`
+    CREATE TABLE IF NOT EXISTS tasks (
+      id              VARCHAR(255) PRIMARY KEY,
+      session_id      VARCHAR(255) NOT NULL,
+      name            TEXT NOT NULL,
+      description     TEXT,
+      prompt          TEXT NOT NULL,
+      status          VARCHAR(32) NOT NULL DEFAULT 'pending',
+      agent           VARCHAR(128),
+      model           TEXT,
+      billing_mode    VARCHAR(32),
+      worktree_path   TEXT,
+      worktree_branch TEXT,
+      worktree_cleaned_at TEXT,
+      worker_id       TEXT,
+      budget_usd      DOUBLE,
+      cost_usd        DOUBLE NOT NULL DEFAULT 0.0,
+      input_tokens    INTEGER NOT NULL DEFAULT 0,
+      output_tokens   INTEGER NOT NULL DEFAULT 0,
+      result          TEXT,
+      error           TEXT,
+      exit_code       INTEGER,
+      retry_count     INTEGER NOT NULL DEFAULT 0,
+      max_retries     INTEGER NOT NULL DEFAULT 2,
+      timeout_ms      INTEGER,
+      task_type       TEXT,
+      metadata        TEXT,
+      merge_status    TEXT,
+      merged_files    TEXT,
+      conflict_files  TEXT,
+      budget_exceeded INTEGER NOT NULL DEFAULT 0,
+      started_at      TEXT,
+      completed_at    TEXT,
+      created_at      DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+      updated_at      DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+    )
+  `);
+	await adapter.exec("CREATE INDEX IF NOT EXISTS idx_tasks_session ON tasks(session_id)");
+	await adapter.exec("CREATE INDEX IF NOT EXISTS idx_tasks_status ON tasks(status)");
+	await adapter.exec("CREATE INDEX IF NOT EXISTS idx_tasks_agent ON tasks(agent)");
+	await adapter.exec("CREATE INDEX IF NOT EXISTS idx_tasks_session_status ON tasks(session_id, status)");
+	await adapter.exec(`
+    CREATE TABLE IF NOT EXISTS task_dependencies (
+      task_id    VARCHAR(255) NOT NULL,
+      depends_on VARCHAR(255) NOT NULL,
+      PRIMARY KEY (task_id, depends_on),
+      CHECK (task_id != depends_on)
+    )
+  `);
+	await adapter.exec("CREATE INDEX IF NOT EXISTS idx_deps_depends_on ON task_dependencies(depends_on)");
+	await adapter.exec(`
+    CREATE TABLE IF NOT EXISTS execution_log (
+      id         INTEGER PRIMARY KEY AUTO_INCREMENT,
+      session_id VARCHAR(255) NOT NULL,
+      task_id    VARCHAR(255),
+      event      VARCHAR(128) NOT NULL,
+      old_status VARCHAR(32),
+      new_status VARCHAR(32),
+      agent      VARCHAR(128),
+      cost_usd   DOUBLE,
+      data       TEXT,
+      timestamp  DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+    )
+  `);
+	await adapter.exec("CREATE INDEX IF NOT EXISTS idx_log_session ON execution_log(session_id)");
+	await adapter.exec("CREATE INDEX IF NOT EXISTS idx_log_task ON execution_log(task_id)");
+	await adapter.exec("CREATE INDEX IF NOT EXISTS idx_log_event ON execution_log(event)");
+	await adapter.exec("CREATE INDEX IF NOT EXISTS idx_log_timestamp ON execution_log(timestamp)");
+	await adapter.exec(`
+    CREATE TABLE IF NOT EXISTS cost_entries (
+      id             INTEGER PRIMARY KEY AUTO_INCREMENT,
+      session_id     VARCHAR(255) NOT NULL,
+      task_id        VARCHAR(255),
+      agent          VARCHAR(128) NOT NULL,
+      billing_mode   VARCHAR(32) NOT NULL,
+      category       VARCHAR(64) NOT NULL DEFAULT 'execution',
+      provider       VARCHAR(64) NOT NULL DEFAULT 'unknown',
+      input_tokens   INTEGER NOT NULL DEFAULT 0,
+      output_tokens  INTEGER NOT NULL DEFAULT 0,
+      estimated_cost DOUBLE NOT NULL DEFAULT 0.0,
+      actual_cost    DOUBLE,
+      savings_usd    DOUBLE NOT NULL DEFAULT 0.0,
+      model          TEXT,
+      timestamp      DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+    )
+  `);
+	await adapter.exec("CREATE INDEX IF NOT EXISTS idx_cost_session ON cost_entries(session_id)");
+	await adapter.exec("CREATE INDEX IF NOT EXISTS idx_cost_task ON cost_entries(task_id)");
+	await adapter.exec("CREATE INDEX IF NOT EXISTS idx_cost_category ON cost_entries(category)");
+	await adapter.exec("CREATE INDEX IF NOT EXISTS idx_cost_entries_session_task ON cost_entries(session_id, task_id)");
+	await adapter.exec("CREATE INDEX IF NOT EXISTS idx_cost_entries_provider ON cost_entries(provider)");
+	await adapter.exec("CREATE INDEX IF NOT EXISTS idx_cost_session_agent ON cost_entries(session_id, agent)");
+	await adapter.exec("CREATE INDEX IF NOT EXISTS idx_cost_agent ON cost_entries(agent)");
+	await adapter.exec(`
+    CREATE TABLE IF NOT EXISTS session_signals (
+      id           INTEGER PRIMARY KEY AUTO_INCREMENT,
+      session_id   VARCHAR(255) NOT NULL,
+      \`signal\`   VARCHAR(16) NOT NULL CHECK(\`signal\` IN ('pause', 'resume', 'cancel')),
+      created_at   DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+      processed_at TEXT
+    )
+  `);
+	await adapter.exec(`
+    CREATE TABLE IF NOT EXISTS plans (
+      id                 VARCHAR(255) PRIMARY KEY,
+      description        TEXT NOT NULL,
+      task_count         INTEGER NOT NULL DEFAULT 0,
+      estimated_cost_usd DOUBLE NOT NULL DEFAULT 0.0,
+      planning_agent     VARCHAR(128) NOT NULL,
+      plan_yaml          TEXT NOT NULL,
+      status             VARCHAR(32) NOT NULL DEFAULT 'draft',
+      current_version    INTEGER NOT NULL DEFAULT 1,
+      created_at         DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+      updated_at         DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+    )
+  `);
+	await adapter.exec("CREATE INDEX IF NOT EXISTS idx_plans_status ON plans(status)");
+	await adapter.exec("CREATE INDEX IF NOT EXISTS idx_plans_created ON plans(created_at)");
+	await adapter.exec(`
+    CREATE TABLE IF NOT EXISTS plan_versions (
+      plan_id           VARCHAR(255) NOT NULL,
+      version           INTEGER NOT NULL,
+      task_graph_yaml   TEXT NOT NULL,
+      feedback_used     TEXT,
+      planning_cost_usd DOUBLE NOT NULL DEFAULT 0.0,
+      created_at        DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+      PRIMARY KEY (plan_id, version)
+    )
+  `);
+	await adapter.exec("CREATE INDEX IF NOT EXISTS idx_plan_versions_plan_id ON plan_versions(plan_id)");
+	await adapter.exec(`
+    CREATE TABLE IF NOT EXISTS pipeline_runs (
+      id               VARCHAR(255) PRIMARY KEY,
+      methodology      VARCHAR(128) NOT NULL,
+      current_phase    VARCHAR(64),
+      status           VARCHAR(32) NOT NULL DEFAULT 'running'
+                       CHECK(status IN ('running','paused','completed','failed','stopped')),
+      config_json      TEXT,
+      token_usage_json TEXT,
+      parent_run_id    VARCHAR(255),
+      created_at       DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+      updated_at       DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+    )
+  `);
+	await adapter.exec("CREATE INDEX IF NOT EXISTS idx_pipeline_runs_status ON pipeline_runs(status)");
+	await adapter.exec("CREATE INDEX IF NOT EXISTS idx_pipeline_runs_parent_run_id ON pipeline_runs(parent_run_id)");
+	await adapter.exec(`
+    CREATE TABLE IF NOT EXISTS decisions (
+      id              VARCHAR(255) PRIMARY KEY,
+      pipeline_run_id VARCHAR(255),
+      phase           VARCHAR(64) NOT NULL,
+      category        VARCHAR(64) NOT NULL,
+      \`key\`         VARCHAR(255) NOT NULL,
+      value           TEXT NOT NULL,
+      rationale       TEXT,
+      superseded_by   VARCHAR(255),
+      created_at      DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+      updated_at      DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+    )
+  `);
+	await adapter.exec("CREATE INDEX IF NOT EXISTS idx_decisions_phase ON decisions(phase)");
+	await adapter.exec("CREATE INDEX IF NOT EXISTS idx_decisions_key ON decisions(phase, `key`)");
+	await adapter.exec("CREATE INDEX IF NOT EXISTS idx_decisions_superseded_by ON decisions(superseded_by)");
+	await adapter.exec(`
+    CREATE TABLE IF NOT EXISTS requirements (
+      id              VARCHAR(255) PRIMARY KEY,
+      pipeline_run_id VARCHAR(255),
+      source          VARCHAR(128) NOT NULL,
+      type            VARCHAR(32) NOT NULL CHECK(type IN ('functional','non_functional','constraint')),
+      description     TEXT NOT NULL,
+      priority        VARCHAR(16) NOT NULL CHECK(priority IN ('must','should','could','wont')),
+      status          VARCHAR(32) NOT NULL DEFAULT 'active',
+      created_at      DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+    )
+  `);
+	await adapter.exec("CREATE INDEX IF NOT EXISTS idx_requirements_type ON requirements(type)");
+	await adapter.exec("CREATE INDEX IF NOT EXISTS idx_requirements_status ON requirements(status)");
+	await adapter.exec(`
+    CREATE TABLE IF NOT EXISTS constraints (
+      id              VARCHAR(255) PRIMARY KEY,
+      pipeline_run_id VARCHAR(255),
+      category        VARCHAR(64) NOT NULL,
+      description     TEXT NOT NULL,
+      source          VARCHAR(128) NOT NULL,
+      created_at      DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+    )
+  `);
+	await adapter.exec(`
+    CREATE TABLE IF NOT EXISTS artifacts (
+      id              VARCHAR(255) PRIMARY KEY,
+      pipeline_run_id VARCHAR(255),
+      phase           VARCHAR(64) NOT NULL,
+      type            VARCHAR(128) NOT NULL,
+      path            TEXT NOT NULL,
+      content_hash    TEXT,
+      summary         TEXT,
+      created_at      DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+    )
+  `);
+	await adapter.exec("CREATE INDEX IF NOT EXISTS idx_artifacts_phase ON artifacts(phase)");
+	await adapter.exec(`
+    CREATE TABLE IF NOT EXISTS token_usage (
+      id              INTEGER PRIMARY KEY AUTO_INCREMENT,
+      pipeline_run_id VARCHAR(255),
+      phase           VARCHAR(64) NOT NULL,
+      agent           VARCHAR(128) NOT NULL,
+      input_tokens    INTEGER NOT NULL DEFAULT 0,
+      output_tokens   INTEGER NOT NULL DEFAULT 0,
+      cost_usd        DOUBLE NOT NULL DEFAULT 0.0,
+      metadata        TEXT,
+      created_at      DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+    )
+  `);
+	await adapter.exec("CREATE INDEX IF NOT EXISTS idx_token_usage_run ON token_usage(pipeline_run_id)");
+	await adapter.exec(`
+    CREATE TABLE IF NOT EXISTS run_metrics (
+      run_id              VARCHAR(255) PRIMARY KEY,
+      methodology         VARCHAR(128) NOT NULL,
+      status              VARCHAR(32) NOT NULL DEFAULT 'running',
+      started_at          TEXT NOT NULL,
+      completed_at        TEXT,
+      wall_clock_seconds  DOUBLE DEFAULT 0,
+      total_input_tokens  INTEGER DEFAULT 0,
+      total_output_tokens INTEGER DEFAULT 0,
+      total_cost_usd      DOUBLE DEFAULT 0,
+      stories_attempted   INTEGER DEFAULT 0,
+      stories_succeeded   INTEGER DEFAULT 0,
+      stories_failed      INTEGER DEFAULT 0,
+      stories_escalated   INTEGER DEFAULT 0,
+      total_review_cycles INTEGER DEFAULT 0,
+      total_dispatches    INTEGER DEFAULT 0,
+      concurrency_setting INTEGER DEFAULT 1,
+      max_concurrent_actual INTEGER DEFAULT 1,
+      restarts            INTEGER DEFAULT 0,
+      is_baseline         INTEGER DEFAULT 0,
+      created_at          DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+    )
+  `);
+	await adapter.exec(`
+    CREATE TABLE IF NOT EXISTS story_metrics (
+      id                  INTEGER PRIMARY KEY AUTO_INCREMENT,
+      run_id              VARCHAR(255) NOT NULL,
+      story_key           VARCHAR(255) NOT NULL,
+      result              VARCHAR(32) NOT NULL DEFAULT 'pending',
+      phase_durations_json TEXT,
+      started_at          TEXT,
+      completed_at        TEXT,
+      wall_clock_seconds  DOUBLE DEFAULT 0,
+      input_tokens        INTEGER DEFAULT 0,
+      output_tokens       INTEGER DEFAULT 0,
+      cost_usd            DOUBLE DEFAULT 0,
+      review_cycles       INTEGER DEFAULT 0,
+      dispatches          INTEGER DEFAULT 0,
+      created_at          DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+      UNIQUE(run_id, story_key)
+    )
+  `);
+	await adapter.exec(`
+    CREATE TABLE IF NOT EXISTS task_metrics (
+      task_id        VARCHAR(255) NOT NULL,
+      agent          VARCHAR(128) NOT NULL,
+      task_type      VARCHAR(128) NOT NULL,
+      outcome        VARCHAR(16)  NOT NULL CHECK(outcome IN ('success', 'failure')),
+      failure_reason TEXT,
+      input_tokens   INTEGER NOT NULL DEFAULT 0,
+      output_tokens  INTEGER NOT NULL DEFAULT 0,
+      duration_ms    INTEGER NOT NULL DEFAULT 0,
+      cost           DOUBLE  NOT NULL DEFAULT 0.0,
+      estimated_cost DOUBLE  NOT NULL DEFAULT 0.0,
+      billing_mode   VARCHAR(32) NOT NULL DEFAULT 'api',
+      retries        INTEGER NOT NULL DEFAULT 0,
+      recorded_at    DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+      PRIMARY KEY (task_id, recorded_at)
+    )
+  `);
+	await adapter.exec("CREATE INDEX IF NOT EXISTS idx_tm_agent ON task_metrics(agent)");
+	await adapter.exec("CREATE INDEX IF NOT EXISTS idx_tm_task_type ON task_metrics(task_type)");
+	await adapter.exec("CREATE INDEX IF NOT EXISTS idx_tm_recorded_at ON task_metrics(recorded_at)");
+	await adapter.exec("CREATE INDEX IF NOT EXISTS idx_tm_agent_type ON task_metrics(agent, task_type)");
+	await adapter.exec(`
+    CREATE TABLE IF NOT EXISTS performance_aggregates (
+      agent              VARCHAR(255) NOT NULL,
+      task_type          VARCHAR(255) NOT NULL,
+      total_tasks        INTEGER NOT NULL DEFAULT 0,
+      successful_tasks   INTEGER NOT NULL DEFAULT 0,
+      failed_tasks       INTEGER NOT NULL DEFAULT 0,
+      total_input_tokens INTEGER NOT NULL DEFAULT 0,
+      total_output_tokens INTEGER NOT NULL DEFAULT 0,
+      total_duration_ms  INTEGER NOT NULL DEFAULT 0,
+      total_cost         DOUBLE  NOT NULL DEFAULT 0.0,
+      total_retries      INTEGER NOT NULL DEFAULT 0,
+      last_updated       DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+      PRIMARY KEY (agent, task_type)
+    )
+  `);
+	await adapter.exec(`
+    CREATE TABLE IF NOT EXISTS routing_recommendations (
+      id                INTEGER PRIMARY KEY AUTO_INCREMENT,
+      task_type         VARCHAR(128) NOT NULL,
+      current_agent     VARCHAR(128) NOT NULL,
+      recommended_agent VARCHAR(128) NOT NULL,
+      reason            TEXT,
+      confidence        DOUBLE  NOT NULL DEFAULT 0.0,
+      supporting_data   TEXT,
+      generated_at      DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+      expires_at        TEXT
+    )
+  `);
+	await adapter.exec(`
+    CREATE TABLE IF NOT EXISTS turn_analysis (
+      story_key         VARCHAR(64)    NOT NULL,
+      span_id           VARCHAR(128)   NOT NULL,
+      turn_number       INTEGER        NOT NULL,
+      name              VARCHAR(255)   NOT NULL DEFAULT '',
+      timestamp         BIGINT         NOT NULL DEFAULT 0,
+      source            VARCHAR(32)    NOT NULL DEFAULT '',
+      model             VARCHAR(64),
+      input_tokens      INTEGER        NOT NULL DEFAULT 0,
+      output_tokens     INTEGER        NOT NULL DEFAULT 0,
+      cache_read_tokens INTEGER        NOT NULL DEFAULT 0,
+      fresh_tokens      INTEGER        NOT NULL DEFAULT 0,
+      cache_hit_rate    DOUBLE         NOT NULL DEFAULT 0,
+      cost_usd          DOUBLE         NOT NULL DEFAULT 0,
+      duration_ms       INTEGER        NOT NULL DEFAULT 0,
+      context_size      INTEGER        NOT NULL DEFAULT 0,
+      context_delta     INTEGER        NOT NULL DEFAULT 0,
+      tool_name         VARCHAR(128),
+      is_context_spike  BOOLEAN        NOT NULL DEFAULT 0,
+      child_spans_json  TEXT           NOT NULL DEFAULT '[]',
+      task_type         VARCHAR(64),
+      phase             VARCHAR(64),
+      dispatch_id       VARCHAR(64),
+      PRIMARY KEY (story_key, span_id)
+    )
+  `);
+	await adapter.exec("CREATE INDEX IF NOT EXISTS idx_turn_analysis_story ON turn_analysis (story_key, turn_number)");
+	for (const col of [
+		"task_type",
+		"phase",
+		"dispatch_id"
+	]) try {
+		await adapter.exec(`ALTER TABLE turn_analysis ADD COLUMN ${col} VARCHAR(64)`);
+	} catch {}
+	await adapter.exec(`
+    CREATE TABLE IF NOT EXISTS efficiency_scores (
+      story_key                     VARCHAR(64)  NOT NULL,
+      timestamp                     BIGINT       NOT NULL,
+      composite_score               INTEGER      NOT NULL DEFAULT 0,
+      cache_hit_sub_score           DOUBLE       NOT NULL DEFAULT 0,
+      io_ratio_sub_score            DOUBLE       NOT NULL DEFAULT 0,
+      context_management_sub_score  DOUBLE       NOT NULL DEFAULT 0,
+      avg_cache_hit_rate            DOUBLE       NOT NULL DEFAULT 0,
+      avg_io_ratio                  DOUBLE       NOT NULL DEFAULT 0,
+      context_spike_count           INTEGER      NOT NULL DEFAULT 0,
+      total_turns                   INTEGER      NOT NULL DEFAULT 0,
+      per_model_json                TEXT         NOT NULL DEFAULT '[]',
+      per_source_json               TEXT         NOT NULL DEFAULT '[]',
+      dispatch_id                   TEXT,
+      task_type                     TEXT,
+      phase                         TEXT,
+      PRIMARY KEY (story_key, timestamp)
+    )
+  `);
+	for (const col of [
+		"dispatch_id",
+		"task_type",
+		"phase"
+	]) try {
+		await adapter.exec(`ALTER TABLE efficiency_scores ADD COLUMN ${col} TEXT`);
+	} catch {}
+	await adapter.exec(`
+    CREATE TABLE IF NOT EXISTS recommendations (
+      id                       VARCHAR(16)   NOT NULL,
+      story_key                VARCHAR(64)   NOT NULL,
+      sprint_id                VARCHAR(64),
+      rule_id                  VARCHAR(64)   NOT NULL,
+      severity                 VARCHAR(16)   NOT NULL,
+      title                    TEXT          NOT NULL,
+      description              TEXT          NOT NULL,
+      potential_savings_tokens INTEGER,
+      potential_savings_usd    DOUBLE,
+      action_target            TEXT,
+      generated_at             VARCHAR(32)   NOT NULL,
+      PRIMARY KEY (id)
+    )
+  `);
+	await adapter.exec(`
+    CREATE TABLE IF NOT EXISTS category_stats (
+      story_key            VARCHAR(100)   NOT NULL,
+      category             VARCHAR(30)    NOT NULL,
+      total_tokens         BIGINT         NOT NULL DEFAULT 0,
+      percentage           DECIMAL(6,3)   NOT NULL DEFAULT 0,
+      event_count          INTEGER        NOT NULL DEFAULT 0,
+      avg_tokens_per_event DECIMAL(12,2)  NOT NULL DEFAULT 0,
+      trend                VARCHAR(10)    NOT NULL DEFAULT 'stable',
+      PRIMARY KEY (story_key, category)
+    )
+  `);
+	await adapter.exec(`
+    CREATE TABLE IF NOT EXISTS consumer_stats (
+      story_key            VARCHAR(100)   NOT NULL,
+      consumer_key         VARCHAR(300)   NOT NULL,
+      category             VARCHAR(30)    NOT NULL,
+      total_tokens         BIGINT         NOT NULL DEFAULT 0,
+      percentage           DECIMAL(6,3)   NOT NULL DEFAULT 0,
+      event_count          INTEGER        NOT NULL DEFAULT 0,
+      top_invocations_json TEXT,
+      PRIMARY KEY (story_key, consumer_key)
+    )
+  `);
+	await adapter.exec(`
+    CREATE VIEW IF NOT EXISTS ready_tasks AS
+    SELECT t.* FROM tasks t
+    WHERE t.status = 'pending'
+      AND NOT EXISTS (
+        SELECT 1 FROM task_dependencies td
+        JOIN tasks dep ON dep.id = td.depends_on
+        WHERE td.task_id = t.id
+          AND dep.status NOT IN ('completed', 'cancelled')
+      )
+  `);
+	await adapter.exec(`
+    CREATE VIEW IF NOT EXISTS session_cost_summary AS
+    SELECT
+      s.id   AS session_id,
+      s.name AS session_name,
+      COUNT(DISTINCT t.id) AS total_tasks,
+      SUM(CASE WHEN t.status = 'completed' THEN 1 ELSE 0 END) AS completed_tasks,
+      SUM(CASE WHEN t.status = 'failed'   THEN 1 ELSE 0 END) AS failed_tasks,
+      SUM(CASE WHEN t.status = 'running'  THEN 1 ELSE 0 END) AS running_tasks,
+      COALESCE(SUM(t.cost_usd), 0) AS total_cost_usd,
+      SUM(CASE WHEN t.billing_mode = 'subscription' THEN t.cost_usd ELSE 0 END) AS subscription_cost_usd,
+      SUM(CASE WHEN t.billing_mode = 'api'          THEN t.cost_usd ELSE 0 END) AS api_cost_usd,
+      s.planning_cost_usd
+    FROM sessions s
+    LEFT JOIN tasks t ON t.session_id = s.id
+    GROUP BY s.id
+  `);
+	await adapter.exec(`
+    CREATE TABLE IF NOT EXISTS schema_migrations (
+      version    INTEGER PRIMARY KEY,
+      name       TEXT    NOT NULL,
+      applied_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+    )
+  `);
+}
+
+//#endregion
+//#region src/modules/state/dolt-init.ts
+/**
+* Thrown when the `dolt` binary cannot be found in PATH.
+*/
+var DoltNotInstalled = class extends Error {
+	constructor() {
+		super("Dolt CLI not found in PATH. Install Dolt from https://docs.dolthub.com/introduction/installation");
+		this.name = "DoltNotInstalled";
+	}
+};
+/**
+* Thrown when a Dolt CLI command exits with a non-zero status code.
+*/
+var DoltInitError = class extends Error {
+	constructor(args, exitCode, stderr) {
+		super(`Dolt command "dolt ${args.join(" ")}" failed with exit code ${exitCode}${stderr ? `: ${stderr}` : ""}`);
+		this.name = "DoltInitError";
+	}
+};
+/**
+* Verify that the `dolt` binary is installed and accessible.
+*
+* @throws {DoltNotInstalled} If the binary is not found in PATH.
+*/
+async function checkDoltInstalled() {
+	return new Promise((resolve$2, reject) => {
+		let child;
+		try {
+			child = spawn("dolt", ["version"], { stdio: "ignore" });
+		} catch (err) {
+			const nodeErr = err;
+			if (nodeErr.code === "ENOENT") reject(new DoltNotInstalled());
+			else reject(err);
+			return;
+		}
+		child.on("error", (err) => {
+			if (err.code === "ENOENT") reject(new DoltNotInstalled());
+			else reject(err);
+		});
+		child.on("close", (code) => {
+			if (code === 0) resolve$2();
+			else resolve$2();
+		});
+	});
+}
+/**
+* Run a Dolt CLI command in the given working directory.
+*
+* @param args - Arguments to pass to `dolt` (e.g. `['init']`).
+* @param cwd  - Working directory for the command.
+* @throws {DoltInitError} If the command exits with a non-zero code.
+*/
+async function runDoltCommand(args, cwd) {
+	return new Promise((resolve$2, reject) => {
+		const stderrChunks = [];
+		const child = spawn("dolt", args, {
+			cwd,
+			stdio: [
+				"ignore",
+				"ignore",
+				"pipe"
+			]
+		});
+		child.stderr?.on("data", (chunk) => {
+			stderrChunks.push(chunk);
+		});
+		child.on("error", (err) => {
+			reject(err);
+		});
+		child.on("close", (code) => {
+			if (code === 0) resolve$2();
+			else {
+				const stderr = Buffer.concat(stderrChunks).toString("utf8").trim();
+				reject(new DoltInitError(args, code ?? -1, stderr));
+			}
+		});
+	});
+}
+/**
+* Ensure that Dolt has a global user identity configured.
+* `dolt init` and `dolt commit` fail with "empty ident name not allowed"
+* when no identity exists. This function checks for an existing identity
+* and configures a default one if absent.
+*/
+async function ensureDoltIdentity() {
+	const hasIdentity = await doltConfigGet("user.name");
+	if (hasIdentity) return;
+	await runDoltConfigSet("user.name", "substrate");
+	await runDoltConfigSet("user.email", "substrate@localhost");
+}
+/**
+* Check if a Dolt global config key has a value set.
+*/
+async function doltConfigGet(key) {
+	return new Promise((resolve$2) => {
+		const child = spawn("dolt", [
+			"config",
+			"--global",
+			"--get",
+			key
+		], { stdio: [
+			"ignore",
+			"ignore",
+			"ignore"
+		] });
+		child.on("error", () => resolve$2(false));
+		child.on("close", (code) => resolve$2(code === 0));
+	});
+}
+/**
+* Set a Dolt global config value.
+*/
+async function runDoltConfigSet(key, value) {
+	return new Promise((resolve$2, reject) => {
+		const child = spawn("dolt", [
+			"config",
+			"--global",
+			"--add",
+			key,
+			value
+		], { stdio: [
+			"ignore",
+			"ignore",
+			"pipe"
+		] });
+		const stderrChunks = [];
+		child.stderr?.on("data", (chunk) => stderrChunks.push(chunk));
+		child.on("error", reject);
+		child.on("close", (code) => {
+			if (code === 0) resolve$2();
+			else {
+				const stderr = Buffer.concat(stderrChunks).toString("utf8").trim();
+				reject(new DoltInitError([
+					"config",
+					"--global",
+					"--add",
+					key,
+					value
+				], code ?? -1, stderr));
+			}
+		});
+	});
+}
+/**
+* Initialize a Dolt repository for Substrate state storage.
+*
+* This function is idempotent: running it a second time on an already-
+* initialized repository is safe — `dolt init` is skipped, existing tables
+* are not re-created (IF NOT EXISTS guards), and the schema version row is
+* not duplicated (INSERT IGNORE).
+*
+* @param config - Initialization configuration.
+* @throws {DoltNotInstalled} If the `dolt` binary is not in PATH.
+* @throws {DoltInitError} If any Dolt CLI command fails.
+*/
+async function initializeDolt(config) {
+	const statePath = config.statePath ?? join$1(config.projectRoot, ".substrate", "state");
+	const schemaPath = config.schemaPath ?? fileURLToPath(new URL("./schema.sql", import.meta.url));
+	await checkDoltInstalled();
+	await mkdir(statePath, { recursive: true });
+	await ensureDoltIdentity();
+	const doltDir = join$1(statePath, ".dolt");
+	let doltDirExists = false;
+	try {
+		await access(doltDir);
+		doltDirExists = true;
+	} catch {
+		doltDirExists = false;
+	}
+	if (!doltDirExists) await runDoltCommand(["init"], statePath);
+	await runDoltCommand([
+		"sql",
+		"-f",
+		schemaPath
+	], statePath);
+	let hasCommits = false;
+	try {
+		await runDoltCommand(["log", "--oneline"], statePath);
+		hasCommits = await doltLogHasCommits(statePath);
+	} catch {
+		hasCommits = false;
+	}
+	if (!hasCommits) {
+		await runDoltCommand(["add", "-A"], statePath);
+		await runDoltCommand([
+			"commit",
+			"-m",
+			"Initialize substrate state schema v1"
+		], statePath);
+	}
+}
+/**
+* Returns `true` if there is at least one commit in the Dolt repo.
+*/
+async function doltLogHasCommits(cwd) {
+	return new Promise((resolve$2) => {
+		const stdoutChunks = [];
+		const child = spawn("dolt", ["log", "--oneline"], {
+			cwd,
+			stdio: [
+				"ignore",
+				"pipe",
+				"ignore"
+			]
+		});
+		child.stdout?.on("data", (chunk) => {
+			stdoutChunks.push(chunk);
+		});
+		child.on("error", () => resolve$2(false));
+		child.on("close", (code) => {
+			if (code !== 0) {
+				resolve$2(false);
+				return;
+			}
+			const output = Buffer.concat(stdoutChunks).toString("utf8").trim();
+			resolve$2(output.length > 0);
+		});
+	});
+}
+
+//#endregion
+//#region src/modules/stop-after/types.ts
+/**
+* Stop-After Gate Module — Types
+*
+* Defines the PhaseName type and all parameter/result types for the stop-after gate.
+* VALID_PHASES is the canonical source for pipeline phase names; auto.ts imports from here.
+*/
+/** Canonical pipeline phase names. This is the single source of truth for all phase lists. */
+const VALID_PHASES = [
+	"research",
+	"analysis",
+	"planning",
+	"solutioning",
+	"implementation"
+];
+/**
+* Alias for VALID_PHASES retained for backward compatibility with existing imports.
+* @deprecated Use VALID_PHASES directly.
+*/
+const STOP_AFTER_VALID_PHASES = VALID_PHASES;
+
+//#endregion
+//#region src/cli/commands/pipeline-shared.ts
+/**
+* Parse a DB timestamp string to a Date, correctly treating it as UTC.
+*
+* SQLite stores timestamps as "YYYY-MM-DD HH:MM:SS" without a timezone suffix.
+* JavaScript's Date constructor parses strings without a timezone suffix as
+* *local time*, which causes staleness/duration to be calculated incorrectly
+* on machines not in UTC.
+*
+* Fix: append 'Z' if the string has no timezone marker so it is always
+* parsed as UTC.
+*/
+function parseDbTimestampAsUtc(ts) {
+	if (ts.endsWith("Z") || /[+-]\d{2}:\d{2}$/.test(ts)) return new Date(ts);
+	return new Date(ts.replace(" ", "T") + "Z");
+}
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+/**
+* Find the package root by walking up until we find package.json.
+* Works regardless of build output structure (tsdown bundles into
+* dist/cli/index.js, not dist/cli/commands/auto.js).
+*/
+function findPackageRoot(startDir) {
+	let dir = startDir;
+	while (dir !== dirname(dir)) {
+		if (existsSync(join(dir, "package.json"))) return dir;
+		dir = dirname(dir);
+	}
+	return startDir;
+}
+const PACKAGE_ROOT = join(__dirname, "..", "..", "..");
+/**
+* Resolve the absolute path to the bmad-method package's src/ directory.
+* Uses createRequire so it works in ESM without import.meta.resolve polyfills.
+* Returns null if bmad-method is not installed.
+*/
+function resolveBmadMethodSrcPath(fromDir = __dirname) {
+	try {
+		const require$1 = createRequire$1(join(fromDir, "synthetic.js"));
+		const pkgJsonPath = require$1.resolve("bmad-method/package.json");
+		return join(dirname(pkgJsonPath), "src");
+	} catch {
+		return null;
+	}
+}
+/**
+* Read the version field from bmad-method's package.json.
+* Returns 'unknown' if not resolvable.
+*/
+function resolveBmadMethodVersion(fromDir = __dirname) {
+	try {
+		const require$1 = createRequire$1(join(fromDir, "synthetic.js"));
+		const pkgJsonPath = require$1.resolve("bmad-method/package.json");
+		const pkg = require$1(pkgJsonPath);
+		return pkg.version ?? "unknown";
+	} catch {
+		return "unknown";
+	}
+}
+/** BMAD baseline token total for full pipeline comparison (analysis+planning+solutioning+implementation) */
+const BMAD_BASELINE_TOKENS_FULL = 56800;
+/** BMAD baseline token total for create+dev+review comparison */
+const BMAD_BASELINE_TOKENS = 23800;
+/** Story key pattern: e.g. "10-1", "1-1a", "NEW-26", "E6" */
+const STORY_KEY_PATTERN$1 = /^[A-Za-z0-9]+(-[A-Za-z0-9]+)?$/;
+/**
+* Top-level keys in .claude/settings.json that substrate owns.
+* On init, these are set/updated unconditionally.
+* User-defined keys outside this set are never touched.
+*/
+const SUBSTRATE_OWNED_SETTINGS_KEYS = ["statusLine"];
+function getSubstrateDefaultSettings() {
+	return { statusLine: {
+		type: "command",
+		command: "bash \"$CLAUDE_PROJECT_DIR\"/.claude/statusline.sh",
+		padding: 0
+	} };
+}
+/**
+* Format output according to the requested format.
+*/
+function formatOutput(data, format, success = true, errorMessage) {
+	if (format === "json") {
+		if (!success) return JSON.stringify({
+			success: false,
+			error: errorMessage ?? "Unknown error"
+		});
+		return JSON.stringify({
+			success: true,
+			data
+		});
+	}
+	if (typeof data === "string") return data;
+	return JSON.stringify(data, null, 2);
+}
+/**
+* Build a human-readable token telemetry display from summary rows.
+*/
+function formatTokenTelemetry(summary, baselineTokens = BMAD_BASELINE_TOKENS) {
+	if (summary.length === 0) return "No token usage recorded.";
+	let totalInput = 0;
+	let totalOutput = 0;
+	let totalCost = 0;
+	const lines = ["Pipeline Token Usage:"];
+	for (const row of summary) {
+		totalInput += row.total_input_tokens;
+		totalOutput += row.total_output_tokens;
+		totalCost += row.total_cost_usd;
+		const cost = `$${row.total_cost_usd.toFixed(4)}`;
+		lines.push(`  ${row.phase} (${row.agent}): ${row.total_input_tokens.toLocaleString()} input / ${row.total_output_tokens.toLocaleString()} output (${cost})`);
+	}
+	lines.push("  " + "─".repeat(55));
+	const costDisplay = `$${totalCost.toFixed(4)}`;
+	lines.push(`  Total:  ${totalInput.toLocaleString()} input / ${totalOutput.toLocaleString()} output (${costDisplay})`);
+	const totalTokens = totalInput + totalOutput;
+	const savingsPct = baselineTokens > 0 ? Math.round((baselineTokens - totalTokens) / baselineTokens * 100) : 0;
+	const savingsLabel = savingsPct >= 0 ? `Savings: ${savingsPct}%` : `Overhead: +${Math.abs(savingsPct)}%`;
+	lines.push(`  BMAD Baseline: ${baselineTokens.toLocaleString()} tokens → ${savingsLabel}`);
+	return lines.join("\n");
+}
+/**
+* Validate a story key has the expected format: <epic>-<story> (e.g., "10-1").
+*/
+function validateStoryKey(key) {
+	return STORY_KEY_PATTERN$1.test(key);
+}
+/**
+* Build the AC5 JSON status schema for a pipeline run.
+*/
+function buildPipelineStatusOutput(run, tokenSummary, decisionsCount, storiesCount) {
+	const phases = {};
+	const phaseTokenMap = {};
+	for (const row of tokenSummary) {
+		if (!phaseTokenMap[row.phase]) phaseTokenMap[row.phase] = {
+			input: 0,
+			output: 0
+		};
+		phaseTokenMap[row.phase].input += row.total_input_tokens;
+		phaseTokenMap[row.phase].output += row.total_output_tokens;
+	}
+	let phaseHistory = [];
+	try {
+		if (run.config_json) {
+			const config = JSON.parse(run.config_json);
+			phaseHistory = config.phaseHistory ?? [];
+		}
+	} catch {}
+	const currentPhase = run.current_phase ?? null;
+	for (const phaseName of VALID_PHASES) {
+		const historyEntry = phaseHistory.find((h) => h.phase === phaseName);
+		const tokenUsage = phaseTokenMap[phaseName] ?? {
+			input: 0,
+			output: 0
+		};
+		if (historyEntry?.completedAt) {
+			phases[phaseName] = {
+				status: "complete",
+				completed_at: historyEntry.completedAt,
+				token_usage: tokenUsage
+			};
+			if (historyEntry.startedAt) phases[phaseName].started_at = historyEntry.startedAt;
+		} else if (phaseName === currentPhase || historyEntry?.startedAt) phases[phaseName] = {
+			status: "running",
+			started_at: historyEntry?.startedAt,
+			token_usage: tokenUsage
+		};
+		else phases[phaseName] = { status: "pending" };
+	}
+	let totalInput = 0;
+	let totalOutput = 0;
+	let totalCost = 0;
+	for (const row of tokenSummary) {
+		totalInput += row.total_input_tokens;
+		totalOutput += row.total_output_tokens;
+		totalCost += row.total_cost_usd;
+	}
+	let activeDispatches = 0;
+	let storiesSummary;
+	try {
+		if (run.token_usage_json) {
+			const state = JSON.parse(run.token_usage_json);
+			if (state.stories && Object.keys(state.stories).length > 0) {
+				const now = Date.now();
+				let completed = 0;
+				let inProgress = 0;
+				let escalated = 0;
+				let pending = 0;
+				const details = {};
+				for (const [key, s] of Object.entries(state.stories)) {
+					const phase = s.phase ?? "PENDING";
+					if (phase !== "PENDING" && phase !== "COMPLETE" && phase !== "ESCALATED") activeDispatches++;
+					if (phase === "COMPLETE") completed++;
+					else if (phase === "ESCALATED") escalated++;
+					else if (phase === "PENDING") pending++;
+					else inProgress++;
+					const elapsed = s.startedAt != null ? Math.max(0, Math.round((now - new Date(s.startedAt).getTime()) / 1e3)) : 0;
+					details[key] = {
+						phase,
+						review_cycles: s.reviewCycles ?? 0,
+						elapsed_seconds: elapsed
+					};
+				}
+				storiesSummary = {
+					completed,
+					in_progress: inProgress,
+					escalated,
+					pending,
+					details
+				};
+			}
+		}
+	} 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,
+		phases,
+		total_tokens: {
+			input: totalInput,
+			output: totalOutput,
+			cost_usd: totalCost
+		},
+		decisions_count: decisionsCount,
+		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 ?? "",
+		active_dispatches: activeDispatches,
+		...storiesSummary !== void 0 ? { stories: storiesSummary } : {}
+	};
+}
+/**
+* Format a pipeline status summary in human-readable format.
+*/
+function formatPipelineStatusHuman(status) {
+	const lines = [];
+	lines.push(`Pipeline Run: ${status.run_id}`);
+	lines.push(`  Current Phase: ${status.current_phase ?? "N/A"}`);
+	lines.push("");
+	lines.push("  Phase Status:");
+	const statusIcons = {
+		complete: "[DONE]",
+		running: "[RUN] ",
+		pending: "[    ]"
+	};
+	for (const [phaseName, phaseInfo] of Object.entries(status.phases)) {
+		const icon = statusIcons[phaseInfo.status] ?? "[?]";
+		let line = `    ${icon} ${phaseName}`;
+		if (phaseInfo.status === "complete" && phaseInfo.completed_at) line += ` (completed: ${phaseInfo.completed_at})`;
+		if (phaseInfo.token_usage && (phaseInfo.token_usage.input > 0 || phaseInfo.token_usage.output > 0)) line += ` — tokens: ${phaseInfo.token_usage.input.toLocaleString()} in / ${phaseInfo.token_usage.output.toLocaleString()} out`;
+		lines.push(line);
+	}
+	lines.push("");
+	lines.push(`  Total Tokens: ${(status.total_tokens.input + status.total_tokens.output).toLocaleString()} (in: ${status.total_tokens.input.toLocaleString()}, out: ${status.total_tokens.output.toLocaleString()})`);
+	lines.push(`  Total Cost: $${status.total_tokens.cost_usd.toFixed(4)}`);
+	lines.push(`  Decisions: ${status.decisions_count}`);
+	lines.push(`  Stories: ${status.stories_count}`);
+	if (status.stories !== void 0 && Object.keys(status.stories.details).length > 0) {
+		lines.push("");
+		lines.push("  Sprint Progress:");
+		lines.push("  " + "─".repeat(68));
+		lines.push(`  ${"STORY".padEnd(10)} ${"PHASE".padEnd(24)} ${"CYCLES".padEnd(8)} ELAPSED`);
+		lines.push("  " + "─".repeat(68));
+		for (const [key, detail] of Object.entries(status.stories.details)) {
+			const elapsed = detail.elapsed_seconds > 0 ? `${detail.elapsed_seconds}s` : "-";
+			lines.push(`  ${key.padEnd(10)} ${detail.phase.padEnd(24)} ${String(detail.review_cycles).padEnd(8)} ${elapsed}`);
+		}
+		lines.push("  " + "─".repeat(68));
+		lines.push(`  Completed: ${status.stories.completed}  In Progress: ${status.stories.in_progress}  Escalated: ${status.stories.escalated}  Pending: ${status.stories.pending}`);
+	}
+	return lines.join("\n");
+}
+/**
+* Format a complete pipeline run summary.
+*/
+function formatPipelineSummary(run, tokenSummary, decisionsCount, storiesCount, durationMs, format) {
+	let totalInput = 0;
+	let totalOutput = 0;
+	let totalCost = 0;
+	for (const row of tokenSummary) {
+		totalInput += row.total_input_tokens;
+		totalOutput += row.total_output_tokens;
+		totalCost += row.total_cost_usd;
+	}
+	const totalTokens = totalInput + totalOutput;
+	const savingsPct = BMAD_BASELINE_TOKENS_FULL > 0 ? Math.round((BMAD_BASELINE_TOKENS_FULL - totalTokens) / BMAD_BASELINE_TOKENS_FULL * 100) : 0;
+	const durationSec = Math.round(durationMs / 1e3);
+	if (format === "json") return JSON.stringify({
+		run_id: run.id,
+		status: run.status,
+		duration_ms: durationMs,
+		phases_completed: VALID_PHASES.length,
+		decisions_count: decisionsCount,
+		stories_count: storiesCount,
+		token_usage: {
+			input: totalInput,
+			output: totalOutput,
+			total: totalTokens,
+			cost_usd: totalCost,
+			bmad_baseline: BMAD_BASELINE_TOKENS_FULL,
+			savings_pct: savingsPct
+		}
+	});
+	const lines = [
+		"┌─────────────────────────────────────────────────────┐",
+		"│              Pipeline Run Summary                    │",
+		"└─────────────────────────────────────────────────────┘",
+		`  Run ID:          ${run.id}`,
+		`  Status:          ${run.status}`,
+		`  Duration:        ${durationSec}s`,
+		`  Phases Complete: ${VALID_PHASES.length}`,
+		`  Decisions:       ${decisionsCount}`,
+		`  Stories:         ${storiesCount}`,
+		"",
+		`  Token Usage:     ${totalTokens.toLocaleString()} total`,
+		`    Input:         ${totalInput.toLocaleString()}`,
+		`    Output:        ${totalOutput.toLocaleString()}`,
+		`    Cost:          $${totalCost.toFixed(4)}`,
+		"",
+		`  BMAD Baseline:   ${BMAD_BASELINE_TOKENS_FULL.toLocaleString()} tokens`,
+		`  Token Savings:   ${savingsPct >= 0 ? savingsPct + "%" : "N/A (overhead)"}`
+	];
+	return lines.join("\n");
+}
+
+//#endregion
+//#region src/modules/work-graph/cycle-detector.ts
+/**
+* detectCycles — DFS-based cycle detection for story dependency graphs.
+*
+* Story 31-7: Cycle Detection in Work Graph
+*
+* Pure function; no database or I/O dependencies.
+*/
+/**
+* Detect cycles in a directed dependency graph represented as an edge list.
+*
+* Each edge `{ story_key, depends_on }` means story_key depends on depends_on
+* (i.e. story_key → depends_on is the directed edge we traverse).
+*
+* Uses iterative DFS with an explicit stack to avoid call-stack overflows on
+* large graphs, but also supports a nested recursive helper for cycle path
+* reconstruction.
+*
+* @param edges - List of dependency edges to check.
+* @returns `null` if the graph is acyclic (safe to persist), or a `string[]`
+*   containing the cycle path with the first and last element being the same
+*   story key (e.g. `['A', 'B', 'A']`).
+*/
+function detectCycles(edges) {
+	const adj = new Map();
+	for (const { story_key, depends_on } of edges) {
+		if (!adj.has(story_key)) adj.set(story_key, []);
+		adj.get(story_key).push(depends_on);
+	}
+	const visited = new Set();
+	const visiting = new Set();
+	const path$1 = [];
+	function dfs(node) {
+		if (visiting.has(node)) {
+			const cycleStart = path$1.indexOf(node);
+			return [...path$1.slice(cycleStart), node];
+		}
+		if (visited.has(node)) return null;
+		visiting.add(node);
+		path$1.push(node);
+		for (const neighbor of adj.get(node) ?? []) {
+			const cycle = dfs(neighbor);
+			if (cycle !== null) return cycle;
+		}
+		path$1.pop();
+		visiting.delete(node);
+		visited.add(node);
+		return null;
+	}
+	const allNodes = new Set([...edges.map((e) => e.story_key), ...edges.map((e) => e.depends_on)]);
+	for (const node of allNodes) if (!visited.has(node)) {
+		const cycle = dfs(node);
+		if (cycle !== null) return cycle;
+	}
+	return null;
+}
+
+//#endregion
+//#region src/modules/state/work-graph-repository.ts
+var WorkGraphRepository = class {
+	constructor(db) {
+		this.db = db;
+	}
+	/**
+	* Insert or replace a work-graph story node.
+	* Uses DELETE + INSERT so it works on InMemoryDatabaseAdapter (which does
+	* not support ON DUPLICATE KEY UPDATE).
+	*/
+	async upsertStory(story) {
+		await this.db.query(`DELETE FROM wg_stories WHERE story_key = ?`, [story.story_key]);
+		await this.db.query(`INSERT INTO wg_stories (story_key, epic, title, status, spec_path, created_at, updated_at, completed_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`, [
+			story.story_key,
+			story.epic,
+			story.title ?? null,
+			story.status,
+			story.spec_path ?? null,
+			story.created_at ?? null,
+			story.updated_at ?? null,
+			story.completed_at ?? null
+		]);
+	}
+	/**
+	* Insert a dependency edge.  Idempotent — if a row with the same
+	* (story_key, depends_on) already exists it is silently skipped.
+	*/
+	async addDependency(dep) {
+		const existing = await this.db.query(`SELECT story_key FROM story_dependencies WHERE story_key = ? AND depends_on = ?`, [dep.story_key, dep.depends_on]);
+		if (existing.length > 0) return;
+		await this.db.query(`INSERT INTO story_dependencies (story_key, depends_on, dependency_type, source, created_at) VALUES (?, ?, ?, ?, ?)`, [
+			dep.story_key,
+			dep.depends_on,
+			dep.dependency_type,
+			dep.source,
+			dep.created_at ?? null
+		]);
+	}
+	/**
+	* Persist contract-based dependency edges to `story_dependencies` as
+	* best-effort, idempotent writes.
+	*
+	* - edges where `reason` does NOT start with `'dual export:'` are persisted
+	*   as `dependency_type = 'blocks'` (hard prerequisites).
+	* - edges where `reason` starts with `'dual export:'` are persisted as
+	*   `dependency_type = 'informs'` (serialization hints, not hard gates).
+	*
+	* Idempotency is delegated to `addDependency()`, which skips the INSERT if
+	* a row with the same `(story_key, depends_on)` already exists.
+	*
+	* @param edges - Readonly list of contract dependency edges to persist.
+	*/
+	async addContractDependencies(edges) {
+		if (edges.length === 0) return;
+		for (const edge of edges) {
+			const dependency_type = edge.reason?.startsWith("dual export:") ? "informs" : "blocks";
+			await this.addDependency({
+				story_key: edge.to,
+				depends_on: edge.from,
+				dependency_type,
+				source: "contract",
+				created_at: new Date().toISOString()
+			});
+		}
+	}
+	/**
+	* Return all work-graph stories, optionally filtered by epic and/or status.
+	*/
+	async listStories(filter) {
+		if (!filter || !filter.epic && !filter.status) return this.db.query(`SELECT * FROM wg_stories`);
+		const conditions = [];
+		const params = [];
+		if (filter.epic) {
+			conditions.push(`epic = ?`);
+			params.push(filter.epic);
+		}
+		if (filter.status) {
+			conditions.push(`status = ?`);
+			params.push(filter.status);
+		}
+		const where = conditions.join(" AND ");
+		return this.db.query(`SELECT * FROM wg_stories WHERE ${where}`, params);
+	}
+	/**
+	* Update the `status` (and optionally `completed_at`) of an existing
+	* work-graph story.
+	*
+	* This is a read-modify-write operation: SELECT existing row → build
+	* updated WgStory → upsertStory(). If no row exists for `storyKey` the
+	* call is a no-op (AC4).
+	*
+	* @param storyKey - Story identifier, e.g. "31-4"
+	* @param status   - Target WgStoryStatus value
+	* @param opts     - Optional `completedAt` ISO string for terminal phases
+	*/
+	async updateStoryStatus(storyKey, status, opts) {
+		const rows = await this.db.query(`SELECT * FROM wg_stories WHERE story_key = ?`, [storyKey]);
+		if (rows.length === 0) return;
+		const existing = rows[0];
+		const now = new Date().toISOString();
+		const isTerminal = status === "complete" || status === "escalated";
+		const updated = {
+			...existing,
+			status,
+			updated_at: now,
+			completed_at: isTerminal ? opts?.completedAt ?? now : existing.completed_at
+		};
+		await this.upsertStory(updated);
+	}
+	/**
+	* Return stories that are eligible for dispatch.
+	*
+	* A story is ready when:
+	*   1. Its status is 'planned' or 'ready', AND
+	*   2. It has no 'blocks' dependency whose blocking story is not 'complete'.
+	*
+	* Soft ('informs') dependencies never block dispatch.
+	*
+	* This is implemented programmatically rather than via the `ready_stories`
+	* VIEW so that the InMemoryDatabaseAdapter can handle it without VIEW support.
+	*/
+	async getReadyStories() {
+		const allStories = await this.db.query(`SELECT * FROM wg_stories`);
+		const candidates = allStories.filter((s) => s.status === "planned" || s.status === "ready");
+		if (candidates.length === 0) return [];
+		const deps = await this.db.query(`SELECT story_key, depends_on FROM story_dependencies WHERE dependency_type = 'blocks'`);
+		if (deps.length === 0) return candidates;
+		const blockerStatus = new Map(allStories.map((s) => [s.story_key, s.status]));
+		const depsMap = new Map();
+		for (const d of deps) {
+			if (!depsMap.has(d.story_key)) depsMap.set(d.story_key, []);
+			depsMap.get(d.story_key).push(d.depends_on);
+		}
+		return candidates.filter((s) => {
+			const blocking = depsMap.get(s.story_key) ?? [];
+			return blocking.every((dep) => blockerStatus.get(dep) === "complete");
+		});
+	}
+	/**
+	* Return stories that are planned/ready but cannot be dispatched because
+	* at least one hard-blocking ('blocks') dependency is not yet complete.
+	*
+	* For each blocked story, the returned object includes the full WgStory
+	* record plus the list of unsatisfied blockers (key, title, status).
+	*
+	* Soft ('informs') dependencies are ignored here, matching getReadyStories().
+	*/
+	/**
+	* Query the database for all 'blocks' dependency rows and run DFS cycle
+	* detection over them.
+	*
+	* Returns an empty array if no cycle is found (consistent with other
+	* repository methods that return empty arrays rather than null).
+	*
+	* Only 'blocks' deps are checked — soft 'informs' deps cannot cause
+	* dispatch deadlocks (AC5).
+	*/
+	async detectCycles() {
+		const rows = await this.db.query(`SELECT story_key, depends_on FROM story_dependencies WHERE dependency_type = 'blocks'`);
+		const cycle = detectCycles(rows);
+		return cycle ?? [];
+	}
+	async getBlockedStories() {
+		const allStories = await this.db.query(`SELECT * FROM wg_stories`);
+		const candidates = allStories.filter((s) => s.status === "planned" || s.status === "ready");
+		if (candidates.length === 0) return [];
+		const deps = await this.db.query(`SELECT story_key, depends_on FROM story_dependencies WHERE dependency_type = 'blocks'`);
+		if (deps.length === 0) return [];
+		const statusMap = new Map(allStories.map((s) => [s.story_key, s]));
+		const depsMap = new Map();
+		for (const d of deps) {
+			if (!depsMap.has(d.story_key)) depsMap.set(d.story_key, []);
+			depsMap.get(d.story_key).push(d.depends_on);
+		}
+		const result = [];
+		for (const story of candidates) {
+			const blockerKeys = depsMap.get(story.story_key) ?? [];
+			const unsatisfied = blockerKeys.filter((key) => statusMap.get(key)?.status !== "complete").map((key) => {
+				const s = statusMap.get(key);
+				return {
+					key,
+					title: s?.title ?? key,
+					status: s?.status ?? "unknown"
+				};
+			});
+			if (unsatisfied.length > 0) result.push({
+				story,
+				blockers: unsatisfied
+			});
+		}
+		return result;
+	}
+};
+
+//#endregion
+//#region src/modules/state/file-store.ts
+/**
+* In-memory / file-backed StateStore implementation.
+*
+* Suitable for CI environments and testing where orchestrator state is
+* ephemeral. Use DoltStateStore for branch-per-story isolation and versioned
+* history in production.
+*/
+var FileStateStore = class {
+	_basePath;
+	_stories = new Map();
+	_metrics = [];
+	_contracts = new Map();
+	_contractVerifications = new Map();
+	/** Key-value metrics store: outer key = runId, inner key = metric key */
+	_kvMetrics = new Map();
+	constructor(options = {}) {
+		this._basePath = options.basePath;
+	}
+	async initialize() {}
+	async close() {}
+	async getStoryState(storyKey) {
+		return this._stories.get(storyKey);
+	}
+	async setStoryState(storyKey, state) {
+		this._stories.set(storyKey, {
+			...state,
+			storyKey
+		});
+	}
+	async queryStories(filter) {
+		const all = Array.from(this._stories.values());
+		return all.filter((record) => {
+			if (filter.phase !== void 0) {
+				const phases = Array.isArray(filter.phase) ? filter.phase : [filter.phase];
+				if (!phases.includes(record.phase)) return false;
+			}
+			if (filter.sprint !== void 0 && record.sprint !== filter.sprint) return false;
+			if (filter.storyKey !== void 0 && record.storyKey !== filter.storyKey) return false;
+			return true;
+		});
+	}
+	async recordMetric(metric) {
+		const record = {
+			...metric,
+			recordedAt: metric.recordedAt ?? new Date().toISOString()
+		};
+		this._metrics.push(record);
+	}
+	async queryMetrics(filter) {
+		const storyKey = filter.storyKey ?? filter.story_key;
+		const taskType = filter.taskType ?? filter.task_type;
+		return this._metrics.filter((m) => {
+			if (storyKey !== void 0 && m.storyKey !== storyKey) return false;
+			if (taskType !== void 0 && m.taskType !== taskType) return false;
+			if (filter.sprint !== void 0 && m.sprint !== filter.sprint) return false;
+			if (filter.dateFrom !== void 0 && m.recordedAt !== void 0 && m.recordedAt < filter.dateFrom) return false;
+			if (filter.dateTo !== void 0 && m.recordedAt !== void 0 && m.recordedAt > filter.dateTo) return false;
+			if (filter.since !== void 0 && m.recordedAt !== void 0 && m.recordedAt < filter.since) return false;
+			return true;
+		});
+	}
+	/**
+	* Persist an arbitrary key-value metric for a run.
+	* Stored in memory AND written to `{basePath}/kv-metrics.json` when basePath is set.
+	*/
+	async setMetric(runId, key, value) {
+		let runMap = this._kvMetrics.get(runId);
+		if (runMap === void 0) {
+			runMap = new Map();
+			this._kvMetrics.set(runId, runMap);
+		}
+		runMap.set(key, value);
+		if (this._basePath !== void 0) await this._flushKvMetrics();
+	}
+	/**
+	* Retrieve a previously stored key-value metric for a run.
+	* Reads from in-memory cache, falling back to the JSON file when basePath is set.
+	*/
+	async getMetric(runId, key) {
+		const inMemory = this._kvMetrics.get(runId)?.get(key);
+		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 parsed = JSON.parse(content);
+			return parsed[runId]?.[key] ?? void 0;
+		} catch {}
+		return void 0;
+	}
+	/** Serialize the in-memory kv metrics map to JSON on disk. */
+	async _flushKvMetrics() {
+		if (this._basePath === void 0) return;
+		const serialized = {};
+		for (const [runId, runMap] of this._kvMetrics) {
+			serialized[runId] = {};
+			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");
+	}
+	async getContracts(storyKey) {
+		return this._contracts.get(storyKey) ?? [];
+	}
+	async setContracts(storyKey, contracts) {
+		this._contracts.set(storyKey, contracts.map((c) => ({ ...c })));
+	}
+	async queryContracts(filter) {
+		const all = [];
+		for (const records of this._contracts.values()) for (const r of records) all.push(r);
+		return all.filter((r) => {
+			if (filter?.storyKey !== void 0 && r.storyKey !== filter.storyKey) return false;
+			if (filter?.direction !== void 0 && r.direction !== filter.direction) return false;
+			return true;
+		});
+	}
+	async setContractVerification(storyKey, results) {
+		this._contractVerifications.set(storyKey, results.map((r) => ({ ...r })));
+		if (this._basePath !== void 0) {
+			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");
+		}
+	}
+	async getContractVerification(storyKey) {
+		return this._contractVerifications.get(storyKey) ?? [];
+	}
+	async branchForStory(_storyKey) {}
+	async mergeStory(_storyKey) {}
+	async rollbackStory(_storyKey) {}
+	async diffStory(storyKey) {
+		return {
+			storyKey,
+			tables: []
+		};
+	}
+	async getHistory(_limit) {
+		return [];
+	}
+};
+
+//#endregion
+//#region src/modules/state/dolt-store.ts
+const log = createLogger("modules:state:dolt");
+/**
+* Validate that a story key matches the expected pattern (e.g. "26-7", "1-1a", "NEW-26", "E6").
+* Prevents SQL injection via string-interpolated identifiers.
+*/
+const STORY_KEY_PATTERN = /^[A-Za-z0-9]+(-[A-Za-z0-9]+)?$/;
+function assertValidStoryKey(storyKey) {
+	if (!STORY_KEY_PATTERN.test(storyKey)) throw new DoltQueryError("assertValidStoryKey", `Invalid story key: '${storyKey}'. Must match pattern <key> or <epic>-<story> (e.g. "E6", "10-1", "1-1a", "NEW-26").`);
+}
+/**
+* Dolt-backed implementation of the StateStore interface.
+*
+* Constructor accepts a deps object for DI: `{ repoPath, client }`.
+* Call `initialize()` before any CRUD operations.
+*/
+var DoltStateStore = class DoltStateStore {
+	_repoPath;
+	_client;
+	_storyBranches = new Map();
+	constructor(options) {
+		this._repoPath = options.repoPath;
+		this._client = options.client;
+	}
+	/**
+	* Return the branch name for a story if one has been created via branchForStory(),
+	* or undefined to use the default (main) branch.
+	*/
+	_branchFor(storyKey) {
+		return this._storyBranches.get(storyKey);
+	}
+	async initialize() {
+		await this._client.connect();
+		await this._runMigrations();
+		await this.flush("substrate: schema migrations");
+		log.debug("DoltStateStore initialized at %s", this._repoPath);
+	}
+	async close() {
+		await this._client.close();
+	}
+	async _runMigrations() {
+		const ddl = [
+			`CREATE TABLE IF NOT EXISTS stories (
+        story_key     VARCHAR(100) NOT NULL,
+        phase         VARCHAR(30)  NOT NULL DEFAULT 'PENDING',
+        review_cycles INT          NOT NULL DEFAULT 0,
+        last_verdict  VARCHAR(64)  NULL,
+        error         TEXT         NULL,
+        started_at    VARCHAR(64)  NULL,
+        completed_at  VARCHAR(64)  NULL,
+        sprint        VARCHAR(50)  NULL,
+        PRIMARY KEY (story_key)
+      )`,
+			`CREATE TABLE IF NOT EXISTS metrics (
+        id              BIGINT       NOT NULL AUTO_INCREMENT,
+        story_key       VARCHAR(100) NOT NULL,
+        task_type       VARCHAR(100) NOT NULL,
+        model           VARCHAR(100) NULL,
+        tokens_in       BIGINT       NULL,
+        tokens_out      BIGINT       NULL,
+        cache_read_tokens BIGINT     NULL,
+        cost_usd        DOUBLE       NULL,
+        wall_clock_ms   BIGINT       NULL,
+        review_cycles   INT          NULL,
+        stall_count     INT          NULL,
+        result          VARCHAR(30)  NULL,
+        recorded_at     VARCHAR(64)  NULL,
+        sprint          VARCHAR(50)  NULL,
+        PRIMARY KEY (id)
+      )`,
+			`CREATE TABLE IF NOT EXISTS contracts (
+        story_key     VARCHAR(100) NOT NULL,
+        contract_name VARCHAR(200) NOT NULL,
+        direction     VARCHAR(20)  NOT NULL,
+        schema_path   VARCHAR(500) NULL,
+        transport     VARCHAR(200) NULL,
+        PRIMARY KEY (story_key, contract_name, direction)
+      )`,
+			`CREATE TABLE IF NOT EXISTS review_verdicts (
+        id            BIGINT       NOT NULL AUTO_INCREMENT,
+        story_key     VARCHAR(100) NOT NULL,
+        task_type     VARCHAR(100) NOT NULL,
+        verdict       VARCHAR(64)  NOT NULL,
+        issues_count  INT          NULL,
+        notes         TEXT         NULL,
+        timestamp     VARCHAR(64)  NULL,
+        PRIMARY KEY (id)
+      )`
+		];
+		for (const sql of ddl) await this._client.query(sql);
+		try {
+			const colRows = await this._client.query(`SHOW COLUMNS FROM repo_map_symbols LIKE 'dependencies'`);
+			if (colRows.length === 0) {
+				await this._client.query(`ALTER TABLE repo_map_symbols ADD COLUMN dependencies JSON`);
+				await this._client.query(`INSERT IGNORE INTO _schema_version (version, description) VALUES (6, 'Add dependencies JSON column to repo_map_symbols (Epic 28-3)')`);
+				log.info({
+					component: "dolt-state",
+					migration: "v5-to-v6",
+					column: "dependencies",
+					table: "repo_map_symbols"
+				}, "Applied migration v5-to-v6: added dependencies column to repo_map_symbols");
+			}
+		} catch {
+			log.debug("Skipping repo_map_symbols migration: table not yet created");
+		}
+		log.debug("Schema migrations applied");
+	}
+	/**
+	* Commit pending Dolt changes on the current branch.
+	* Callers can invoke this after a batch of writes for explicit durability.
+	*/
+	async flush(message = "substrate: auto-commit") {
+		try {
+			await this._client.execArgs(["add", "."]);
+			await this._client.execArgs([
+				"commit",
+				"--allow-empty",
+				"-m",
+				message
+			]);
+			log.debug("Dolt flush committed: %s", message);
+		} catch (err) {
+			const detail = err instanceof Error ? err.message : String(err);
+			log.warn({ detail }, "Dolt flush failed (non-fatal)");
+		}
+	}
+	async getStoryState(storyKey) {
+		const rows = await this._client.query("SELECT * FROM stories WHERE story_key = ?", [storyKey]);
+		if (rows.length === 0) return void 0;
+		return this._rowToStory(rows[0]);
+	}
+	async setStoryState(storyKey, state) {
+		const branch = this._branchFor(storyKey);
+		const sql = `REPLACE INTO stories
+      (story_key, phase, review_cycles, last_verdict, error, started_at, completed_at, sprint)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?)`;
+		await this._client.query(sql, [
+			storyKey,
+			state.phase,
+			state.reviewCycles,
+			state.lastVerdict ?? null,
+			state.error ?? null,
+			state.startedAt ?? null,
+			state.completedAt ?? null,
+			state.sprint ?? null
+		], branch);
+	}
+	async queryStories(filter) {
+		const conditions = [];
+		const params = [];
+		if (filter.phase !== void 0) {
+			const phases = Array.isArray(filter.phase) ? filter.phase : [filter.phase];
+			const placeholders = phases.map(() => "?").join(", ");
+			conditions.push(`phase IN (${placeholders})`);
+			params.push(...phases);
+		}
+		if (filter.sprint !== void 0) {
+			conditions.push("sprint = ?");
+			params.push(filter.sprint);
+		}
+		if (filter.storyKey !== void 0) {
+			conditions.push("story_key = ?");
+			params.push(filter.storyKey);
+		}
+		const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+		const sql = `SELECT * FROM stories ${where} ORDER BY story_key`;
+		const rows = await this._client.query(sql, params);
+		return rows.map((r) => this._rowToStory(r));
+	}
+	_rowToStory(row) {
+		return {
+			storyKey: row.story_key,
+			phase: row.phase,
+			reviewCycles: Number(row.review_cycles),
+			lastVerdict: row.last_verdict ?? void 0,
+			error: row.error ?? void 0,
+			startedAt: row.started_at ?? void 0,
+			completedAt: row.completed_at ?? void 0,
+			sprint: row.sprint ?? void 0
+		};
+	}
+	async recordMetric(metric) {
+		const branch = this._branchFor(metric.storyKey);
+		const recordedAt = metric.recordedAt ?? metric.timestamp ?? new Date().toISOString();
+		const sql = `INSERT INTO metrics
+      (story_key, task_type, model, tokens_in, tokens_out, cache_read_tokens,
+       cost_usd, wall_clock_ms, review_cycles, stall_count, result, recorded_at, sprint)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`;
+		await this._client.query(sql, [
+			metric.storyKey,
+			metric.taskType,
+			metric.model ?? null,
+			metric.tokensIn ?? null,
+			metric.tokensOut ?? null,
+			metric.cacheReadTokens ?? null,
+			metric.costUsd ?? null,
+			metric.wallClockMs ?? null,
+			metric.reviewCycles ?? null,
+			metric.stallCount ?? null,
+			metric.result ?? null,
+			recordedAt,
+			metric.sprint ?? null
+		], branch);
+	}
+	async queryMetrics(filter) {
+		const conditions = [];
+		const params = [];
+		const storyKey = filter.storyKey ?? filter.story_key;
+		const taskType = filter.taskType ?? filter.task_type;
+		if (storyKey !== void 0) {
+			conditions.push("story_key = ?");
+			params.push(storyKey);
+		}
+		if (taskType !== void 0) {
+			conditions.push("task_type = ?");
+			params.push(taskType);
+		}
+		if (filter.sprint !== void 0) {
+			conditions.push("sprint = ?");
+			params.push(filter.sprint);
+		}
+		if (filter.dateFrom !== void 0) {
+			conditions.push("recorded_at >= ?");
+			params.push(filter.dateFrom);
+		}
+		if (filter.dateTo !== void 0) {
+			conditions.push("recorded_at <= ?");
+			params.push(filter.dateTo);
+		}
+		if (filter.since !== void 0) {
+			conditions.push("recorded_at >= ?");
+			params.push(filter.since);
+		}
+		const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+		if (filter.aggregate) {
+			const sql$1 = `SELECT task_type,
+        AVG(cost_usd) AS avg_cost_usd,
+        SUM(tokens_in) AS sum_tokens_in,
+        SUM(tokens_out) AS sum_tokens_out,
+        COUNT(*) AS count
+        FROM metrics ${where} GROUP BY task_type ORDER BY task_type`;
+			const aggRows = await this._client.query(sql$1, params);
+			return aggRows.map((r) => this._aggregateRowToMetric(r));
+		}
+		const sql = `SELECT * FROM metrics ${where} ORDER BY id`;
+		const rows = await this._client.query(sql, params);
+		return rows.map((r) => this._rowToMetric(r));
+	}
+	_aggregateRowToMetric(row) {
+		return {
+			storyKey: "",
+			taskType: row.task_type,
+			costUsd: row.avg_cost_usd ?? void 0,
+			tokensIn: row.sum_tokens_in ?? void 0,
+			tokensOut: row.sum_tokens_out ?? void 0,
+			count: row.count,
+			result: "aggregate"
+		};
+	}
+	_rowToMetric(row) {
+		return {
+			storyKey: row.story_key,
+			taskType: row.task_type,
+			model: row.model ?? void 0,
+			tokensIn: row.tokens_in ?? void 0,
+			tokensOut: row.tokens_out ?? void 0,
+			cacheReadTokens: row.cache_read_tokens ?? void 0,
+			costUsd: row.cost_usd ?? void 0,
+			wallClockMs: row.wall_clock_ms ?? void 0,
+			reviewCycles: row.review_cycles ?? void 0,
+			stallCount: row.stall_count ?? void 0,
+			result: row.result ?? void 0,
+			recordedAt: row.recorded_at ?? void 0,
+			sprint: row.sprint ?? void 0,
+			timestamp: row.timestamp ?? row.recorded_at ?? void 0
+		};
+	}
+	async getContracts(storyKey) {
+		const rows = await this._client.query("SELECT * FROM contracts WHERE story_key = ? ORDER BY contract_name", [storyKey]);
+		return rows.map((r) => this._rowToContract(r));
+	}
+	async setContracts(storyKey, contracts) {
+		const branch = this._branchFor(storyKey);
+		await this._client.query("DELETE FROM contracts WHERE story_key = ?", [storyKey], branch);
+		for (const c of contracts) await this._client.query(`INSERT INTO contracts (story_key, contract_name, direction, schema_path, transport)
+         VALUES (?, ?, ?, ?, ?)`, [
+			c.storyKey,
+			c.contractName,
+			c.direction,
+			c.schemaPath,
+			c.transport ?? null
+		], branch);
+	}
+	_rowToContract(row) {
+		return {
+			storyKey: row.story_key,
+			contractName: row.contract_name,
+			direction: row.direction,
+			schemaPath: row.schema_path,
+			transport: row.transport ?? void 0
+		};
+	}
+	async queryContracts(filter) {
+		const conditions = [];
+		const params = [];
+		if (filter?.storyKey !== void 0) {
+			conditions.push("story_key = ?");
+			params.push(filter.storyKey);
+		}
+		if (filter?.direction !== void 0) {
+			conditions.push("direction = ?");
+			params.push(filter.direction);
+		}
+		const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+		const sql = `SELECT * FROM contracts ${where} ORDER BY story_key, contract_name`;
+		const rows = await this._client.query(sql, params);
+		return rows.map((r) => this._rowToContract(r));
+	}
+	async setContractVerification(storyKey, results) {
+		const branch = this._branchFor(storyKey);
+		await this._client.query(`DELETE FROM review_verdicts WHERE story_key = ? AND task_type = 'contract-verification'`, [storyKey], branch);
+		const failCount = results.filter((r) => r.verdict === "fail").length;
+		for (const r of results) await this._client.query(`INSERT INTO review_verdicts (story_key, task_type, verdict, issues_count, notes, timestamp)
+         VALUES (?, 'contract-verification', ?, ?, ?, ?)`, [
+			storyKey,
+			r.verdict,
+			failCount,
+			JSON.stringify({
+				contractName: r.contractName,
+				mismatchDescription: r.mismatchDescription
+			}),
+			r.verifiedAt
+		], branch);
+	}
+	async getContractVerification(storyKey) {
+		const rows = await this._client.query(`SELECT * FROM review_verdicts WHERE story_key = ? AND task_type = 'contract-verification' ORDER BY timestamp DESC`, [storyKey]);
+		return rows.map((row) => {
+			let contractName = "";
+			let mismatchDescription;
+			if (row.notes !== null) try {
+				const parsed = JSON.parse(row.notes);
+				if (typeof parsed.contractName === "string") contractName = parsed.contractName;
+				if (typeof parsed.mismatchDescription === "string") mismatchDescription = parsed.mismatchDescription;
+			} catch {}
+			return {
+				storyKey: row.story_key,
+				contractName,
+				verdict: row.verdict,
+				...mismatchDescription !== void 0 ? { mismatchDescription } : {},
+				verifiedAt: row.timestamp ?? new Date().toISOString()
+			};
+		});
+	}
+	async branchForStory(storyKey) {
+		assertValidStoryKey(storyKey);
+		const branchName = `story/${storyKey}`;
+		try {
+			await this._client.query(`CALL DOLT_BRANCH('${branchName}')`, [], "main");
+			this._storyBranches.set(storyKey, branchName);
+			log.debug("Created Dolt branch %s for story %s", branchName, storyKey);
+		} catch (err) {
+			const detail = err instanceof Error ? err.message : String(err);
+			throw new DoltQueryError(`CALL DOLT_BRANCH('${branchName}')`, detail);
+		}
+	}
+	async mergeStory(storyKey) {
+		assertValidStoryKey(storyKey);
+		const branchName = this._storyBranches.get(storyKey);
+		if (branchName === void 0) {
+			log.warn({ storyKey }, "mergeStory called but no branch registered — no-op");
+			return;
+		}
+		try {
+			try {
+				await this._client.query(`CALL DOLT_ADD('-A')`, [], branchName);
+				await this._client.query(`CALL DOLT_COMMIT('-m', 'Story ${storyKey}: pre-merge commit', '--allow-empty')`, [], branchName);
+			} catch {}
+			try {
+				await this._client.query(`CALL DOLT_ADD('-A')`, [], "main");
+				await this._client.query(`CALL DOLT_COMMIT('-m', 'substrate: pre-merge auto-commit', '--allow-empty')`, [], "main");
+			} catch {}
+			const mergeRows = await this._client.query(`CALL DOLT_MERGE('${branchName}')`, [], "main");
+			const mergeResult = mergeRows[0];
+			if (mergeResult && (mergeResult.conflicts ?? 0) > 0) {
+				let table = "stories";
+				let rowKey = "unknown";
+				let ourValue;
+				let theirValue;
+				try {
+					const conflictRows = await this._client.query(`SELECT * FROM dolt_conflicts_stories LIMIT 1`, [], "main");
+					if (conflictRows.length > 0) {
+						const row = conflictRows[0];
+						rowKey = String(row["base_story_key"] ?? row["our_story_key"] ?? "unknown");
+						ourValue = JSON.stringify(row["our_status"] ?? row);
+						theirValue = JSON.stringify(row["their_status"] ?? row);
+					}
+				} catch {}
+				this._storyBranches.delete(storyKey);
+				throw new DoltMergeConflictError(table, [rowKey], {
+					rowKey,
+					ourValue,
+					theirValue
+				});
+			}
+			try {
+				await this._client.query(`CALL DOLT_COMMIT('-m', 'Merge story ${storyKey}: COMPLETE')`, [], "main");
+			} catch (commitErr) {
+				const msg = commitErr instanceof Error ? commitErr.message : String(commitErr);
+				if (!msg.includes("nothing to commit")) throw commitErr;
+			}
+			this._storyBranches.delete(storyKey);
+			log.debug("Merged branch %s into main for story %s", branchName, storyKey);
+		} catch (err) {
+			if (err instanceof DoltMergeConflictError) throw err;
+			const detail = err instanceof Error ? err.message : String(err);
+			throw new DoltQueryError(`CALL DOLT_MERGE('${branchName}')`, detail);
+		}
+	}
+	async rollbackStory(storyKey) {
+		assertValidStoryKey(storyKey);
+		const branchName = this._storyBranches.get(storyKey);
+		if (branchName === void 0) {
+			log.warn({ storyKey }, "rollbackStory called but no branch registered — no-op");
+			return;
+		}
+		try {
+			await this._client.query(`CALL DOLT_BRANCH('-D', '${branchName}')`, [], "main");
+			this._storyBranches.delete(storyKey);
+			log.debug("Rolled back (deleted) branch %s for story %s", branchName, storyKey);
+		} catch (err) {
+			const detail = err instanceof Error ? err.message : String(err);
+			log.warn({
+				detail,
+				storyKey,
+				branchName
+			}, "rollbackStory failed (non-fatal)");
+			this._storyBranches.delete(storyKey);
+		}
+	}
+	/**
+	* Tables queried by diffStory(). Each table is checked for row-level changes
+	* via SELECT * FROM DOLT_DIFF('main', branchName, tableName).
+	*/
+	static DIFF_TABLES = [
+		"stories",
+		"contracts",
+		"metrics",
+		"dispatch_log",
+		"build_results",
+		"review_verdicts"
+	];
+	async diffStory(storyKey) {
+		assertValidStoryKey(storyKey);
+		const branchName = this._storyBranches.get(storyKey);
+		if (branchName === void 0) return this._diffMergedStory(storyKey);
+		try {
+			await this._client.query(`CALL DOLT_ADD('-A')`, [], branchName);
+			await this._client.query(`CALL DOLT_COMMIT('-m', 'Story ${storyKey}: pre-diff snapshot', '--allow-empty')`, [], branchName);
+		} catch {}
+		return this._diffRange("main", branchName, storyKey);
+	}
+	/**
+	* Diff a merged story by finding its merge commit in the Dolt log.
+	* Queries the `dolt_log` system table for commits referencing the story,
+	* then diffs `<hash>~1` vs `<hash>` for row-level changes.
+	*/
+	async _diffMergedStory(storyKey) {
+		try {
+			const rows = await this._client.query(`SELECT commit_hash FROM dolt_log WHERE message LIKE ? LIMIT 1`, [`%${storyKey}%`]);
+			if (rows.length === 0) return {
+				storyKey,
+				tables: []
+			};
+			const hash = String(rows[0].commit_hash);
+			if (!hash) return {
+				storyKey,
+				tables: []
+			};
+			return this._diffRange(`${hash}~1`, hash, storyKey);
+		} catch {
+			return {
+				storyKey,
+				tables: []
+			};
+		}
+	}
+	/**
+	* Compute row-level diffs between two Dolt revisions (branches or commit hashes)
+	* across all tracked tables.
+	*/
+	async _diffRange(fromRef, toRef, storyKey) {
+		const tableDiffs = [];
+		for (const table of DoltStateStore.DIFF_TABLES) try {
+			const rows = await this._client.query(`SELECT * FROM DOLT_DIFF('${fromRef}', '${toRef}', '${table}')`, [], "main");
+			if (rows.length === 0) continue;
+			const added = [];
+			const modified = [];
+			const deleted = [];
+			for (const row of rows) {
+				const diffType = row["diff_type"];
+				const rowKey = this._extractRowKey(row);
+				const before = this._extractPrefixedFields(row, "before_");
+				const after = this._extractPrefixedFields(row, "after_");
+				const diffRow = {
+					rowKey,
+					...before !== void 0 && { before },
+					...after !== void 0 && { after }
+				};
+				if (diffType === "added") added.push(diffRow);
+				else if (diffType === "modified") modified.push(diffRow);
+				else if (diffType === "removed") deleted.push(diffRow);
+			}
+			if (added.length > 0 || modified.length > 0 || deleted.length > 0) tableDiffs.push({
+				table,
+				added,
+				modified,
+				deleted
+			});
+		} catch {}
+		return {
+			storyKey,
+			tables: tableDiffs
+		};
+	}
+	/**
+	* Extract a human-readable row key from a DOLT_DIFF result row.
+	* Tries after_ fields first (for added/modified rows), then before_ fields
+	* (for removed rows). Skips commit_hash pseudo-columns.
+	*/
+	_extractRowKey(row) {
+		for (const prefix of ["after_", "before_"]) for (const [key, val] of Object.entries(row)) if (key.startsWith(prefix) && !key.endsWith("_commit_hash") && val !== null && val !== void 0) return String(val);
+		return "unknown";
+	}
+	/**
+	* Extract all fields with a given prefix from a DOLT_DIFF result row,
+	* stripping the prefix from the key names. Returns undefined if no matching
+	* fields are found.
+	*/
+	_extractPrefixedFields(row, prefix) {
+		const result = {};
+		for (const [key, val] of Object.entries(row)) if (key.startsWith(prefix)) result[key.slice(prefix.length)] = val;
+		return Object.keys(result).length > 0 ? result : void 0;
+	}
+	/** In-memory KV store for per-run arbitrary metrics. Not persisted to Dolt. */
+	_kvMetrics = new Map();
+	async setMetric(runId, key, value) {
+		let runMap = this._kvMetrics.get(runId);
+		if (runMap === void 0) {
+			runMap = new Map();
+			this._kvMetrics.set(runId, runMap);
+		}
+		runMap.set(key, value);
+	}
+	async getMetric(runId, key) {
+		return this._kvMetrics.get(runId)?.get(key);
+	}
+	async getHistory(limit) {
+		const effectiveLimit = limit ?? 20;
+		try {
+			const rows = await this._client.query(`SELECT commit_hash, date, message, committer FROM dolt_log LIMIT ?`, [effectiveLimit]);
+			const entries = [];
+			for (const row of rows) {
+				const hash = String(row.commit_hash ?? "");
+				const dateVal = row.date;
+				const timestamp = dateVal instanceof Date ? dateVal.toISOString() : String(dateVal ?? "");
+				const message = String(row.message ?? "");
+				const author = row.committer ? String(row.committer) : void 0;
+				const storyKeyMatch = /story\/([0-9]+-[0-9]+)/i.exec(message);
+				entries.push({
+					hash,
+					timestamp,
+					storyKey: storyKeyMatch ? storyKeyMatch[1] : null,
+					message,
+					author
+				});
+			}
+			return entries;
+		} catch (err) {
+			const detail = err instanceof Error ? err.message : String(err);
+			throw new DoltQueryError("getHistory", detail);
+		}
+	}
+};
+
+//#endregion
+//#region src/modules/state/index.ts
+const logger$1 = createLogger("state:factory");
+/**
+* Synchronously check whether Dolt is available and a Dolt repo exists at the
+* canonical state path under `basePath`.
+*
+* @param basePath - Project root to check (e.g. `process.cwd()`).
+* @returns `{ available: true, reason: '...' }` when both probes pass,
+*          `{ available: false, reason: '...' }` otherwise.
+*/
+function detectDoltAvailableSync(basePath) {
+	const result = spawnSync("dolt", ["version"], { stdio: "ignore" });
+	const binaryFound = result.error == null && result.status === 0;
+	if (!binaryFound) return {
+		available: false,
+		reason: "dolt binary not found on PATH"
+	};
+	const stateDoltDir = join$1(basePath, ".substrate", "state", ".dolt");
+	const repoExists = existsSync$1(stateDoltDir);
+	if (!repoExists) return {
+		available: false,
+		reason: `Dolt repo not initialised at ${stateDoltDir}`
+	};
+	return {
+		available: true,
+		reason: "dolt binary found and repo initialised"
+	};
+}
+/**
+* Create a StateStore backed by the specified backend.
+*
+* @param config - Optional configuration. Defaults to `{ backend: 'auto' }`.
+* @returns A StateStore instance. Call `initialize()` before use.
+*/
+function createStateStore(config = {}) {
+	const backend = config.backend ?? "auto";
+	if (backend === "dolt") {
+		const repoPath = config.basePath ?? process.cwd();
+		const client = new DoltClient({ repoPath });
+		return new DoltStateStore({
+			repoPath,
+			client
+		});
+	}
+	if (backend === "auto") {
+		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")})`);
+			const client = new DoltClient({ repoPath });
+			return new DoltStateStore({
+				repoPath,
+				client
+			});
+		} else {
+			logger$1.debug(`Dolt not found, using FileStateStore (reason: ${detection.reason})`);
+			return new FileStateStore({ basePath: config.basePath });
+		}
+	}
+	return new FileStateStore({ basePath: config.basePath });
+}
+
+//#endregion
+//#region src/cli/commands/health.ts
+const logger = 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("substrate") || 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 = {
+		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");
+		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$1 = 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);
+				}
+			}
+		}
+	} 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);
+				}
+			}
+		}
+		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, stateStore, stateStoreConfig } = options;
+	const dbRoot = await resolveMainRepoRoot(projectRoot);
+	const dbPath = join(dbRoot, ".substrate", "substrate.db");
+	let doltStateInfo;
+	if (stateStoreConfig?.backend === "dolt" && stateStore) {
+		const repoPath = stateStoreConfig.basePath ?? projectRoot;
+		const doltDirPath = join(repoPath, ".dolt");
+		const initialized = existsSync$1(doltDirPath);
+		let responsive = false;
+		let version;
+		let branches;
+		let currentBranch;
+		try {
+			await stateStore.getHistory(1);
+			responsive = true;
+			try {
+				const { execFile: ef } = await import("node:child_process");
+				const { promisify: p } = await import("node:util");
+				const execFileAsync = p(ef);
+				const { stdout } = await execFileAsync("dolt", ["version"]);
+				const match = stdout.match(/dolt version (\S+)/);
+				if (match) version = match[1];
+			} catch {}
+			try {
+				const { execFile: ef } = await import("node:child_process");
+				const { promisify: p } = await import("node:util");
+				const execFileAsync = p(ef);
+				const { stdout } = await execFileAsync("dolt", ["branch", "--list"], { cwd: repoPath });
+				const lines = stdout.split("\n").filter((l) => l.trim().length > 0);
+				branches = lines.map((l) => {
+					const trimmed = l.trim();
+					if (trimmed.startsWith("* ")) {
+						currentBranch = trimmed.slice(2).trim();
+						return currentBranch;
+					}
+					return trimmed;
+				});
+			} catch {}
+		} catch {
+			responsive = false;
+		}
+		doltStateInfo = {
+			initialized,
+			responsive,
+			...version !== void 0 ? { version } : {},
+			...branches !== void 0 ? { branches } : {},
+			...currentBranch !== void 0 ? { current_branch: currentBranch } : {}
+		};
+	}
+	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: {}
+		},
+		...doltStateInfo !== void 0 ? { dolt_state: doltStateInfo } : {}
+	};
+	const doltDir = join(dbRoot, ".substrate", "state", ".dolt");
+	if (!existsSync$1(dbPath) && !existsSync$1(doltDir)) return NO_PIPELINE;
+	const adapter = createDatabaseAdapter({
+		backend: "auto",
+		basePath: dbRoot
+	});
+	try {
+		await initSchema(adapter);
+		let run;
+		if (runId !== void 0) run = await getPipelineRunById(adapter, runId);
+		else run = await getLatestRun(adapter);
+		if (run === void 0) {
+			const substrateDirPath$1 = join(dbRoot, ".substrate");
+			const fallbackProcessInfo = inspectProcessTree({
+				projectRoot: dbRoot,
+				substrateDirPath: substrateDirPath$1
+			});
+			if (fallbackProcessInfo.orchestrator_pid !== null) return {
+				verdict: "HEALTHY",
+				run_id: null,
+				status: "running",
+				current_phase: "implementation",
+				staleness_seconds: 0,
+				last_activity: new Date().toISOString(),
+				process: fallbackProcessInfo,
+				stories: {
+					active: 0,
+					completed: 0,
+					escalated: 0,
+					details: {}
+				},
+				...doltStateInfo !== void 0 ? { dolt_state: doltStateInfo } : {}
+			};
+			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 if (processInfo.orchestrator_pid === null && active > 0) verdict = "STALLED";
+		else verdict = "HEALTHY";
+		else if (run.status === "completed" || run.status === "failed" || run.status === "stopped") verdict = "NO_PIPELINE_RUNNING";
+		const healthOutput = {
+			verdict,
+			run_id: run.id,
+			status: run.status,
+			current_phase: run.current_phase ?? null,
+			staleness_seconds: stalenessSeconds,
+			last_activity: run.updated_at ?? "",
+			process: processInfo,
+			stories: {
+				active,
+				completed,
+				escalated,
+				pending,
+				details: storyDetails
+			},
+			...doltStateInfo !== void 0 ? { dolt_state: doltStateInfo } : {}
+		};
+		return healthOutput;
+	} finally {
+		try {
+			await adapter.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`);
+				}
+			}
+			if (health.dolt_state !== void 0) {
+				const ds = health.dolt_state;
+				const initStr = ds.initialized ? "yes" : "no";
+				const respStr = ds.responsive ? "yes" : "no";
+				const verStr = ds.version !== void 0 ? ` (v${ds.version})` : "";
+				process.stdout.write(`\n  Dolt State:   initialized=${initStr} responsive=${respStr}${verStr}\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.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 root = opts.projectRoot;
+		let stateStore;
+		let stateStoreConfig;
+		const doltStatePath = join(root, ".substrate", "state", ".dolt");
+		if (existsSync$1(doltStatePath)) {
+			const basePath = join(root, ".substrate", "state");
+			stateStoreConfig = {
+				backend: "dolt",
+				basePath
+			};
+			try {
+				stateStore = createStateStore({
+					backend: "dolt",
+					basePath
+				});
+				await stateStore.initialize();
+			} catch {
+				stateStore = void 0;
+				stateStoreConfig = void 0;
+			}
+		}
+		try {
+			const exitCode = await runHealthAction({
+				outputFormat,
+				runId: opts.runId,
+				projectRoot: root,
+				stateStore,
+				stateStoreConfig
+			});
+			process.exitCode = exitCode;
+		} finally {
+			try {
+				await stateStore?.close();
+			} catch {}
+		}
+	});
+}
+
+//#endregion
+export { BMAD_BASELINE_TOKENS_FULL, DEFAULT_STALL_THRESHOLD_SECONDS, DoltClient, DoltMergeConflict, DoltNotInstalled, FileStateStore, STOP_AFTER_VALID_PHASES, STORY_KEY_PATTERN$1 as STORY_KEY_PATTERN, SUBSTRATE_OWNED_SETTINGS_KEYS, VALID_PHASES, WorkGraphRepository, __commonJS, __require, __toESM, buildPipelineStatusOutput, checkDoltInstalled, createDatabaseAdapter, createDoltClient, createStateStore, detectCycles, findPackageRoot, formatOutput, formatPipelineStatusHuman, formatPipelineSummary, formatTokenTelemetry, getAllDescendantPids, getAutoHealthData, getSubstrateDefaultSettings, initSchema, initializeDolt, inspectProcessTree, isOrchestratorProcessLine, isSyncAdapter, parseDbTimestampAsUtc, registerHealthCommand, resolveBmadMethodSrcPath, resolveBmadMethodVersion, resolveMainRepoRoot, runHealthAction, validateStoryKey };
+//# sourceMappingURL=health-Dnx-FGva.js.map