substrate-ai 0.20.78 → 0.20.81

package/dist/{run-5R5ZPgSw.js → run-CElciHC1.js}

@@ -1,11 +1,11 @@
-import { BMAD_BASELINE_TOKENS_FULL, DoltMergeConflict, FileStateStore, STOP_AFTER_VALID_PHASES, STORY_KEY_PATTERN, VALID_PHASES, __commonJS, __require, __toESM, buildPipelineStatusOutput, createDatabaseAdapter, formatOutput, formatPipelineSummary, formatTokenTelemetry, inspectProcessTree, parseDbTimestampAsUtc, validateStoryKey } from "./health-EyALt_76.js";
+import { BMAD_BASELINE_TOKENS_FULL, DoltMergeConflict, FileStateStore, STOP_AFTER_VALID_PHASES, STORY_KEY_PATTERN, VALID_PHASES, __commonJS, __require, __toESM, buildPipelineStatusOutput, createDatabaseAdapter, formatOutput, formatPipelineSummary, formatTokenTelemetry, inspectProcessTree, parseDbTimestampAsUtc, validateStoryKey } from "./health-CuKzY0Fn.js";
 import { createLogger } from "./logger-KeHncl-f.js";
 import { TypedEventBusImpl, createEventBus, createTuiApp, isTuiCapable, printNonTtyWarning, sleep } from "./helpers-CElYrONe.js";
 import { ADVISORY_NOTES, Categorizer, ConsumerAnalyzer, DEFAULT_GLOBAL_SETTINGS, DispatcherImpl, DoltClient, ESCALATION_DIAGNOSIS, EXPERIMENT_RESULT, EfficiencyScorer, IngestionServer, LogTurnAnalyzer, OPERATIONAL_FINDING, Recommender, RoutingRecommender, RoutingResolver, RoutingTelemetry, RoutingTokenAccumulator, RoutingTuner, STORY_METRICS, STORY_OUTCOME, SubstrateConfigSchema, TEST_EXPANSION_FINDING, TEST_PLAN, TelemetryNormalizer, TelemetryPipeline, TurnAnalyzer, addTokenUsage, aggregateTokenUsageForRun, aggregateTokenUsageForStory, callLLM, classifyVersionGap, createConfigSystem, createDatabaseAdapter$1, createDecision, createPipelineRun, createRequirement, detectInterfaceChanges, getArtifactByTypeForRun, getArtifactsByRun, getDecisionsByCategory, getDecisionsByPhase, getDecisionsByPhaseForRun, getLatestRun, getPipelineRunById, getRunMetrics, getRunningPipelineRuns, getStoryMetricsForRun, getTokenUsageSummary, initSchema, listRequirements, loadModelRoutingConfig, registerArtifact, swallowDebug, updatePipelineRun, updatePipelineRunConfig, upsertDecision, writeRunMetrics, writeStoryMetrics } from "./dist-DCBSXUiX.js";
-import { FindingsInjector, RunManifest, RuntimeProbeListSchema, applyConfigToGraph, createDefaultVerificationPipeline, createGraphOrchestrator, createSdlcCodeReviewHandler, createSdlcCreateStoryHandler, createSdlcDevStoryHandler, createSdlcPhaseHandler, detectsEventDrivenAC, detectsStateIntegratingAC, extractTargetFilesFromStoryContent, renderFindings, resolveGraphPath, resolveMainRepoRoot, runAcTraceabilityCheck, runStaleVerificationRecovery } from "./manifest-read-DP4lBymM.js";
+import { FindingsInjector, RunManifest, RuntimeProbeListSchema, applyConfigToGraph, createDefaultVerificationPipeline, createGraphOrchestrator, createSdlcCodeReviewHandler, createSdlcCreateStoryHandler, createSdlcDevStoryHandler, createSdlcPhaseHandler, detectsEventDrivenAC, detectsStateIntegratingAC, extractTargetFilesFromStoryContent, renderFindings, resolveGraphPath, resolveMainRepoRoot, runAcTraceabilityCheck, runStaleVerificationRecovery } from "./manifest-read-Boipz5aP.js";
 import { WorkGraphRepository, detectCycles } from "./work-graph-repository-DZyJv5pV.js";
 import { deriveExitCode, routeDecision } from "./decision-router-DblHY8se.js";
-import { runInteractivePrompt } from "./interactive-prompt-DqvUvzPv.js";
+import { runInteractivePrompt } from "./interactive-prompt-CsvMelhG.js";
 import { runRecoveryEngine } from "./recovery-engine-BKGBeBnW.js";
 import { basename, dirname, extname, join } from "path";
 import { access, readFile, readdir, stat } from "fs/promises";
@@ -14,12 +14,14 @@ import yaml from "js-yaml";
 import * as actualFS from "node:fs";
 import { accessSync, existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, statSync, unlinkSync, unwatchFile, watchFile, writeFileSync } from "node:fs";
 import { exec, execFile, execFileSync, execSync, spawn } from "node:child_process";
+import * as path$5 from "node:path";
+import * as path$4 from "node:path";
 import * as path$2 from "node:path";
 import path, { basename as basename$1, dirname as dirname$1, extname as extname$1, isAbsolute, join as join$1, posix, resolve as resolve$1, win32 } from "node:path";
 import { tmpdir } from "node:os";
 import { createHash, randomUUID } from "node:crypto";
 import { z } from "zod";
-import { access as access$1, lstat, mkdir as mkdir$1, readFile as readFile$1, readdir as readdir$1, readlink, realpath, rename, stat as stat$1, unlink as unlink$1, writeFile as writeFile$1 } from "node:fs/promises";
+import { access as access$1, lstat, mkdir as mkdir$1, readFile as readFile$1, readdir as readdir$1, readlink, realpath, rename, rm, stat as stat$1, unlink as unlink$1, writeFile as writeFile$1 } from "node:fs/promises";
 import { existsSync as existsSync$1, lstatSync, mkdirSync as mkdirSync$1, readFileSync as readFileSync$1, readdir as readdir$2, readdirSync as readdirSync$1, readlinkSync, realpathSync as realpathSync$1, unlinkSync as unlinkSync$1, writeFileSync as writeFileSync$1 } from "fs";
 import { promisify } from "node:util";
 import { fileURLToPath } from "node:url";
@@ -31,6 +33,623 @@ import { channel, tracingChannel } from "node:diagnostics_channel";
 import Stream from "node:stream";
 import { StringDecoder } from "node:string_decoder";
 
