substrate-ai 0.20.147 → 0.20.149

package/dist/{run-BBVZdkEo.js → run-BAUlPom3.js}

@@ -1,11 +1,11 @@
-import { BMAD_BASELINE_TOKENS_FULL, FileKvStore, STOP_AFTER_VALID_PHASES, STORY_KEY_PATTERN, VALID_PHASES, __commonJS, __require, __toESM, buildPipelineStatusOutput, createDatabaseAdapter, formatOutput, formatPipelineSummary, formatTokenTelemetry, inspectProcessTree, parseDbTimestampAsUtc, validateStoryKey } from "./health-nQ_Txd5T.js";
+import { BMAD_BASELINE_TOKENS_FULL, FileKvStore, STOP_AFTER_VALID_PHASES, STORY_KEY_PATTERN, VALID_PHASES, __commonJS, __require, __toESM, buildPipelineStatusOutput, createDatabaseAdapter, formatOutput, formatPipelineSummary, formatTokenTelemetry, inspectProcessTree, parseDbTimestampAsUtc, validateStoryKey } from "./health-ByQadq3J.js";
 import { createLogger } from "./logger-KeHncl-f.js";
 import { TypedEventBusImpl, createEventBus, createTuiApp, isTuiCapable, printNonTtyWarning, sleep } from "./helpers-CElYrONe.js";
-import { ADVISORY_NOTES, CLAUDE_AUTH_FAILURE_HINT, CODEX_SANDBOX_BLOCK_HINT, 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, createStderrLogger, detectClaudeAuthFailure, detectCodexSandboxBlock, detectInterfaceChanges, getArtifactByTypeForRun, getArtifactsByRun, getDecisionsByCategory, getDecisionsByPhase, getDecisionsByPhaseForRun, getLatestRun, getPipelineRunById, getRunMetrics, getRunningPipelineRuns, getStoryMetricsForRun, getTokenUsageSummary, initSchema, listRequirements, loadModelRoutingConfig, registerArtifact, swallowDebug, updatePipelineRun, updatePipelineRunConfig, upsertDecision, writeRunMetrics, writeStoryMetrics } from "./dist-DT378h1M.js";
-import { FindingsInjector, RunManifest, RuntimeProbeListSchema, applyConfigToGraph, createDefaultVerificationPipeline, createGraphOrchestrator, createSdlcCodeReviewHandler, createSdlcCreateStoryHandler, createSdlcDevStoryHandler, createSdlcPhaseHandler, detectsEventDrivenAC, detectsStateIntegratingAC, extractTargetFilesFromStoryContent, parseRuntimeProbes, renderFindings, resolveGraphPath, resolveMainRepoRoot, runAcTraceabilityCheck, runStaleVerificationRecovery } from "./manifest-read-DlWwZpfO.js";
+import { ADVISORY_NOTES, BRANCH_PREFIX, CLAUDE_AUTH_FAILURE_HINT, CODEX_SANDBOX_BLOCK_HINT, 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, createGitWorktreeManager, createPipelineRun, createRequirement, detectClaudeAuthFailure, detectCodexSandboxBlock, detectInterfaceChanges, getArtifactByTypeForRun, getArtifactsByRun, getDecisionsByCategory, getDecisionsByPhase, getDecisionsByPhaseForRun, getLatestRun, getPipelineRunById, getRunMetrics, getRunningPipelineRuns, getStoryMetricsForRun, getTokenUsageSummary, initSchema, listRequirements, loadModelRoutingConfig, registerArtifact, swallowDebug, updatePipelineRun, updatePipelineRunConfig, upsertDecision, writeRunMetrics, writeStoryMetrics } from "./dist-C2CAZDep.js";
+import { FindingsInjector, RunManifest, RuntimeProbeListSchema, applyConfigToGraph, createDefaultVerificationPipeline, createGraphOrchestrator, createSdlcCodeReviewHandler, createSdlcCreateStoryHandler, createSdlcDevStoryHandler, createSdlcPhaseHandler, detectsEventDrivenAC, detectsStateIntegratingAC, extractTargetFilesFromStoryContent, parseRuntimeProbes, renderFindings, resolveGraphPath, resolveMainRepoRoot, runAcTraceabilityCheck, runStaleVerificationRecovery } from "./manifest-read-knD2uWkz.js";
 import { WorkGraphRepository, detectCycles } from "./work-graph-repository-DZyJv5pV.js";
 import { deriveExitCode, routeDecision } from "./decision-router-BAPpON_C.js";
-import { runInteractivePrompt } from "./interactive-prompt-xJ3K-IUQ.js";
+import { runInteractivePrompt } from "./interactive-prompt-CMBlj6UF.js";
 import { runRecoveryEngine } from "./recovery-engine-BKGBeBnW.js";
 import { basename, dirname, extname, join } from "path";
 import { access, readFile, readdir, stat } from "fs/promises";