+//#region packages/core/dist/git/git-utils.js
+const MIN_GIT_MAJOR = 2;
+const MIN_GIT_MINOR = 20;
+/**
+* Spawn a git subprocess with the given args.
+*
+* @param args    - Arguments to pass to git (e.g., ['worktree', 'add', ...])
+* @param options - Optional spawn options (cwd, env)
+* @returns       - Object with stdout, stderr, and exit code
+*/
+function spawnGit(args, options) {
+	return new Promise((resolve$6) => {
+		const proc$1 = spawn("git", args, {
+			cwd: options?.cwd,
+			env: options?.env ?? process.env,
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			]
+		});
+		let stdout = "";
+		let stderr = "";
+		proc$1.stdout?.on("data", (chunk) => {
+			stdout += chunk.toString();
+		});
+		proc$1.stderr?.on("data", (chunk) => {
+			stderr += chunk.toString();
+		});
+		proc$1.on("close", (code) => {
+			resolve$6({
+				stdout: stdout.trim(),
+				stderr: stderr.trim(),
+				code: code ?? 1
+			});
+		});
+		proc$1.on("error", (err) => {
+			resolve$6({
+				stdout: "",
+				stderr: err.message,
+				code: 1
+			});
+		});
+	});
+}
+/**
+* Get the installed git version string.
+*
+* @returns Version string like "2.42.0"
+* @throws  Error if git is not installed or version cannot be parsed
+*/
+async function getGitVersion() {
+	const result = await spawnGit(["--version"]);
+	if (result.code !== 0) throw new Error(`git --version failed: ${result.stderr}`);
+	const match$2 = /git version\s+(\d+\.\d+(?:\.\d+)?)/.exec(result.stdout);
+	if (match$2 === null || match$2[1] === void 0) throw new Error(`Unable to parse git version from output: "${result.stdout}"`);
+	return match$2[1];
+}
+/**
+* Parse a git version string into major/minor/patch components.
+*
+* @param versionString - Version string like "2.42.0" or "2.20"
+* @returns             - Parsed version components
+*/
+function parseGitVersion(versionString) {
+	const parts = versionString.split(".").map(Number);
+	return {
+		major: parts[0] ?? 0,
+		minor: parts[1] ?? 0,
+		patch: parts[2] ?? 0
+	};
+}
+/**
+* Check if the given git version string is >= 2.20.0.
+*
+* @param version - Version string like "2.42.0"
+* @returns       - true if version >= 2.20.0
+*/
+function isGitVersionSupported(version) {
+	const { major, minor } = parseGitVersion(version);
+	if (major > MIN_GIT_MAJOR) return true;
+	if (major === MIN_GIT_MAJOR && minor >= MIN_GIT_MINOR) return true;
+	return false;
+}
+/**
+* Verify that git is installed and version >= 2.20.
+*
+* @throws Error with clear message if git is not installed or too old
+*/
+async function verifyGitVersion() {
+	let version;
+	try {
+		version = await getGitVersion();
+	} catch (err) {
+		throw new Error(`git is not installed or could not be executed. Please install git 2.20 or newer. Details: ${String(err)}`);
+	}
+	if (!isGitVersionSupported(version)) {
+		const { major, minor, patch } = parseGitVersion(version);
+		throw new Error(`Git version ${major}.${minor}.${patch} is too old. Substrate requires git 2.20 or newer. Please upgrade git: https://git-scm.com/downloads`);
+	}
+}
+/**
+* Create a git worktree and its associated branch.
+*
+* Uses a single `git worktree add {worktreePath} -b {branchName} {baseBranch}`
+* command to create the worktree with a new branch in one step.
+*
+* @param projectRoot - Absolute path to the git repository root
+* @param taskId      - Task identifier (used in path derivation)
+* @param branchName  - Branch name to create (e.g., "substrate/task-abc123")
+* @param baseBranch  - Branch to base the worktree on (e.g., "main")
+* @returns           - Object with the worktreePath
+* @throws            - Error if git command fails
+*/
+async function createWorktree(projectRoot, taskId, branchName, baseBranch) {
+	const worktreePath = path$5.join(projectRoot, ".substrate-worktrees", taskId);
+	const worktreeExists = await access$1(worktreePath).then(() => true).catch((err) => {
+		if (err.code === "ENOENT") return false;
+		throw err;
+	});
+	if (worktreeExists) {
+		const listResult = await spawnGit([
+			"worktree",
+			"list",
+			"--porcelain"
+		], { cwd: projectRoot });
+		const registeredPaths = listResult.stdout.split("\n").filter((line) => line.startsWith("worktree ")).map((line) => line.slice(9).trim());
+		const isRegistered = registeredPaths.includes(worktreePath);
+		if (!isRegistered) await rm(worktreePath, {
+			recursive: true,
+			force: true
+		});
+		else throw new Error(`Worktree at ${worktreePath} is already registered. Run \`substrate worktrees --cleanup\` to remove it.`);
+	}
+	const addResult = await spawnGit([
+		"worktree",
+		"add",
+		worktreePath,
+		"-b",
+		branchName,
+		baseBranch
+	], { cwd: projectRoot });
+	if (addResult.code !== 0) throw new Error(`git worktree add failed for task "${taskId}": ${addResult.stderr || addResult.stdout}`);
+	return { worktreePath };
+}
+/**
+* Remove a git worktree by path.
+*
+* Uses `git worktree remove --force` to handle unclean worktrees.
+*
+* @param worktreePath - Absolute path to the worktree directory
+* @param projectRoot  - Absolute path to the git repository root
+* @throws             - Error if git command fails
+*/
+async function removeWorktree(worktreePath, projectRoot) {
+	const spawnOpts = {};
+	if (projectRoot !== void 0) spawnOpts.cwd = projectRoot;
+	const result = await spawnGit([
+		"worktree",
+		"remove",
+		"--force",
+		worktreePath
+	], spawnOpts);
+	if (result.code !== 0) throw new Error(`git worktree remove failed for "${worktreePath}": ${result.stderr || result.stdout}`);
+}
+/**
+* Delete a git branch using `git branch -D`.
+*
+* @param branchName  - Branch name to delete (e.g., "substrate/task-abc123")
+* @param projectRoot - Absolute path to the git repository root
+* @returns           - true if branch was successfully deleted, false otherwise
+*/
+async function removeBranch(branchName, projectRoot) {
+	const spawnOpts = {};
+	if (projectRoot !== void 0) spawnOpts.cwd = projectRoot;
+	const result = await spawnGit([
+		"branch",
+		"-D",
+		branchName
+	], spawnOpts);
+	if (result.code !== 0) return false;
+	return true;
+}
+/**
+* Scan the worktrees base directory and return paths of all found worktree directories.
+*
+* @param projectRoot   - Absolute path to the git repository root
+* @param baseDirectory - Relative directory name for worktrees (default: '.substrate-worktrees')
+* @returns             - Array of absolute worktree directory paths
+*/
+async function getOrphanedWorktrees(projectRoot, baseDirectory = ".substrate-worktrees") {
+	const worktreesDir = path$5.join(projectRoot, baseDirectory);
+	try {
+		await access$1(worktreesDir);
+	} catch {
+		return [];
+	}
+	let entries;
+	try {
+		entries = await readdir$1(worktreesDir, { withFileTypes: true });
+	} catch {
+		return [];
+	}
+	return entries.filter((entry) => entry.isDirectory()).map((entry) => path$5.join(worktreesDir, entry.name));
+}
+/**
+* Simulate a merge using git merge --no-commit --no-ff without committing.
+*
+* This runs in the target branch's working directory (the project root or
+* worktree path). The simulation must be aborted after checking conflicts
+* via abortMerge().
+*
+* @param branchName  - The source branch to simulate merging
+* @param cwd         - Working directory (must be on the target branch)
+* @returns           - true if merge would be clean, false if there are conflicts
+*/
+async function simulateMerge(branchName, cwd) {
+	const result = await spawnGit([
+		"merge",
+		"--no-commit",
+		"--no-ff",
+		branchName
+	], { cwd });
+	if (result.code === 0) return true;
+	return false;
+}
+/**
+* Abort a merge in progress using git merge --abort.
+*
+* Should be called after simulateMerge() to clean up the merge state,
+* regardless of whether conflicts were found.
+*
+* @param cwd - Working directory (same as used for simulateMerge)
+*/
+async function abortMerge(cwd) {
+	await spawnGit(["merge", "--abort"], { cwd });
+}
+/**
+* Get a list of files with conflicts during a merge.
+*
+* Must be called while a merge is in progress (after simulateMerge() and
+* before abortMerge()).
+*
+* @param cwd - Working directory of the repository
+* @returns   - Array of conflicting file paths
+*/
+async function getConflictingFiles(cwd) {
+	const result = await spawnGit([
+		"diff",
+		"--name-only",
+		"--diff-filter=U"
+	], { cwd });
+	if (result.code !== 0) return [];
+	if (result.stdout.trim() === "") return [];
+	return result.stdout.trim().split("\n").filter((f$1) => f$1.trim().length > 0);
+}
+/**
+* Perform an actual merge using git merge --no-ff.
+*
+* Should only be called after detectConflicts() confirms there are no conflicts.
+* Creates a merge commit even if fast-forward is possible (--no-ff ensures history).
+*
+* @param branchName  - The source branch to merge
+* @param cwd         - Working directory (must be on the target branch)
+* @returns           - true if merge succeeded, false otherwise
+*/
+async function performMerge(branchName, cwd) {
+	const result = await spawnGit([
+		"merge",
+		"--no-ff",
+		branchName
+	], { cwd });
+	if (result.code !== 0) return false;
+	return true;
+}
+/**
+* Get a list of files changed in the most recent merge.
+*
+* Uses git diff --name-only HEAD~1..HEAD to find files in the merge commit.
+* Falls back to empty array if commit history is insufficient.
+*
+* @param cwd - Working directory of the repository
+* @returns   - Array of file paths that were merged
+*/
+async function getMergedFiles(cwd) {
+	const result = await spawnGit([
+		"diff",
+		"--name-only",
+		"HEAD~1..HEAD"
+	], { cwd });
+	if (result.code !== 0) {
+		const altResult = await spawnGit([
+			"show",
+			"--name-only",
+			"--format=",
+			"HEAD"
+		], { cwd });
+		if (altResult.code !== 0) return [];
+		return altResult.stdout.trim().split("\n").filter((f$1) => f$1.trim().length > 0);
+	}
+	if (result.stdout.trim() === "") return [];
+	return result.stdout.trim().split("\n").filter((f$1) => f$1.trim().length > 0);
+}
+
+//#endregion
+//#region packages/core/dist/git/git-worktree-manager-impl.js
+const BRANCH_PREFIX = "substrate/task-";
+const DEFAULT_WORKTREE_BASE = ".substrate-worktrees";
+var GitWorktreeManagerImpl = class {
+	_eventBus;
+	_projectRoot;
+	_baseDirectory;
+	_db;
+	_logger;
+	/** Bound listener references for cleanup in shutdown() */
+	_onTaskReady;
+	_onTaskComplete;
+	_onTaskFailed;
+	constructor(eventBus, projectRoot, baseDirectory = DEFAULT_WORKTREE_BASE, db = null, logger$27) {
+		this._eventBus = eventBus;
+		this._projectRoot = projectRoot;
+		this._baseDirectory = baseDirectory;
+		this._db = db;
+		this._logger = logger$27 ?? console;
+		this._onTaskReady = ({ taskId }) => {
+			this._handleTaskReady(taskId).catch((err) => {
+				this._logger.error({
+					taskId,
+					err
+				}, "Unhandled error in _handleTaskReady");
+			});
+		};
+		this._onTaskComplete = ({ taskId }) => {
+			this._handleTaskDone(taskId);
+		};
+		this._onTaskFailed = ({ taskId }) => {
+			this._handleTaskDone(taskId);
+		};
+	}
+	async initialize() {
+		this._logger.info({ projectRoot: this._projectRoot }, "GitWorktreeManager.initialize()");
+		await this.verifyGitVersion();
+		const cleaned = await this.cleanupAllWorktrees();
+		if (cleaned > 0) this._logger.info({ cleaned }, "Recovered orphaned worktrees on startup");
+		this._eventBus.on("task:ready", this._onTaskReady);
+		this._eventBus.on("task:complete", this._onTaskComplete);
+		this._eventBus.on("task:failed", this._onTaskFailed);
+		this._logger.info("GitWorktreeManager initialized");
+	}
+	async shutdown() {
+		this._logger.info("GitWorktreeManager.shutdown()");
+		this._eventBus.off("task:ready", this._onTaskReady);
+		this._eventBus.off("task:complete", this._onTaskComplete);
+		this._eventBus.off("task:failed", this._onTaskFailed);
+		await this.cleanupAllWorktrees();
+		this._logger.info("GitWorktreeManager shutdown complete");
+	}
+	async _handleTaskReady(taskId) {
+		this._logger.debug({ taskId }, "task:ready — creating worktree");
+		try {
+			await this.createWorktree(taskId);
+		} catch (err) {
+			this._logger.error({
+				taskId,
+				err
+			}, "Failed to create worktree for task");
+		}
+	}
+	async _handleTaskDone(taskId) {
+		this._logger.debug({ taskId }, "task done — cleaning up worktree");
+		try {
+			await this.cleanupWorktree(taskId);
+		} catch (err) {
+			this._logger.warn({
+				taskId,
+				err
+			}, "Failed to cleanup worktree for task");
+		}
+	}
+	async createWorktree(taskId, baseBranch = "main") {
+		if (!taskId || taskId.trim().length === 0) throw new Error("createWorktree: taskId must be a non-empty string");
+		const branchName = BRANCH_PREFIX + taskId;
+		const worktreePath = this.getWorktreePath(taskId);
+		this._logger.debug({
+			taskId,
+			branchName,
+			worktreePath,
+			baseBranch
+		}, "createWorktree");
+		await createWorktree(this._projectRoot, taskId, branchName, baseBranch);
+		const createdAt = new Date();
+		this._eventBus.emit("worktree:created", {
+			taskId,
+			branchName,
+			worktreePath,
+			createdAt
+		});
+		const info = {
+			taskId,
+			branchName,
+			worktreePath,
+			createdAt
+		};
+		this._logger.info({
+			taskId,
+			branchName,
+			worktreePath
+		}, "Worktree created");
+		return info;
+	}
+	async cleanupWorktree(taskId) {
+		const branchName = BRANCH_PREFIX + taskId;
+		const worktreePath = this.getWorktreePath(taskId);
+		this._logger.debug({
+			taskId,
+			branchName,
+			worktreePath
+		}, "cleanupWorktree");
+		let worktreeExists = false;
+		try {
+			await access$1(worktreePath);
+			worktreeExists = true;
+		} catch {
+			this._logger.debug({
+				taskId,
+				worktreePath
+			}, "cleanupWorktree: worktree does not exist, skipping removal");
+		}
+		if (worktreeExists) try {
+			await removeWorktree(worktreePath, this._projectRoot);
+		} catch (err) {
+			this._logger.warn({
+				taskId,
+				worktreePath,
+				err
+			}, "removeWorktree failed during cleanup");
+		}
+		try {
+			await removeBranch(branchName, this._projectRoot);
+		} catch (err) {
+			this._logger.warn({
+				taskId,
+				branchName,
+				err
+			}, "removeBranch failed during cleanup");
+		}
+		this._eventBus.emit("worktree:removed", {
+			taskId,
+			branchName
+		});
+		this._logger.info({
+			taskId,
+			branchName
+		}, "Worktree cleaned up");
+	}
+	async cleanupAllWorktrees() {
+		this._logger.debug({ projectRoot: this._projectRoot }, "cleanupAllWorktrees");
+		const orphanedPaths = await getOrphanedWorktrees(this._projectRoot, this._baseDirectory);
+		let cleaned = 0;
+		for (const worktreePath of orphanedPaths) {
+			const taskId = path$4.basename(worktreePath);
+			let worktreeRemoved = false;
+			try {
+				await removeWorktree(worktreePath, this._projectRoot);
+				worktreeRemoved = true;
+				this._logger.debug({
+					taskId,
+					worktreePath
+				}, "cleanupAllWorktrees: removed orphaned worktree");
+			} catch (err) {
+				this._logger.warn({
+					taskId,
+					worktreePath,
+					err
+				}, "cleanupAllWorktrees: failed to remove worktree");
+			}
+			const branchName = BRANCH_PREFIX + taskId;
+			try {
+				const branchRemoved = await removeBranch(branchName, this._projectRoot);
+				if (branchRemoved) this._logger.debug({
+					taskId,
+					branchName
+				}, "cleanupAllWorktrees: removed orphaned branch");
+			} catch (err) {
+				this._logger.warn({
+					taskId,
+					branchName,
+					err
+				}, "cleanupAllWorktrees: failed to remove branch");
+			}
+			if (worktreeRemoved) cleaned++;
+		}
+		if (cleaned > 0) this._logger.info({ cleaned }, "cleanupAllWorktrees: recovered orphaned worktrees");
+		return cleaned;
+	}
+	async detectConflicts(taskId, targetBranch = "main") {
+		if (!taskId || taskId.trim().length === 0) throw new Error("detectConflicts: taskId must be a non-empty string");
+		const branchName = BRANCH_PREFIX + taskId;
+		const worktreePath = this.getWorktreePath(taskId);
+		this._logger.debug({
+			taskId,
+			branchName,
+			targetBranch
+		}, "detectConflicts");
+		try {
+			await access$1(worktreePath);
+		} catch {
+			throw new Error(`detectConflicts: Worktree for task "${taskId}" not found at "${worktreePath}". The worktree may have already been cleaned up.`);
+		}
+		const mergeClean = await simulateMerge(branchName, this._projectRoot);
+		let conflictingFiles = [];
+		try {
+			if (!mergeClean) conflictingFiles = await getConflictingFiles(this._projectRoot);
+		} finally {
+			await abortMerge(this._projectRoot);
+		}
+		const report = {
+			hasConflicts: !mergeClean || conflictingFiles.length > 0,
+			conflictingFiles,
+			taskId,
+			targetBranch
+		};
+		if (report.hasConflicts) this._eventBus.emit("worktree:conflict", {
+			taskId,
+			branch: branchName,
+			conflictingFiles: report.conflictingFiles
+		});
+		this._logger.info({
+			taskId,
+			hasConflicts: report.hasConflicts,
+			conflictCount: conflictingFiles.length
+		}, "Conflict detection complete");
+		return report;
+	}
+	async mergeWorktree(taskId, targetBranch = "main") {
+		if (!taskId || taskId.trim().length === 0) throw new Error("mergeWorktree: taskId must be a non-empty string");
+		const branchName = BRANCH_PREFIX + taskId;
+		this._logger.debug({
+			taskId,
+			branchName,
+			targetBranch
+		}, "mergeWorktree");
+		const conflictReport = await this.detectConflicts(taskId, targetBranch);
+		if (conflictReport.hasConflicts) {
+			this._logger.info({
+				taskId,
+				conflictCount: conflictReport.conflictingFiles.length
+			}, "Merge skipped due to conflicts");
+			return {
+				success: false,
+				mergedFiles: [],
+				conflicts: conflictReport
+			};
+		}
+		const mergeSuccess = await performMerge(branchName, this._projectRoot);
+		if (!mergeSuccess) throw new Error(`mergeWorktree: git merge --no-ff failed for task "${taskId}" branch "${branchName}"`);
+		const mergedFiles = await getMergedFiles(this._projectRoot);
+		this._eventBus.emit("worktree:merged", {
+			taskId,
+			branch: branchName,
+			mergedFiles
+		});
+		const result = {
+			success: true,
+			mergedFiles
+		};
+		this._logger.info({
+			taskId,
+			branchName,
+			mergedFileCount: mergedFiles.length
+		}, "Worktree merged successfully");
+		return result;
+	}
+	async listWorktrees() {
+		this._logger.debug({
+			projectRoot: this._projectRoot,
+			baseDirectory: this._baseDirectory
+		}, "listWorktrees");
+		const worktreePaths = await getOrphanedWorktrees(this._projectRoot, this._baseDirectory);
+		const results = [];
+		for (const worktreePath of worktreePaths) {
+			const taskId = path$4.basename(worktreePath);
+			const branchName = BRANCH_PREFIX + taskId;
+			let createdAt;
+			try {
+				const { stat: stat$2 } = await import("node:fs/promises");
+				const stats = await stat$2(worktreePath);
+				createdAt = stats.birthtime ?? stats.ctime;
+			} catch {
+				createdAt = new Date();
+			}
+			results.push({
+				taskId,
+				branchName,
+				worktreePath,
+				createdAt
+			});
+		}
+		this._logger.debug({ count: results.length }, "listWorktrees: found worktrees");
+		return results;
+	}
+	getWorktreePath(taskId) {
+		return path$4.join(this._projectRoot, this._baseDirectory, taskId);
+	}
+	async verifyGitVersion() {
+		try {
+			await verifyGitVersion();
+		} catch (err) {
+			throw new Error(`GitWorktreeManager: git version check failed: ${String(err)}`);
+		}
+	}
+};
+function createGitWorktreeManager(options) {
+	return new GitWorktreeManagerImpl(options.eventBus, options.projectRoot, options.baseDirectory, options.db ?? null, options.logger);
+}
+
+//#endregion
 //#region src/modules/methodology-pack/schemas.ts
 /**
 * A reference to a context value to inject into a step prompt.
@@ -1820,6 +2439,33 @@ const PIPELINE_EVENT_METADATA = [
 				description: "Human-readable reason for skipping."
 			}
 		]
+	},
+	{
+		type: "pipeline:merge-conflict-detected",
+		description: "A story branch could not be merged into the base branch — both branches edited the same lines. The story is marked ESCALATED. The worktree and branch are preserved for operator inspection.",
+		when: "Emitted during the merge-to-main phase when a 3-way merge fails due to conflicts. Story 75-2.",
+		fields: [
+			{
+				name: "ts",
+				type: "string",
+				description: "Timestamp."
+			},
+			{
+				name: "storyKey",
+				type: "string",
+				description: "Story key whose branch could not be merged."
+			},
+			{
+				name: "branchName",
+				type: "string",
+				description: "Branch name being merged (e.g., \"substrate/story-75-2\")."
+			},
+			{
+				name: "conflictingFiles",
+				type: "string[]",
+				description: "Files with unresolved merge conflicts."
+			}
+		]
 	}
 ];
 /**
@@ -1899,6 +2545,7 @@ Options:
 - \`--research\` — Enable the research phase even if not set in the pack config
 - \`--skip-research\` — Skip the research phase even if enabled in the pack config
 - \`--skip-ux\` — Skip the UX design phase even if enabled in the pack config
+- \`--no-worktree\` — Disable per-story git worktrees; all implementation runs in the main working tree (use for submodule repos or bare repos that don't support worktrees)
 - \`--help-agent\` — Print this agent instruction fragment and exit
 
 Examples:
@@ -2064,6 +2711,7 @@ These on-disk files back the new autonomy commands. External monitors (dashboard
 - \`.substrate/current-run-id\` — plain text file containing the latest run ID; consulted by the canonical run-discovery chain.
 - \`.substrate/notifications/<run-id>-<timestamp>.json\` — operator halt notifications written by the Recovery Engine when \`--halt-on\` triggers; deleted by \`substrate report\` after read.
 - \`pending_proposals[]\` field in the run manifest — Recovery Engine Tier B re-scope proposals collected here for next-morning operator review. Back-pressure pauses dispatching at \`>= 2\` proposals (work-graph-aware) or \`>= 5\` (safety valve).
+- \`.substrate-worktrees/story-<key>/\` — per-story git worktree directories created during dispatch. Removed on successful merge; preserved on failure for \`substrate reconcile-from-disk\` inspection. Use \`--no-worktree\` to disable.
 
 ## Environment Variables
 
@@ -2230,7 +2878,7 @@ async function runHelpAgent() {
 
 //#endregion
 //#region src/persistence/dolt-server.ts
-const logger$25 = createLogger("dolt-server");
+const logger$26 = createLogger("dolt-server");
 /**
 * Start a dolt sql-server for the given project, if Dolt is available and no
 * server is already running (socket already exists).
@@ -2247,7 +2895,7 @@ async function startDoltServer(projectRoot) {
 	if (!existsSync(join$1(stateDir, ".dolt"))) return null;
 	try {
 		await access$1(socketPath);
-		logger$25.debug("Dolt socket already exists at %s — using existing server", socketPath);
+		logger$26.debug("Dolt socket already exists at %s — using existing server", socketPath);
 		return null;
 	} catch {}
 	try {
@@ -2256,10 +2904,10 @@ async function startDoltServer(projectRoot) {
 			stdio: "pipe"
 		});
 	} catch {
-		logger$25.debug("dolt binary not on PATH — cannot start server");
+		logger$26.debug("dolt binary not on PATH — cannot start server");
 		return null;
 	}
-	logger$25.debug("Starting dolt sql-server at %s", socketPath);
+	logger$26.debug("Starting dolt sql-server at %s", socketPath);
 	let proc$1;
 	try {
 		proc$1 = spawn("dolt", [
@@ -2280,26 +2928,26 @@ async function startDoltServer(projectRoot) {
 			detached: false
 		});
 	} catch (err) {
-		logger$25.debug("Failed to spawn dolt sql-server: %s", err instanceof Error ? err.message : String(err));
+		logger$26.debug("Failed to spawn dolt sql-server: %s", err instanceof Error ? err.message : String(err));
 		return null;
 	}
 	let failed = false;
 	proc$1.on("error", (err) => {
-		logger$25.debug("dolt sql-server error: %s", err.message);
+		logger$26.debug("dolt sql-server error: %s", err.message);
 		failed = true;
 	});
 	proc$1.on("exit", (code) => {
-		if (code !== null && code !== 0) logger$25.debug("dolt sql-server exited with code %d", code);
+		if (code !== null && code !== 0) logger$26.debug("dolt sql-server exited with code %d", code);
 	});
 	proc$1.stderr?.on("data", (chunk) => {
 		const line = chunk.toString().trim();
-		if (line) logger$25.debug("dolt-server: %s", line);
+		if (line) logger$26.debug("dolt-server: %s", line);
 	});
 	const deadline = Date.now() + 5e3;
 	while (Date.now() < deadline && !failed) try {
 		await access$1(socketPath);
 		const pid = proc$1.pid ?? 0;
-		logger$25.info("Auto-started dolt sql-server (pid=%d, socket=%s)", pid, socketPath);
+		logger$26.info("Auto-started dolt sql-server (pid=%d, socket=%s)", pid, socketPath);
 		let stopped = false;
 		return {
 			pid,
@@ -2307,14 +2955,14 @@ async function startDoltServer(projectRoot) {
 			stop: () => {
 				if (stopped) return;
 				stopped = true;
-				logger$25.debug("Stopping dolt sql-server (pid=%d)", pid);
+				logger$26.debug("Stopping dolt sql-server (pid=%d)", pid);
 				proc$1.kill("SIGTERM");
 			}
 		};
 	} catch {
 		await new Promise((resolve$6) => setTimeout(resolve$6, 100));
 	}
-	logger$25.debug("dolt sql-server did not start within 5s — killing");
+	logger$26.debug("dolt sql-server did not start within 5s — killing");
 	proc$1.kill("SIGTERM");
 	return null;
 }
@@ -2384,7 +3032,7 @@ function truncateToTokens(text, maxTokens) {
 
 //#endregion
 //#region src/modules/context-compiler/context-compiler-impl.ts
-const logger$24 = createLogger("context-compiler");
+const logger$25 = createLogger("context-compiler");
 /**
 * Fraction of the original token budget that must remain (after required +
 * important sections) before an optional section is included.
@@ -2445,7 +3093,7 @@ var ContextCompilerImpl = class {
 	}
 	_applyExclusionFilter(text, sectionName) {
 		for (const excludedPath of this._excludedPaths) if (text.includes(excludedPath)) {
-			logger$24.warn({
+			logger$25.warn({
 				sectionName,
 				excludedPath
 			}, "ContextCompiler: section excluded — contains path from exclusion list");
@@ -2503,7 +3151,7 @@ var ContextCompilerImpl = class {
 				includedParts.push(truncated);
 				remainingBudget -= truncatedTokens;
 				anyTruncated = true;
-				logger$24.warn({
+				logger$25.warn({
 					section: section.name,
 					originalTokens: tokens,
 					budgetTokens: truncatedTokens
@@ -2517,7 +3165,7 @@ var ContextCompilerImpl = class {
 				});
 			} else {
 				anyTruncated = true;
-				logger$24.warn({
+				logger$25.warn({
 					section: section.name,
 					tokens
 				}, "Context compiler: omitted \"important\" section — no budget remaining");
@@ -2544,7 +3192,7 @@ var ContextCompilerImpl = class {
 				} else {
 					if (tokens > 0) {
 						anyTruncated = true;
-						logger$24.warn({
+						logger$25.warn({
 							section: section.name,
 							tokens,
 							budgetFractionRemaining: budgetFractionRemaining.toFixed(2)
@@ -2638,8 +3286,8 @@ var GrammarLoader = class {
 	_extensionMap;
 	_cache = new Map();
 	_unavailable = false;
-	constructor(logger$26) {
-		this._logger = logger$26;
+	constructor(logger$27) {
+		this._logger = logger$27;
 		this._extensionMap = new Map([
 			[".ts", "tree-sitter-typescript/typescript"],
 			[".tsx", "tree-sitter-typescript/tsx"],
@@ -2676,8 +3324,8 @@ var GrammarLoader = class {
 			throw err;
 		}
 	}
-	_loadModule(path$4) {
-		return __require(path$4);
+	_loadModule(path$6) {
+		return __require(path$6);
 	}
 };
 
@@ -2725,9 +3373,9 @@ const ERR_REPO_MAP_GIT_FAILED = "ERR_REPO_MAP_GIT_FAILED";
 var SymbolParser = class {
 	_grammarLoader;
 	_logger;
-	constructor(grammarLoader, logger$26) {
+	constructor(grammarLoader, logger$27) {
 		this._grammarLoader = grammarLoader;
-		this._logger = logger$26;
+		this._logger = logger$27;
 	}
 	async parseFile(filePath) {
 		const ext$2 = extname$1(filePath);
@@ -2872,9 +3520,9 @@ async function computeFileHash(filePath) {
 var DoltSymbolRepository = class {
 	_client;
 	_logger;
-	constructor(client, logger$26) {
+	constructor(client, logger$27) {
 		this._client = client;
-		this._logger = logger$26;
+		this._logger = logger$27;
 	}
 	/**
 	* Atomically replace all symbols for filePath.
@@ -3080,11 +3728,11 @@ var RepoMapStorage = class {
 	_metaRepo;
 	_gitClient;
 	_logger;
-	constructor(symbolRepo, metaRepo, gitClient, logger$26) {
+	constructor(symbolRepo, metaRepo, gitClient, logger$27) {
 		this._symbolRepo = symbolRepo;
 		this._metaRepo = metaRepo;
 		this._gitClient = gitClient;
-		this._logger = logger$26;
+		this._logger = logger$27;
 	}
 	/**
 	* Returns true if the file's current content hash differs from the stored hash.
@@ -3201,8 +3849,8 @@ function runGit(args, cwd) {
 */
 var GitClient = class {
 	_logger;
-	constructor(logger$26) {
-		this._logger = logger$26;
+	constructor(logger$27) {
+		this._logger = logger$27;
 	}
 	/**
 	* Returns the current HEAD commit SHA.
@@ -4558,9 +5206,9 @@ var RepoMapQueryEngine = class {
 	repo;
 	logger;
 	telemetry;
-	constructor(repo, logger$26, telemetry) {
+	constructor(repo, logger$27, telemetry) {
 		this.repo = repo;
-		this.logger = logger$26;
+		this.logger = logger$27;
 		this.telemetry = telemetry;
 	}
 	async query(q) {
@@ -4780,9 +5428,9 @@ var RepoMapFormatter = class {
 var RepoMapTelemetry = class {
 	_telemetry;
 	_logger;
-	constructor(telemetry, logger$26) {
+	constructor(telemetry, logger$27) {
 		this._telemetry = telemetry;
-		this._logger = logger$26;
+		this._logger = logger$27;
 	}
 	/**
 	* Emit a `repo_map.query` span.
@@ -4807,9 +5455,9 @@ var RepoMapTelemetry = class {
 var RepoMapModule = class {
 	_metaRepo;
 	_logger;
-	constructor(metaRepo, logger$26) {
+	constructor(metaRepo, logger$27) {
 		this._metaRepo = metaRepo;
-		this._logger = logger$26;
+		this._logger = logger$27;
 	}
 	/**
 	* Check whether the stored repo-map is stale relative to the current HEAD commit.
@@ -4853,9 +5501,9 @@ var RepoMapModule = class {
 var RepoMapInjector = class {
 	_queryEngine;
 	_logger;
-	constructor(queryEngine, logger$26) {
+	constructor(queryEngine, logger$27) {
 		this._queryEngine = queryEngine;
-		this._logger = logger$26;
+		this._logger = logger$27;
 	}
 	/**
 	* Build repo-map context by extracting file references from the story content,
@@ -4937,7 +5585,7 @@ const DEFAULT_TIMEOUTS = {
 
 //#endregion
 //#region src/modules/agent-dispatch/dispatcher-impl.ts
-const logger$23 = createLogger("agent-dispatch");
+const logger$24 = createLogger("agent-dispatch");
 /**
 * Create a new Dispatcher instance.
 *
@@ -5081,7 +5729,7 @@ function runBuildVerification(options) {
 	let cmd;
 	if (verifyCommand === void 0) {
 		const detection = detectPackageManager(projectRoot);
-		logger$23.info({
+		logger$24.info({
 			packageManager: detection.packageManager,
 			lockfile: detection.lockfile,
 			resolvedCommand: detection.command
@@ -5093,7 +5741,7 @@ function runBuildVerification(options) {
 		const filters = deriveTurboFilters(changedFiles, projectRoot);
 		if (filters.length > 0) {
 			cmd = `${cmd} ${filters.join(" ")}`;
-			logger$23.info({
+			logger$24.info({
 				filters,
 				originalCmd: options.verifyCommand ?? "(auto-detected)"
 			}, "Build verification: scoped turbo build to affected packages");
@@ -5136,7 +5784,7 @@ function runBuildVerification(options) {
 			};
 			const missingScriptPattern = /Missing script[:\s]|No script found|Command "build" not found/i;
 			if (missingScriptPattern.test(combinedOutput)) {
-				logger$23.warn("Build script not found — skipping pre-flight (greenfield repo)");
+				logger$24.warn("Build script not found — skipping pre-flight (greenfield repo)");
 				return {
 					status: "skipped",
 					exitCode,
@@ -5146,7 +5794,7 @@ function runBuildVerification(options) {
 			}
 			const pep668Pattern = /externally-managed-environment|This environment is externally managed/i;
 			if (pep668Pattern.test(combinedOutput)) {
-				logger$23.warn("PEP 668: pip blocked by externally-managed-environment — skipping pre-flight. Create a .venv to resolve.");
+				logger$24.warn("PEP 668: pip blocked by externally-managed-environment — skipping pre-flight. Create a .venv to resolve.");
 				return {
 					status: "skipped",
 					exitCode,
@@ -5330,7 +5978,7 @@ function pickRecommendation(distribution, profile, totalIssues, reviewCycles, la
 
 //#endregion
 //#region src/modules/implementation-orchestrator/project-findings.ts
-const logger$22 = createLogger("project-findings");
+const logger$23 = createLogger("project-findings");
 /** Maximum character length for the findings summary */
 const MAX_CHARS = 2e3;
 /**
@@ -5403,7 +6051,7 @@ async function getProjectFindings(db) {
 		if (summary.length > MAX_CHARS) summary = summary.slice(0, MAX_CHARS - 3) + "...";
 		return summary;
 	} catch (err) {
-		logger$22.warn({ err }, "Failed to query project findings (graceful fallback)");
+		logger$23.warn({ err }, "Failed to query project findings (graceful fallback)");
 		return "";
 	}
 }
@@ -5426,7 +6074,7 @@ function extractRecurringPatterns(outcomes) {
 
 //#endregion
 //#region src/modules/compiled-workflows/prompt-assembler.ts
-const logger$21 = createLogger("compiled-workflows:prompt-assembler");
+const logger$22 = createLogger("compiled-workflows:prompt-assembler");
 /**
 * Assemble a final prompt from a template and sections map.
 *
@@ -5451,7 +6099,7 @@ function assemblePrompt(template, sections, tokenCeiling = 2200) {
 		tokenCount,
 		truncated: false
 	};
-	logger$21.warn({
+	logger$22.warn({
 		tokenCount,
 		ceiling: tokenCeiling
 	}, "Prompt exceeds token ceiling — truncating optional sections");
@@ -5467,10 +6115,10 @@ function assemblePrompt(template, sections, tokenCeiling = 2200) {
 			const targetSectionTokens = Math.max(0, currentSectionTokens - overBy);
 			if (targetSectionTokens === 0) {
 				contentMap[section.name] = "";
-				logger$21.warn({ sectionName: section.name }, "Section eliminated to fit token budget");
+				logger$22.warn({ sectionName: section.name }, "Section eliminated to fit token budget");
 			} else {
 				contentMap[section.name] = truncateToTokens(section.content, targetSectionTokens);
-				logger$21.warn({
+				logger$22.warn({
 					sectionName: section.name,
 					targetSectionTokens
 				}, "Section truncated to fit token budget");
@@ -5481,7 +6129,7 @@ function assemblePrompt(template, sections, tokenCeiling = 2200) {
 		}
 		if (tokenCount <= tokenCeiling) break;
 	}
-	if (tokenCount > tokenCeiling) logger$21.warn({
+	if (tokenCount > tokenCeiling) logger$22.warn({
 		tokenCount,
 		ceiling: tokenCeiling
 	}, "Required sections alone exceed token ceiling — returning over-budget prompt");
@@ -5821,7 +6469,7 @@ function getTokenCeiling(workflowType, tokenCeilings) {
 
 //#endregion
 //#region src/modules/compiled-workflows/create-story.ts
-const logger$20 = createLogger("compiled-workflows:create-story");
+const logger$21 = createLogger("compiled-workflows:create-story");
 /**
 * Compute a hex SHA-256 of the normalized source AC section text.
 *
@@ -5856,13 +6504,13 @@ function hashSourceAcSection(section) {
 */
 async function runCreateStory(deps, params) {
 	const { epicId, storyKey, pipelineRunId, source_ac_hash, priorDriftFeedback } = params;
-	logger$20.debug({
+	logger$21.debug({
 		epicId,
 		storyKey,
 		pipelineRunId
 	}, "Starting create-story workflow");
 	const { ceiling: TOKEN_CEILING, source: tokenCeilingSource } = getTokenCeiling("create-story", deps.tokenCeilings);
-	logger$20.info({
+	logger$21.info({
 		workflow: "create-story",
 		ceiling: TOKEN_CEILING,
 		source: tokenCeilingSource
@@ -5872,7 +6520,7 @@ async function runCreateStory(deps, params) {
 		template = await deps.pack.getPrompt("create-story");
 	} catch (err) {
 		const error = err instanceof Error ? err.message : String(err);
-		logger$20.error({ error }, "Failed to retrieve create-story prompt template");
+		logger$21.error({ error }, "Failed to retrieve create-story prompt template");
 		return {
 			result: "failed",
 			error: `Failed to retrieve prompt template: ${error}`,
@@ -5889,7 +6537,7 @@ async function runCreateStory(deps, params) {
 		const storySection = extractStorySection(epicShardContent, storyKey);
 		if (storySection !== null) {
 			const computedHash = hashSourceAcSection(storySection);
-			if (source_ac_hash !== void 0 && source_ac_hash !== computedHash) logger$20.debug({
+			if (source_ac_hash !== void 0 && source_ac_hash !== computedHash) logger$21.debug({
 				storyKey,
 				suppliedHash: source_ac_hash,
 				computedHash
@@ -5904,7 +6552,7 @@ async function runCreateStory(deps, params) {
 		const storyDef = storyDecisions.find((d) => d.category === "stories" && d.key === storyKey);
 		if (storyDef) {
 			storyDefinitionContent = storyDef.value;
-			logger$20.debug({ storyKey }, "Injected story definition from solutioning decisions");
+			logger$21.debug({ storyKey }, "Injected story definition from solutioning decisions");
 		}
 	} catch {}
 	const archConstraintsContent = await getArchConstraints$3(deps);
@@ -5955,7 +6603,7 @@ async function runCreateStory(deps, params) {
 			priority: "optional"
 		}]
 	], TOKEN_CEILING);
-	logger$20.debug({
+	logger$21.debug({
 		tokenCount,
 		truncated,
 		tokenCeiling: TOKEN_CEILING
@@ -5975,7 +6623,7 @@ async function runCreateStory(deps, params) {
 		dispatchResult = await handle.result;
 	} catch (err) {
 		const error = err instanceof Error ? err.message : String(err);
-		logger$20.error({
+		logger$21.error({
 			epicId,
 			storyKey,
 			error
@@ -5996,7 +6644,7 @@ async function runCreateStory(deps, params) {
 	if (dispatchResult.status === "failed") {
 		const errorMsg = dispatchResult.parseError ?? `Dispatch failed with exit code ${dispatchResult.exitCode}`;
 		const stderrDetail = dispatchResult.output ? ` Output: ${dispatchResult.output}` : "";
-		logger$20.warn({
+		logger$21.warn({
 			epicId,
 			storyKey,
 			exitCode: dispatchResult.exitCode,
@@ -6009,7 +6657,7 @@ async function runCreateStory(deps, params) {
 		};
 	}
 	if (dispatchResult.status === "timeout") {
-		logger$20.warn({
+		logger$21.warn({
 			epicId,
 			storyKey
 		}, "Create-story dispatch timed out");
@@ -6022,7 +6670,7 @@ async function runCreateStory(deps, params) {
 	if (dispatchResult.parsed === null) {
 		const details = dispatchResult.parseError ?? "No YAML block found in output";
 		const rawSnippet = dispatchResult.output ? dispatchResult.output.slice(0, 1e3) : "(empty)";
-		logger$20.warn({
+		logger$21.warn({
 			epicId,
 			storyKey,
 			details,
@@ -6038,7 +6686,7 @@ async function runCreateStory(deps, params) {
 	const parseResult = CreateStoryResultSchema.safeParse(dispatchResult.parsed);
 	if (!parseResult.success) {
 		const details = parseResult.error.message;
-		logger$20.warn({
+		logger$21.warn({
 			epicId,
 			storyKey,
 			details
@@ -6051,7 +6699,7 @@ async function runCreateStory(deps, params) {
 		};
 	}
 	const parsed = parseResult.data;
-	logger$20.info({
+	logger$21.info({
 		epicId,
 		storyKey,
 		storyFile: parsed.story_file,
@@ -6079,7 +6727,7 @@ async function getImplementationDecisions(deps, pipelineRunId) {
 		}
 		return await getDecisionsByPhase(deps.db, "implementation");
 	} catch (err) {
-		logger$20.warn({ error: err instanceof Error ? err.message : String(err) }, "Failed to retrieve implementation decisions");
+		logger$21.warn({ error: err instanceof Error ? err.message : String(err) }, "Failed to retrieve implementation decisions");
 		return [];
 	}
 }
@@ -6166,10 +6814,10 @@ function computeStoryFileFidelity(storyFileContent, namedPaths) {
 	};
 	const missing = [];
 	const present = [];
-	for (const path$4 of namedPaths) {
-		const basename$2 = path$4.includes("/") ? path$4.slice(path$4.lastIndexOf("/") + 1) : path$4;
-		if (storyFileContent.includes(path$4) || storyFileContent.includes(basename$2)) present.push(path$4);
-		else missing.push(path$4);
+	for (const path$6 of namedPaths) {
+		const basename$2 = path$6.includes("/") ? path$6.slice(path$6.lastIndexOf("/") + 1) : path$6;
+		if (storyFileContent.includes(path$6) || storyFileContent.includes(basename$2)) present.push(path$6);
+		else missing.push(path$6);
 	}
 	return {
 		missing,
@@ -6370,7 +7018,7 @@ function getEpicShard(decisions, epicId, projectRoot, storyKey) {
 		if (storyKey) {
 			const perStoryShard = decisions.find((d) => d.category === "epic-shard" && d.key === storyKey);
 			if (perStoryShard?.value) {
-				logger$20.debug({
+				logger$21.debug({
 					epicId,
 					storyKey
 				}, "Found per-story epic shard (direct lookup)");
@@ -6382,13 +7030,13 @@ function getEpicShard(decisions, epicId, projectRoot, storyKey) {
 		if (shardContent && storyKey) {
 			const storySection = extractStorySection(shardContent, storyKey);
 			if (storySection) {
-				logger$20.debug({
+				logger$21.debug({
 					epicId,
 					storyKey
 				}, "Extracted per-story section from epic shard (pre-37-0 fallback)");
 				return storySection;
 			}
-			logger$20.info({
+			logger$21.info({
 				epicId,
 				storyKey
 			}, "Story section absent in decisions-store shard — attempting file-based fallback before returning stale shard");
@@ -6396,11 +7044,11 @@ function getEpicShard(decisions, epicId, projectRoot, storyKey) {
 		if (projectRoot) {
 			const fallback = readEpicShardFromFile(projectRoot, epicId);
 			if (fallback) {
-				logger$20.info({ epicId }, "Using file-based fallback for epic shard");
+				logger$21.info({ epicId }, "Using file-based fallback for epic shard");
 				if (storyKey) {
 					const storySection = extractStorySection(fallback, storyKey);
 					if (storySection) {
-						logger$20.debug({
+						logger$21.debug({
 							epicId,
 							storyKey
 						}, "Extracted per-story section from file-based epic shard");
@@ -6413,7 +7061,7 @@ function getEpicShard(decisions, epicId, projectRoot, storyKey) {
 		if (shardContent) return shardContent;
 		return "";
 	} catch (err) {
-		logger$20.warn({
+		logger$21.warn({
 			epicId,
 			error: err instanceof Error ? err.message : String(err)
 		}, "Failed to retrieve epic shard");
@@ -6430,7 +7078,7 @@ function getPrevDevNotes(decisions, epicId) {
 		if (devNotes.length === 0) return "";
 		return devNotes[devNotes.length - 1].value;
 	} catch (err) {
-		logger$20.warn({
+		logger$21.warn({
 			epicId,
 			error: err instanceof Error ? err.message : String(err)
 		}, "Failed to retrieve prev dev notes");
@@ -6463,7 +7111,7 @@ async function getArchConstraints$3(deps) {
 				const truncatedBody = body.length > 300 ? body.slice(0, 297) + "..." : body;
 				return `${header}\n${truncatedBody}`;
 			}).join("\n\n");
-			logger$20.info({
+			logger$21.info({
 				fullLength: full.length,
 				summarizedLength: summarized.length,
 				decisions: constraints.length
@@ -6473,13 +7121,13 @@ async function getArchConstraints$3(deps) {
 		if (deps.projectRoot) {
 			const fallback = readArchConstraintsFromFile(deps.projectRoot);
 			if (fallback) {
-				logger$20.info("Using file-based fallback for architecture constraints (decisions table empty)");
+				logger$21.info("Using file-based fallback for architecture constraints (decisions table empty)");
 				return fallback.length > ARCH_CONSTRAINT_MAX_CHARS ? fallback.slice(0, ARCH_CONSTRAINT_MAX_CHARS) + "\n\n[truncated for token budget]" : fallback;
 			}
 		}
 		return "";
 	} catch (err) {
-		logger$20.warn({ error: err instanceof Error ? err.message : String(err) }, "Failed to retrieve architecture constraints");
+		logger$21.warn({ error: err instanceof Error ? err.message : String(err) }, "Failed to retrieve architecture constraints");
 		return "";
 	}
 }
@@ -6532,7 +7180,7 @@ function readEpicShardFromFile(projectRoot, epicId) {
 		} catch {}
 		return "";
 	} catch (err) {
-		logger$20.warn({
+		logger$21.warn({
 			epicId,
 			error: err instanceof Error ? err.message : String(err)
 		}, "File-based epic shard fallback failed");
@@ -6555,7 +7203,7 @@ function readArchConstraintsFromFile(projectRoot) {
 		const content = readFileSync(archPath, "utf-8");
 		return content.slice(0, 1500);
 	} catch (err) {
-		logger$20.warn({ error: err instanceof Error ? err.message : String(err) }, "File-based architecture fallback failed");
+		logger$21.warn({ error: err instanceof Error ? err.message : String(err) }, "File-based architecture fallback failed");
 		return "";
 	}
 }
@@ -6568,7 +7216,7 @@ async function getStoryTemplate(deps) {
 	try {
 		return await deps.pack.getTemplate("story");
 	} catch (err) {
-		logger$20.warn({ error: err instanceof Error ? err.message : String(err) }, "Failed to retrieve story template from pack");
+		logger$21.warn({ error: err instanceof Error ? err.message : String(err) }, "Failed to retrieve story template from pack");
 		return "";
 	}
 }
@@ -6605,7 +7253,7 @@ async function isValidStoryFile(filePath) {
 
 //#endregion
 //#region src/modules/compiled-workflows/git-helpers.ts
-const logger$19 = createLogger("compiled-workflows:git-helpers");
+const logger$20 = createLogger("compiled-workflows:git-helpers");
 /**
 * Check whether the repo at `cwd` has at least one commit (HEAD resolves).
 * Returns false for fresh repos with no commits, avoiding `fatal: bad revision 'HEAD'`.
@@ -6642,7 +7290,7 @@ function hasCommits(cwd) {
 */
 async function getGitDiffSummary(workingDirectory = process.cwd()) {
 	if (!hasCommits(workingDirectory)) {
-		logger$19.debug({ cwd: workingDirectory }, "No commits in repo — returning empty diff");
+		logger$20.debug({ cwd: workingDirectory }, "No commits in repo — returning empty diff");
 		return "";
 	}
 	return runGitCommand(["diff", "HEAD"], workingDirectory, "git-diff-summary");
@@ -6659,7 +7307,7 @@ async function getGitDiffSummary(workingDirectory = process.cwd()) {
 */
 async function getGitDiffStatSummary(workingDirectory = process.cwd()) {
 	if (!hasCommits(workingDirectory)) {
-		logger$19.debug({ cwd: workingDirectory }, "No commits in repo — returning empty stat");
+		logger$20.debug({ cwd: workingDirectory }, "No commits in repo — returning empty stat");
 		return "";
 	}
 	return runGitCommand([
@@ -6708,7 +7356,7 @@ async function getGitDiffStatBetweenCommits(baseCommit, endCommit = "HEAD", work
 async function getGitDiffForFiles(files, workingDirectory = process.cwd()) {
 	if (files.length === 0) return "";
 	if (!hasCommits(workingDirectory)) {
-		logger$19.debug({ cwd: workingDirectory }, "No commits in repo — returning empty diff for files");
+		logger$20.debug({ cwd: workingDirectory }, "No commits in repo — returning empty diff for files");
 		return "";
 	}
 	await stageIntentToAdd(files, workingDirectory);
@@ -6735,7 +7383,7 @@ async function getGitDiffForFiles(files, workingDirectory = process.cwd()) {
 async function getGitDiffStatForFiles(files, workingDirectory = process.cwd()) {
 	if (files.length === 0) return "";
 	if (!hasCommits(workingDirectory)) {
-		logger$19.debug({ cwd: workingDirectory }, "No commits in repo — returning empty stat for files");
+		logger$20.debug({ cwd: workingDirectory }, "No commits in repo — returning empty stat for files");
 		return "";
 	}
 	return runGitCommand([
@@ -6784,7 +7432,7 @@ async function stageIntentToAdd(files, workingDirectory) {
 	if (files.length === 0) return;
 	const existing = files.filter((f$1) => {
 		const exists = existsSync(f$1);
-		if (!exists) logger$19.debug({ file: f$1 }, "Skipping nonexistent file in stageIntentToAdd");
+		if (!exists) logger$20.debug({ file: f$1 }, "Skipping nonexistent file in stageIntentToAdd");
 		return exists;
 	});
 	if (existing.length === 0) return;
@@ -6818,7 +7466,7 @@ async function runGitCommand(args, cwd, logLabel) {
 			stderr += chunk.toString("utf-8");
 		});
 		proc$1.on("error", (err) => {
-			logger$19.warn({
+			logger$20.warn({
 				label: logLabel,
 				cwd,
 				error: err.message
@@ -6827,7 +7475,7 @@ async function runGitCommand(args, cwd, logLabel) {
 		});
 		proc$1.on("close", (code) => {
 			if (code !== 0) {
-				logger$19.warn({
+				logger$20.warn({
 					label: logLabel,
 					cwd,
 					code,
@@ -6843,7 +7491,7 @@ async function runGitCommand(args, cwd, logLabel) {
 
 //#endregion
 //#region src/modules/compiled-workflows/story-complexity.ts
-const logger$18 = createLogger("compiled-workflows:story-complexity");
+const logger$19 = createLogger("compiled-workflows:story-complexity");
 /**
 * Compute a complexity score from story markdown content.
 *
@@ -6895,7 +7543,7 @@ function resolveFixStoryMaxTurns(complexityScore) {
 * @param resolvedMaxTurns - Turn limit resolved for this dispatch
 */
 function logComplexityResult(storyKey, complexity, resolvedMaxTurns) {
-	logger$18.info({
+	logger$19.info({
 		storyKey,
 		taskCount: complexity.taskCount,
 		subtaskCount: complexity.subtaskCount,
@@ -7151,7 +7799,7 @@ function resolveInstallCommand(projectRoot) {
 
 //#endregion
 //#region src/modules/compiled-workflows/dev-story.ts
-const logger$17 = createLogger("compiled-workflows:dev-story");
+const logger$18 = createLogger("compiled-workflows:dev-story");
 /** Default timeout for dev-story dispatches in milliseconds (30 min) */
 const DEFAULT_TIMEOUT_MS$2 = 18e5;
 /**
@@ -7163,12 +7811,12 @@ const DEFAULT_TIMEOUT_MS$2 = 18e5;
 */
 async function runDevStory(deps, params) {
 	const { storyKey, storyFilePath, taskScope, priorFiles, findingsPrompt: handlerFindingsPrompt } = params;
-	logger$17.info({
+	logger$18.info({
 		storyKey,
 		storyFilePath
 	}, "Starting compiled dev-story workflow");
 	const { ceiling: TOKEN_CEILING, source: tokenCeilingSource } = getTokenCeiling("dev-story", deps.tokenCeilings);
-	logger$17.info({
+	logger$18.info({
 		workflow: "dev-story",
 		ceiling: TOKEN_CEILING,
 		source: tokenCeilingSource
@@ -7211,10 +7859,10 @@ async function runDevStory(deps, params) {
 	let template;
 	try {
 		template = await deps.pack.getPrompt("dev-story");
-		logger$17.debug({ storyKey }, "Retrieved dev-story prompt template from pack");
+		logger$18.debug({ storyKey }, "Retrieved dev-story prompt template from pack");
 	} catch (err) {
 		const error = err instanceof Error ? err.message : String(err);
-		logger$17.error({
+		logger$18.error({
 			storyKey,
 			error
 		}, "Failed to retrieve dev-story prompt template");
@@ -7225,14 +7873,14 @@ async function runDevStory(deps, params) {
 		storyContent = await readFile$1(storyFilePath, "utf-8");
 	} catch (err) {
 		if (err.code === "ENOENT") {
-			logger$17.error({
+			logger$18.error({
 				storyKey,
 				storyFilePath
 			}, "Story file not found");
 			return makeFailureResult("story_file_not_found");
 		}
 		const error = err instanceof Error ? err.message : String(err);
-		logger$17.error({
+		logger$18.error({
 			storyKey,
 			storyFilePath,
 			error
@@ -7240,7 +7888,7 @@ async function runDevStory(deps, params) {
 		return makeFailureResult(`story_file_read_error: ${error}`);
 	}
 	if (storyContent.trim().length === 0) {
-		logger$17.error({
+		logger$18.error({
 			storyKey,
 			storyFilePath
 		}, "Story file is empty");
@@ -7248,7 +7896,7 @@ async function runDevStory(deps, params) {
 	}
 	const staleStatus = detectDeprecatedStatusField(storyContent);
 	if (staleStatus !== null) {
-		logger$17.warn({
+		logger$18.warn({
 			storyFilePath,
 			staleStatus
 		}, "Story spec contains deprecated Status field — stripped before dispatch (status is managed by Dolt work graph)");
@@ -7263,17 +7911,17 @@ async function runDevStory(deps, params) {
 		const testPatternDecisions = solutioningDecisions.filter((d) => d.category === "test-patterns");
 		if (testPatternDecisions.length > 0) {
 			testPatternsContent = "## Test Patterns\n" + testPatternDecisions.map((d) => `- ${d.key}: ${d.value}`).join("\n");
-			logger$17.debug({
+			logger$18.debug({
 				storyKey,
 				count: testPatternDecisions.length
 			}, "Loaded test patterns from decision store");
 		} else {
 			testPatternsContent = resolveDefaultTestPatterns(deps.projectRoot);
-			logger$17.debug({ storyKey }, "No test-pattern decisions — using stack-aware defaults");
+			logger$18.debug({ storyKey }, "No test-pattern decisions — using stack-aware defaults");
 		}
 	} catch (err) {
 		const error = err instanceof Error ? err.message : String(err);
-		logger$17.warn({
+		logger$18.warn({
 			storyKey,
 			error
 		}, "Failed to load test patterns — using defaults");
@@ -7287,7 +7935,7 @@ async function runDevStory(deps, params) {
 	if (deps.repoMapInjector !== void 0) {
 		const injection = await deps.repoMapInjector.buildContext(storyContent, deps.maxRepoMapTokens ?? 2e3);
 		repoContextContent = injection.text;
-		logger$17.info({
+		logger$18.info({
 			storyKey,
 			repoMapTokens: Math.ceil(injection.text.length / 4),
 			symbolCount: injection.symbolCount,
@@ -7297,7 +7945,7 @@ async function runDevStory(deps, params) {
 	let priorFindingsContent = "";
 	if (handlerFindingsPrompt !== void 0 && handlerFindingsPrompt.length > 0) {
 		priorFindingsContent = handlerFindingsPrompt;
-		logger$17.debug({
+		logger$18.debug({
 			storyKey,
 			findingsLen: handlerFindingsPrompt.length
 		}, "Using pre-computed findings from handler (Story 53-8 AC2)");
@@ -7309,7 +7957,7 @@ async function runDevStory(deps, params) {
 		});
 		if (findings.length > 0) {
 			priorFindingsContent = findings;
-			logger$17.debug({
+			logger$18.debug({
 				storyKey,
 				findingsLen: findings.length
 			}, "Injecting relevance-scored findings into dev-story prompt");
@@ -7329,7 +7977,7 @@ async function runDevStory(deps, params) {
 			if (plan.test_categories && plan.test_categories.length > 0) parts.push(`\n### Categories: ${plan.test_categories.join(", ")}`);
 			if (plan.coverage_notes) parts.push(`\n### Coverage Notes\n${plan.coverage_notes}`);
 			testPlanContent = parts.join("\n");
-			logger$17.debug({ storyKey }, "Injecting test plan into dev-story prompt");
+			logger$18.debug({ storyKey }, "Injecting test plan into dev-story prompt");
 		}
 	} catch {}
 	const sections = [
@@ -7390,7 +8038,7 @@ async function runDevStory(deps, params) {
 		}
 	];
 	const { prompt, tokenCount, truncated } = assemblePrompt(template, sections, TOKEN_CEILING);
-	logger$17.info({
+	logger$18.info({
 		storyKey,
 		tokenCount,
 		ceiling: TOKEN_CEILING,
@@ -7414,7 +8062,7 @@ async function runDevStory(deps, params) {
 		dispatchResult = await handle.result;
 	} catch (err) {
 		const error = err instanceof Error ? err.message : String(err);
-		logger$17.error({
+		logger$18.error({
 			storyKey,
 			error
 		}, "Dispatch threw an unexpected error");
@@ -7425,11 +8073,11 @@ async function runDevStory(deps, params) {
 		output: dispatchResult.tokenEstimate.output
 	};
 	if (dispatchResult.status === "timeout") {
-		logger$17.error({
+		logger$18.error({
 			storyKey,
 			durationMs: dispatchResult.durationMs
 		}, "Dev-story dispatch timed out");
-		if (dispatchResult.output.length > 0) logger$17.info({
+		if (dispatchResult.output.length > 0) logger$18.info({
 			storyKey,
 			partialOutput: dispatchResult.output.slice(0, 500)
 		}, "Partial output before timeout");
@@ -7439,12 +8087,12 @@ async function runDevStory(deps, params) {
 		};
 	}
 	if (dispatchResult.status === "failed" || dispatchResult.exitCode !== 0) {
-		logger$17.error({
+		logger$18.error({
 			storyKey,
 			exitCode: dispatchResult.exitCode,
 			status: dispatchResult.status
 		}, "Dev-story dispatch failed");
-		if (dispatchResult.output.length > 0) logger$17.info({
+		if (dispatchResult.output.length > 0) logger$18.info({
 			storyKey,
 			partialOutput: dispatchResult.output.slice(0, 500)
 		}, "Partial output from failed dispatch");
@@ -7456,7 +8104,7 @@ async function runDevStory(deps, params) {
 	if (dispatchResult.parseError !== null || dispatchResult.parsed === null) {
 		const details = dispatchResult.parseError ?? "parsed result was null";
 		const rawSnippet = dispatchResult.output ? dispatchResult.output.slice(0, 1e3) : "(empty)";
-		logger$17.error({
+		logger$18.error({
 			storyKey,
 			parseError: details,
 			rawOutputSnippet: rawSnippet
@@ -7464,12 +8112,12 @@ async function runDevStory(deps, params) {
 		let filesModified = [];
 		try {
 			filesModified = await getGitChangedFiles(deps.projectRoot ?? process.cwd());
-			if (filesModified.length > 0) logger$17.info({
+			if (filesModified.length > 0) logger$18.info({
 				storyKey,
 				fileCount: filesModified.length
 			}, "Recovered files_modified from git status (YAML fallback)");
 		} catch (err) {
-			logger$17.warn({
+			logger$18.warn({
 				storyKey,
 				error: err instanceof Error ? err.message : String(err)
 			}, "Failed to recover files_modified from git");
@@ -7486,7 +8134,7 @@ async function runDevStory(deps, params) {
 		};
 	}
 	const parsed = dispatchResult.parsed;
-	logger$17.info({
+	logger$18.info({
 		storyKey,
 		result: parsed.result,
 		acMet: parsed.ac_met.length
@@ -7602,7 +8250,7 @@ function extractReferencedFiles(storyContent) {
 	const matches = storyContent.match(filePathRegex) ?? [];
 	const freq = new Map();
 	for (const m of matches) freq.set(m, (freq.get(m) ?? 0) + 1);
-	const sorted = [...freq.entries()].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).map(([path$4]) => path$4);
+	const sorted = [...freq.entries()].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).map(([path$6]) => path$6);
 	return sorted.filter((p) => !p.includes(".test."));
 }
 function extractFilesInScope(storyContent) {
@@ -7899,7 +8547,7 @@ function resolvesIntoExpected(modifiedFilePath, relativePath, expectedFiles) {
 
 //#endregion
 //#region src/modules/compiled-workflows/code-review.ts
-const logger$16 = createLogger("compiled-workflows:code-review");
+const logger$17 = createLogger("compiled-workflows:code-review");
 /**
 * Default fallback result when dispatch fails or times out.
 * Uses NEEDS_MINOR_FIXES (not NEEDS_MAJOR_REWORK) so a parse/schema failure
@@ -7974,14 +8622,14 @@ async function countTestMetrics(filesModified, cwd) {
 async function runCodeReview(deps, params) {
 	const { storyKey, storyFilePath, workingDirectory, pipelineRunId, filesModified, previousIssues, buildPassed, baselineCommit } = params;
 	const cwd = workingDirectory ?? process.cwd();
-	logger$16.debug({
+	logger$17.debug({
 		storyKey,
 		storyFilePath,
 		cwd,
 		pipelineRunId
 	}, "Starting code-review workflow");
 	const { ceiling: TOKEN_CEILING, source: tokenCeilingSource } = getTokenCeiling("code-review", deps.tokenCeilings);
-	logger$16.info({
+	logger$17.info({
 		workflow: "code-review",
 		ceiling: TOKEN_CEILING,
 		source: tokenCeilingSource
@@ -7991,7 +8639,7 @@ async function runCodeReview(deps, params) {
 		template = await deps.pack.getPrompt("code-review");
 	} catch (err) {
 		const error = err instanceof Error ? err.message : String(err);
-		logger$16.error({ error }, "Failed to retrieve code-review prompt template");
+		logger$17.error({ error }, "Failed to retrieve code-review prompt template");
 		return defaultFailResult(`Failed to retrieve prompt template: ${error}`, {
 			input: 0,
 			output: 0
@@ -8002,7 +8650,7 @@ async function runCodeReview(deps, params) {
 		storyContent = await readFile$1(storyFilePath, "utf-8");
 	} catch (err) {
 		const error = err instanceof Error ? err.message : String(err);
-		logger$16.error({
+		logger$17.error({
 			storyFilePath,
 			error
 		}, "Failed to read story file");
@@ -8022,12 +8670,12 @@ async function runCodeReview(deps, params) {
 		const scopedTotal = nonDiffTokens + countTokens(scopedDiff);
 		if (scopedTotal <= TOKEN_CEILING) {
 			gitDiffContent = scopedDiff;
-			logger$16.debug({
+			logger$17.debug({
 				fileCount: filesModified.length,
 				tokenCount: scopedTotal
 			}, "Using scoped file diff");
 		} else {
-			logger$16.warn({
+			logger$17.warn({
 				estimatedTotal: scopedTotal,
 				ceiling: TOKEN_CEILING,
 				fileCount: filesModified.length
@@ -8041,7 +8689,7 @@ async function runCodeReview(deps, params) {
 		const fullTotal = nonDiffTokens + countTokens(fullDiff);
 		if (fullTotal <= TOKEN_CEILING) gitDiffContent = fullDiff;
 		else {
-			logger$16.warn({
+			logger$17.warn({
 				estimatedTotal: fullTotal,
 				ceiling: TOKEN_CEILING
 			}, "Full git diff would exceed token ceiling — using stat-only summary");
@@ -8049,7 +8697,7 @@ async function runCodeReview(deps, params) {
 		}
 	}
 	if (gitDiffContent.trim().length === 0 && baselineCommit) {
-		logger$16.info({
+		logger$17.info({
 			storyKey,
 			baselineCommit
 		}, "Working tree diff empty — diffing against baseline commit");
@@ -8057,7 +8705,7 @@ async function runCodeReview(deps, params) {
 		const commitTotal = nonDiffTokens + countTokens(commitDiff);
 		if (commitDiff.trim().length > 0) if (commitTotal <= TOKEN_CEILING) gitDiffContent = commitDiff;
 		else {
-			logger$16.warn({
+			logger$17.warn({
 				estimatedTotal: commitTotal,
 				ceiling: TOKEN_CEILING
 			}, "Baseline..HEAD diff exceeds token ceiling — using stat-only summary");
@@ -8065,7 +8713,7 @@ async function runCodeReview(deps, params) {
 		}
 	}
 	if (gitDiffContent.trim().length === 0) {
-		logger$16.info({ storyKey }, "Empty git diff — skipping review with SHIP_IT");
+		logger$17.info({ storyKey }, "Empty git diff — skipping review with SHIP_IT");
 		return {
 			verdict: "SHIP_IT",
 			issues: 0,
@@ -8081,7 +8729,7 @@ async function runCodeReview(deps, params) {
 	if (deps.repoMapInjector !== void 0) {
 		const injection = await deps.repoMapInjector.buildContext(storyContent, deps.maxRepoMapTokens ?? 2e3);
 		repoContextContent = injection.text;
-		logger$16.info({
+		logger$17.info({
 			storyKey,
 			repoMapTokens: Math.ceil(injection.text.length / 4),
 			symbolCount: injection.symbolCount,
@@ -8101,17 +8749,17 @@ async function runCodeReview(deps, params) {
 		const findings = await getProjectFindings(deps.db);
 		if (findings.length > 0) {
 			priorFindingsContent = "Previous reviews found these recurring patterns — pay special attention:\n\n" + findings;
-			logger$16.debug({
+			logger$17.debug({
 				storyKey,
 				findingsLen: findings.length
 			}, "Injecting prior findings into code-review prompt");
 		}
 	} catch {}
 	const testMetricsContent = await countTestMetrics(filesModified, cwd);
-	if (testMetricsContent) logger$16.debug({ storyKey }, "Injecting verified test-count metrics into code-review context");
+	if (testMetricsContent) logger$17.debug({ storyKey }, "Injecting verified test-count metrics into code-review context");
 	const fileDiffs = gitDiffContent ? parseDiffByFile(gitDiffContent) : void 0;
 	const scopeAnalysisContent = storyContent && filesModified ? ScopeGuardrail.buildAnalysis(storyContent, filesModified, fileDiffs) : "";
-	if (scopeAnalysisContent) logger$16.debug({ storyKey }, "Scope analysis detected out-of-scope files");
+	if (scopeAnalysisContent) logger$17.debug({ storyKey }, "Scope analysis detected out-of-scope files");
 	const buildStatusPrefix = buildPassed === true ? "BUILD STATUS: PASSED — code compiles and passes build verification. Focus on logic correctness, style, and acceptance criteria rather than compilation errors.\n\n" : "";
 	const sections = [
 		{
@@ -8156,11 +8804,11 @@ async function runCodeReview(deps, params) {
 		}
 	];
 	const assembleResult = assemblePrompt(template, sections, TOKEN_CEILING);
-	if (assembleResult.truncated) logger$16.warn({
+	if (assembleResult.truncated) logger$17.warn({
 		storyKey,
 		tokenCount: assembleResult.tokenCount
 	}, "Code-review prompt truncated to fit token ceiling");
-	logger$16.debug({
+	logger$17.debug({
 		storyKey,
 		tokenCount: assembleResult.tokenCount,
 		truncated: assembleResult.truncated
@@ -8181,7 +8829,7 @@ async function runCodeReview(deps, params) {
 		dispatchResult = await handle.result;
 	} catch (err) {
 		const error = err instanceof Error ? err.message : String(err);
-		logger$16.error({
+		logger$17.error({
 			storyKey,
 			error
 		}, "Code-review dispatch threw unexpected error");
@@ -8197,7 +8845,7 @@ async function runCodeReview(deps, params) {
 	const rawOutput = dispatchResult.output ?? void 0;
 	if (dispatchResult.status === "failed") {
 		const errorMsg = `Dispatch status: failed. Exit code: ${dispatchResult.exitCode}. ${dispatchResult.parseError ?? ""} ${dispatchResult.output ? `Stderr: ${dispatchResult.output}` : ""}`.trim();
-		logger$16.warn({
+		logger$17.warn({
 			storyKey,
 			exitCode: dispatchResult.exitCode
 		}, "Code-review dispatch failed");
@@ -8207,7 +8855,7 @@ async function runCodeReview(deps, params) {
 		};
 	}
 	if (dispatchResult.status === "timeout") {
-		logger$16.warn({ storyKey }, "Code-review dispatch timed out");
+		logger$17.warn({ storyKey }, "Code-review dispatch timed out");
 		return {
 			...defaultFailResult("Dispatch status: timeout. The agent did not complete within the allowed time.", tokenUsage),
 			rawOutput
@@ -8215,7 +8863,7 @@ async function runCodeReview(deps, params) {
 	}
 	if (dispatchResult.parsed === null) {
 		const details = dispatchResult.parseError ?? "No YAML block found in output";
-		logger$16.warn({
+		logger$17.warn({
 			storyKey,
 			details
 		}, "Code-review output schema validation failed");
@@ -8233,7 +8881,7 @@ async function runCodeReview(deps, params) {
 	const parseResult = CodeReviewResultSchema.safeParse(dispatchResult.parsed);
 	if (!parseResult.success) {
 		const details = parseResult.error.message;
-		logger$16.warn({
+		logger$17.warn({
 			storyKey,
 			details
 		}, "Code-review output failed schema validation");
@@ -8249,13 +8897,13 @@ async function runCodeReview(deps, params) {
 		};
 	}
 	const parsed = parseResult.data;
-	if (parsed.agentVerdict !== parsed.verdict) logger$16.info({
+	if (parsed.agentVerdict !== parsed.verdict) logger$17.info({
 		storyKey,
 		agentVerdict: parsed.agentVerdict,
 		pipelineVerdict: parsed.verdict,
 		issues: parsed.issues
 	}, "Pipeline overrode agent verdict based on issue severities");
-	logger$16.info({
+	logger$17.info({
 		storyKey,
 		verdict: parsed.verdict,
 		issues: parsed.issues
@@ -8280,11 +8928,236 @@ async function getArchConstraints$2(deps) {
 		if (constraints.length === 0) return "";
 		return constraints.map((d) => `${d.key}: ${d.value}`).join("\n");
 	} catch (err) {
-		logger$16.warn({ error: err instanceof Error ? err.message : String(err) }, "Failed to retrieve architecture constraints");
+		logger$17.warn({ error: err instanceof Error ? err.message : String(err) }, "Failed to retrieve architecture constraints");
 		return "";
 	}
 }
 
+//#endregion
+//#region src/modules/compiled-workflows/merge-to-main.ts
+const logger$16 = createLogger("compiled-workflows:merge-to-main");
+/**
+* Execute the merge-to-main phase: merge the story branch into the base branch.
+*
+* Attempts fast-forward first, falls back to 3-way merge. On conflict:
+* emits `pipeline:merge-conflict-detected` event, aborts the merge, preserves
+* the worktree and branch for operator inspection, and returns a failure result.
+*
+* Merge commands run against `projectRoot` (the main working tree).
+* The main working tree must already be on `startBranch` (checked out at
+* orchestrator startup — no branch switching is performed here).
+*
+* @param params - Merge phase parameters (storyKey, branchName, startBranch,
+*                 worktreeManager, eventBus, projectRoot)
+* @returns MergeToMainResult — success=true on merged; success=false with
+*          reason='merge-conflict-detected' and conflictingFiles on conflict.
+*/
+async function runMergeToMain(params) {
+	const { storyKey, branchName, startBranch, worktreeManager, eventBus, projectRoot } = params;
+	logger$16.info({
+		storyKey,
+		branchName,
+		startBranch
+	}, "Starting merge-to-main phase");
+	const ffSuccess = tryFfMerge(branchName, projectRoot);
+	if (ffSuccess) {
+		logger$16.info({
+			storyKey,
+			branchName
+		}, "Fast-forward merge succeeded");
+		await cleanupAfterSuccessfulMerge(storyKey, branchName, worktreeManager, projectRoot);
+		return { success: true };
+	}
+	logger$16.info({
+		storyKey,
+		branchName
+	}, "Fast-forward merge failed — attempting 3-way merge");
+	const threeWayResult = tryThreeWayMerge(branchName, projectRoot);
+	if (threeWayResult.success) {
+		logger$16.info({
+			storyKey,
+			branchName
+		}, "3-way merge succeeded");
+		await cleanupAfterSuccessfulMerge(storyKey, branchName, worktreeManager, projectRoot);
+		return { success: true };
+	}
+	const { conflictingFiles } = threeWayResult;
+	logger$16.warn({
+		storyKey,
+		branchName,
+		conflictingFiles
+	}, "Merge conflict detected — preserving worktree for operator inspection");
+	eventBus.emit("pipeline:merge-conflict-detected", {
+		storyKey,
+		branchName,
+		conflictingFiles
+	});
+	return {
+		success: false,
+		reason: "merge-conflict-detected",
+		conflictingFiles
+	};
+}
+/**
+* Attempt a fast-forward merge of `branchName` into the current branch.
+*
+* @param branchName  - Branch to merge
+* @param projectRoot - Working directory (main worktree, already on startBranch)
+* @returns           - true if FF succeeded, false if it failed (branch diverged)
+*/
+function tryFfMerge(branchName, projectRoot) {
+	try {
+		execFileSync("git", [
+			"merge",
+			"--ff-only",
+			branchName
+		], {
+			cwd: projectRoot,
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			]
+		});
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* Attempt a 3-way merge of `branchName` into the current branch.
+*
+* On conflict: parses conflicting files from `git diff --name-only --diff-filter=U`
+* and aborts the merge before returning.
+*
+* @param branchName  - Branch to merge
+* @param projectRoot - Working directory (main worktree, already on startBranch)
+* @returns           - { success: true } on clean merge;
+*                      { success: false, conflictingFiles: string[] } on conflict
+*/
+function tryThreeWayMerge(branchName, projectRoot) {
+	try {
+		execFileSync("git", [
+			"merge",
+			"--no-edit",
+			branchName
+		], {
+			cwd: projectRoot,
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			]
+		});
+		return {
+			success: true,
+			conflictingFiles: []
+		};
+	} catch {
+		let conflictingFiles = [];
+		try {
+			const diffOutput = execFileSync("git", [
+				"diff",
+				"--name-only",
+				"--diff-filter=U"
+			], {
+				cwd: projectRoot,
+				encoding: "utf-8",
+				stdio: [
+					"ignore",
+					"pipe",
+					"pipe"
+				]
+			});
+			conflictingFiles = diffOutput.trim().split("\n").filter((line) => line.length > 0);
+		} catch (diffErr) {
+			logger$16.warn({ err: diffErr }, "Failed to list conflicting files (best-effort)");
+		}
+		try {
+			execFileSync("git", ["merge", "--abort"], {
+				cwd: projectRoot,
+				stdio: [
+					"ignore",
+					"pipe",
+					"pipe"
+				]
+			});
+		} catch (abortErr) {
+			logger$16.warn({ err: abortErr }, "Failed to abort merge (best-effort)");
+		}
+		return {
+			success: false,
+			conflictingFiles
+		};
+	}
+}
+/**
+* Clean up the worktree and delete the merged branch after a successful merge.
+*
+* Cleanup is best-effort — a failure here does not revert the already-completed
+* git merge. Both operations are attempted independently.
+*
+* @param storyKey       - Story key (used as worktree task ID)
+* @param branchName     - Branch that was merged (to delete)
+* @param worktreeManager - Manager for removing the worktree directory
+* @param projectRoot    - Working directory for git branch deletion
+*/
+async function cleanupAfterSuccessfulMerge(storyKey, branchName, worktreeManager, projectRoot) {
+	try {
+		await worktreeManager.cleanupWorktree(storyKey);
+		logger$16.info({ storyKey }, "Worktree removed after successful merge");
+	} catch (worktreeErr) {
+		logger$16.warn({
+			storyKey,
+			err: worktreeErr
+		}, "Failed to remove worktree (best-effort)");
+	}
+	try {
+		execFileSync("git", [
+			"branch",
+			"-d",
+			branchName
+		], {
+			cwd: projectRoot,
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			]
+		});
+		logger$16.info({
+			storyKey,
+			branchName
+		}, "Merged branch deleted");
+	} catch (branchErr) {
+		logger$16.warn({
+			storyKey,
+			branchName,
+			err: branchErr
+		}, "Failed to delete merged branch (best-effort)");
+	}
+}
+/**
+* Create a serialized merge queue to prevent concurrent git merge operations.
+*
+* Returns an `enqueueMerge` function that wraps `runMergeToMain`. All calls
+* through the returned function are serialized: each invocation waits for the
+* previous to fully complete before starting. This prevents data-corruption
+* from concurrent `git merge` operations against the same base branch (AC7).
+*
+* Used by `orchestrator-impl.ts` to create a per-run merge queue. Exported
+* separately so the serialization logic can be unit-tested independently of
+* the orchestrator (see AC8d in Story 75-2).
+*
+* @returns A queue-serialized wrapper around `runMergeToMain`.
+*/
+function createMergeQueue() {
+	let queue = Promise.resolve();
+	return (params) => new Promise((resolve$6, reject) => {
+		queue = queue.then(() => runMergeToMain(params)).then(resolve$6, reject).then(() => void 0, () => void 0);
+	});
+}
+
 //#endregion
 //#region src/modules/compiled-workflows/test-plan.ts
 const logger$15 = createLogger("compiled-workflows:test-plan");
@@ -12071,6 +12944,17 @@ function topologicalSortByDependencies(keys, projectRoot) {
 function toSdlcEventBus(bus) {
 	return bus;
 }
+/**
+* Project the monolith event bus to `TypedEventBus<CoreEvents>` for GitWorktreeManager.
+*
+* Story 75-1 (Path E spike 2026-05-10): OrchestratorEvents mirrors the CoreEvents worktree
+* events ('worktree:created', 'worktree:removed') so the cast is safe at runtime.
+* TypeScript cannot perform the direct cast due to generic method signatures; the
+* `as unknown` intermediate is isolated here to keep call sites clean.
+*/
+function toCoreEventBus(bus) {
+	return bus;
+}
 function estimateDispatchCost(input, output) {
 	return (input * 3 + output * 15) / 1e6;
 }
@@ -12386,8 +13270,13 @@ function checkProfileStaleness(projectRoot) {
 * @returns A fully-configured ImplementationOrchestrator ready to call run()
 */
 function createImplementationOrchestrator(deps) {
-	const { db, pack, contextCompiler, dispatcher, eventBus, config, projectRoot, tokenCeilings, stateStore, telemetryPersistence, ingestionServer, repoMapInjector, maxRepoMapTokens, agentId, runManifest = null } = deps;
-	const logger$26 = createLogger("implementation-orchestrator");
+	const { db, pack, contextCompiler, dispatcher, eventBus, config, projectRoot, tokenCeilings, stateStore, telemetryPersistence, ingestionServer, repoMapInjector, maxRepoMapTokens, agentId, runManifest = null, worktreeManager } = deps;
+	const noWorktree = config.noWorktree ?? false;
+	const _worktreeManager = worktreeManager ?? (projectRoot !== void 0 && !noWorktree ? createGitWorktreeManager({
+		eventBus: toCoreEventBus(eventBus),
+		projectRoot
+	}) : void 0);
+	const logger$27 = createLogger("implementation-orchestrator");
 	const telemetryAdvisor = db !== void 0 ? createTelemetryAdvisor({ db }) : void 0;
 	const wgRepo = new WorkGraphRepository(db);
 	const _wgInProgressWritten = new Set();
@@ -12413,6 +13302,7 @@ function createImplementationOrchestrator(deps) {
 	let _completedDispatches = 0;
 	let _maxConcurrentActual = 0;
 	let _packageSnapshot;
+	let _orchestratorStartBranch;
 	let _contractMismatches;
 	const _costChecker = new CostGovernanceChecker();
 	let _costWarningEmitted = false;
@@ -12429,6 +13319,7 @@ function createImplementationOrchestrator(deps) {
 	const verificationPipeline = createDefaultVerificationPipeline(toSdlcEventBus(eventBus), void 0);
 	const _stateStoreCache = new Map();
 	const _checkpoints = new Map();
+	const enqueueMerge = createMergeQueue();
 	const MEMORY_PRESSURE_BACKOFF_MS = [
 		3e4,
 		6e4,
@@ -12471,7 +13362,7 @@ function createImplementationOrchestrator(deps) {
 			const existingCount = storyState?.retry_count ?? 0;
 			_storyRetryCount.set(storyKey, existingCount);
 		} catch (err) {
-			logger$26.warn({
+			logger$27.warn({
 				err,
 				storyKey
 			}, "initRetryCount: failed to read manifest — starting at 0");
@@ -12485,7 +13376,7 @@ function createImplementationOrchestrator(deps) {
 		const current = _storyRetryCount.get(storyKey) ?? 0;
 		const next = current + 1;
 		_storyRetryCount.set(storyKey, next);
-		if (runManifest !== null && runManifest !== void 0) runManifest.patchStoryState(storyKey, { retry_count: next }).catch((err) => logger$26.warn({
+		if (runManifest !== null && runManifest !== void 0) runManifest.patchStoryState(storyKey, { retry_count: next }).catch((err) => logger$27.warn({
 			err,
 			storyKey
 		}, "patchStoryState(retry_count) failed — pipeline continues"));
@@ -12498,7 +13389,7 @@ function createImplementationOrchestrator(deps) {
 		const nowMs = Date.now();
 		for (const [phase, startMs] of starts) {
 			const endMs = ends?.get(phase);
-			if (endMs === void 0) logger$26.warn({
+			if (endMs === void 0) logger$27.warn({
 				storyKey,
 				phase
 			}, "Phase has no end time — story may have errored mid-phase. Duration capped to now() and may be inflated.");
@@ -12515,7 +13406,7 @@ function createImplementationOrchestrator(deps) {
 			const wallClockSeconds = startedAt ? Math.round((new Date(completedAt).getTime() - new Date(startedAt).getTime()) / 1e3) : 0;
 			const wallClockMs = startedAt ? new Date(completedAt).getTime() - new Date(startedAt).getTime() : 0;
 			const tokenAgg = await aggregateTokenUsageForStory(db, config.pipelineRunId, storyKey);
-			if (runManifest !== null) runManifest.patchStoryState(storyKey, { cost_usd: tokenAgg.cost }).catch((err) => logger$26.warn({
+			if (runManifest !== null) runManifest.patchStoryState(storyKey, { cost_usd: tokenAgg.cost }).catch((err) => logger$27.warn({
 				err,
 				storyKey
 			}, "patchStoryState(cost_usd) failed — pipeline continues"));
@@ -12551,7 +13442,7 @@ function createImplementationOrchestrator(deps) {
 				recordedAt: completedAt,
 				timestamp: completedAt
 			}).catch((storeErr) => {
-				logger$26.warn({
+				logger$27.warn({
 					err: storeErr,
 					storyKey
 				}, "Failed to record metric to StateStore (best-effort)");
@@ -12573,7 +13464,7 @@ function createImplementationOrchestrator(deps) {
 					rationale: `Story ${storyKey} completed with result=${result} in ${wallClockSeconds}s. Tokens: ${tokenAgg.input}+${tokenAgg.output}. Review cycles: ${reviewCycles}.`
 				});
 			} catch (decisionErr) {
-				logger$26.warn({
+				logger$27.warn({
 					err: decisionErr,
 					storyKey
 				}, "Failed to write story-metrics decision (best-effort)");
@@ -12652,7 +13543,7 @@ function createImplementationOrchestrator(deps) {
 				const LOW_OUTPUT_TOKEN_THRESHOLD = 100;
 				const unverified = tokenAgg.output < LOW_OUTPUT_TOKEN_THRESHOLD;
 				if (unverified) {
-					logger$26.warn({
+					logger$27.warn({
 						storyKey,
 						outputTokens: tokenAgg.output,
 						threshold: LOW_OUTPUT_TOKEN_THRESHOLD
@@ -12676,13 +13567,13 @@ function createImplementationOrchestrator(deps) {
 					...unverified ? { unverified: true } : {}
 				});
 			} catch (emitErr) {
-				logger$26.warn({
+				logger$27.warn({
 					err: emitErr,
 					storyKey
 				}, "Failed to emit story:metrics event (best-effort)");
 			}
 		} catch (err) {
-			logger$26.warn({
+			logger$27.warn({
 				err,
 				storyKey
 			}, "Failed to write story metrics (best-effort)");
@@ -12711,7 +13602,7 @@ function createImplementationOrchestrator(deps) {
 				rationale: `Story ${storyKey} ${outcome} after ${reviewCycles} review cycle(s).`
 			});
 		} catch (err) {
-			logger$26.warn({
+			logger$27.warn({
 				err,
 				storyKey
 			}, "Failed to write story-outcome decision (best-effort)");
@@ -12749,7 +13640,7 @@ function createImplementationOrchestrator(deps) {
 				rationale: `Escalation diagnosis for ${payload.storyKey}: ${diagnosis.recommendedAction} — ${diagnosis.rationale}`
 			});
 		} catch (err) {
-			logger$26.warn({
+			logger$27.warn({
 				err,
 				storyKey: payload.storyKey
 			}, "Failed to persist escalation diagnosis (best-effort)");
@@ -12799,7 +13690,7 @@ function createImplementationOrchestrator(deps) {
 		const existing = _stories.get(storyKey);
 		if (existing !== void 0) {
 			Object.assign(existing, updates);
-			persistStoryState(storyKey, existing).catch((err) => logger$26.warn({
+			persistStoryState(storyKey, existing).catch((err) => logger$27.warn({
 				err,
 				storyKey
 			}, "StateStore write failed after updateStory"));
@@ -12808,12 +13699,12 @@ function createImplementationOrchestrator(deps) {
 					storyKey,
 					conflict: err
 				});
-				else logger$26.warn({
+				else logger$27.warn({
 					err,
 					storyKey
 				}, "mergeStory failed");
 			});
-			else if (updates.phase === "ESCALATED" || updates.phase === "VERIFICATION_FAILED") stateStore?.rollbackStory(storyKey).catch((err) => logger$26.warn({
+			else if (updates.phase === "ESCALATED" || updates.phase === "VERIFICATION_FAILED") stateStore?.rollbackStory(storyKey).catch((err) => logger$27.warn({
 				err,
 				storyKey
 			}, "rollbackStory failed — branch may persist"));
@@ -12825,7 +13716,7 @@ function createImplementationOrchestrator(deps) {
 						...updates
 					};
 					const opts = targetStatus === "complete" || targetStatus === "escalated" ? { completedAt: fullUpdated.completedAt } : void 0;
-					wgRepo.updateStoryStatus(storyKey, targetStatus, opts).catch((err) => logger$26.warn({
+					wgRepo.updateStoryStatus(storyKey, targetStatus, opts).catch((err) => logger$27.warn({
 						err,
 						storyKey
 					}, "wg_stories status update failed (best-effort)"));
@@ -12841,7 +13732,7 @@ function createImplementationOrchestrator(deps) {
 					status: "dispatched",
 					phase: String(updates.phase),
 					started_at: fullUpdated.startedAt ?? new Date().toISOString()
-				}).catch((err) => logger$26.warn({
+				}).catch((err) => logger$27.warn({
 					err,
 					storyKey
 				}, "patchStoryState(dispatched) failed — pipeline continues"));
@@ -12853,13 +13744,13 @@ function createImplementationOrchestrator(deps) {
 						completed_at: fullUpdated.completedAt ?? new Date().toISOString(),
 						review_cycles: fullUpdated.reviewCycles ?? 0,
 						dispatches: _storyDispatches.get(storyKey) ?? 0
-					}).catch((err) => logger$26.warn({
+					}).catch((err) => logger$27.warn({
 						err,
 						storyKey
 					}, `patchStoryState(${manifestStatus}) failed — pipeline continues`));
 				} else {
 					const intermediatePhase = updates.phase;
-					runManifest.patchStoryState(storyKey, { phase: String(intermediatePhase) }).catch((err) => logger$26.warn({
+					runManifest.patchStoryState(storyKey, { phase: String(intermediatePhase) }).catch((err) => logger$27.warn({
 						err,
 						storyKey,
 						phase: intermediatePhase
@@ -12890,7 +13781,7 @@ function createImplementationOrchestrator(deps) {
 			};
 			await stateStore.setStoryState(storyKey, record);
 		} catch (err) {
-			logger$26.warn({
+			logger$27.warn({
 				err,
 				storyKey
 			}, "StateStore.setStoryState failed (best-effort)");
@@ -12906,7 +13797,7 @@ function createImplementationOrchestrator(deps) {
 				token_usage_json: serialized
 			});
 		} catch (err) {
-			logger$26.warn({ err }, "Failed to persist orchestrator state");
+			logger$27.warn({ err }, "Failed to persist orchestrator state");
 		}
 	}
 	function recordProgress() {
@@ -12954,7 +13845,7 @@ function createImplementationOrchestrator(deps) {
 				...Object.keys(perStoryState).length > 0 ? { perStoryState } : {}
 			});
 			if (config.pipelineRunId !== void 0) updatePipelineRun(db, config.pipelineRunId, { current_phase: "implementation" }).catch((err) => {
-				logger$26.debug({ err }, "Heartbeat: failed to touch updated_at (non-fatal)");
+				logger$27.debug({ err }, "Heartbeat: failed to touch updated_at (non-fatal)");
 			});
 			const elapsed = Date.now() - _lastProgressTs;
 			let childPids = [];
@@ -12976,7 +13867,7 @@ function createImplementationOrchestrator(deps) {
 				}
 				if (childActive) {
 					_lastProgressTs = Date.now();
-					logger$26.debug({
+					logger$27.debug({
 						storyKey: key,
 						phase: s$1.phase,
 						childPids
@@ -12985,7 +13876,7 @@ function createImplementationOrchestrator(deps) {
 				}
 				_stalledStories.add(key);
 				_storiesWithStall.add(key);
-				logger$26.warn({
+				logger$27.warn({
 					storyKey: key,
 					phase: s$1.phase,
 					elapsedMs: elapsed,
@@ -13030,7 +13921,7 @@ function createImplementationOrchestrator(deps) {
 		for (let attempt = 0; attempt < MEMORY_PRESSURE_BACKOFF_MS.length; attempt++) {
 			const memState = dispatcher.getMemoryState();
 			if (!memState.isPressured) return true;
-			logger$26.warn({
+			logger$27.warn({
 				storyKey,
 				freeMB: memState.freeMB,
 				thresholdMB: memState.thresholdMB,
@@ -13050,12 +13941,12 @@ function createImplementationOrchestrator(deps) {
 	* exhausted retries the story is ESCALATED.
 	*/
 	async function processStory(storyKey, storyOptions) {
-		logger$26.info({ storyKey }, "Processing story");
+		logger$27.info({ storyKey }, "Processing story");
 		await initRetryCount(storyKey);
 		{
 			const memoryOk = await checkMemoryPressure(storyKey);
 			if (!memoryOk) {
-				logger$26.warn({ storyKey }, "Memory pressure exhausted — escalating story without dispatch");
+				logger$27.warn({ storyKey }, "Memory pressure exhausted — escalating story without dispatch");
 				const memPressureState = {
 					phase: "ESCALATED",
 					reviewCycles: 0,
@@ -13064,7 +13955,7 @@ function createImplementationOrchestrator(deps) {
 					completedAt: new Date().toISOString()
 				};
 				_stories.set(storyKey, memPressureState);
-				persistStoryState(storyKey, memPressureState).catch((err) => logger$26.warn({
+				persistStoryState(storyKey, memPressureState).catch((err) => logger$27.warn({
 					err,
 					storyKey
 				}, "StateStore write failed after memory-pressure escalation"));
@@ -13079,9 +13970,14 @@ function createImplementationOrchestrator(deps) {
 				return;
 			}
 		}
+		let effectiveProjectRoot = projectRoot;
+		if (!noWorktree && _worktreeManager !== void 0 && projectRoot !== void 0) {
+			const wt = await _worktreeManager.createWorktree(storyKey);
+			effectiveProjectRoot = wt.worktreePath;
+		}
 		await waitIfPaused();
 		if (_state !== "RUNNING") return;
-		stateStore?.branchForStory(storyKey).catch((err) => logger$26.warn({
+		stateStore?.branchForStory(storyKey).catch((err) => logger$27.warn({
 			err,
 			storyKey
 		}, "branchForStory failed — continuing without branch isolation"));
@@ -13092,7 +13988,7 @@ function createImplementationOrchestrator(deps) {
 		});
 		let storyFilePath;
 		let sourceAcHash;
-		const artifactsDir = projectRoot ? join$1(projectRoot, "_bmad-output", "implementation-artifacts") : void 0;
+		const artifactsDir = effectiveProjectRoot ? join$1(effectiveProjectRoot, "_bmad-output", "implementation-artifacts") : void 0;
 		if (artifactsDir && existsSync(artifactsDir)) try {
 			const files = readdirSync(artifactsDir);
 			const STALE_SUFFIX = /\.stale-\d+\.md$/;
@@ -13100,7 +13996,7 @@ function createImplementationOrchestrator(deps) {
 			if (match$2) {
 				const candidatePath = join$1(artifactsDir, match$2);
 				const validation = await isValidStoryFile(candidatePath);
-				if (!validation.valid) logger$26.warn({
+				if (!validation.valid) logger$27.warn({
 					storyKey,
 					storyFilePath: candidatePath,
 					reason: validation.reason
@@ -13108,7 +14004,7 @@ function createImplementationOrchestrator(deps) {
 				else {
 					let isDrift = false;
 					try {
-						const epicsPath = projectRoot ? findEpicsFile(projectRoot) : void 0;
+						const epicsPath = effectiveProjectRoot ? findEpicsFile(effectiveProjectRoot) : void 0;
 						if (epicsPath !== void 0) {
 							const epicContent = readFileSync(epicsPath, "utf-8");
 							const sourceSection = extractStorySection(epicContent, storyKey);
@@ -13125,7 +14021,7 @@ function createImplementationOrchestrator(deps) {
 										storedHash,
 										currentHash
 									});
-									logger$26.info({
+									logger$27.info({
 										storyKey,
 										storedHash,
 										currentHash
@@ -13136,7 +14032,7 @@ function createImplementationOrchestrator(deps) {
 					} catch {}
 					if (!isDrift) {
 						storyFilePath = candidatePath;
-						logger$26.info({
+						logger$27.info({
 							storyKey,
 							storyFilePath
 						}, "Found existing story file — skipping create-story");
@@ -13156,12 +14052,12 @@ function createImplementationOrchestrator(deps) {
 						const staleName = match$2.replace(/\.md$/, `.stale-${ts}.md`);
 						const stalePath = join$1(artifactsDir, staleName);
 						renameSync(candidatePath, stalePath);
-						logger$26.info({
+						logger$27.info({
 							storyKey,
 							staleName
 						}, `[orchestrator] story ${storyKey}: renamed drifted artifact to ${staleName} before re-dispatch`);
 					} catch (renameErr) {
-						logger$26.warn({
+						logger$27.warn({
 							storyKey,
 							err: renameErr
 						}, "Failed to rename stale artifact before create-story re-dispatch; relying on 58-9d fraud-guard");
@@ -13169,8 +14065,8 @@ function createImplementationOrchestrator(deps) {
 				}
 			}
 		} catch {}
-		if (storyFilePath === void 0 && projectRoot && isImplicitlyCovered(storyKey, projectRoot)) {
-			logger$26.info({ storyKey }, `Story ${storyKey} appears implicitly covered — all expected new files already exist. Skipping create-story.`);
+		if (storyFilePath === void 0 && effectiveProjectRoot && isImplicitlyCovered(storyKey, effectiveProjectRoot)) {
+			logger$27.info({ storyKey }, `Story ${storyKey} appears implicitly covered — all expected new files already exist. Skipping create-story.`);
 			endPhase(storyKey, "create-story");
 			eventBus.emit("orchestrator:story-phase-complete", {
 				storyKey,
@@ -13199,7 +14095,7 @@ function createImplementationOrchestrator(deps) {
 					pack,
 					contextCompiler,
 					dispatcher,
-					projectRoot,
+					projectRoot: effectiveProjectRoot,
 					tokenCeilings,
 					otlpEndpoint: _otlpEndpoint,
 					agentId
@@ -13223,7 +14119,7 @@ function createImplementationOrchestrator(deps) {
 					output_tokens: createResult.tokenUsage.output,
 					cost_usd: estimateDispatchCost(createResult.tokenUsage.input, createResult.tokenUsage.output),
 					metadata: JSON.stringify({ storyKey })
-				})).catch((tokenErr) => logger$26.warn({
+				})).catch((tokenErr) => logger$27.warn({
 					storyKey,
 					err: tokenErr
 				}, "Failed to record create-story token usage"));
@@ -13231,7 +14127,7 @@ function createImplementationOrchestrator(deps) {
 				if (createResult.result === "failed") {
 					const errMsg = createResult.error ?? "create-story failed";
 					const stderrSnippet = errMsg.includes("--- stderr ---") ? errMsg.slice(errMsg.indexOf("--- stderr ---") + 15, errMsg.indexOf("--- stderr ---") + 515) : errMsg.slice(0, 500);
-					logger$26.error({
+					logger$27.error({
 						storyKey,
 						stderrSnippet
 					}, `Create-story failed: ${stderrSnippet.split("\n")[0]}`);
@@ -13267,13 +14163,13 @@ function createImplementationOrchestrator(deps) {
 					await persistState();
 					return;
 				}
-				if (projectRoot !== void 0) {
-					const expectedArtifactsDir = join$1(projectRoot, "_bmad-output", "implementation-artifacts");
+				if (effectiveProjectRoot !== void 0) {
+					const expectedArtifactsDir = join$1(effectiveProjectRoot, "_bmad-output", "implementation-artifacts");
 					const escapedExpectedDir = expectedArtifactsDir.replace("/_bmad-output/", "/\\_bmad-output/");
 					let claimedPath = createResult.story_file;
 					if (claimedPath.startsWith(escapedExpectedDir)) {
 						claimedPath = claimedPath.replace("/\\_bmad-output/", "/_bmad-output/");
-						logger$26.warn({
+						logger$27.warn({
 							storyKey,
 							originalClaim: createResult.story_file,
 							normalizedClaim: claimedPath
@@ -13291,7 +14187,7 @@ function createImplementationOrchestrator(deps) {
 							if (escapedVariant !== claimedPath && existsSync(escapedVariant)) try {
 								renameSync(escapedVariant, claimedPath);
 								actualPath = claimedPath;
-								logger$26.warn({
+								logger$27.warn({
 									storyKey,
 									escapedVariant,
 									canonicalPath: claimedPath
@@ -13302,7 +14198,7 @@ function createImplementationOrchestrator(deps) {
 								});
 							} catch (renameErr) {
 								actualPath = escapedVariant;
-								logger$26.warn({
+								logger$27.warn({
 									storyKey,
 									escapedVariant,
 									canonicalPath: claimedPath,
@@ -13317,7 +14213,7 @@ function createImplementationOrchestrator(deps) {
 						if (actualPath === null) {
 							const outputTokens = createResult.tokenUsage?.output ?? 0;
 							const errMsg = `create-story claimed success (story_file: ${createResult.story_file}) but the file does not exist on disk (output tokens: ${outputTokens})`;
-							logger$26.error({
+							logger$27.error({
 								storyKey,
 								claimedPath: createResult.story_file,
 								outputTokens
@@ -13344,7 +14240,7 @@ function createImplementationOrchestrator(deps) {
 							const mtimeISO = new Date(claimedStat.mtimeMs).toISOString();
 							const dispatchStartISO = new Date(dispatchStartMs).toISOString();
 							const errMsg = `create-story claimed success but did not rewrite ${actualPath} during this dispatch (file mtime ${mtimeISO} predates dispatch start ${dispatchStartISO}; output tokens: ${outputTokens})`;
-							logger$26.error({
+							logger$27.error({
 								storyKey,
 								claimedPath: actualPath,
 								mtimeISO,
@@ -13367,7 +14263,7 @@ function createImplementationOrchestrator(deps) {
 							return;
 						}
 					} catch (verifyErr) {
-						logger$26.warn({
+						logger$27.warn({
 							storyKey,
 							err: verifyErr
 						}, "create-story post-dispatch file verification threw; proceeding with claimed path");
@@ -13390,7 +14286,7 @@ function createImplementationOrchestrator(deps) {
 							const overlap = computeTitleOverlap(expectedTitle, createResult.story_title);
 							if (overlap < TITLE_OVERLAP_WARNING_THRESHOLD) {
 								const msg = `Story title mismatch: expected "${expectedTitle}" but got "${createResult.story_title}" (word overlap: ${Math.round(overlap * 100)}%). This may indicate the create-story agent received truncated context.`;
-								logger$26.warn({
+								logger$27.warn({
 									storyKey,
 									expectedTitle,
 									generatedTitle: createResult.story_title,
@@ -13400,7 +14296,7 @@ function createImplementationOrchestrator(deps) {
 									storyKey,
 									msg
 								});
-							} else logger$26.debug({
+							} else logger$27.debug({
 								storyKey,
 								expectedTitle,
 								generatedTitle: createResult.story_title,
@@ -13409,7 +14305,7 @@ function createImplementationOrchestrator(deps) {
 						}
 					}
 				} catch (titleValidationErr) {
-					logger$26.debug({
+					logger$27.debug({
 						storyKey,
 						err: titleValidationErr
 					}, "Story title validation skipped due to error");
@@ -13432,7 +14328,7 @@ function createImplementationOrchestrator(deps) {
 				await persistState();
 				return;
 			}
-			if (storyFilePath !== void 0 && projectRoot !== void 0) try {
+			if (storyFilePath !== void 0 && effectiveProjectRoot !== void 0) try {
 				const epicId = storyKey.split("-")[0] ?? storyKey;
 				const fidelityImplDecisions = await getDecisionsByPhase(db, "implementation");
 				let fidelitySourceContent;
@@ -13450,7 +14346,7 @@ function createImplementationOrchestrator(deps) {
 					const pathDrift = pathFidelity?.drift ?? 0;
 					const clauseDrift = clauseFidelity.drift;
 					const overallDrift = Math.max(pathDrift, clauseDrift);
-					logger$26.debug({
+					logger$27.debug({
 						storyKey,
 						pathDrift,
 						clauseDrift,
@@ -13472,7 +14368,7 @@ function createImplementationOrchestrator(deps) {
 								if (pathMissing.length > 0) reasons.push(`${pathMissing.length} named path(s) missing`);
 								if (numericMismatches.length > 0) reasons.push(`${numericMismatches.length} numeric quantifier mismatch(es) (e.g., "${numericMismatches[0].noun}" source=${numericMismatches[0].sourceCount} rendered=${numericMismatches[0].renderedCount})`);
 								if (clauseFidelity.clauseRatio < .7) reasons.push(`clause shortfall (rendered ${clauseFidelity.renderedClauseCount}/${clauseFidelity.sourceClauseCount} = ${Math.round(clauseFidelity.clauseRatio * 100)}%)`);
-								logger$26.warn({
+								logger$27.warn({
 									storyKey,
 									pathDrift,
 									clauseDrift,
@@ -13515,7 +14411,7 @@ function createImplementationOrchestrator(deps) {
 								storyFilePath = void 0;
 								continue;
 							} catch (renameErr) {
-								logger$26.warn({
+								logger$27.warn({
 									storyKey,
 									err: renameErr,
 									stalePath
@@ -13529,7 +14425,7 @@ function createImplementationOrchestrator(deps) {
 							if (numericMismatches.length > 0) reasons.push(`numeric mismatches: ${numericMismatches.map((m) => `${m.noun} (source=${m.sourceCount}, rendered=${m.renderedCount})`).join("; ")}`);
 							if (clauseFidelity.clauseRatio < .7) reasons.push(`clause shortfall: source=${clauseFidelity.sourceClauseCount}, rendered=${clauseFidelity.renderedClauseCount}`);
 							const errMsg = `create-story output drifted from source AC after ${MAX_FIDELITY_RETRIES} retries; ` + reasons.join("; ");
-							logger$26.error({
+							logger$27.error({
 								storyKey,
 								pathDrift,
 								clauseDrift,
@@ -13556,7 +14452,7 @@ function createImplementationOrchestrator(deps) {
 					}
 				}
 			} catch (fidelityErr) {
-				logger$26.warn({
+				logger$27.warn({
 					storyKey,
 					err: fidelityErr
 				}, "fidelity gate threw; proceeding without retry");
@@ -13587,21 +14483,21 @@ function createImplementationOrchestrator(deps) {
 						...contract.transport !== void 0 ? { transport: contract.transport } : {}
 					})
 				});
-				logger$26.info({
+				logger$27.info({
 					storyKey,
 					contractCount: contracts.length,
 					contracts
 				}, "Stored interface contract declarations");
 			}
 		} catch (err) {
-			logger$26.warn({
+			logger$27.warn({
 				storyKey,
 				error: err instanceof Error ? err.message : String(err)
 			}, "Failed to parse interface contracts — continuing without contract declarations");
 		}
 		if (storyFilePath && _probeAuthorEffectiveMode === "enabled") try {
 			let probeAuthorEpicContent = "";
-			const probeAuthorEpicsPath = findEpicFileForStory(projectRoot ?? process.cwd(), storyKey);
+			const probeAuthorEpicsPath = findEpicFileForStory(effectiveProjectRoot ?? process.cwd(), storyKey);
 			if (probeAuthorEpicsPath) try {
 				const epicFull = readFileSync(probeAuthorEpicsPath, "utf-8");
 				const section = extractStorySection(epicFull, storyKey);
@@ -13612,7 +14508,7 @@ function createImplementationOrchestrator(deps) {
 			const isStateIntegrating = stateIntegratingEnabled && detectsStateIntegratingAC(probeAuthorEpicContent);
 			if (isEventDriven || isStateIntegrating) {
 				const triggerClass = isEventDriven && isStateIntegrating ? "both" : isStateIntegrating ? "state-integrating" : "event-driven";
-				if (runManifest !== null && runManifest !== void 0) runManifest.patchStoryState(storyKey, { probe_author_triggered_by: triggerClass }).catch((err) => logger$26.warn({
+				if (runManifest !== null && runManifest !== void 0) runManifest.patchStoryState(storyKey, { probe_author_triggered_by: triggerClass }).catch((err) => logger$27.warn({
 					err,
 					storyKey
 				}, "patchStoryState(probe_author_triggered_by) failed — pipeline continues"));
@@ -13627,7 +14523,7 @@ function createImplementationOrchestrator(deps) {
 						pack,
 						contextCompiler,
 						dispatcher,
-						projectRoot,
+						projectRoot: effectiveProjectRoot,
 						tokenCeilings,
 						otlpEndpoint: _otlpEndpoint,
 						agentId
@@ -13646,7 +14542,7 @@ function createImplementationOrchestrator(deps) {
 							});
 						}
 					});
-					logger$26.info({
+					logger$27.info({
 						storyKey,
 						result: probeAuthorResult.result,
 						probesAuthoredCount: probeAuthorResult.probesAuthoredCount
@@ -13658,14 +14554,14 @@ function createImplementationOrchestrator(deps) {
 						output_tokens: probeAuthorResult.tokenUsage.output,
 						cost_usd: estimateDispatchCost(probeAuthorResult.tokenUsage.input, probeAuthorResult.tokenUsage.output),
 						metadata: JSON.stringify({ storyKey })
-					})).catch((tokenErr) => logger$26.warn({
+					})).catch((tokenErr) => logger$27.warn({
 						storyKey,
 						err: tokenErr
 					}, "Failed to record probe-author token usage"));
-				} else logger$26.debug({ storyKey }, "probe-author: story artifact already has ## Runtime Probes — skipping gate");
-			} else logger$26.debug({ storyKey }, "probe-author: source AC not event-driven — skipping gate");
+				} else logger$27.debug({ storyKey }, "probe-author: story artifact already has ## Runtime Probes — skipping gate");
+			} else logger$27.debug({ storyKey }, "probe-author: source AC not event-driven — skipping gate");
 		} catch (probeAuthorErr) {
-			logger$26.warn({
+			logger$27.warn({
 				storyKey,
 				err: probeAuthorErr
 			}, "probe-author gate threw unexpectedly; proceeding to test-plan without authored probes");
@@ -13683,7 +14579,7 @@ function createImplementationOrchestrator(deps) {
 				pack,
 				contextCompiler,
 				dispatcher,
-				projectRoot,
+				projectRoot: effectiveProjectRoot,
 				tokenCeilings,
 				otlpEndpoint: _otlpEndpoint,
 				agentId
@@ -13694,10 +14590,10 @@ function createImplementationOrchestrator(deps) {
 			});
 			testPlanPhaseResult = testPlanResult.result;
 			testPlanTokenUsage = testPlanResult.tokenUsage;
-			if (testPlanResult.result === "success") logger$26.info({ storyKey }, "Test plan generated successfully");
-			else logger$26.warn({ storyKey }, "Test planning returned failed result — proceeding to dev-story without test plan");
+			if (testPlanResult.result === "success") logger$27.info({ storyKey }, "Test plan generated successfully");
+			else logger$27.warn({ storyKey }, "Test planning returned failed result — proceeding to dev-story without test plan");
 		} catch (err) {
-			logger$26.warn({
+			logger$27.warn({
 				storyKey,
 				err
 			}, "Test planning failed — proceeding to dev-story without test plan");
@@ -13710,7 +14606,7 @@ function createImplementationOrchestrator(deps) {
 			output_tokens: testPlanTokenUsage.output,
 			cost_usd: estimateDispatchCost(testPlanTokenUsage.input, testPlanTokenUsage.output),
 			metadata: JSON.stringify({ storyKey })
-		})).catch((tokenErr) => logger$26.warn({
+		})).catch((tokenErr) => logger$27.warn({
 			storyKey,
 			err: tokenErr
 		}, "Failed to record test-plan token usage"));
@@ -13762,7 +14658,7 @@ function createImplementationOrchestrator(deps) {
 		let baselineHeadSha;
 		try {
 			baselineHeadSha = execSync("git rev-parse HEAD", {
-				cwd: projectRoot ?? process.cwd(),
+				cwd: effectiveProjectRoot ?? process.cwd(),
 				encoding: "utf-8",
 				timeout: 3e3,
 				stdio: [
@@ -13778,7 +14674,7 @@ function createImplementationOrchestrator(deps) {
 				storyContentForAnalysis = await readFile$1(storyFilePath ?? "", "utf-8");
 				storyContentForVerification = storyContentForAnalysis;
 			} catch (err) {
-				logger$26.error({
+				logger$27.error({
 					storyKey,
 					storyFilePath,
 					error: err instanceof Error ? err.message : String(err)
@@ -13786,7 +14682,7 @@ function createImplementationOrchestrator(deps) {
 			}
 			const analysis = analyzeStoryComplexity(storyContentForAnalysis);
 			const batches = planTaskBatches(analysis);
-			logger$26.info({
+			logger$27.info({
 				storyKey,
 				estimatedScope: analysis.estimatedScope,
 				batchCount: batches.length,
@@ -13804,7 +14700,7 @@ function createImplementationOrchestrator(deps) {
 					if (_state !== "RUNNING") break;
 					const taskScope = batch.taskIds.map((id, i) => `T${id}: ${batch.taskTitles[i] ?? ""}`).join("\n");
 					const priorFiles = allFilesModified.size > 0 ? Array.from(allFilesModified) : void 0;
-					logger$26.info({
+					logger$27.info({
 						storyKey,
 						batchIndex: batch.batchIndex,
 						taskCount: batch.taskIds.length
@@ -13818,7 +14714,7 @@ function createImplementationOrchestrator(deps) {
 							pack,
 							contextCompiler,
 							dispatcher,
-							projectRoot,
+							projectRoot: effectiveProjectRoot,
 							tokenCeilings,
 							otlpEndpoint: _otlpEndpoint,
 							repoMapInjector,
@@ -13835,7 +14731,7 @@ function createImplementationOrchestrator(deps) {
 						});
 					} catch (batchErr) {
 						const errMsg = batchErr instanceof Error ? batchErr.message : String(batchErr);
-						logger$26.warn({
+						logger$27.warn({
 							storyKey,
 							batchIndex: batch.batchIndex,
 							error: errMsg
@@ -13856,7 +14752,7 @@ function createImplementationOrchestrator(deps) {
 						filesModified: batchFilesModified,
 						result: batchResult.result === "success" ? "success" : "failed"
 					};
-					logger$26.info(batchMetrics, "Batch dev-story metrics");
+					logger$27.info(batchMetrics, "Batch dev-story metrics");
 					for (const f$1 of batchFilesModified) allFilesModified.add(f$1);
 					if (batchFilesModified.length > 0) batchFileGroups.push({
 						batchIndex: batch.batchIndex,
@@ -13875,13 +14771,13 @@ function createImplementationOrchestrator(deps) {
 							durationMs: batchDurationMs,
 							result: batchMetrics.result
 						})
-					})).catch((tokenErr) => logger$26.warn({
+					})).catch((tokenErr) => logger$27.warn({
 						storyKey,
 						batchIndex: batch.batchIndex,
 						err: tokenErr
 					}, "Failed to record batch token usage"));
 					if (batchResult.tokenUsage?.output !== void 0) devOutputTokenCount = (devOutputTokenCount ?? 0) + batchResult.tokenUsage.output;
-					if (batchResult.result === "failed") logger$26.warn({
+					if (batchResult.result === "failed") logger$27.warn({
 						storyKey,
 						batchIndex: batch.batchIndex,
 						error: batchResult.error
@@ -13902,7 +14798,7 @@ function createImplementationOrchestrator(deps) {
 					pack,
 					contextCompiler,
 					dispatcher,
-					projectRoot,
+					projectRoot: effectiveProjectRoot,
 					tokenCeilings,
 					otlpEndpoint: _otlpEndpoint,
 					repoMapInjector,
@@ -13924,7 +14820,7 @@ function createImplementationOrchestrator(deps) {
 					output_tokens: devResult.tokenUsage.output,
 					cost_usd: estimateDispatchCost(devResult.tokenUsage.input, devResult.tokenUsage.output),
 					metadata: JSON.stringify({ storyKey })
-				})).catch((tokenErr) => logger$26.warn({
+				})).catch((tokenErr) => logger$27.warn({
 					storyKey,
 					err: tokenErr
 				}, "Failed to record dev-story token usage"));
@@ -13937,9 +14833,9 @@ function createImplementationOrchestrator(deps) {
 				let checkpointHandled = false;
 				if (devResult.result === "failed" && devResult.error?.startsWith("dispatch_timeout")) {
 					endPhase(storyKey, "dev-story");
-					const timeoutFiles = checkGitDiffFiles(projectRoot ?? process.cwd());
+					const timeoutFiles = checkGitDiffFiles(effectiveProjectRoot ?? process.cwd());
 					if (timeoutFiles.length === 0) {
-						logger$26.warn({ storyKey }, "Dev-story timeout with zero modified files — escalating immediately (no checkpoint)");
+						logger$27.warn({ storyKey }, "Dev-story timeout with zero modified files — escalating immediately (no checkpoint)");
 						updateStory(storyKey, {
 							phase: "ESCALATED",
 							error: "timeout-no-files",
@@ -13955,14 +14851,14 @@ function createImplementationOrchestrator(deps) {
 						await persistState();
 						return;
 					}
-					logger$26.info({
+					logger$27.info({
 						storyKey,
 						filesCount: timeoutFiles.length
 					}, "Dev-story timeout with partial files — capturing checkpoint");
 					let gitDiff = "";
 					try {
 						gitDiff = execSync(`git diff HEAD -- ${timeoutFiles.map((f$1) => `"${f$1}"`).join(" ")}`, {
-							cwd: projectRoot ?? process.cwd(),
+							cwd: effectiveProjectRoot ?? process.cwd(),
 							encoding: "utf-8",
 							timeout: 1e4,
 							stdio: [
@@ -13972,7 +14868,7 @@ function createImplementationOrchestrator(deps) {
 							]
 						}).trim();
 					} catch (diffErr) {
-						logger$26.warn({
+						logger$27.warn({
 							storyKey,
 							error: diffErr instanceof Error ? diffErr.message : String(diffErr)
 						}, "Failed to capture git diff for checkpoint — proceeding with empty diff");
@@ -13999,7 +14895,7 @@ function createImplementationOrchestrator(deps) {
 						recordedAt: new Date().toISOString(),
 						sprint: config.sprint
 					}).catch((storeErr) => {
-						logger$26.warn({
+						logger$27.warn({
 							err: storeErr,
 							storyKey
 						}, "Failed to record timeout metric to StateStore (best-effort)");
@@ -14058,9 +14954,9 @@ function createImplementationOrchestrator(deps) {
 						checkpointRetryPrompt = assembled.prompt;
 					} catch {
 						checkpointRetryPrompt = `Continue story ${storyKey} from checkpoint. Your prior attempt timed out. Do not redo completed work.`;
-						logger$26.warn({ storyKey }, "Failed to assemble checkpoint retry prompt — using fallback");
+						logger$27.warn({ storyKey }, "Failed to assemble checkpoint retry prompt — using fallback");
 					}
-					logger$26.info({
+					logger$27.info({
 						storyKey,
 						filesCount: checkpointData.filesModified.length
 					}, "Dispatching checkpoint retry for timed-out story");
@@ -14073,7 +14969,7 @@ function createImplementationOrchestrator(deps) {
 						taskType: "dev-story",
 						outputSchema: DevStoryResultSchema,
 						...checkpointRetryMaxTurns !== void 0 ? { maxTurns: checkpointRetryMaxTurns } : {},
-						...projectRoot !== void 0 ? { workingDirectory: projectRoot } : {},
+						...effectiveProjectRoot !== void 0 ? { workingDirectory: effectiveProjectRoot } : {},
 						..._otlpEndpoint !== void 0 ? { otlpEndpoint: _otlpEndpoint } : {},
 						...config.perStoryContextCeilings?.[storyKey] !== void 0 ? { maxContextTokens: config.perStoryContextCeilings[storyKey] } : {},
 						storyKey
@@ -14089,7 +14985,7 @@ function createImplementationOrchestrator(deps) {
 						} : void 0 }
 					});
 					if (checkpointRetryResult.status === "timeout") {
-						logger$26.warn({ storyKey }, "Checkpoint retry dispatch timed out — escalating story");
+						logger$27.warn({ storyKey }, "Checkpoint retry dispatch timed out — escalating story");
 						updateStory(storyKey, {
 							phase: "ESCALATED",
 							error: "checkpoint-retry-timeout",
@@ -14107,9 +15003,9 @@ function createImplementationOrchestrator(deps) {
 					}
 					const retryParsed = checkpointRetryResult.parsed;
 					replaceDevStorySignals(retryParsed);
-					devFilesModified = retryParsed?.files_modified ?? checkGitDiffFiles(projectRoot ?? process.cwd());
+					devFilesModified = retryParsed?.files_modified ?? checkGitDiffFiles(effectiveProjectRoot ?? process.cwd());
 					if (checkpointRetryResult.status === "completed" && retryParsed?.result === "success") devStoryWasSuccess = true;
-					else logger$26.warn({
+					else logger$27.warn({
 						storyKey,
 						status: checkpointRetryResult.status
 					}, "Checkpoint retry completed with failure — proceeding to code review");
@@ -14119,13 +15015,13 @@ function createImplementationOrchestrator(deps) {
 					replaceDevStorySignals(devResult);
 					if (devResult.result === "success") devStoryWasSuccess = true;
 					else {
-						logger$26.warn({
+						logger$27.warn({
 							storyKey,
 							error: devResult.error,
 							filesModified: devFilesModified.length
 						}, "Dev-story reported failure, proceeding to code review");
 						if (!devResult.error?.startsWith("dispatch_timeout")) {
-							logger$26.warn({
+							logger$27.warn({
 								storyKey,
 								error: devResult.error
 							}, "Agent process failure (non-timeout) — story will proceed to code review with partial work");
@@ -14157,12 +15053,12 @@ function createImplementationOrchestrator(deps) {
 		}
 		let gitDiffFiles;
 		if (devStoryWasSuccess) {
-			gitDiffFiles = checkGitDiffFiles(projectRoot ?? process.cwd());
+			gitDiffFiles = checkGitDiffFiles(effectiveProjectRoot ?? process.cwd());
 			if (gitDiffFiles.length === 0) {
 				let hasNewCommits = false;
 				if (baselineHeadSha) try {
 					const currentHead = execSync("git rev-parse HEAD", {
-						cwd: projectRoot ?? process.cwd(),
+						cwd: effectiveProjectRoot ?? process.cwd(),
 						encoding: "utf-8",
 						timeout: 3e3,
 						stdio: [
@@ -14176,7 +15072,7 @@ function createImplementationOrchestrator(deps) {
 				if (hasNewCommits && baselineHeadSha) {
 					try {
 						const committedFiles = execSync(`git diff --name-only ${baselineHeadSha}..HEAD`, {
-							cwd: projectRoot ?? process.cwd(),
+							cwd: effectiveProjectRoot ?? process.cwd(),
 							encoding: "utf-8",
 							timeout: 5e3,
 							stdio: [
@@ -14187,13 +15083,13 @@ function createImplementationOrchestrator(deps) {
 						}).trim();
 						if (committedFiles.length > 0) gitDiffFiles = committedFiles.split("\n").filter(Boolean);
 					} catch {}
-					logger$26.info({
+					logger$27.info({
 						storyKey,
 						baselineHeadSha,
 						committedFileCount: gitDiffFiles?.length ?? 0
 					}, "Working tree clean but new commits detected since dispatch — skipping zero-diff escalation");
 				} else {
-					logger$26.warn({ storyKey }, "Zero-diff detected after COMPLETE dev-story — no file changes and no new commits");
+					logger$27.warn({ storyKey }, "Zero-diff detected after COMPLETE dev-story — no file changes and no new commits");
 					eventBus.emit("orchestrator:zero-diff-escalation", {
 						storyKey,
 						reason: "zero-diff-on-complete"
@@ -14222,11 +15118,11 @@ function createImplementationOrchestrator(deps) {
 			let buildVerifyResult = config.skipBuildVerify === true ? { status: "skipped" } : runBuildVerification({
 				verifyCommand: pack.manifest.verifyCommand,
 				verifyTimeoutMs: pack.manifest.verifyTimeoutMs,
-				projectRoot: projectRoot ?? process.cwd(),
+				projectRoot: effectiveProjectRoot ?? process.cwd(),
 				changedFiles: gitDiffFiles
 			});
 			if (buildVerifyResult.status === "passed") {
-				const resolvedRootForTsc = projectRoot ?? process.cwd();
+				const resolvedRootForTsc = effectiveProjectRoot ?? process.cwd();
 				const tscBin = join$1(resolvedRootForTsc, "node_modules", ".bin", "tsc");
 				const typecheckConfig = join$1(resolvedRootForTsc, "tsconfig.typecheck.json");
 				const defaultConfig = join$1(resolvedRootForTsc, "tsconfig.json");
@@ -14243,10 +15139,10 @@ function createImplementationOrchestrator(deps) {
 							"pipe"
 						]
 					});
-					logger$26.info({ storyKey }, "Secondary typecheck (tsc --noEmit) passed");
+					logger$27.info({ storyKey }, "Secondary typecheck (tsc --noEmit) passed");
 				} catch (tscErr) {
 					const tscOutput = tscErr instanceof Error && "stdout" in tscErr ? String(tscErr.stdout ?? "").slice(0, 2e3) : "";
-					logger$26.warn({
+					logger$27.warn({
 						storyKey,
 						tscOutput
 					}, "Secondary typecheck (tsc --noEmit) failed — treating as build failure");
@@ -14261,16 +15157,16 @@ function createImplementationOrchestrator(deps) {
 			if (buildVerifyResult.status === "passed") {
 				_buildPassed = true;
 				eventBus.emit("story:build-verification-passed", { storyKey });
-				logger$26.info({ storyKey }, "Build verification passed");
+				logger$27.info({ storyKey }, "Build verification passed");
 			} else if (buildVerifyResult.status === "failed" || buildVerifyResult.status === "timeout") {
 				const truncatedOutput = (buildVerifyResult.output ?? "").slice(0, 2e3);
 				const reason = buildVerifyResult.reason ?? "build-verification-failed";
 				let retryPassed = false;
 				if (_packageSnapshot !== void 0 && buildVerifyResult.status !== "timeout") {
-					const resolvedRoot = projectRoot ?? process.cwd();
+					const resolvedRoot = effectiveProjectRoot ?? process.cwd();
 					const hasChanges = detectPackageChanges(_packageSnapshot, resolvedRoot);
 					if (hasChanges) {
-						logger$26.warn({ storyKey }, "Package files changed since snapshot — restoring to prevent cascade");
+						logger$27.warn({ storyKey }, "Package files changed since snapshot — restoring to prevent cascade");
 						const restoreResult = restorePackageSnapshot(_packageSnapshot, { projectRoot: resolvedRoot });
 						if (restoreResult.restored) {
 							const retryAfterRestore = runBuildVerification({
@@ -14283,11 +15179,11 @@ function createImplementationOrchestrator(deps) {
 								retryPassed = true;
 								_buildPassed = true;
 								eventBus.emit("story:build-verification-passed", { storyKey });
-								logger$26.warn({
+								logger$27.warn({
 									storyKey,
 									filesRestored: restoreResult.filesRestored
 								}, "Build passed after package snapshot restore — cross-story pollution detected and cleaned");
-							} else logger$26.warn({
+							} else logger$27.warn({
 								storyKey,
 								filesRestored: restoreResult.filesRestored
 							}, "Build still fails after snapshot restore — story has its own build errors");
@@ -14298,8 +15194,8 @@ function createImplementationOrchestrator(deps) {
 				const missingPkgMatch = fullOutput.match(/Cannot find (?:module|package) ['"]([^'"]+)['"]/) ?? fullOutput.match(/ERR_MODULE_NOT_FOUND[^]*?['"]([^'"]+)['"]/);
 				if (missingPkgMatch && buildVerifyResult.status !== "timeout") {
 					const missingPkg = missingPkgMatch[1].replace(/^(@[^/]+\/[^/]+)\/.*$/, "$1").replace(/^([^@][^/]*)\/.*$/, "$1");
-					const resolvedRoot = projectRoot ?? process.cwd();
-					logger$26.warn({
+					const resolvedRoot = effectiveProjectRoot ?? process.cwd();
+					logger$27.warn({
 						storyKey,
 						missingPkg
 					}, "Build-fix retry: detected missing npm package — attempting npm install");
@@ -14310,7 +15206,7 @@ function createImplementationOrchestrator(deps) {
 							encoding: "utf-8",
 							stdio: "pipe"
 						});
-						logger$26.warn({
+						logger$27.warn({
 							storyKey,
 							missingPkg
 						}, "Build-fix retry: npm install succeeded — retrying build verification");
@@ -14324,18 +15220,18 @@ function createImplementationOrchestrator(deps) {
 							retryPassed = true;
 							_buildPassed = true;
 							eventBus.emit("story:build-verification-passed", { storyKey });
-							logger$26.warn({
+							logger$27.warn({
 								storyKey,
 								missingPkg
 							}, "Build-fix retry: build verification passed after installing missing package");
-						} else logger$26.warn({
+						} else logger$27.warn({
 							storyKey,
 							missingPkg,
 							retryStatus: retryResult.status
 						}, "Build-fix retry: build still fails after installing missing package — escalating");
 					} catch (installErr) {
 						const installMsg = installErr instanceof Error ? installErr.message : String(installErr);
-						logger$26.warn({
+						logger$27.warn({
 							storyKey,
 							missingPkg,
 							error: installMsg
@@ -14345,7 +15241,7 @@ function createImplementationOrchestrator(deps) {
 				if (!retryPassed) {
 					let buildFixPassed = false;
 					if (buildVerifyResult.status === "failed" && storyFilePath !== void 0) try {
-						logger$26.info({ storyKey }, "Dispatching build-fix agent");
+						logger$27.info({ storyKey }, "Dispatching build-fix agent");
 						startPhase(storyKey, "build-fix");
 						const storyContent = await readFile$1(storyFilePath, "utf-8");
 						let buildFixTemplate;
@@ -14366,7 +15262,7 @@ function createImplementationOrchestrator(deps) {
 							agent: deps.agentId ?? "claude-code",
 							taskType: "build-fix",
 							maxTurns: 15,
-							workingDirectory: projectRoot ?? process.cwd(),
+							workingDirectory: effectiveProjectRoot ?? process.cwd(),
 							...config.perStoryContextCeilings?.[storyKey] !== void 0 ? { maxContextTokens: config.perStoryContextCeilings[storyKey] } : {},
 							..._otlpEndpoint !== void 0 ? { otlpEndpoint: _otlpEndpoint } : {}
 						});
@@ -14375,18 +15271,18 @@ function createImplementationOrchestrator(deps) {
 						const retryAfterFix = runBuildVerification({
 							verifyCommand: pack.manifest.verifyCommand,
 							verifyTimeoutMs: pack.manifest.verifyTimeoutMs,
-							projectRoot: projectRoot ?? process.cwd(),
+							projectRoot: effectiveProjectRoot ?? process.cwd(),
 							changedFiles: gitDiffFiles
 						});
 						if (retryAfterFix.status === "passed") {
 							buildFixPassed = true;
 							_buildPassed = true;
 							eventBus.emit("story:build-verification-passed", { storyKey });
-							logger$26.info({ storyKey }, "Build passed after build-fix dispatch");
-						} else logger$26.warn({ storyKey }, "Build still fails after build-fix dispatch — escalating");
+							logger$27.info({ storyKey }, "Build passed after build-fix dispatch");
+						} else logger$27.warn({ storyKey }, "Build still fails after build-fix dispatch — escalating");
 					} catch (fixErr) {
 						const fixMsg = fixErr instanceof Error ? fixErr.message : String(fixErr);
-						logger$26.warn({
+						logger$27.warn({
 							storyKey,
 							error: fixMsg
 						}, "Build-fix dispatch failed — escalating");
@@ -14423,7 +15319,7 @@ function createImplementationOrchestrator(deps) {
 									eventBus.emit("decision:halt-skipped-non-interactive", payload);
 								}
 							}).catch((err) => {
-								logger$26.warn({
+								logger$27.warn({
 									err,
 									storyKey
 								}, "interactive prompt failed — continuing with default action");
@@ -14440,7 +15336,7 @@ function createImplementationOrchestrator(deps) {
 							exitCode: buildVerifyResult.exitCode ?? 1,
 							output: truncatedOutput
 						});
-						logger$26.warn({
+						logger$27.warn({
 							storyKey,
 							reason,
 							exitCode: buildVerifyResult.exitCode,
@@ -14470,11 +15366,11 @@ function createImplementationOrchestrator(deps) {
 			if (filesModified.length > 0) {
 				const icResult = detectInterfaceChanges({
 					filesModified,
-					projectRoot: projectRoot ?? process.cwd(),
+					projectRoot: effectiveProjectRoot ?? process.cwd(),
 					storyKey
 				});
 				if (icResult.potentiallyAffectedTests.length > 0) {
-					logger$26.warn({
+					logger$27.warn({
 						storyKey,
 						modifiedInterfaces: icResult.modifiedInterfaces,
 						potentiallyAffectedTests: icResult.potentiallyAffectedTests
@@ -14514,7 +15410,7 @@ function createImplementationOrchestrator(deps) {
 					rawOutput: reviewResult.rawOutput
 				} : void 0;
 				let sourceEpicContent;
-				const epicsPath = findEpicFileForStory(projectRoot ?? process.cwd(), storyKey);
+				const epicsPath = findEpicFileForStory(effectiveProjectRoot ?? process.cwd(), storyKey);
 				if (epicsPath) try {
 					const epicFull = readFileSync(epicsPath, "utf-8");
 					const section = extractStorySection(epicFull, storyKey);
@@ -14523,7 +15419,7 @@ function createImplementationOrchestrator(deps) {
 				await persistDevStorySignals(storyKey, devStorySignals, runManifest);
 				const verifContext = assembleVerificationContext({
 					storyKey,
-					workingDir: projectRoot ?? process.cwd(),
+					workingDir: effectiveProjectRoot ?? process.cwd(),
 					reviewResult: latestReviewSignals,
 					storyContent: storyContentForVerification,
 					devStoryResult: devStorySignals,
@@ -14557,20 +15453,20 @@ function createImplementationOrchestrator(deps) {
 							adapter: db,
 							engine: "linear"
 						}).catch((recoveryErr) => {
-							logger$26.warn({
+							logger$27.warn({
 								storyKey,
 								err: recoveryErr instanceof Error ? recoveryErr.message : String(recoveryErr)
 							}, "Recovery Engine invocation failed — falling through to VERIFICATION_FAILED (best-effort)");
 							return null;
 						});
 						if (recoveryResult?.action === "halt-entire-run") {
-							logger$26.error({
+							logger$27.error({
 								storyKey,
 								pendingProposalsCount: recoveryResult.pendingProposalsCount
 							}, "Recovery Engine safety valve: halting entire run due to >= 5 pending proposals");
 							_budgetExhausted = true;
 						} else if (recoveryResult?.action === "retry") {
-							logger$26.info({
+							logger$27.info({
 								storyKey,
 								attempt: recoveryResult.attempt,
 								retryBudgetRemaining: recoveryResult.retryBudgetRemaining
@@ -14582,7 +15478,7 @@ function createImplementationOrchestrator(deps) {
 									pack,
 									contextCompiler,
 									dispatcher,
-									projectRoot,
+									projectRoot: effectiveProjectRoot,
 									tokenCeilings,
 									otlpEndpoint: _otlpEndpoint,
 									repoMapInjector,
@@ -14598,7 +15494,7 @@ function createImplementationOrchestrator(deps) {
 								await persistDevStorySignals(storyKey, devStorySignals, runManifest);
 								const retryVerifContext = assembleVerificationContext({
 									storyKey,
-									workingDir: projectRoot ?? process.cwd(),
+									workingDir: effectiveProjectRoot ?? process.cwd(),
 									reviewResult: latestReviewSignals,
 									storyContent: storyContentForVerification,
 									devStoryResult: devStorySignals,
@@ -14610,23 +15506,23 @@ function createImplementationOrchestrator(deps) {
 								verificationStore.set(storyKey, retryVerifSummary);
 								await persistVerificationResult(storyKey, retryVerifSummary, runManifest);
 								if (retryVerifSummary.status !== "fail") {
-									logger$26.info({ storyKey }, "Recovery Engine Tier A retry succeeded — story proceeding to COMPLETE");
+									logger$27.info({ storyKey }, "Recovery Engine Tier A retry succeeded — story proceeding to COMPLETE");
 									shouldFallThroughToComplete = true;
-								} else logger$26.warn({ storyKey }, "Recovery Engine Tier A retry still failed — falling through to VERIFICATION_FAILED");
+								} else logger$27.warn({ storyKey }, "Recovery Engine Tier A retry still failed — falling through to VERIFICATION_FAILED");
 							} catch (retryErr) {
-								logger$26.warn({
+								logger$27.warn({
 									storyKey,
 									err: retryErr instanceof Error ? retryErr.message : String(retryErr)
 								}, "Recovery Engine Tier A re-dispatch threw — falling through to VERIFICATION_FAILED");
 							}
 						} else if (recoveryResult?.action === "propose") {
-							logger$26.info({ storyKey }, "Recovery Engine Tier B: proposal appended — marking story ESCALATED for operator re-scope");
+							logger$27.info({ storyKey }, "Recovery Engine Tier B: proposal appended — marking story ESCALATED for operator re-scope");
 							updateStory(storyKey, {
 								phase: "ESCALATED",
 								completedAt: new Date().toISOString(),
 								error: "recovery-engine-propose"
 							});
-							persistStoryState(storyKey, _stories.get(storyKey)).catch((err) => logger$26.warn({
+							persistStoryState(storyKey, _stories.get(storyKey)).catch((err) => logger$27.warn({
 								err,
 								storyKey
 							}, "StateStore write failed after recovery-propose"));
@@ -14640,7 +15536,7 @@ function createImplementationOrchestrator(deps) {
 							await persistState();
 							return "verification-failed";
 						} else if (recoveryResult?.action === "halt") {
-							logger$26.warn({ storyKey }, "Recovery Engine Tier C: halt — invoking interactive prompt for operator decision");
+							logger$27.warn({ storyKey }, "Recovery Engine Tier C: halt — invoking interactive prompt for operator decision");
 							const haltRunId = config.pipelineRunId ?? storyKey;
 							await runInteractivePrompt({
 								runId: haltRunId,
@@ -14657,7 +15553,7 @@ function createImplementationOrchestrator(deps) {
 									eventBus.emit("decision:halt-skipped-non-interactive", haltPayload);
 								}
 							}).catch((err) => {
-								logger$26.warn({
+								logger$27.warn({
 									err,
 									storyKey
 								}, "Recovery Engine Tier C: interactive prompt failed — escalating anyway");
@@ -14667,7 +15563,7 @@ function createImplementationOrchestrator(deps) {
 								completedAt: new Date().toISOString(),
 								error: "recovery-engine-halt"
 							});
-							persistStoryState(storyKey, _stories.get(storyKey)).catch((err) => logger$26.warn({
+							persistStoryState(storyKey, _stories.get(storyKey)).catch((err) => logger$27.warn({
 								err,
 								storyKey
 							}, "StateStore write failed after recovery-halt"));
@@ -14687,7 +15583,7 @@ function createImplementationOrchestrator(deps) {
 							phase: "VERIFICATION_FAILED",
 							completedAt: new Date().toISOString()
 						});
-						persistStoryState(storyKey, _stories.get(storyKey)).catch((err) => logger$26.warn({
+						persistStoryState(storyKey, _stories.get(storyKey)).catch((err) => logger$27.warn({
 							err,
 							storyKey
 						}, "StateStore write failed after verification-failed"));
@@ -14713,7 +15609,7 @@ function createImplementationOrchestrator(deps) {
 			if (autoApprove?.downgradeLastVerdict !== void 0) completeUpdate.lastVerdict = autoApprove.downgradeLastVerdict;
 			updateStory(storyKey, completeUpdate);
 			if (config.skipVerification !== true && runManifest != null) Promise.resolve().then(() => runManifest.read()).then((manifest) => {
-				if (manifest?.per_story_state?.[storyKey]?.verification_result == null) logger$26.warn({
+				if (manifest?.per_story_state?.[storyKey]?.verification_result == null) logger$27.warn({
 					storyKey,
 					category: "verification-result-missing"
 				}, "post-COMPLETE invariant: verification_result absent in manifest");
@@ -14782,7 +15678,7 @@ function createImplementationOrchestrator(deps) {
 						"NEEDS_MAJOR_REWORK": 2
 					};
 					for (const group of batchFileGroups) {
-						logger$26.info({
+						logger$27.info({
 							storyKey,
 							batchIndex: group.batchIndex,
 							fileCount: group.files.length
@@ -14793,7 +15689,7 @@ function createImplementationOrchestrator(deps) {
 							pack,
 							contextCompiler,
 							dispatcher,
-							projectRoot,
+							projectRoot: effectiveProjectRoot,
 							tokenCeilings,
 							otlpEndpoint: _otlpEndpoint,
 							repoMapInjector,
@@ -14803,7 +15699,7 @@ function createImplementationOrchestrator(deps) {
 						}, {
 							storyKey,
 							storyFilePath: storyFilePath ?? "",
-							workingDirectory: projectRoot,
+							workingDirectory: effectiveProjectRoot,
 							pipelineRunId: config.pipelineRunId,
 							filesModified: group.files,
 							buildPassed: _buildPassed,
@@ -14827,7 +15723,7 @@ function createImplementationOrchestrator(deps) {
 						rawOutput: lastRawOutput,
 						tokenUsage: aggregateTokens
 					};
-					logger$26.info({
+					logger$27.info({
 						storyKey,
 						batchCount: batchFileGroups.length,
 						verdict: worstVerdict,
@@ -14840,7 +15736,7 @@ function createImplementationOrchestrator(deps) {
 						pack,
 						contextCompiler,
 						dispatcher,
-						projectRoot,
+						projectRoot: effectiveProjectRoot,
 						tokenCeilings,
 						otlpEndpoint: _otlpEndpoint,
 						repoMapInjector,
@@ -14850,7 +15746,7 @@ function createImplementationOrchestrator(deps) {
 					}, {
 						storyKey,
 						storyFilePath: storyFilePath ?? "",
-						workingDirectory: projectRoot,
+						workingDirectory: effectiveProjectRoot,
 						pipelineRunId: config.pipelineRunId,
 						filesModified: devFilesModified,
 						buildPassed: _buildPassed,
@@ -14870,7 +15766,7 @@ function createImplementationOrchestrator(deps) {
 							storyKey,
 							reviewCycle: reviewCycles
 						})
-					})).catch((tokenErr) => logger$26.warn({
+					})).catch((tokenErr) => logger$27.warn({
 						storyKey,
 						err: tokenErr
 					}, "Failed to record code-review token usage"));
@@ -14888,7 +15784,7 @@ function createImplementationOrchestrator(deps) {
 						...reviewResult.details !== void 0 ? { details: reviewResult.details } : {}
 					});
 					if (schemaValidationRetries <= MAX_SCHEMA_VALIDATION_RETRIES) {
-						logger$26.warn({
+						logger$27.warn({
 							storyKey,
 							reviewCycles,
 							attempt: schemaValidationRetries,
@@ -14897,7 +15793,7 @@ function createImplementationOrchestrator(deps) {
 						previousIterationWasMalformed = true;
 						continue;
 					}
-					logger$26.warn({
+					logger$27.warn({
 						storyKey,
 						reviewCycles,
 						schemaValidationRetries
@@ -14920,7 +15816,7 @@ function createImplementationOrchestrator(deps) {
 				}
 				if (isPhantomReview && !timeoutRetried) {
 					timeoutRetried = true;
-					logger$26.warn({
+					logger$27.warn({
 						storyKey,
 						reviewCycles,
 						error: reviewResult.error
@@ -14928,7 +15824,7 @@ function createImplementationOrchestrator(deps) {
 					continue;
 				}
 				if (isPhantomReview && timeoutRetried) {
-					logger$26.warn({
+					logger$27.warn({
 						storyKey,
 						reviewCycles,
 						error: reviewResult.error
@@ -14952,7 +15848,7 @@ function createImplementationOrchestrator(deps) {
 				verdict = reviewResult.verdict;
 				issueList = reviewResult.issue_list ?? [];
 				if (verdict === "NEEDS_MAJOR_REWORK" && reviewCycles > 0 && previousIssueList.length > 0 && issueList.length < previousIssueList.length) {
-					logger$26.info({
+					logger$27.info({
 						storyKey,
 						originalVerdict: verdict,
 						issuesBefore: previousIssueList.length,
@@ -14988,7 +15884,7 @@ function createImplementationOrchestrator(deps) {
 					if (_decomposition !== void 0) parts.push(`decomposed: ${_decomposition.batchCount} batches`);
 					parts.push(`${fileCount} files`);
 					parts.push(`${totalTokensK} tokens`);
-					logger$26.info({
+					logger$27.info({
 						storyKey,
 						verdict,
 						agentVerdict: reviewResult.agentVerdict
@@ -15032,9 +15928,9 @@ function createImplementationOrchestrator(deps) {
 						}),
 						rationale: `Advisory notes from LGTM_WITH_NOTES review of ${storyKey}`
 					});
-					logger$26.info({ storyKey }, "Advisory notes persisted to decision store");
+					logger$27.info({ storyKey }, "Advisory notes persisted to decision store");
 				} catch (advisoryErr) {
-					logger$26.warn({
+					logger$27.warn({
 						storyKey,
 						error: advisoryErr instanceof Error ? advisoryErr.message : String(advisoryErr)
 					}, "Failed to persist advisory notes (best-effort)");
@@ -15042,27 +15938,27 @@ function createImplementationOrchestrator(deps) {
 				if (telemetryPersistence !== void 0) try {
 					const turns = await telemetryPersistence.getTurnAnalysis(storyKey);
 					if (turns.length > 0) {
-						const scorer = new EfficiencyScorer(logger$26);
+						const scorer = new EfficiencyScorer(logger$27);
 						const effScore = scorer.score(storyKey, turns);
 						await telemetryPersistence.storeEfficiencyScore(effScore);
-						logger$26.info({
+						logger$27.info({
 							storyKey,
 							compositeScore: effScore.compositeScore,
 							modelCount: effScore.perModelBreakdown.length
 						}, "Efficiency score computed and persisted");
-					} else logger$26.debug({ storyKey }, "No turn analysis data available — skipping efficiency scoring");
+					} else logger$27.debug({ storyKey }, "No turn analysis data available — skipping efficiency scoring");
 				} catch (effErr) {
-					logger$26.warn({
+					logger$27.warn({
 						storyKey,
 						error: effErr instanceof Error ? effErr.message : String(effErr)
 					}, "Efficiency scoring failed — story verdict unchanged");
 				}
 				if (telemetryPersistence !== void 0) try {
 					const turns = await telemetryPersistence.getTurnAnalysis(storyKey);
-					if (turns.length === 0) logger$26.debug({ storyKey }, "No turn analysis data for telemetry categorization — skipping");
+					if (turns.length === 0) logger$27.debug({ storyKey }, "No turn analysis data for telemetry categorization — skipping");
 					else {
-						const categorizer = new Categorizer(logger$26);
-						const consumerAnalyzer = new ConsumerAnalyzer(categorizer, logger$26);
+						const categorizer = new Categorizer(logger$27);
+						const consumerAnalyzer = new ConsumerAnalyzer(categorizer, logger$27);
 						const categoryStats = categorizer.computeCategoryStatsFromTurns(turns);
 						const consumerStats = consumerAnalyzer.analyzeFromTurns(turns);
 						await telemetryPersistence.storeCategoryStats(storyKey, categoryStats);
@@ -15070,7 +15966,7 @@ function createImplementationOrchestrator(deps) {
 						const growingCount = categoryStats.filter((c) => c.trend === "growing").length;
 						const topCategory = categoryStats[0]?.category ?? "none";
 						const topConsumer = consumerStats[0]?.consumerKey ?? "none";
-						logger$26.info({
+						logger$27.info({
 							storyKey,
 							topCategory,
 							topConsumer,
@@ -15078,7 +15974,7 @@ function createImplementationOrchestrator(deps) {
 						}, "Semantic categorization and consumer analysis complete");
 					}
 				} catch (catErr) {
-					logger$26.warn({
+					logger$27.warn({
 						storyKey,
 						error: catErr instanceof Error ? catErr.message : String(catErr)
 					}, "Semantic categorization failed — story verdict unchanged");
@@ -15089,7 +15985,7 @@ function createImplementationOrchestrator(deps) {
 						pack,
 						contextCompiler,
 						dispatcher,
-						projectRoot,
+						projectRoot: effectiveProjectRoot,
 						tokenCeilings,
 						otlpEndpoint: _otlpEndpoint,
 						agentId
@@ -15098,9 +15994,9 @@ function createImplementationOrchestrator(deps) {
 						storyFilePath: storyFilePath ?? "",
 						pipelineRunId: config.pipelineRunId,
 						filesModified: devFilesModified,
-						workingDirectory: projectRoot
+						workingDirectory: effectiveProjectRoot
 					});
-					logger$26.debug({
+					logger$27.debug({
 						storyKey,
 						expansion_priority: expansionResult.expansion_priority,
 						coverage_gaps: expansionResult.coverage_gaps.length
@@ -15113,11 +16009,73 @@ function createImplementationOrchestrator(deps) {
 						value: JSON.stringify(expansionResult)
 					});
 				} catch (expansionErr) {
-					logger$26.warn({
+					logger$27.warn({
 						storyKey,
 						error: expansionErr instanceof Error ? expansionErr.message : String(expansionErr)
 					}, "Test expansion failed — story verdict unchanged");
 				}
+				if (!noWorktree && _worktreeManager !== void 0 && _orchestratorStartBranch !== void 0 && projectRoot !== void 0) {
+					const branchName = `substrate/story-${storyKey}`;
+					logger$27.info({
+						storyKey,
+						branchName,
+						startBranch: _orchestratorStartBranch
+					}, "Invoking merge-to-main phase");
+					let mergeResult;
+					try {
+						mergeResult = await enqueueMerge({
+							storyKey,
+							branchName,
+							startBranch: _orchestratorStartBranch,
+							worktreeManager: _worktreeManager,
+							eventBus,
+							projectRoot
+						});
+					} catch (mergeErr) {
+						const errMsg = mergeErr instanceof Error ? mergeErr.message : String(mergeErr);
+						logger$27.error({
+							storyKey,
+							err: mergeErr
+						}, "merge-to-main phase threw unexpectedly — escalating story");
+						updateStory(storyKey, {
+							phase: "ESCALATED",
+							error: `merge-to-main-error: ${errMsg}`,
+							completedAt: new Date().toISOString()
+						});
+						await emitEscalation({
+							storyKey,
+							lastVerdict: "merge-to-main-error",
+							reviewCycles: completedReviewCycles,
+							issues: [`merge-to-main phase threw: ${errMsg}`]
+						});
+						await persistState();
+						return;
+					}
+					if (!mergeResult.success) {
+						logger$27.warn({
+							storyKey,
+							branchName,
+							conflictingFiles: mergeResult.conflictingFiles
+						}, "merge-to-main conflict — escalating story with merge-conflict-detected");
+						updateStory(storyKey, {
+							phase: "ESCALATED",
+							error: "merge-conflict-detected",
+							completedAt: new Date().toISOString()
+						});
+						await emitEscalation({
+							storyKey,
+							lastVerdict: "merge-conflict-detected",
+							reviewCycles: completedReviewCycles,
+							issues: [`merge conflict in ${mergeResult.conflictingFiles?.length ?? 0} file(s): ${(mergeResult.conflictingFiles ?? []).join(", ")}`]
+						});
+						await persistState();
+						return;
+					}
+					logger$27.info({
+						storyKey,
+						branchName
+					}, "merge-to-main phase completed successfully");
+				}
 				keepReviewing = false;
 				return;
 			}
@@ -15140,7 +16098,7 @@ function createImplementationOrchestrator(deps) {
 					await persistState();
 					return;
 				}
-				logger$26.info({
+				logger$27.info({
 					storyKey,
 					reviewCycles: finalReviewCycles,
 					issueCount: issueList.length
@@ -15206,13 +16164,13 @@ function createImplementationOrchestrator(deps) {
 						fixPrompt = assembled.prompt;
 					} catch {
 						fixPrompt = `Fix story ${storyKey}: verdict=${verdict}, minor fixes needed`;
-						logger$26.warn({ storyKey }, "Failed to assemble auto-approve fix prompt, using fallback");
+						logger$27.warn({ storyKey }, "Failed to assemble auto-approve fix prompt, using fallback");
 					}
 					const handle = dispatcher.dispatch({
 						prompt: fixPrompt,
 						agent: deps.agentId ?? "claude-code",
 						taskType: "minor-fixes",
-						workingDirectory: projectRoot,
+						workingDirectory: effectiveProjectRoot,
 						...autoApproveMaxTurns !== void 0 ? { maxTurns: autoApproveMaxTurns } : {},
 						...config.perStoryContextCeilings?.[storyKey] !== void 0 ? { maxContextTokens: config.perStoryContextCeilings[storyKey] } : {},
 						..._otlpEndpoint !== void 0 ? { otlpEndpoint: _otlpEndpoint } : {},
@@ -15227,9 +16185,9 @@ function createImplementationOrchestrator(deps) {
 							output: fixResult.tokenEstimate.output
 						} : void 0 }
 					});
-					if (fixResult.status === "timeout") logger$26.warn({ storyKey }, "Auto-approve fix timed out — approving anyway (issues were minor)");
+					if (fixResult.status === "timeout") logger$27.warn({ storyKey }, "Auto-approve fix timed out — approving anyway (issues were minor)");
 				} catch (err) {
-					logger$26.warn({
+					logger$27.warn({
 						storyKey,
 						err
 					}, "Auto-approve fix dispatch failed — approving anyway (issues were minor)");
@@ -15257,7 +16215,7 @@ function createImplementationOrchestrator(deps) {
 				outcome: "retried",
 				cost_usd: 0,
 				timestamp: new Date().toISOString()
-			}).catch((err) => logger$26.warn({
+			}).catch((err) => logger$27.warn({
 				err,
 				storyKey
 			}, "appendRecoveryEntry failed — pipeline continues"));
@@ -15309,9 +16267,9 @@ function createImplementationOrchestrator(deps) {
 					} catch {}
 					let gitDiffContent = "";
 					try {
-						const diffFiles = checkGitDiffFiles(projectRoot ?? process.cwd());
+						const diffFiles = checkGitDiffFiles(effectiveProjectRoot ?? process.cwd());
 						if (diffFiles.length > 0) gitDiffContent = execSync(`git diff HEAD -- ${diffFiles.map((f$1) => `"${f$1}"`).join(" ")}`, {
-							cwd: projectRoot ?? process.cwd(),
+							cwd: effectiveProjectRoot ?? process.cwd(),
 							encoding: "utf-8",
 							timeout: 1e4,
 							stdio: [
@@ -15397,7 +16355,7 @@ function createImplementationOrchestrator(deps) {
 					fixPrompt = assembled.prompt;
 				} catch {
 					fixPrompt = `Fix story ${storyKey}: verdict=${verdict}, taskType=${taskType}`;
-					logger$26.warn({
+					logger$27.warn({
 						storyKey,
 						taskType
 					}, "Failed to assemble fix prompt, using fallback");
@@ -15411,7 +16369,7 @@ function createImplementationOrchestrator(deps) {
 					outputSchema: DevStoryResultSchema,
 					...fixMaxTurns !== void 0 ? { maxTurns: fixMaxTurns } : {},
 					...config.perStoryContextCeilings?.[storyKey] !== void 0 ? { maxContextTokens: config.perStoryContextCeilings[storyKey] } : {},
-					...projectRoot !== void 0 ? { workingDirectory: projectRoot } : {},
+					...effectiveProjectRoot !== void 0 ? { workingDirectory: effectiveProjectRoot } : {},
 					..._otlpEndpoint !== void 0 ? { otlpEndpoint: _otlpEndpoint } : {}
 				}) : dispatcher.dispatch({
 					prompt: fixPrompt,
@@ -15420,7 +16378,7 @@ function createImplementationOrchestrator(deps) {
 					...fixModel !== void 0 ? { model: fixModel } : {},
 					...fixMaxTurns !== void 0 ? { maxTurns: fixMaxTurns } : {},
 					...config.perStoryContextCeilings?.[storyKey] !== void 0 ? { maxContextTokens: config.perStoryContextCeilings[storyKey] } : {},
-					...projectRoot !== void 0 ? { workingDirectory: projectRoot } : {},
+					...effectiveProjectRoot !== void 0 ? { workingDirectory: effectiveProjectRoot } : {},
 					..._otlpEndpoint !== void 0 ? { otlpEndpoint: _otlpEndpoint } : {}
 				});
 				const fixResult = await handle.result;
@@ -15437,7 +16395,7 @@ function createImplementationOrchestrator(deps) {
 					if (taskType === "minor-fixes") {
 						const finalReviewCycles = reviewCycles + 1;
 						const downgradedVerdict = "LGTM_WITH_NOTES";
-						logger$26.warn({
+						logger$27.warn({
 							storyKey,
 							reviewCycles: finalReviewCycles,
 							issueCount: issueList.length
@@ -15456,7 +16414,7 @@ function createImplementationOrchestrator(deps) {
 						keepReviewing = false;
 						return;
 					}
-					logger$26.warn({
+					logger$27.warn({
 						storyKey,
 						taskType
 					}, "Fix dispatch timed out — escalating story");
@@ -15478,7 +16436,7 @@ function createImplementationOrchestrator(deps) {
 				}
 				if (fixResult.status === "failed") {
 					if (isMajorRework) {
-						logger$26.warn({
+						logger$27.warn({
 							storyKey,
 							exitCode: fixResult.exitCode
 						}, "Major rework dispatch failed — escalating story");
@@ -15498,7 +16456,7 @@ function createImplementationOrchestrator(deps) {
 						await persistState();
 						return;
 					}
-					logger$26.warn({
+					logger$27.warn({
 						storyKey,
 						taskType,
 						exitCode: fixResult.exitCode
@@ -15506,7 +16464,7 @@ function createImplementationOrchestrator(deps) {
 				}
 				if (isMajorRework) replaceDevStorySignals(fixResult.parsed);
 			} catch (err) {
-				logger$26.warn({
+				logger$27.warn({
 					storyKey,
 					taskType,
 					err
@@ -15564,7 +16522,7 @@ function createImplementationOrchestrator(deps) {
 					eventBus.emit("decision:halt-skipped-non-interactive", payload);
 				}
 			}).catch((err) => {
-				logger$26.warn({ err }, "interactive prompt failed during cost-ceiling halt — continuing with default action");
+				logger$27.warn({ err }, "interactive prompt failed during cost-ceiling halt — continuing with default action");
 			});
 		} else eventBus.emit("decision:autonomous", {
 			runId,
@@ -15592,7 +16550,7 @@ function createImplementationOrchestrator(deps) {
 			severity: routeResult.severity
 		});
 		_budgetExhausted = true;
-		logger$26.warn({
+		logger$27.warn({
 			skipped: allSkipped.length,
 			cumulative: result.cumulative,
 			ceiling: result.ceiling,
@@ -15611,7 +16569,7 @@ function createImplementationOrchestrator(deps) {
 		const completedStoryKeys = [];
 		for (const storyKey of group) {
 			if (_shutdownRequested) {
-				logger$26.info({ storyKey }, "shutdown requested — skipping dispatch");
+				logger$27.info({ storyKey }, "shutdown requested — skipping dispatch");
 				return;
 			}
 			if (runManifest !== null && runManifest !== void 0) try {
@@ -15634,7 +16592,7 @@ function createImplementationOrchestrator(deps) {
 					}
 				}
 			} catch (err) {
-				logger$26.debug({ err }, "Cost ceiling check failed — proceeding without enforcement");
+				logger$27.debug({ err }, "Cost ceiling check failed — proceeding without enforcement");
 			}
 			let optimizationDirectives;
 			if (telemetryAdvisor !== void 0 && completedStoryKeys.length > 0) try {
@@ -15642,13 +16600,13 @@ function createImplementationOrchestrator(deps) {
 				const directives = telemetryAdvisor.formatOptimizationDirectives(recs);
 				if (directives.length > 0) {
 					optimizationDirectives = directives;
-					logger$26.debug({
+					logger$27.debug({
 						storyKey,
 						directiveCount: recs.filter((r) => r.severity !== "info").length
 					}, "Optimization directives ready for dispatch");
 				}
 			} catch (err) {
-				logger$26.debug({
+				logger$27.debug({
 					err,
 					storyKey
 				}, "Failed to fetch optimization directives — proceeding without");
@@ -15772,7 +16730,7 @@ function createImplementationOrchestrator(deps) {
 					recommendedAction: "serialize"
 				});
 			} catch {}
-			logger$26.info({
+			logger$27.info({
 				storyKeys: evt.storyKeys,
 				collisionPaths: evt.collisionPaths
 			}, "Cross-story file collision detected — serializing affected groups to prevent race conditions");
@@ -15785,7 +16743,7 @@ function createImplementationOrchestrator(deps) {
 			mergedGroupMap.set(root2, [...existing, ...group]);
 		}
 		const result = [...mergedGroupMap.values()];
-		logger$26.info({
+		logger$27.info({
 			originalGroupCount: batchGroups.length,
 			mergedGroupCount: result.length,
 			collisionCount
@@ -15829,7 +16787,7 @@ function createImplementationOrchestrator(deps) {
 	async function shutdownGracefully(reason, signal) {
 		if (_shutdownRequested) return;
 		_shutdownRequested = true;
-		logger$26.info({
+		logger$27.info({
 			reason,
 			signal
 		}, "Graceful shutdown initiated — stopping new dispatches");
@@ -15839,8 +16797,8 @@ function createImplementationOrchestrator(deps) {
 			run_status: "stopped",
 			stopped_reason: reason,
 			stopped_at: new Date().toISOString()
-		}).catch((err) => logger$26.warn({ err }, "patchRunStatus failed during shutdown (best-effort)"));
-		if (config.pipelineRunId !== void 0) await updatePipelineRun(db, config.pipelineRunId, { status: "stopped" }).catch((err) => logger$26.warn({ err }, "updatePipelineRun(stopped) failed during shutdown (best-effort)"));
+		}).catch((err) => logger$27.warn({ err }, "patchRunStatus failed during shutdown (best-effort)"));
+		if (config.pipelineRunId !== void 0) await updatePipelineRun(db, config.pipelineRunId, { status: "stopped" }).catch((err) => logger$27.warn({ err }, "updatePipelineRun(stopped) failed during shutdown (best-effort)"));
 		const activePhases = [
 			"PENDING",
 			"IN_STORY_CREATION",
@@ -15851,7 +16809,7 @@ function createImplementationOrchestrator(deps) {
 			"CHECKPOINT"
 		];
 		const cancellations = [];
-		for (const [storyKey, state] of _stories.entries()) if (activePhases.includes(state.phase)) cancellations.push(wgRepo.updateStoryStatus(storyKey, "cancelled").catch((err) => logger$26.warn({
+		for (const [storyKey, state] of _stories.entries()) if (activePhases.includes(state.phase)) cancellations.push(wgRepo.updateStoryStatus(storyKey, "cancelled").catch((err) => logger$27.warn({
 			err,
 			storyKey
 		}, "wg_stories → cancelled failed during shutdown (best-effort)")));
@@ -15860,15 +16818,29 @@ function createImplementationOrchestrator(deps) {
 	}
 	async function run(storyKeys) {
 		if (_state === "RUNNING" || _state === "PAUSED") {
-			logger$26.warn({ state: _state }, "run() called while orchestrator is already running or paused — ignoring");
+			logger$27.warn({ state: _state }, "run() called while orchestrator is already running or paused — ignoring");
 			return getStatus();
 		}
 		if (_state === "COMPLETE") {
-			logger$26.warn({ state: _state }, "run() called on a COMPLETE orchestrator — ignoring");
+			logger$27.warn({ state: _state }, "run() called on a COMPLETE orchestrator — ignoring");
 			return getStatus();
 		}
 		_state = "RUNNING";
 		_startedAt = new Date().toISOString();
+		if (projectRoot !== void 0) try {
+			_orchestratorStartBranch = execSync("git rev-parse --abbrev-ref HEAD", {
+				cwd: projectRoot,
+				encoding: "utf-8",
+				stdio: [
+					"ignore",
+					"pipe",
+					"pipe"
+				]
+			}).trim();
+			logger$27.info({ orchestratorStartBranch: _orchestratorStartBranch }, "Captured orchestrator start branch for merge-to-main");
+		} catch (branchErr) {
+			logger$27.warn({ err: branchErr }, "Failed to capture orchestrator start branch — merge-to-main will skip worktree integration");
+		}
 		for (const key of storyKeys) {
 			const pendingState = {
 				phase: "PENDING",
@@ -15910,12 +16882,13 @@ function createImplementationOrchestrator(deps) {
 		await persistState();
 		recordProgress();
 		if (config.enableHeartbeat) startHeartbeat();
+		if (_orchestratorStartBranch !== void 0 && runManifest !== null) runManifest.patchRunStatus({ orchestrator_start_branch: _orchestratorStartBranch }).catch((err) => logger$27.warn({ err }, "Failed to persist orchestrator_start_branch to manifest (best-effort)"));
 		const _startupTimings = {};
 		if (projectRoot !== void 0) {
 			const seedStart = Date.now();
 			const seedResult = await seedMethodologyContext(db, projectRoot);
 			_startupTimings.seedMethodologyMs = Date.now() - seedStart;
-			if (seedResult.decisionsCreated > 0) logger$26.info({
+			if (seedResult.decisionsCreated > 0) logger$27.info({
 				decisionsCreated: seedResult.decisionsCreated,
 				skippedCategories: seedResult.skippedCategories,
 				durationMs: _startupTimings.seedMethodologyMs
@@ -15925,12 +16898,12 @@ function createImplementationOrchestrator(deps) {
 			const ingestStart = Date.now();
 			try {
 				const ingestResult = await autoIngestEpicsDependencies(db, projectRoot);
-				if (ingestResult.storiesIngested > 0 || ingestResult.dependenciesIngested > 0) logger$26.info({
+				if (ingestResult.storiesIngested > 0 || ingestResult.dependenciesIngested > 0) logger$27.info({
 					...ingestResult,
 					durationMs: Date.now() - ingestStart
 				}, "Auto-ingested stories and dependencies from epics document");
 			} catch (err) {
-				logger$26.debug({ err }, "Auto-ingest from epics document skipped — work graph may be unavailable");
+				logger$27.debug({ err }, "Auto-ingest from epics document skipped — work graph may be unavailable");
 			}
 		}
 		const sigtermHandler = () => {
@@ -15948,7 +16921,7 @@ function createImplementationOrchestrator(deps) {
 				_startupTimings.stateStoreInitMs = Date.now() - stateStoreInitStart;
 				for (const key of storyKeys) {
 					const pendingState = _stories.get(key);
-					if (pendingState !== void 0) persistStoryState(key, pendingState).catch((err) => logger$26.warn({
+					if (pendingState !== void 0) persistStoryState(key, pendingState).catch((err) => logger$27.warn({
 						err,
 						storyKey: key
 					}, "StateStore write failed during PENDING init"));
@@ -15959,12 +16932,12 @@ function createImplementationOrchestrator(deps) {
 					_startupTimings.queryStoriesMs = Date.now() - queryStoriesStart;
 					for (const record of existingRecords) _stateStoreCache.set(record.storyKey, record);
 				} catch (err) {
-					logger$26.warn({ err }, "StateStore.queryStories() failed during init — status merge will be empty (best-effort)");
+					logger$27.warn({ err }, "StateStore.queryStories() failed during init — status merge will be empty (best-effort)");
 				}
 			}
 			if (ingestionServer !== void 0) {
 				if (telemetryPersistence !== void 0) try {
-					const pipelineLogger = logger$26;
+					const pipelineLogger = logger$27;
 					const telemetryPipeline = new TelemetryPipeline({
 						normalizer: new TelemetryNormalizer(pipelineLogger),
 						turnAnalyzer: new TurnAnalyzer(pipelineLogger),
@@ -15976,14 +16949,14 @@ function createImplementationOrchestrator(deps) {
 						persistence: telemetryPersistence
 					});
 					ingestionServer.setPipeline(telemetryPipeline);
-					logger$26.info("TelemetryPipeline wired to IngestionServer");
+					logger$27.info("TelemetryPipeline wired to IngestionServer");
 				} catch (pipelineErr) {
-					logger$26.warn({ err: pipelineErr }, "Failed to create TelemetryPipeline — continuing without analysis pipeline");
+					logger$27.warn({ err: pipelineErr }, "Failed to create TelemetryPipeline — continuing without analysis pipeline");
 				}
-				await ingestionServer.start().catch((err) => logger$26.warn({ err }, "IngestionServer.start() failed — continuing without telemetry (best-effort)"));
+				await ingestionServer.start().catch((err) => logger$27.warn({ err }, "IngestionServer.start() failed — continuing without telemetry (best-effort)"));
 				try {
 					_otlpEndpoint = ingestionServer.getOtlpEnvVars().OTEL_EXPORTER_OTLP_ENDPOINT;
-					logger$26.info({ otlpEndpoint: _otlpEndpoint }, "OTLP telemetry ingestion active");
+					logger$27.info({ otlpEndpoint: _otlpEndpoint }, "OTLP telemetry ingestion active");
 				} catch {}
 			}
 			let contractDeclarations = [];
@@ -16023,12 +16996,12 @@ function createImplementationOrchestrator(deps) {
 			const conflictDetectStart = Date.now();
 			const { batches, edges: contractEdges } = detectConflictGroupsWithContracts(storyKeys, { moduleMap: pack.manifest.conflictGroups }, contractDeclarations);
 			_startupTimings.conflictDetectMs = Date.now() - conflictDetectStart;
-			if (contractEdges.length > 0) logger$26.info({
+			if (contractEdges.length > 0) logger$27.info({
 				contractEdges,
 				edgeCount: contractEdges.length
 			}, "Contract dependency edges detected — applying contract-aware dispatch ordering");
-			wgRepo.addContractDependencies(contractEdges).catch((err) => logger$26.warn({ err }, "contract dep persistence failed (best-effort)"));
-			logger$26.info({
+			wgRepo.addContractDependencies(contractEdges).catch((err) => logger$27.warn({ err }, "contract dep persistence failed (best-effort)"));
+			logger$27.info({
 				storyCount: storyKeys.length,
 				groupCount: batches.reduce((sum, b) => sum + b.length, 0),
 				batchCount: batches.length,
@@ -16038,7 +17011,7 @@ function createImplementationOrchestrator(deps) {
 					groups: batch.map((g) => g.join(","))
 				}))
 			}, "Orchestrator starting");
-			logger$26.info({
+			logger$27.info({
 				storyCount: storyKeys.length,
 				conflictGroups: batches.length,
 				maxConcurrency: config.maxConcurrency
@@ -16059,7 +17032,7 @@ function createImplementationOrchestrator(deps) {
 						exitCode,
 						output: truncatedOutput
 					});
-					logger$26.error({
+					logger$27.error({
 						exitCode,
 						reason: preFlightResult.reason
 					}, "Pre-flight build check failed — aborting pipeline before any story dispatch");
@@ -16068,19 +17041,19 @@ function createImplementationOrchestrator(deps) {
 					await persistState();
 					return getStatus();
 				}
-				if (preFlightResult.status !== "skipped") logger$26.info("Pre-flight build check passed");
+				if (preFlightResult.status !== "skipped") logger$27.info("Pre-flight build check passed");
 			}
-			logger$26.info(_startupTimings, "Orchestrator startup timings (ms)");
+			logger$27.info(_startupTimings, "Orchestrator startup timings (ms)");
 			const totalGroups = batches.reduce((sum, b) => sum + b.length, 0);
 			const actualConcurrency = Math.min(config.maxConcurrency, totalGroups);
 			if (actualConcurrency > 1 && projectRoot !== void 0) try {
 				_packageSnapshot = capturePackageSnapshot({ projectRoot });
-				logger$26.info({
+				logger$27.info({
 					fileCount: _packageSnapshot.files.size,
 					installCommand: _packageSnapshot.installCommand
 				}, "Package snapshot captured for concurrent story protection");
 			} catch (snapErr) {
-				logger$26.warn({ err: snapErr }, "Failed to capture package snapshot — continuing without protection");
+				logger$27.warn({ err: snapErr }, "Failed to capture package snapshot — continuing without protection");
 			}
 			try {
 				for (const rawBatchGroups of batches) {
@@ -16105,14 +17078,14 @@ function createImplementationOrchestrator(deps) {
 								manifest: runManifest,
 								adapter: db
 							});
-							if (!recoveryResult.noStale) logger$26.info({
+							if (!recoveryResult.noStale) logger$27.info({
 								recovered: recoveryResult.recovered,
 								stillFailed: recoveryResult.stillFailed,
 								recoveredCount: recoveryResult.recovered.length,
 								stillFailedCount: recoveryResult.stillFailed.length
 							}, "Cross-story race recovery complete");
 						} catch (recoveryErr) {
-							logger$26.warn({ err: recoveryErr }, "Cross-story race recovery failed (non-fatal) — pipeline continues");
+							logger$27.warn({ err: recoveryErr }, "Cross-story race recovery failed (non-fatal) — pipeline continues");
 						}
 					}
 				}
@@ -16121,7 +17094,7 @@ function createImplementationOrchestrator(deps) {
 				_state = "FAILED";
 				_completedAt = new Date().toISOString();
 				await persistState();
-				logger$26.error({ err }, "Orchestrator failed with unhandled error");
+				logger$27.error({ err }, "Orchestrator failed with unhandled error");
 				return getStatus();
 			}
 			stopHeartbeat();
@@ -16131,7 +17104,7 @@ function createImplementationOrchestrator(deps) {
 				const totalDeclarations = contractDeclarations.length;
 				const currentSprintDeclarations = contractDeclarations.filter((d) => storyKeys.includes(d.storyKey));
 				const stalePruned = totalDeclarations - currentSprintDeclarations.length;
-				if (stalePruned > 0) logger$26.info({
+				if (stalePruned > 0) logger$27.info({
 					stalePruned,
 					remaining: currentSprintDeclarations.length
 				}, "Pruned stale contract declarations from previous epics");
@@ -16145,11 +17118,11 @@ function createImplementationOrchestrator(deps) {
 						contractName: mismatch.contractName,
 						mismatchDescription: mismatch.mismatchDescription
 					});
-					logger$26.warn({
+					logger$27.warn({
 						mismatchCount: mismatches.length,
 						mismatches
 					}, "Post-sprint contract verification found mismatches — manual review required");
-				} else if (currentSprintDeclarations.length > 0) logger$26.info("Post-sprint contract verification passed — all declared contracts satisfied");
+				} else if (currentSprintDeclarations.length > 0) logger$27.info("Post-sprint contract verification passed — all declared contracts satisfied");
 				eventBus.emit("pipeline:contract-verification-summary", {
 					verified: currentSprintDeclarations.length,
 					stalePruned,
@@ -16184,12 +17157,12 @@ function createImplementationOrchestrator(deps) {
 						});
 						await stateStore.setContractVerification(sk, records);
 					}
-					logger$26.info({ storyCount: contractsByStory.size }, "Contract verification results persisted to StateStore");
+					logger$27.info({ storyCount: contractsByStory.size }, "Contract verification results persisted to StateStore");
 				} catch (persistErr) {
-					logger$26.warn({ err: persistErr }, "Failed to persist contract verification results to StateStore");
+					logger$27.warn({ err: persistErr }, "Failed to persist contract verification results to StateStore");
 				}
 			} catch (err) {
-				logger$26.error({ err }, "Post-sprint contract verification threw an error — skipping");
+				logger$27.error({ err }, "Post-sprint contract verification threw an error — skipping");
 			}
 			if (projectRoot !== void 0) try {
 				const indicators = checkProfileStaleness(projectRoot);
@@ -16199,10 +17172,10 @@ function createImplementationOrchestrator(deps) {
 						message,
 						indicators
 					});
-					logger$26.warn({ indicators }, message);
+					logger$27.warn({ indicators }, message);
 				}
 			} catch (err) {
-				logger$26.debug({ err }, "Profile staleness check failed (best-effort)");
+				logger$27.debug({ err }, "Profile staleness check failed (best-effort)");
 			}
 			let completed = 0;
 			let escalated = 0;
@@ -16221,8 +17194,8 @@ function createImplementationOrchestrator(deps) {
 		} finally {
 			process.off("SIGTERM", sigtermHandler);
 			process.off("SIGINT", sigintHandler);
-			if (stateStore !== void 0) await stateStore.close().catch((err) => logger$26.warn({ err }, "StateStore.close() failed (best-effort)"));
-			if (ingestionServer !== void 0) await ingestionServer.stop().catch((err) => logger$26.warn({ err }, "IngestionServer.stop() failed (best-effort)"));
+			if (stateStore !== void 0) await stateStore.close().catch((err) => logger$27.warn({ err }, "StateStore.close() failed (best-effort)"));
+			if (ingestionServer !== void 0) await ingestionServer.stop().catch((err) => logger$27.warn({ err }, "IngestionServer.stop() failed (best-effort)"));
 		}
 	}
 	function pause() {
@@ -16231,7 +17204,7 @@ function createImplementationOrchestrator(deps) {
 		_pauseGate = createPauseGate();
 		_state = "PAUSED";
 		eventBus.emit("orchestrator:paused", {});
-		logger$26.info("Orchestrator paused");
+		logger$27.info("Orchestrator paused");
 	}
 	function resume() {
 		if (_state !== "PAUSED") return;
@@ -16242,7 +17215,7 @@ function createImplementationOrchestrator(deps) {
 		}
 		_state = "RUNNING";
 		eventBus.emit("orchestrator:resumed", {});
-		logger$26.info("Orchestrator resumed");
+		logger$27.info("Orchestrator resumed");
 	}
 	return {
 		run,
@@ -17658,8 +18631,8 @@ async function resolveContext(ref, deps, runId, params, stepOutputs) {
 		return params[key] ?? "";
 	}
 	if (source.startsWith("decision:")) {
-		const path$4 = source.slice(9);
-		const [phase, category] = path$4.split(".");
+		const path$6 = source.slice(9);
+		const [phase, category] = path$6.split(".");
 		if (!phase || !category) return "";
 		const decisions = await getDecisionsByPhaseForRun(deps.db, runId, phase);
 		const filtered = decisions.filter((d) => d.category === category);
@@ -17730,8 +18703,8 @@ async function runSteps(steps, deps, runId, phase, params) {
 				for (const ref of step.context) {
 					let value;
 					if (ref.source.startsWith("decision:")) {
-						const path$4 = ref.source.slice(9);
-						const [decPhase, decCategory] = path$4.split(".");
+						const path$6 = ref.source.slice(9);
+						const [decPhase, decCategory] = path$6.split(".");
 						if (decPhase && decCategory) {
 							const decisions = await getDecisionsByPhaseForRun(deps.db, runId, decPhase);
 							const filtered = decisions.filter((d) => d.category === decCategory);
@@ -28778,8 +29751,8 @@ var require_uri_all = __commonJS({ "node_modules/uri-js/dist/es5/uri.all.js"(exp
 					wsComponents.secure = void 0;
 				}
 				if (wsComponents.resourceName) {
-					var _wsComponents$resourc = wsComponents.resourceName.split("?"), _wsComponents$resourc2 = slicedToArray(_wsComponents$resourc, 2), path$4 = _wsComponents$resourc2[0], query = _wsComponents$resourc2[1];
-					wsComponents.path = path$4 && path$4 !== "/" ? path$4 : void 0;
+					var _wsComponents$resourc = wsComponents.resourceName.split("?"), _wsComponents$resourc2 = slicedToArray(_wsComponents$resourc, 2), path$6 = _wsComponents$resourc2[0], query = _wsComponents$resourc2[1];
+					wsComponents.path = path$6 && path$6 !== "/" ? path$6 : void 0;
 					wsComponents.query = query;
 					wsComponents.resourceName = void 0;
 				}
@@ -29120,12 +30093,12 @@ var require_util = __commonJS({ "node_modules/ajv/lib/compile/util.js"(exports,
 		return "'" + escapeQuotes(str) + "'";
 	}
 	function getPathExpr(currentPath, expr, jsonPointers, isNumber) {
-		var path$4 = jsonPointers ? "'/' + " + expr + (isNumber ? "" : ".replace(/~/g, '~0').replace(/\\//g, '~1')") : isNumber ? "'[' + " + expr + " + ']'" : "'[\\'' + " + expr + " + '\\']'";
-		return joinPaths(currentPath, path$4);
+		var path$6 = jsonPointers ? "'/' + " + expr + (isNumber ? "" : ".replace(/~/g, '~0').replace(/\\//g, '~1')") : isNumber ? "'[' + " + expr + " + ']'" : "'[\\'' + " + expr + " + '\\']'";
+		return joinPaths(currentPath, path$6);
 	}
 	function getPath(currentPath, prop, jsonPointers) {
-		var path$4 = jsonPointers ? toQuotedString("/" + escapeJsonPointer(prop)) : toQuotedString(getProperty(prop));
-		return joinPaths(currentPath, path$4);
+		var path$6 = jsonPointers ? toQuotedString("/" + escapeJsonPointer(prop)) : toQuotedString(getProperty(prop));
+		return joinPaths(currentPath, path$6);
 	}
 	var JSON_POINTER$1 = /^\/(?:[^~]|~0|~1)*$/;
 	var RELATIVE_JSON_POINTER$1 = /^([0-9]+)(#|\/(?:[^~]|~0|~1)*)?$/;
@@ -33293,16 +34266,16 @@ var require_ajv = __commonJS({ "node_modules/ajv/lib/ajv.js"(exports, module) {
 		return metaOpts;
 	}
 	function setLogger(self) {
-		var logger$26 = self._opts.logger;
-		if (logger$26 === false) self.logger = {
+		var logger$27 = self._opts.logger;
+		if (logger$27 === false) self.logger = {
 			log: noop,
 			warn: noop,
 			error: noop
 		};
 		else {
-			if (logger$26 === void 0) logger$26 = console;
-			if (!(typeof logger$26 == "object" && logger$26.log && logger$26.warn && logger$26.error)) throw new Error("logger must implement log, warn and error methods");
-			self.logger = logger$26;
+			if (logger$27 === void 0) logger$27 = console;
+			if (!(typeof logger$27 == "object" && logger$27.log && logger$27.warn && logger$27.error)) throw new Error("logger must implement log, warn and error methods");
+			self.logger = logger$27;
 		}
 	}
 	function noop() {}
@@ -33334,8 +34307,8 @@ var ToolRegistry = class {
 		if (!valid) {
 			const errors = validate$1.errors ?? [];
 			const messages = errors.map((e) => {
-				const path$4 = e.instancePath ?? e.dataPath ?? "";
-				return `${path$4} ${e.message ?? ""}`.trim();
+				const path$6 = e.instancePath ?? e.dataPath ?? "";
+				return `${path$6} ${e.message ?? ""}`.trim();
 			}).join(", ");
 			return {
 				content: `Validation failed for tool '${name}': ${messages}`,
@@ -40041,10 +41014,10 @@ var PathBase = class {
 	/**
 	* Get the Path object referenced by the string path, resolved from this Path
 	*/
-	resolve(path$4) {
-		if (!path$4) return this;
-		const rootPath = this.getRootString(path$4);
-		const dir = path$4.substring(rootPath.length);
+	resolve(path$6) {
+		if (!path$6) return this;
+		const rootPath = this.getRootString(path$6);
+		const dir = path$6.substring(rootPath.length);
 		const dirParts = dir.split(this.splitSep);
 		const result = rootPath ? this.getRoot(rootPath).#resolveParts(dirParts) : this.#resolveParts(dirParts);
 		return result;
@@ -40699,8 +41672,8 @@ var PathWin32 = class PathWin32 extends PathBase {
 	/**
 	* @internal
 	*/
-	getRootString(path$4) {
-		return win32.parse(path$4).root;
+	getRootString(path$6) {
+		return win32.parse(path$6).root;
 	}
 	/**
 	* @internal
@@ -40745,8 +41718,8 @@ var PathPosix = class PathPosix extends PathBase {
 	/**
 	* @internal
 	*/
-	getRootString(path$4) {
-		return path$4.startsWith("/") ? "/" : "";
+	getRootString(path$6) {
+		return path$6.startsWith("/") ? "/" : "";
 	}
 	/**
 	* @internal
@@ -40839,9 +41812,9 @@ var PathScurryBase = class {
 	/**
 	* Get the depth of a provided path, string, or the cwd
 	*/
-	depth(path$4 = this.cwd) {
-		if (typeof path$4 === "string") path$4 = this.cwd.resolve(path$4);
-		return path$4.depth();
+	depth(path$6 = this.cwd) {
+		if (typeof path$6 === "string") path$6 = this.cwd.resolve(path$6);
+		return path$6.depth();
 	}
 	/**
 	* Return the cache of child entries.  Exposed so subclasses can create
@@ -41222,9 +42195,9 @@ var PathScurryBase = class {
 		process$1();
 		return results;
 	}
-	chdir(path$4 = this.cwd) {
+	chdir(path$6 = this.cwd) {
 		const oldCwd = this.cwd;
-		this.cwd = typeof path$4 === "string" ? this.cwd.resolve(path$4) : path$4;
+		this.cwd = typeof path$6 === "string" ? this.cwd.resolve(path$6) : path$6;
 		this.cwd[setAsCwd](oldCwd);
 	}
 };
@@ -41608,8 +42581,8 @@ var MatchRecord = class {
 		this.store.set(target, current === void 0 ? n$1 : n$1 & current);
 	}
 	entries() {
-		return [...this.store.entries()].map(([path$4, n$1]) => [
-			path$4,
+		return [...this.store.entries()].map(([path$6, n$1]) => [
+			path$6,
 			!!(n$1 & 2),
 			!!(n$1 & 1)
 		]);
@@ -41785,9 +42758,9 @@ var GlobUtil = class {
 	signal;
 	maxDepth;
 	includeChildMatches;
-	constructor(patterns, path$4, opts) {
+	constructor(patterns, path$6, opts) {
 		this.patterns = patterns;
-		this.path = path$4;
+		this.path = path$6;
 		this.opts = opts;
 		this.#sep = !opts.posix && opts.platform === "win32" ? "\\" : "/";
 		this.includeChildMatches = opts.includeChildMatches !== false;
@@ -41808,11 +42781,11 @@ var GlobUtil = class {
 			});
 		}
 	}
-	#ignored(path$4) {
-		return this.seen.has(path$4) || !!this.#ignore?.ignored?.(path$4);
+	#ignored(path$6) {
+		return this.seen.has(path$6) || !!this.#ignore?.ignored?.(path$6);
 	}
-	#childrenIgnored(path$4) {
-		return !!this.#ignore?.childrenIgnored?.(path$4);
+	#childrenIgnored(path$6) {
+		return !!this.#ignore?.childrenIgnored?.(path$6);
 	}
 	pause() {
 		this.paused = true;
@@ -41994,8 +42967,8 @@ var GlobUtil = class {
 };
 var GlobWalker = class extends GlobUtil {
 	matches = new Set();
-	constructor(patterns, path$4, opts) {
-		super(patterns, path$4, opts);
+	constructor(patterns, path$6, opts) {
+		super(patterns, path$6, opts);
 	}
 	matchEmit(e) {
 		this.matches.add(e);
@@ -42022,8 +42995,8 @@ var GlobWalker = class extends GlobUtil {
 };
 var GlobStream = class extends GlobUtil {
 	results;
-	constructor(patterns, path$4, opts) {
-		super(patterns, path$4, opts);
+	constructor(patterns, path$6, opts) {
+		super(patterns, path$6, opts);
 		this.results = new Minipass({
 			signal: this.signal,
 			objectMode: true
@@ -44583,7 +45556,7 @@ function resolveProbeAuthorStateIntegrating(cliFlag) {
 *   substrate run --non-interactive --halt-on none --events --output-format json
 */
 async function runRunAction(options) {
-	const { pack: packName, from: startPhase, stopAfter, concept: conceptArg, conceptFile, stories: storiesArg, concurrency, outputFormat, projectRoot, events: eventsFlag, verbose: verboseFlag, tui: tuiFlag, skipUx, research: researchFlag, skipResearch: skipResearchFlag, skipPreflight, skipVerification, epic: epicNumber, dryRun, maxReviewCycles = 2, engine, agent: agentId, registry: injectedRegistry, haltOn: haltOnOpt, costCeiling, probeAuthor, probeAuthorStateIntegrating: probeAuthorStateIntegratingFlag, nonInteractive, verifyAc } = options;
+	const { pack: packName, from: startPhase, stopAfter, concept: conceptArg, conceptFile, stories: storiesArg, concurrency, outputFormat, projectRoot, events: eventsFlag, verbose: verboseFlag, tui: tuiFlag, skipUx, research: researchFlag, skipResearch: skipResearchFlag, skipPreflight, skipVerification, epic: epicNumber, dryRun, maxReviewCycles = 2, engine, agent: agentId, registry: injectedRegistry, haltOn: haltOnOpt, costCeiling, probeAuthor, probeAuthorStateIntegrating: probeAuthorStateIntegratingFlag, nonInteractive, verifyAc, noWorktree } = options;
 	const haltOn = haltOnOpt;
 	const VALID_PROBE_AUTHOR_MODES = [
 		"enabled",
@@ -44803,7 +45776,8 @@ async function runRunAction(options) {
 		engineType: resolvedEngine,
 		maxReviewCycles: effectiveMaxReviewCycles,
 		retryBudget: configRetryBudget ?? 2,
-		agentId
+		agentId,
+		...noWorktree === true ? { noWorktree: true } : {}
 	});
 	let storyKeys = [...parsedStoryKeys];
 	if (!existsSync$1(dbDir)) mkdirSync$1(dbDir, { recursive: true });
@@ -44902,7 +45876,8 @@ async function runRunAction(options) {
 				...agentId !== void 0 ? { agent: agentId } : {},
 				...skipVerification === true ? { skip_verification: true } : {},
 				...eventsFlag === true ? { events: true } : {},
-				...nonInteractive === true ? { non_interactive: true } : {}
+				...nonInteractive === true ? { non_interactive: true } : {},
+				...noWorktree === true ? { no_worktree: true } : {}
 			};
 			const manifest = RunManifest.open(pipelineRun.id, runsDir);
 			await manifest.patchCLIFlags(cliFlags);
@@ -45354,7 +46329,8 @@ async function runRunAction(options) {
 					skipPreflight: skipPreflight === true,
 					...skipVerification === true ? { skipVerification: true } : {},
 					...probeAuthor !== void 0 ? { probeAuthorMode: probeAuthor } : {},
-					probeAuthorStateIntegrating: resolvedProbeAuthorStateIntegrating
+					probeAuthorStateIntegrating: resolvedProbeAuthorStateIntegrating,
+					...noWorktree === true ? { noWorktree: true } : {}
 				},
 				projectRoot,
 				tokenCeilings,
@@ -45572,7 +46548,7 @@ async function runRunAction(options) {
 	}
 }
 async function runFullPipeline(options) {
-	const { packName, packPath, dbDir, dbPath, startPhase, stopAfter, concept, concurrency, outputFormat, projectRoot, events: eventsFlag, skipUx, research: researchFlag, skipResearch: skipResearchFlag, skipPreflight, skipVerification, maxReviewCycles = 2, retryBudget, registry: injectedRegistry, tokenCeilings, stories: explicitStories, telemetryEnabled: fullTelemetryEnabled, telemetryPort: fullTelemetryPort, agentId, meshUrl: fpMeshUrl, meshProjectId: fpMeshProjectId, engineType: fpEngineType, probeAuthor, probeAuthorStateIntegrating: fpProbeAuthorStateIntegrating } = options;
+	const { packName, packPath, dbDir, dbPath, startPhase, stopAfter, concept, concurrency, outputFormat, projectRoot, events: eventsFlag, skipUx, research: researchFlag, skipResearch: skipResearchFlag, skipPreflight, skipVerification, maxReviewCycles = 2, retryBudget, registry: injectedRegistry, tokenCeilings, stories: explicitStories, telemetryEnabled: fullTelemetryEnabled, telemetryPort: fullTelemetryPort, agentId, meshUrl: fpMeshUrl, meshProjectId: fpMeshProjectId, engineType: fpEngineType, probeAuthor, probeAuthorStateIntegrating: fpProbeAuthorStateIntegrating, noWorktree } = options;
 	if (!existsSync$1(dbDir)) mkdirSync$1(dbDir, { recursive: true });
 	let doltServerFull = null;
 	try {
@@ -45881,7 +46857,8 @@ async function runFullPipeline(options) {
 						skipPreflight: skipPreflight === true,
 						...skipVerification === true ? { skipVerification: true } : {},
 						...probeAuthor !== void 0 ? { probeAuthorMode: probeAuthor } : {},
-						...fpProbeAuthorStateIntegrating !== void 0 ? { probeAuthorStateIntegrating: fpProbeAuthorStateIntegrating } : {}
+						...fpProbeAuthorStateIntegrating !== void 0 ? { probeAuthorStateIntegrating: fpProbeAuthorStateIntegrating } : {},
+						...noWorktree === true ? { noWorktree: true } : {}
 					},
 					projectRoot,
 					tokenCeilings,
@@ -46091,7 +47068,7 @@ function registerRunCommand(program, version = "0.0.0", projectRoot = process.cw
 		"",
 		"--halt-on defaults to critical. Skipped halt decisions are recorded as",
 		"decision:halt-skipped-non-interactive events in --non-interactive mode."
-	].join("\n      ")).option("--verify-ac", "Run AC-to-test traceability heuristic after the pipeline completes (Story 74-1)").action(async (opts) => {
+	].join("\n      ")).option("--verify-ac", "Run AC-to-test traceability heuristic after the pipeline completes (Story 74-1)").option("--no-worktree", "Bypass per-story git worktrees (safety valve for submodules, bare repos, or large checkouts where parallel worktrees blow disk — not the recommended path)").action(async (opts) => {
 		if (opts.helpAgent) {
 			process.exitCode = await runHelpAgent();
 			return;
@@ -46138,7 +47115,8 @@ function registerRunCommand(program, version = "0.0.0", projectRoot = process.cw
 			probeAuthor: opts.probeAuthor,
 			probeAuthorStateIntegrating: opts.probeAuthorStateIntegrating,
 			nonInteractive: opts.nonInteractive,
-			verifyAc: opts.verifyAc
+			verifyAc: opts.verifyAc,
+			noWorktree: opts.worktree === false || process.env["SUBSTRATE_NO_WORKTREE"] === "1"
 		});
 		if (opts.nonInteractive === true) process.exit(exitCode);
 		process.exitCode = exitCode;
@@ -46146,5 +47124,5 @@ function registerRunCommand(program, version = "0.0.0", projectRoot = process.cw
 }
 
 //#endregion
-export { AdapterTelemetryPersistence, AppError, DoltRepoMapMetaRepository, DoltSymbolRepository, ERR_REPO_MAP_STORAGE_WRITE, EpicIngester, GLOBSTAR$1 as GLOBSTAR, GitClient, GrammarLoader, Minimatch$1 as Minimatch, Minipass, RepoMapInjector, RepoMapModule, RepoMapQueryEngine, RepoMapStorage, SymbolParser, createContextCompiler, createDispatcher, createEventEmitter, createImplementationOrchestrator, createPackLoader, createPhaseOrchestrator, createStopAfterGate, createTelemetryAdvisor, escape$1 as escape, formatPhaseCompletionSummary, getFactoryRunSummaries, getScenarioResultsForRun, getTwinRunsForRun, listGraphRuns, normalizeGraphSummaryToStatus, registerExportCommand, registerFactoryCommand, registerRunCommand, registerScenariosCommand, resolveMaxReviewCycles, resolveProbeAuthorStateIntegrating, resolveStoryKeys, runAnalysisPhase, runPlanningPhase, runProbeAuthor, runRunAction, runSolutioningPhase, unescape$1 as unescape, validateStopAfterFromConflict, wireNdjsonEmitter };
-//# sourceMappingURL=run-5R5ZPgSw.js.map
+export { AdapterTelemetryPersistence, AppError, DoltRepoMapMetaRepository, DoltSymbolRepository, ERR_REPO_MAP_STORAGE_WRITE, EpicIngester, GLOBSTAR$1 as GLOBSTAR, GitClient, GrammarLoader, Minimatch$1 as Minimatch, Minipass, RepoMapInjector, RepoMapModule, RepoMapQueryEngine, RepoMapStorage, SymbolParser, createContextCompiler, createDispatcher, createEventEmitter, createGitWorktreeManager, createImplementationOrchestrator, createPackLoader, createPhaseOrchestrator, createStopAfterGate, createTelemetryAdvisor, escape$1 as escape, formatPhaseCompletionSummary, getFactoryRunSummaries, getScenarioResultsForRun, getTwinRunsForRun, listGraphRuns, normalizeGraphSummaryToStatus, registerExportCommand, registerFactoryCommand, registerRunCommand, registerScenariosCommand, resolveMaxReviewCycles, resolveProbeAuthorStateIntegrating, resolveStoryKeys, runAnalysisPhase, runPlanningPhase, runProbeAuthor, runRunAction, runSolutioningPhase, unescape$1 as unescape, validateStopAfterFromConflict, wireNdjsonEmitter };
+//# sourceMappingURL=run-CElciHC1.js.map