@@ -15,14 +15,12 @@ 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, relative, 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, copyFile, 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 { 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 { 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";
@@ -34,780 +32,6 @@ 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`);
-	}
-}
-/**
-* Decide whether a registered worktree from a prior dispatch can be reclaimed
-* for a fresh re-run. Safe only when there is nothing to lose: no uncommitted
-* changes AND no commits on the branch beyond the base branch. A negative
-* `commitsAhead` means the ahead-count could not be determined → not safe.
-*
-* Pure + exported for testing (the git I/O that produces the inputs lives in
-* createWorktree).
-*/
-function decideWorktreeReclaim(hasUncommittedChanges, commitsAhead, baseBranch) {
-	if (hasUncommittedChanges) return {
-		safe: false,
-		reason: "it has uncommitted changes that are NOT on the branch"
-	};
-	if (commitsAhead > 0) return {
-		safe: false,
-		reason: `its branch has ${String(commitsAhead)} commit(s) beyond ${baseBranch}`
-	};
-	if (commitsAhead < 0) return {
-		safe: false,
-		reason: "its state could not be verified as safe to discard"
-	};
-	return { safe: true };
-}
-/**
-* Decide whether removing a story worktree AND deleting its branch is safe
-* (H0.3, field findings #17/#19). Unsafe when:
-*   - the worktree has uncommitted changes (removal destroys the only copy), or
-*   - the branch carries commits not reachable from the project's current HEAD
-*     (branch -D destroys them — this is where H0.1's wip checkpoints live), or
-*   - either state could not be determined (negative unmergedCommits).
-*
-* Pure + exported for testing (mirrors decideWorktreeReclaim; the git I/O that
-* produces the inputs lives in inspectWorktreeRemovalSafety).
-*/
-function decideWorktreeRemoval(hasUncommittedChanges, uncommittedFiles, unmergedCommits, branchName) {
-	const reasons = [];
-	if (hasUncommittedChanges) {
-		const preview = uncommittedFiles.slice(0, 10).join(", ");
-		const more = uncommittedFiles.length > 10 ? ` (+${String(uncommittedFiles.length - 10)} more)` : "";
-		reasons.push(`the worktree has ${String(uncommittedFiles.length)} uncommitted change(s) that removal would destroy` + (preview.length > 0 ? `: ${preview}${more}` : ""));
-	}
-	if (unmergedCommits > 0) reasons.push(`branch ${branchName} carries ${String(unmergedCommits)} commit(s) not reachable from the current HEAD — deleting the branch would destroy them`);
-	if (unmergedCommits < 0) reasons.push("the branch state could not be verified as safe to discard");
-	return {
-		safe: reasons.length === 0,
-		reasons
-	};
-}
-/**
-* Gather the inputs for `decideWorktreeRemoval` from git. Thin I/O wrapper:
-*   - `git status --porcelain` inside the worktree (skipped when the directory
-*     is missing — nothing on disk to lose)
-*   - `git rev-list --count HEAD..<branch>` in the project root (commits the
-*     branch has that the current checkout does not; 0 when the branch is
-*     merged or absent, -1 when the count could not be determined)
-*/
-async function inspectWorktreeRemovalSafety(worktreePath, projectRoot, branchName) {
-	let hasUncommittedChanges = false;
-	let uncommittedFiles = [];
-	const worktreeOnDisk = await access$1(worktreePath).then(() => true).catch(() => false);
-	if (worktreeOnDisk) {
-		const statusResult = await spawnGit(["status", "--porcelain"], { cwd: worktreePath });
-		if (statusResult.code === 0) {
-			uncommittedFiles = statusResult.stdout.split("\n").filter((line) => line.trim().length > 0).map((line) => line.slice(3).trim());
-			hasUncommittedChanges = uncommittedFiles.length > 0;
-		} else return decideWorktreeRemoval(false, [], -1, branchName);
-	}
-	const branchExists = (await spawnGit([
-		"rev-parse",
-		"--verify",
-		branchName
-	], { cwd: projectRoot })).code === 0;
-	let unmergedCommits = 0;
-	if (branchExists) {
-		const aheadResult = await spawnGit([
-			"rev-list",
-			"--count",
-			`HEAD..${branchName}`
-		], { cwd: projectRoot });
-		unmergedCommits = aheadResult.code === 0 ? Number.parseInt(aheadResult.stdout.trim(), 10) || 0 : -1;
-	}
-	return decideWorktreeRemoval(hasUncommittedChanges, uncommittedFiles, unmergedCommits, branchName);
-}
-async function createWorktree(projectRoot, taskId, branchName, baseBranch, copyFiles = []) {
-	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 {
-			const statusResult = await spawnGit(["status", "--porcelain"], { cwd: worktreePath });
-			const hasUncommittedChanges = statusResult.code === 0 && statusResult.stdout.trim().length > 0;
-			const aheadResult = await spawnGit([
-				"rev-list",
-				"--count",
-				`${baseBranch}..${branchName}`
-			], { cwd: projectRoot });
-			const commitsAhead = aheadResult.code === 0 ? Number.parseInt(aheadResult.stdout.trim(), 10) || 0 : -1;
-			const decision = decideWorktreeReclaim(hasUncommittedChanges, commitsAhead, baseBranch);
-			if (!decision.safe) throw new Error(`Worktree at ${worktreePath} is already registered (branch: ${branchName}) and ${decision.reason}.\nIt was preserved from a prior dispatch for inspection — inspect before removing.\n\nTo remove and re-dispatch:\n  substrate worktrees --cleanup ${taskId}\n\nTo remove all substrate worktrees:\n  substrate worktrees --cleanup`);
-			await spawnGit([
-				"worktree",
-				"remove",
-				"--force",
-				worktreePath
-			], { cwd: projectRoot });
-			await spawnGit([
-				"branch",
-				"-D",
-				branchName
-			], { cwd: projectRoot });
-		}
-	}
-	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}`);
-	await copyFilesToWorktree(projectRoot, worktreePath, copyFiles);
-	return { worktreePath };
-}
-/**
-* Copy files from a source directory into a target worktree.
-*
-* Skips missing files silently (intentional — config like `[".env",
-* ".env.local"]` should not blow up if `.env.local` doesn't exist in the
-* parent checkout). Creates parent directories for nested paths.
-*
-* Exported for testability; not part of the public worktree API.
-*/
-async function copyFilesToWorktree(sourceRoot, worktreePath, files) {
-	if (files.length === 0) return;
-	for (const relativePath of files) {
-		if (path$5.isAbsolute(relativePath) || relativePath.split(path$5.sep).includes("..")) continue;
-		const sourcePath = path$5.join(sourceRoot, relativePath);
-		const destPath = path$5.join(worktreePath, relativePath);
-		try {
-			await access$1(sourcePath);
-		} catch {
-			continue;
-		}
-		const destDir = path$5.dirname(destPath);
-		if (destDir !== worktreePath) await mkdir$1(destDir, { recursive: true });
-		await copyFile(sourcePath, destPath);
-	}
-}
-/**
-* 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/story-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
-/**
-* Branch name prefix for substrate per-story branches.
-*
-* Exported as the canonical source of truth so consumers (orchestrator,
-* integration tests, tooling) can compose branch names without
-* independently encoding the prefix. v0.20.82 production bug:
-* `orchestrator-impl.ts:4290` hardcoded `substrate/story-${storyKey}`
-* while this module created `substrate/task-${taskId}` — the resulting
-* merge-to-main looked at a non-existent branch. Recurrence prevention:
-* all branch-name construction MUST import this constant.
-*/
-const BRANCH_PREFIX = "substrate/story-";
-const DEFAULT_WORKTREE_BASE = ".substrate-worktrees";
-var GitWorktreeManagerImpl = class {
-	_eventBus;
-	_projectRoot;
-	_baseDirectory;
-	_db;
-	_logger;
-	/** v0.20.109: files to copy from project root into each new worktree (e.g. `.env`). */
-	_copyFiles;
-	/** Bound listener references for cleanup in shutdown() */
-	_onTaskReady;
-	_onTaskComplete;
-	_onTaskFailed;
-	constructor(eventBus, projectRoot, baseDirectory = DEFAULT_WORKTREE_BASE, db = null, logger$27, copyFiles = []) {
-		this._eventBus = eventBus;
-		this._projectRoot = projectRoot;
-		this._baseDirectory = baseDirectory;
-		this._db = db;
-		this._logger = logger$27 ?? createStderrLogger("git-worktree-manager");
-		this._copyFiles = copyFiles;
-		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,
-			copyFiles: this._copyFiles
-		}, "createWorktree");
-		const copyFiles = this._copyFiles.includes(".substrate/project-profile.yaml") ? this._copyFiles : [...this._copyFiles, ".substrate/project-profile.yaml"];
-		await createWorktree(this._projectRoot, taskId, branchName, baseBranch, copyFiles);
-		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, opts) {
-		const branchName = BRANCH_PREFIX + taskId;
-		const worktreePath = this.getWorktreePath(taskId);
-		this._logger.debug({
-			taskId,
-			branchName,
-			worktreePath,
-			force: opts?.force === true
-		}, "cleanupWorktree");
-		if (opts?.force !== true) {
-			const decision = await inspectWorktreeRemovalSafety(worktreePath, this._projectRoot, branchName);
-			const blockingReasons = opts?.keepBranch === true ? decision.reasons.filter((r) => r.includes("uncommitted")) : decision.reasons;
-			if (blockingReasons.length > 0) throw new Error(`refusing to clean up worktree for "${taskId}": ${blockingReasons.join("; ")}.\nInspect first (git -C ${worktreePath} status; git log ${branchName} --oneline) or re-run with --force to discard.`);
-		}
-		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");
-		}
-		if (opts?.keepBranch !== true) 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(opts) {
-		this._logger.debug({
-			projectRoot: this._projectRoot,
-			force: opts?.force === true
-		}, "cleanupAllWorktrees");
-		const orphanedPaths = await getOrphanedWorktrees(this._projectRoot, this._baseDirectory);
-		let cleaned = 0;
-		for (const worktreePath of orphanedPaths) {
-			const taskId = path$4.basename(worktreePath);
-			const branchGuardName = BRANCH_PREFIX + taskId;
-			const decision = opts?.force === true ? {
-				safe: true,
-				reasons: []
-			} : await inspectWorktreeRemovalSafety(worktreePath, this._projectRoot, branchGuardName);
-			if (!decision.safe) {
-				this._logger.warn({
-					taskId,
-					worktreePath,
-					reasons: decision.reasons
-				}, "cleanupAllWorktrees: preserving worktree — removal would destroy work (use `substrate worktrees cleanup --force` to discard)");
-				continue;
-			}
-			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, options.copyFiles);
-}
-
-//#endregion
 //#region src/modules/methodology-pack/schemas.ts
 /**
 * A reference to a context value to inject into a step prompt.
@@ -2961,7 +2185,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 on branch \`substrate/story-<key>\`. **Substrate auto-commits** the dispatched agent's output to the branch after SHIP_IT with a \`feat(story-N-M): <title>\` message (v0.20.86+ — substrate does not rely on the agent committing). Pre-commit hooks fire on the substrate commit. The branch is then merged to the base branch and the worktree is removed. On verification failure or auto-commit failure, the worktree and branch are preserved for \`substrate reconcile-from-disk\` inspection. Use \`--no-worktree\` (or \`SUBSTRATE_NO_WORKTREE=1\`) to disable per-story worktrees entirely; dispatch then runs against the parent project tree.
+- Per-story git worktrees are created during dispatch on branch \`substrate/story-<key>\`. H4.2: the default base is EXTERNAL — \`~/.substrate/worktrees/<projectname>-<hash8>/<key>/\` — so agents have no parent repo above their worktree; set \`worktree.base: in-repo\` in .substrate/config.yaml to restore the legacy \`.substrate-worktrees/<key>/\` location (tooling that globbed the old path should use \`substrate worktrees list\`). **Substrate auto-commits** the dispatched agent's output to the branch after SHIP_IT with a \`feat(story-N-M): <title>\` message (v0.20.86+ — substrate does not rely on the agent committing). Pre-commit hooks fire on the substrate commit. The branch is then merged to the base branch and the worktree is removed. On verification failure or auto-commit failure, the worktree and branch are preserved for \`substrate reconcile-from-disk\` inspection. Use \`--no-worktree\` (or \`SUBSTRATE_NO_WORKTREE=1\`) to disable per-story worktrees entirely; dispatch then runs against the parent project tree.
 
 ## Environment Variables
 
@@ -3574,8 +2798,8 @@ var GrammarLoader = class {
 			throw err;
 		}
 	}
-	_loadModule(path$6) {
-		return __require(path$6);
+	_loadModule(path$4) {
+		return __require(path$4);
 	}
 };
 
@@ -7192,10 +6416,10 @@ function computeStoryFileFidelity(storyFileContent, namedPaths) {
 	};
 	const missing = [];
 	const present = [];
-	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);
+	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);
 	}
 	return {
 		missing,
@@ -8901,7 +8125,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$6]) => path$6);
+	const sorted = [...freq.entries()].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).map(([path$4]) => path$4);
 	return sorted.filter((p) => !p.includes(".test."));
 }
 function extractFilesInScope(storyContent) {
@@ -9606,11 +8830,26 @@ const logger$16 = createLogger("compiled-workflows:merge-to-main");
 */
 async function runMergeToMain(params) {
 	const { storyKey, branchName, startBranch, worktreeManager, eventBus, projectRoot } = params;
+	const mergeStrategy = params.mergeStrategy ?? "ff-only";
 	logger$16.info({
 		storyKey,
 		branchName,
-		startBranch
+		startBranch,
+		mergeStrategy
 	}, "Starting merge-to-main phase");
+	const dirtiedFiles = listParentDirtyIntersection(branchName, startBranch, projectRoot);
+	if (dirtiedFiles.length > 0) {
+		logger$16.warn({
+			storyKey,
+			branchName,
+			dirtiedFiles
+		}, "parent working tree has uncommitted changes to files in the story diff — refusing to merge");
+		return {
+			success: false,
+			reason: "parent-tree-dirtied-by-run",
+			dirtiedFiles
+		};
+	}
 	const ffSuccess = tryFfMerge(branchName, projectRoot);
 	if (ffSuccess) {
 		logger$16.info({
@@ -9620,6 +8859,17 @@ async function runMergeToMain(params) {
 		await cleanupAfterSuccessfulMerge(storyKey, branchName, worktreeManager, projectRoot);
 		return { success: true };
 	}
+	if (mergeStrategy === "ff-only") {
+		logger$16.warn({
+			storyKey,
+			branchName,
+			startBranch
+		}, "fast-forward not possible (base moved since the story branched) and merge_strategy is ff-only — refusing 3-way merge. Set finalization.merge_strategy: three-way to allow it (required for concurrent multi-story runs), or integrate the branch manually.");
+		return {
+			success: false,
+			reason: "ff-only-merge-not-possible"
+		};
+	}
 	logger$16.info({
 		storyKey,
 		branchName
@@ -9651,6 +8901,47 @@ async function runMergeToMain(params) {
 	};
 }
 /**
+* H3.3 (AC1): files that are both dirty in the parent working tree and part of
+* the story branch's diff against the start branch. Best-effort: if either
+* git query fails, returns [] (the merge itself will surface genuine issues).
+*/
+function listParentDirtyIntersection(branchName, startBranch, projectRoot) {
+	try {
+		const statusOut = execFileSync("git", ["status", "--porcelain"], {
+			cwd: projectRoot,
+			encoding: "utf-8",
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			]
+		});
+		const dirty = new Set(statusOut.split("\n").filter((line) => line.trim().length > 0).map((line) => {
+			const body = line.slice(3).trim();
+			const arrow = body.indexOf(" -> ");
+			return arrow === -1 ? body : body.slice(arrow + 4);
+		}));
+		if (dirty.size === 0) return [];
+		const diffOut = execFileSync("git", [
+			"diff",
+			"--name-only",
+			`${startBranch}...${branchName}`
+		], {
+			cwd: projectRoot,
+			encoding: "utf-8",
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			]
+		});
+		return diffOut.split("\n").filter((f$1) => f$1.trim().length > 0).filter((f$1) => dirty.has(f$1));
+	} catch (err) {
+		logger$16.warn({ err }, "parent-clean precondition check failed (best-effort) — proceeding to merge");
+		return [];
+	}
+}
+/**
 * Attempt a fast-forward merge of `branchName` into the current branch.
 *
 * @param branchName  - Branch to merge
@@ -16746,6 +16037,63 @@ function createImplementationOrchestrator(deps) {
 					}, "merge-to-main pre-flight verification failed — proceeding with merge phase");
 				}
 				const finalizationMode = config.finalizationMode ?? "merge";
+				const epicGateCommand = config.epicGateCommand;
+				if (epicGateCommand !== void 0 && epicGateCommand.trim() !== "" && finalizationMode !== "branch") {
+					const epicOf = (key) => key.includes("-") ? key.slice(0, key.lastIndexOf("-")) : key;
+					const epicId = epicOf(storyKey);
+					const TERMINAL_PHASES = ["COMPLETE", "ESCALATED"];
+					const isLastOfEpic = [..._stories.entries()].filter(([key]) => key !== storyKey && epicOf(key) === epicId).every(([, st]) => TERMINAL_PHASES.includes(st.phase));
+					if (isLastOfEpic) {
+						logger$27.info({
+							storyKey,
+							epicId,
+							epicGateCommand
+						}, "H3.4: last story of epic — running epic gate command");
+						let gateOutput = "";
+						let gatePassed = false;
+						try {
+							gateOutput = execSync(epicGateCommand, {
+								cwd: projectRoot,
+								encoding: "utf-8",
+								stdio: [
+									"ignore",
+									"pipe",
+									"pipe"
+								],
+								timeout: 6e5,
+								maxBuffer: 10 * 1024 * 1024
+							});
+							gatePassed = true;
+						} catch (gateCmdErr) {
+							const e = gateCmdErr;
+							gateOutput = `${e.stdout ?? ""}${e.stderr ?? ""}`.trim() || (e.message ?? String(gateCmdErr));
+						}
+						if (!gatePassed) {
+							logger$27.error({
+								storyKey,
+								epicId,
+								output: gateOutput.slice(0, 500)
+							}, "H3.4: epic gate command failed — halting finalization; branch preserved");
+							updateStory(storyKey, {
+								phase: "ESCALATED",
+								error: "epic-gate-failed",
+								completedAt: new Date().toISOString()
+							});
+							await emitEscalation({
+								storyKey,
+								lastVerdict: "epic-gate-failed",
+								reviewCycles: completedReviewCycles,
+								issues: [`epic gate command failed for epic ${epicId} (last story ${storyKey}): \`${epicGateCommand}\`\noutput (truncated):\n${gateOutput.slice(0, 4e3)}`]
+							});
+							await persistState();
+							return "terminal";
+						}
+						logger$27.info({
+							storyKey,
+							epicId
+						}, "H3.4: epic gate passed");
+					}
+				}
 				if (finalizationMode === "branch" || finalizationMode === "pr") {
 					let prUrl;
 					if (finalizationMode === "pr") try {
@@ -16822,7 +16170,8 @@ function createImplementationOrchestrator(deps) {
 						startBranch: _orchestratorStartBranch,
 						worktreeManager: _worktreeManager,
 						eventBus,
-						projectRoot
+						projectRoot,
+						mergeStrategy: config.mergeStrategy ?? "ff-only"
 					});
 				} catch (mergeErr) {
 					const errMsg = mergeErr instanceof Error ? mergeErr.message : String(mergeErr);
@@ -16845,21 +16194,28 @@ function createImplementationOrchestrator(deps) {
 					return "terminal";
 				}
 				if (!mergeResult.success) {
+					const failReason = mergeResult.reason ?? "merge-conflict-detected";
+					const issues = [];
+					if (failReason === "parent-tree-dirtied-by-run") issues.push(`parent working tree has uncommitted changes to ${mergeResult.dirtiedFiles?.length ?? 0} file(s) the story also modified: ${(mergeResult.dirtiedFiles ?? []).join(", ")} — merging would entangle unreviewed parent edits with verified story content. Commit or stash the parent changes, then merge ${branchName} manually.`);
+					else if (failReason === "ff-only-merge-not-possible") issues.push(`${_orchestratorStartBranch ?? "the start branch"} moved since ${branchName} was created and merge_strategy is ff-only — substrate will not synthesize a merge commit. Set finalization.merge_strategy: three-way (required for concurrent multi-story runs) or integrate the branch manually.`);
+					else issues.push(`merge conflict in ${mergeResult.conflictingFiles?.length ?? 0} file(s): ${(mergeResult.conflictingFiles ?? []).join(", ")}`);
 					logger$27.warn({
 						storyKey,
 						branchName,
-						conflictingFiles: mergeResult.conflictingFiles
-					}, "merge-to-main conflict — escalating story with merge-conflict-detected");
+						reason: failReason,
+						conflictingFiles: mergeResult.conflictingFiles,
+						dirtiedFiles: mergeResult.dirtiedFiles
+					}, `merge-to-main failed — escalating story with ${failReason}`);
 					updateStory(storyKey, {
 						phase: "ESCALATED",
-						error: "merge-conflict-detected",
+						error: failReason,
 						completedAt: new Date().toISOString()
 					});
 					await emitEscalation({
 						storyKey,
-						lastVerdict: "merge-conflict-detected",
+						lastVerdict: failReason,
 						reviewCycles: completedReviewCycles,
-						issues: [`merge conflict in ${mergeResult.conflictingFiles?.length ?? 0} file(s): ${(mergeResult.conflictingFiles ?? []).join(", ")}`]
+						issues
 					});
 					await persistState();
 					return "terminal";
@@ -18116,7 +17472,13 @@ function createImplementationOrchestrator(deps) {
 			}).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");
+			if (config.noWorktree !== true) {
+				logger$27.error({ err: branchErr }, "FATAL: failed to capture the orchestrator start branch (git rev-parse --abbrev-ref HEAD). Worktree finalization cannot work without it. Fix git in the project root or re-run with --no-worktree.");
+				_state = "FAILED";
+				_completedAt = new Date().toISOString();
+				return getStatus();
+			}
+			logger$27.warn({ err: branchErr }, "Failed to capture orchestrator start branch — merge-to-main will skip worktree integration (--no-worktree run)");
 		}
 		for (const key of storyKeys) {
 			const pendingState = {
@@ -19841,8 +19203,8 @@ async function resolveContext(ref, deps, runId, params, stepOutputs) {
 		return params[key] ?? "";
 	}
 	if (source.startsWith("decision:")) {
-		const path$6 = source.slice(9);
-		const [phase, category] = path$6.split(".");
+		const path$4 = source.slice(9);
+		const [phase, category] = path$4.split(".");
 		if (!phase || !category) return "";
 		const decisions = await getDecisionsByPhaseForRun(deps.db, runId, phase);
 		const filtered = decisions.filter((d) => d.category === category);
@@ -19913,8 +19275,8 @@ async function runSteps(steps, deps, runId, phase, params) {
 				for (const ref of step.context) {
 					let value;
 					if (ref.source.startsWith("decision:")) {
-						const path$6 = ref.source.slice(9);
-						const [decPhase, decCategory] = path$6.split(".");
+						const path$4 = ref.source.slice(9);
+						const [decPhase, decCategory] = path$4.split(".");
 						if (decPhase && decCategory) {
 							const decisions = await getDecisionsByPhaseForRun(deps.db, runId, decPhase);
 							const filtered = decisions.filter((d) => d.category === decCategory);
@@ -31002,8 +30364,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$6 = _wsComponents$resourc2[0], query = _wsComponents$resourc2[1];
-					wsComponents.path = path$6 && path$6 !== "/" ? path$6 : void 0;
+					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;
 					wsComponents.query = query;
 					wsComponents.resourceName = void 0;
 				}
@@ -31344,12 +30706,12 @@ var require_util = __commonJS({ "node_modules/ajv/lib/compile/util.js"(exports,
 		return "'" + escapeQuotes(str) + "'";
 	}
 	function getPathExpr(currentPath, expr, jsonPointers, isNumber) {
-		var path$6 = jsonPointers ? "'/' + " + expr + (isNumber ? "" : ".replace(/~/g, '~0').replace(/\\//g, '~1')") : isNumber ? "'[' + " + expr + " + ']'" : "'[\\'' + " + expr + " + '\\']'";
-		return joinPaths(currentPath, path$6);
+		var path$4 = jsonPointers ? "'/' + " + expr + (isNumber ? "" : ".replace(/~/g, '~0').replace(/\\//g, '~1')") : isNumber ? "'[' + " + expr + " + ']'" : "'[\\'' + " + expr + " + '\\']'";
+		return joinPaths(currentPath, path$4);
 	}
 	function getPath(currentPath, prop, jsonPointers) {
-		var path$6 = jsonPointers ? toQuotedString("/" + escapeJsonPointer(prop)) : toQuotedString(getProperty(prop));
-		return joinPaths(currentPath, path$6);
+		var path$4 = jsonPointers ? toQuotedString("/" + escapeJsonPointer(prop)) : toQuotedString(getProperty(prop));
+		return joinPaths(currentPath, path$4);
 	}
 	var JSON_POINTER$1 = /^\/(?:[^~]|~0|~1)*$/;
 	var RELATIVE_JSON_POINTER$1 = /^([0-9]+)(#|\/(?:[^~]|~0|~1)*)?$/;
@@ -35558,8 +34920,8 @@ var ToolRegistry = class {
 		if (!valid) {
 			const errors = validate$1.errors ?? [];
 			const messages = errors.map((e) => {
-				const path$6 = e.instancePath ?? e.dataPath ?? "";
-				return `${path$6} ${e.message ?? ""}`.trim();
+				const path$4 = e.instancePath ?? e.dataPath ?? "";
+				return `${path$4} ${e.message ?? ""}`.trim();
 			}).join(", ");
 			return {
 				content: `Validation failed for tool '${name}': ${messages}`,
@@ -42265,10 +41627,10 @@ var PathBase = class {
 	/**
 	* Get the Path object referenced by the string path, resolved from this Path
 	*/
-	resolve(path$6) {
-		if (!path$6) return this;
-		const rootPath = this.getRootString(path$6);
-		const dir = path$6.substring(rootPath.length);
+	resolve(path$4) {
+		if (!path$4) return this;
+		const rootPath = this.getRootString(path$4);
+		const dir = path$4.substring(rootPath.length);
 		const dirParts = dir.split(this.splitSep);
 		const result = rootPath ? this.getRoot(rootPath).#resolveParts(dirParts) : this.#resolveParts(dirParts);
 		return result;
@@ -42923,8 +42285,8 @@ var PathWin32 = class PathWin32 extends PathBase {
 	/**
 	* @internal
 	*/
-	getRootString(path$6) {
-		return win32.parse(path$6).root;
+	getRootString(path$4) {
+		return win32.parse(path$4).root;
 	}
 	/**
 	* @internal
@@ -42969,8 +42331,8 @@ var PathPosix = class PathPosix extends PathBase {
 	/**
 	* @internal
 	*/
-	getRootString(path$6) {
-		return path$6.startsWith("/") ? "/" : "";
+	getRootString(path$4) {
+		return path$4.startsWith("/") ? "/" : "";
 	}
 	/**
 	* @internal
@@ -43063,9 +42425,9 @@ var PathScurryBase = class {
 	/**
 	* Get the depth of a provided path, string, or the cwd
 	*/
-	depth(path$6 = this.cwd) {
-		if (typeof path$6 === "string") path$6 = this.cwd.resolve(path$6);
-		return path$6.depth();
+	depth(path$4 = this.cwd) {
+		if (typeof path$4 === "string") path$4 = this.cwd.resolve(path$4);
+		return path$4.depth();
 	}
 	/**
 	* Return the cache of child entries.  Exposed so subclasses can create
@@ -43446,9 +42808,9 @@ var PathScurryBase = class {
 		process$1();
 		return results;
 	}
-	chdir(path$6 = this.cwd) {
+	chdir(path$4 = this.cwd) {
 		const oldCwd = this.cwd;
-		this.cwd = typeof path$6 === "string" ? this.cwd.resolve(path$6) : path$6;
+		this.cwd = typeof path$4 === "string" ? this.cwd.resolve(path$4) : path$4;
 		this.cwd[setAsCwd](oldCwd);
 	}
 };
@@ -43832,8 +43194,8 @@ var MatchRecord = class {
 		this.store.set(target, current === void 0 ? n$1 : n$1 & current);
 	}
 	entries() {
-		return [...this.store.entries()].map(([path$6, n$1]) => [
-			path$6,
+		return [...this.store.entries()].map(([path$4, n$1]) => [
+			path$4,
 			!!(n$1 & 2),
 			!!(n$1 & 1)
 		]);
@@ -44009,9 +43371,9 @@ var GlobUtil = class {
 	signal;
 	maxDepth;
 	includeChildMatches;
-	constructor(patterns, path$6, opts) {
+	constructor(patterns, path$4, opts) {
 		this.patterns = patterns;
-		this.path = path$6;
+		this.path = path$4;
 		this.opts = opts;
 		this.#sep = !opts.posix && opts.platform === "win32" ? "\\" : "/";
 		this.includeChildMatches = opts.includeChildMatches !== false;
@@ -44032,11 +43394,11 @@ var GlobUtil = class {
 			});
 		}
 	}
-	#ignored(path$6) {
-		return this.seen.has(path$6) || !!this.#ignore?.ignored?.(path$6);
+	#ignored(path$4) {
+		return this.seen.has(path$4) || !!this.#ignore?.ignored?.(path$4);
 	}
-	#childrenIgnored(path$6) {
-		return !!this.#ignore?.childrenIgnored?.(path$6);
+	#childrenIgnored(path$4) {
+		return !!this.#ignore?.childrenIgnored?.(path$4);
 	}
 	pause() {
 		this.paused = true;
@@ -44218,8 +43580,8 @@ var GlobUtil = class {
 };
 var GlobWalker = class extends GlobUtil {
 	matches = new Set();
-	constructor(patterns, path$6, opts) {
-		super(patterns, path$6, opts);
+	constructor(patterns, path$4, opts) {
+		super(patterns, path$4, opts);
 	}
 	matchEmit(e) {
 		this.matches.add(e);
@@ -44246,8 +43608,8 @@ var GlobWalker = class extends GlobUtil {
 };
 var GlobStream = class extends GlobUtil {
 	results;
-	constructor(patterns, path$6, opts) {
-		super(patterns, path$6, opts);
+	constructor(patterns, path$4, opts) {
+		super(patterns, path$4, opts);
 		this.results = new Minipass({
 			signal: this.signal,
 			objectMode: true
@@ -46953,6 +46315,8 @@ async function runRunAction(options) {
 	let meshProjectId;
 	let configRetryBudget;
 	let configFinalizationMode;
+	let configMergeStrategy;
+	let configEpicGateCommand;
 	let configWorktreeCopyFiles;
 	try {
 		const configSystem = createConfigSystem({ projectConfigDir: dbDir });
@@ -46980,6 +46344,8 @@ async function runRunAction(options) {
 		}
 		if (typeof cfg.retry_budget === "number") configRetryBudget = cfg.retry_budget;
 		if (cfg.finalization?.mode !== void 0) configFinalizationMode = cfg.finalization.mode;
+		if (cfg.finalization?.merge_strategy !== void 0) configMergeStrategy = cfg.finalization.merge_strategy;
+		if (cfg.finalization?.epic_gate_command !== void 0) configEpicGateCommand = cfg.finalization.epic_gate_command;
 		if (Array.isArray(cfg.worktree?.copy_files) && cfg.worktree.copy_files.length > 0) {
 			configWorktreeCopyFiles = [...cfg.worktree.copy_files];
 			logger.info({ copyFiles: configWorktreeCopyFiles }, "Loaded worktree.copy_files from config");
@@ -47080,6 +46446,8 @@ async function runRunAction(options) {
 		agentId,
 		...noWorktree === true ? { noWorktree: true } : {},
 		...finalization !== void 0 ? { finalizationMode: finalization } : configFinalizationMode !== void 0 ? { finalizationMode: configFinalizationMode } : {},
+		...configMergeStrategy !== void 0 ? { mergeStrategy: configMergeStrategy } : {},
+		...configEpicGateCommand !== void 0 ? { epicGateCommand: configEpicGateCommand } : {},
 		...configWorktreeCopyFiles !== void 0 ? { worktreeCopyFiles: configWorktreeCopyFiles } : {}
 	});
 	let storyKeys = [...parsedStoryKeys];
@@ -47644,6 +47012,8 @@ async function runRunAction(options) {
 					probeAuthorStateIntegrating: resolvedProbeAuthorStateIntegrating,
 					...noWorktree === true ? { noWorktree: true } : {},
 					...finalization !== void 0 ? { finalizationMode: finalization } : configFinalizationMode !== void 0 ? { finalizationMode: configFinalizationMode } : {},
+					...configMergeStrategy !== void 0 ? { mergeStrategy: configMergeStrategy } : {},
+					...configEpicGateCommand !== void 0 ? { epicGateCommand: configEpicGateCommand } : {},
 					...configWorktreeCopyFiles !== void 0 ? { worktreeCopyFiles: configWorktreeCopyFiles } : {}
 				},
 				projectRoot,
@@ -47867,7 +47237,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, noWorktree, worktreeCopyFiles: fpWorktreeCopyFiles, finalizationMode: fpFinalizationMode } = 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, worktreeCopyFiles: fpWorktreeCopyFiles, finalizationMode: fpFinalizationMode, mergeStrategy: fpMergeStrategy, epicGateCommand: fpEpicGateCommand } = options;
 	if (!existsSync$1(dbDir)) mkdirSync$1(dbDir, { recursive: true });
 	let doltServerFull = null;
 	try {
@@ -48178,6 +47548,8 @@ async function runFullPipeline(options) {
 						...fpProbeAuthorStateIntegrating !== void 0 ? { probeAuthorStateIntegrating: fpProbeAuthorStateIntegrating } : {},
 						...noWorktree === true ? { noWorktree: true } : {},
 						...fpFinalizationMode !== void 0 ? { finalizationMode: fpFinalizationMode } : {},
+						...fpMergeStrategy !== void 0 ? { mergeStrategy: fpMergeStrategy } : {},
+						...fpEpicGateCommand !== void 0 ? { epicGateCommand: fpEpicGateCommand } : {},
 						...fpWorktreeCopyFiles !== void 0 ? { worktreeCopyFiles: fpWorktreeCopyFiles } : {}
 					},
 					projectRoot,
@@ -48348,7 +47720,7 @@ async function runFullPipeline(options) {
 */
 async function emitPreDispatchVersionAdvisory(currentVersion) {
 	if (process.env["SUBSTRATE_NO_UPDATE_CHECK"] === "1") return;
-	const { createVersionManager } = await import("./version-manager-impl-BWqvme_f.js");
+	const { createVersionManager } = await import("./version-manager-impl-DizCvYy8.js");
 	const vm = createVersionManager();
 	const result = await vm.checkForUpdates(true);
 	const gap = classifyVersionGap(currentVersion, result.latestVersion);
@@ -48454,5 +47826,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, 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-BBVZdkEo.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, 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-BAUlPom3.js.map