substrate-ai 0.20.138 → 0.20.141

package/dist/{run-Dbwlb4Md.js → run-CRvusFIv.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-2Kfa00-H.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-BQRsVP6s.js";
 import { createLogger } from "./logger-KeHncl-f.js";
 import { TypedEventBusImpl, createEventBus, createTuiApp, isTuiCapable, printNonTtyWarning, sleep } from "./helpers-CElYrONe.js";
-import { ADVISORY_NOTES, 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, 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-DnvGvKLu.js";
-import { FindingsInjector, RunManifest, RuntimeProbeListSchema, applyConfigToGraph, createDefaultVerificationPipeline, createGraphOrchestrator, createSdlcCodeReviewHandler, createSdlcCreateStoryHandler, createSdlcDevStoryHandler, createSdlcPhaseHandler, detectsEventDrivenAC, detectsStateIntegratingAC, extractTargetFilesFromStoryContent, parseRuntimeProbes, renderFindings, resolveGraphPath, resolveMainRepoRoot, runAcTraceabilityCheck, runStaleVerificationRecovery } from "./manifest-read-DJFbGhSd.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-DiNK6QOD.js";
+import { FindingsInjector, RunManifest, RuntimeProbeListSchema, applyConfigToGraph, createDefaultVerificationPipeline, createGraphOrchestrator, createSdlcCodeReviewHandler, createSdlcCreateStoryHandler, createSdlcDevStoryHandler, createSdlcPhaseHandler, detectsEventDrivenAC, detectsStateIntegratingAC, extractTargetFilesFromStoryContent, parseRuntimeProbes, renderFindings, resolveGraphPath, resolveMainRepoRoot, runAcTraceabilityCheck, runStaleVerificationRecovery } from "./manifest-read-Doh2Ion5.js";
 import { WorkGraphRepository, detectCycles } from "./work-graph-repository-DZyJv5pV.js";
-import { deriveExitCode, routeDecision } from "./decision-router-DblHY8se.js";
-import { runInteractivePrompt } from "./interactive-prompt-B91mG5v4.js";
+import { deriveExitCode, routeDecision } from "./decision-router-BAPpON_C.js";
+import { runInteractivePrompt } from "./interactive-prompt-CgerI5Y6.js";
 import { runRecoveryEngine } from "./recovery-engine-BKGBeBnW.js";
 import { basename, dirname, extname, join } from "path";
 import { access, readFile, readdir, stat } from "fs/promises";
@@ -159,6 +159,66 @@ function decideWorktreeReclaim(hasUncommittedChanges, commitsAhead, baseBranch)
 	};
 	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) => {
@@ -518,14 +578,19 @@ var GitWorktreeManagerImpl = class {
 		}, "Worktree created");
 		return info;
 	}
-	async cleanupWorktree(taskId) {
+	async cleanupWorktree(taskId, opts) {
 		const branchName = BRANCH_PREFIX + taskId;
 		const worktreePath = this.getWorktreePath(taskId);
 		this._logger.debug({
 			taskId,
 			branchName,
-			worktreePath
+			worktreePath,
+			force: opts?.force === true
 		}, "cleanupWorktree");
+		if (opts?.force !== true) {
+			const decision = await inspectWorktreeRemovalSafety(worktreePath, this._projectRoot, branchName);
+			if (!decision.safe) throw new Error(`refusing to clean up worktree for "${taskId}": ${decision.reasons.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);
@@ -563,12 +628,28 @@ var GitWorktreeManagerImpl = class {
 			branchName
 		}, "Worktree cleaned up");
 	}
-	async cleanupAllWorktrees() {
-		this._logger.debug({ projectRoot: this._projectRoot }, "cleanupAllWorktrees");
+	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);
@@ -6813,6 +6894,21 @@ 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)";
+		const authSignature = detectClaudeAuthFailure(dispatchResult.output);
+		if (authSignature !== null) {
+			logger$21.error({
+				epicId,
+				storyKey,
+				authSignature,
+				rawOutputSnippet: rawSnippet
+			}, "Create-story dispatch died on authentication");
+			return {
+				result: "failed",
+				error: "auth-failure",
+				details: `Claude CLI authentication failure (matched: "${authSignature}"). Agent output: ${rawSnippet}`,
+				tokenUsage
+			};
+		}
 		logger$21.warn({
 			epicId,
 			storyKey,
@@ -7549,6 +7645,104 @@ async function commitDevStoryOutput(storyKey, storyTitle, filesModified, working
 	};
 }
 /**
+* Commit the worktree's dirty state as a recovery checkpoint (H0.1, field
+* finding #17): on every failure path the story branch — not the worktree's
+* working tree — must be the durable copy of the agent's work. Before this,
+* a verification-failed or escalated story left its only copy as uncommitted
+* files, and any `git worktree remove --force` (operator cleanup, orphan
+* sweep) destroyed it permanently.
+*
+* Semantics differ from `commitDevStoryOutput` deliberately:
+* - Stages EVERYTHING dirty (`git add -A`; .gitignore still applies) — a
+*   checkpoint must not guess which files matter.
+* - Bypasses hooks (`--no-verify`): this is a recovery snapshot, not a
+*   deliverable. Deliverable `feat(story-…)` commits keep hooks; wip
+*   checkpoints never merge on their own — `reconcile-from-disk` and the
+*   operator decide what to do with them.
+* - Message prefix `wip(story-<key>):` so tooling can tell checkpoints from
+*   deliverables (reconcile-from-disk greps both, prefers feat).
+*
+* Never throws; all failure modes return a structured status.
+*/
+async function checkpointStoryWorktree(storyKey, reason, workingDir) {
+	if (!existsSync(workingDir)) return { status: "no-changes" };
+	try {
+		execSync("git add -A", {
+			cwd: workingDir,
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			],
+			timeout: 3e4
+		});
+	} catch (err) {
+		const stderr = err instanceof Error && "stderr" in err ? String(err.stderr ?? err.message) : err instanceof Error ? err.message : String(err);
+		return {
+			status: "failed",
+			stderr: `git add -A failed: ${stderr}`
+		};
+	}
+	const cachedCheck = spawn("git", [
+		"diff",
+		"--cached",
+		"--quiet"
+	], {
+		cwd: workingDir,
+		stdio: [
+			"ignore",
+			"pipe",
+			"pipe"
+		]
+	});
+	const cachedStatus = await new Promise((res) => {
+		cachedCheck.on("close", (code) => res(code ?? 0));
+		cachedCheck.on("error", () => res(0));
+	});
+	if (cachedStatus === 0) return { status: "no-changes" };
+	const cleanReason = (reason.split("\n")[0] ?? "checkpoint").split("").filter((ch) => ch.charCodeAt(0) >= 32).join("").slice(0, 100);
+	const message = `wip(story-${storyKey}): ${cleanReason}`;
+	try {
+		execSync(`git commit --no-verify -m ${JSON.stringify(message)}`, {
+			cwd: workingDir,
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			],
+			timeout: 6e4
+		});
+	} catch (err) {
+		const stderr = err instanceof Error && "stderr" in err ? String(err.stderr ?? err.message) : err instanceof Error ? err.message : String(err);
+		return {
+			status: "failed",
+			stderr: `git commit --no-verify failed: ${stderr}`
+		};
+	}
+	let sha = "";
+	try {
+		sha = execSync("git rev-parse HEAD", {
+			cwd: workingDir,
+			encoding: "utf-8",
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			],
+			timeout: 5e3
+		}).trim();
+	} catch {}
+	logger$20.info({
+		storyKey,
+		sha,
+		reason: cleanReason
+	}, "checkpointStoryWorktree: committed recovery checkpoint");
+	return {
+		status: "committed",
+		sha
+	};
+}
+/**
 * 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'`.
 * Synchronous (execSync) to keep it simple — this is a fast local check.
@@ -12562,6 +12756,48 @@ var CostGovernanceChecker = class {
 	}
 };
 
+//#endregion
+//#region src/modules/implementation-orchestrator/dispatch-telemetry-aggregation.ts
+/**
+* Aggregates turn counts and token usage across an array of dispatch records.
+*
+* Returns an object with `total_turns` and/or `total_tokens` populated only
+* when at least one record carries the corresponding telemetry:
+* - If NO record has `turns` data → `total_turns` is absent.
+* - If NO record has `tokens` data → `total_tokens` is absent.
+* - If SOME records have turns/tokens and some don't, the available data is
+*   summed; records without the field do not contribute zero.
+*
+* Absence MUST NOT be treated as zero by consumers — use `?? null` at call
+* sites per the `PerStoryState.total_turns` / `total_tokens` semantics.
+*
+* @param dispatchRecords - Array of per-dispatch records for one story.
+*   Pass `_storyAgents.get(storyKey) ?? []` from the orchestrator. In the
+*   current implementation those records don't carry token/turn data, so
+*   the result is `{}` — this is the documented known gap.
+* @returns Partial telemetry aggregate: `{}` when no data, populated when present.
+*/
+function aggregateStoryDispatchTelemetry(dispatchRecords) {
+	if (dispatchRecords.length === 0) return {};
+	let turnsSum;
+	let tokensInput;
+	let tokensOutput;
+	for (const record of dispatchRecords) {
+		if (record.turns !== void 0) turnsSum = (turnsSum ?? 0) + record.turns;
+		if (record.tokens !== void 0) {
+			tokensInput = (tokensInput ?? 0) + record.tokens.input;
+			tokensOutput = (tokensOutput ?? 0) + record.tokens.output;
+		}
+	}
+	const result = {};
+	if (turnsSum !== void 0) result.total_turns = turnsSum;
+	if (tokensInput !== void 0 && tokensOutput !== void 0) result.total_tokens = {
+		input: tokensInput,
+		output: tokensOutput
+	};
+	return result;
+}
+
 //#endregion
 //#region src/modules/work-graph/epic-ingester.ts
 var EpicIngester = class {
@@ -13545,6 +13781,7 @@ function createImplementationOrchestrator(deps) {
 	const _phaseEndMs = new Map();
 	const _storyDispatches = new Map();
 	const _storyAgents = new Map();
+	const _storyWorktrees = new Map();
 	const _storyRetryCount = new Map();
 	let _completedDispatches = 0;
 	let _maxConcurrentActual = 0;
@@ -13554,6 +13791,7 @@ function createImplementationOrchestrator(deps) {
 	const _costChecker = new CostGovernanceChecker();
 	let _costWarningEmitted = false;
 	let _budgetExhausted = false;
+	let _authFailureHalted = false;
 	let _shutdownRequested = false;
 	let _inFlightCount = 0;
 	let _drainResolve = null;
@@ -13860,6 +14098,38 @@ function createImplementationOrchestrator(deps) {
 	* diagnosis to the decision store (Story 22-3).
 	*/
 	async function emitEscalation(payload) {
+		const escalationWorktree = _storyWorktrees.get(payload.storyKey);
+		if (escalationWorktree !== void 0) {
+			const cp = await checkpointStoryWorktree(payload.storyKey, `escalation: ${payload.escalationReason ?? payload.lastVerdict}`, escalationWorktree);
+			if (cp.status === "committed") {
+				logger$27.info({
+					storyKey: payload.storyKey,
+					sha: cp.sha
+				}, "escalation checkpoint: uncommitted worktree state preserved on story branch");
+				if (runManifest !== null && cp.sha) runManifest.patchStoryState(payload.storyKey, { checkpoint_sha: cp.sha }).catch((err) => logger$27.warn({
+					err,
+					storyKey: payload.storyKey
+				}, "patchStoryState(checkpoint_sha, escalation) failed — pipeline continues"));
+			} else if (cp.status === "failed") logger$27.warn({
+				storyKey: payload.storyKey,
+				stderr: cp.stderr.slice(0, 500)
+			}, "escalation checkpoint failed — worktree state remains uncommitted (inspect before any cleanup)");
+		}
+		if (escalationWorktree !== void 0 && projectRoot !== void 0) {
+			const leakedFiles = detectWorkOutsideWorktree(escalationWorktree, projectRoot, checkGitDiffFiles);
+			if (leakedFiles.length > 0) {
+				const leakMsg = `PARENT-TREE LEAK: the MAIN checkout at ${projectRoot} carries ${String(leakedFiles.length)} uncommitted change(s) during this story's escalation (e.g. ${leakedFiles.slice(0, 10).join(", ")}). Story output may have landed OUTSIDE the worktree — inspect \`git -C ${projectRoot} status\` BEFORE any cleanup; reconcile-from-disk inspects the branch, not main, and will not see these files.`;
+				payload.issues = [...payload.issues, leakMsg];
+				eventBus.emit("orchestrator:story-warn", {
+					storyKey: payload.storyKey,
+					msg: leakMsg
+				});
+				logger$27.warn({
+					storyKey: payload.storyKey,
+					leakedFileCount: leakedFiles.length
+				}, "escalation parent-tree leak detected");
+			}
+		}
 		const diagnosis = generateEscalationDiagnosis(payload.issues, payload.reviewCycles, payload.lastVerdict);
 		eventBus.emit("orchestrator:story-escalated", {
 			...payload,
@@ -14173,6 +14443,7 @@ function createImplementationOrchestrator(deps) {
 		if (!noWorktree && _worktreeManager !== void 0 && projectRoot !== void 0) {
 			const wt = await _worktreeManager.createWorktree(storyKey);
 			effectiveProjectRoot = wt.worktreePath;
+			_storyWorktrees.set(storyKey, wt.worktreePath);
 		}
 		let _capturedStoryTitle;
 		await waitIfPaused();
@@ -14335,6 +14606,20 @@ function createImplementationOrchestrator(deps) {
 						completedAt: new Date().toISOString()
 					});
 					await writeStoryMetricsBestEffort(storyKey, "failed", 0);
+					const authSignature = createResult.error === "auth-failure" ? createResult.details ?? "auth-failure" : detectClaudeAuthFailure(errMsg);
+					if (authSignature !== null) {
+						const authDetail = createResult.details ?? errMsg;
+						await emitEscalation({
+							storyKey,
+							lastVerdict: "auth-failure",
+							reviewCycles: 0,
+							issues: [authDetail, CLAUDE_AUTH_FAILURE_HINT],
+							escalationReason: "auth-failure"
+						});
+						await triggerAuthFailureHalt(storyKey, authSignature.slice(0, 200));
+						await persistState();
+						return;
+					}
 					const codexHint = detectCodexSandboxBlock(errMsg);
 					await emitEscalation({
 						storyKey,
@@ -14902,6 +15187,10 @@ function createImplementationOrchestrator(deps) {
 				]
 			}).trim();
 		} catch {}
+		if (baselineHeadSha !== void 0 && runManifest !== null) runManifest.patchStoryState(storyKey, { baseline_sha: baselineHeadSha }).catch((err) => logger$27.warn({
+			err,
+			storyKey
+		}, "patchStoryState(baseline_sha) failed — pipeline continues"));
 		try {
 			let storyContentForAnalysis = "";
 			try {
@@ -15282,6 +15571,19 @@ function createImplementationOrchestrator(deps) {
 				completedAt: new Date().toISOString()
 			});
 			await writeStoryMetricsBestEffort(storyKey, "failed", 0);
+			const devAuthSignature = detectClaudeAuthFailure(errMsg);
+			if (devAuthSignature !== null) {
+				await emitEscalation({
+					storyKey,
+					lastVerdict: "auth-failure",
+					reviewCycles: 0,
+					issues: [errMsg, CLAUDE_AUTH_FAILURE_HINT],
+					escalationReason: "auth-failure"
+				});
+				await triggerAuthFailureHalt(storyKey, devAuthSignature);
+				await persistState();
+				return;
+			}
 			await emitEscalation({
 				storyKey,
 				lastVerdict: "dev-story-exception",
@@ -15360,6 +15662,49 @@ function createImplementationOrchestrator(deps) {
 				}
 			}
 		}
+		let _devOutputCommitHookFailure;
+		const _commitFirstEligible = !noWorktree && _worktreeManager !== void 0 && effectiveProjectRoot !== void 0 && effectiveProjectRoot !== projectRoot;
+		if (_commitFirstEligible && effectiveProjectRoot !== void 0) {
+			const dirtyNow = await getGitChangedFiles(effectiveProjectRoot);
+			if (dirtyNow.length > 0) if (devStoryWasSuccess) {
+				const earlyCommit = await commitDevStoryOutput(storyKey, _capturedStoryTitle, dirtyNow, effectiveProjectRoot);
+				if (earlyCommit.status === "committed") {
+					logger$27.info({
+						storyKey,
+						sha: earlyCommit.sha,
+						fileCount: earlyCommit.filesStaged.length
+					}, "commit-first: dev-story output committed to story branch");
+					if (runManifest !== null && earlyCommit.sha) runManifest.patchStoryState(storyKey, { commit_sha: earlyCommit.sha }).catch((err) => logger$27.warn({
+						err,
+						storyKey
+					}, "patchStoryState(commit_sha, commit-first) failed — pipeline continues"));
+				} else if (earlyCommit.status === "failed") {
+					_devOutputCommitHookFailure = earlyCommit.stderr;
+					const cp = await checkpointStoryWorktree(storyKey, "dev-story output (deliverable commit rejected by hooks)", effectiveProjectRoot);
+					logger$27.warn({
+						storyKey,
+						checkpoint: cp.status,
+						hookStderr: earlyCommit.stderr.slice(0, 500)
+					}, "commit-first: hooks rejected feat commit — work preserved as wip checkpoint");
+					if (cp.status === "committed" && runManifest !== null && cp.sha) runManifest.patchStoryState(storyKey, { checkpoint_sha: cp.sha }).catch((err) => logger$27.warn({
+						err,
+						storyKey
+					}, "patchStoryState(checkpoint_sha) failed — pipeline continues"));
+				}
+			} else {
+				const cp = await checkpointStoryWorktree(storyKey, "dev-story partial output", effectiveProjectRoot);
+				if (cp.status === "committed") {
+					logger$27.info({
+						storyKey,
+						sha: cp.sha
+					}, "commit-first: partial dev-story output checkpointed");
+					if (runManifest !== null && cp.sha) runManifest.patchStoryState(storyKey, { checkpoint_sha: cp.sha }).catch((err) => logger$27.warn({
+						err,
+						storyKey
+					}, "patchStoryState(checkpoint_sha) failed — pipeline continues"));
+				}
+			}
+		}
 		endPhase(storyKey, "dev-story", devStoryModel);
 		let _buildPassed = false;
 		{
@@ -15871,6 +16216,19 @@ function createImplementationOrchestrator(deps) {
 						}
 					}
 					if (!shouldFallThroughToComplete) {
+						if (effectiveProjectRoot !== void 0 && effectiveProjectRoot !== projectRoot) {
+							const cp = await checkpointStoryWorktree(storyKey, `verification-failed: ${verificationFailReason ?? "tier-a-fail"}`, effectiveProjectRoot);
+							if (cp.status === "committed") {
+								logger$27.info({
+									storyKey,
+									sha: cp.sha
+								}, "verification-failed checkpoint: uncommitted worktree state preserved on story branch");
+								if (runManifest !== null && cp.sha) runManifest.patchStoryState(storyKey, { checkpoint_sha: cp.sha }).catch((err) => logger$27.warn({
+									err,
+									storyKey
+								}, "patchStoryState(checkpoint_sha, verification-failed) failed — pipeline continues"));
+							}
+						}
 						updateStory(storyKey, {
 							phase: "VERIFICATION_FAILED",
 							completedAt: new Date().toISOString()
@@ -15915,6 +16273,242 @@ function createImplementationOrchestrator(deps) {
 			await persistState();
 			return "completed";
 		}
+		async function finalizeStory(completedReviewCycles) {
+			if (!noWorktree && _worktreeManager !== void 0 && _orchestratorStartBranch !== void 0 && projectRoot !== void 0) {
+				const branchName = `${BRANCH_PREFIX}${storyKey}`;
+				if (effectiveProjectRoot !== void 0) {
+					const dirty = await getGitChangedFiles(effectiveProjectRoot);
+					const commitResult = await commitDevStoryOutput(storyKey, _capturedStoryTitle, dirty, effectiveProjectRoot);
+					if (commitResult.status === "no-changes") {
+						if (_devOutputCommitHookFailure !== void 0) {
+							logger$27.error({
+								storyKey,
+								stderr: _devOutputCommitHookFailure
+							}, "deliverable commit was rejected by hooks at dev-story end and was never resolved — escalating");
+							updateStory(storyKey, {
+								phase: "ESCALATED",
+								error: "dev-story-commit-failed",
+								completedAt: new Date().toISOString()
+							});
+							await emitEscalation({
+								storyKey,
+								lastVerdict: "dev-story-commit-failed",
+								reviewCycles: completedReviewCycles,
+								issues: [`substrate auto-commit was rejected by pre-commit hooks at dev-story end and the rejection was never resolved: ${_devOutputCommitHookFailure}`, "The work IS preserved as a wip(story-…) checkpoint on the story branch (hooks bypassed) — it was deliberately not merged."]
+							});
+							await persistState();
+							return "terminal";
+						}
+						let branchAdvancedSinceBaseline = false;
+						if (baselineHeadSha) try {
+							const headNow = execSync("git rev-parse HEAD", {
+								cwd: effectiveProjectRoot,
+								encoding: "utf-8",
+								stdio: [
+									"ignore",
+									"pipe",
+									"pipe"
+								],
+								timeout: 5e3
+							}).trim();
+							branchAdvancedSinceBaseline = headNow !== baselineHeadSha;
+						} catch {}
+						if (!branchAdvancedSinceBaseline) {
+							logger$27.warn({
+								storyKey,
+								reason: commitResult.reason
+							}, "dev-story produced no committable changes — escalating instead of running merge-to-main on an unchanged branch");
+							updateStory(storyKey, {
+								phase: "ESCALATED",
+								error: `dev-story-no-commit: ${commitResult.reason}`,
+								completedAt: new Date().toISOString()
+							});
+							await emitEscalation({
+								storyKey,
+								lastVerdict: "dev-story-no-commit",
+								reviewCycles: completedReviewCycles,
+								issues: [`dev-story phase reached SHIP_IT but produced no committable changes (reason: ${commitResult.reason})`]
+							});
+							await persistState();
+							return "terminal";
+						}
+						logger$27.info({ storyKey }, "working tree clean at finalize but branch already advanced (commit-first) — proceeding to merge");
+					}
+					if (commitResult.status === "failed") {
+						logger$27.error({
+							storyKey,
+							stderr: commitResult.stderr
+						}, "substrate auto-commit failed — escalating story");
+						updateStory(storyKey, {
+							phase: "ESCALATED",
+							error: "dev-story-commit-failed",
+							completedAt: new Date().toISOString()
+						});
+						await emitEscalation({
+							storyKey,
+							lastVerdict: "dev-story-commit-failed",
+							reviewCycles: completedReviewCycles,
+							issues: [`substrate auto-commit failed: ${commitResult.stderr}`]
+						});
+						await persistState();
+						return "terminal";
+					}
+					let finalizeCommitSha;
+					if (commitResult.status === "committed") {
+						finalizeCommitSha = commitResult.sha || void 0;
+						logger$27.info({
+							storyKey,
+							sha: commitResult.sha,
+							fileCount: commitResult.filesStaged.length
+						}, "substrate auto-committed dev-story output before merge-to-main");
+					} else try {
+						finalizeCommitSha = execSync("git rev-parse HEAD", {
+							cwd: effectiveProjectRoot,
+							encoding: "utf-8",
+							stdio: [
+								"ignore",
+								"pipe",
+								"pipe"
+							],
+							timeout: 5e3
+						}).trim();
+					} catch {}
+					if (runManifest !== null && finalizeCommitSha) {
+						const statePatch = { commit_sha: finalizeCommitSha };
+						if (storyFilePath !== void 0) try {
+							Object.assign(statePatch, captureReconstructionInput(storyFilePath, storyKey, runManifest.baseDir, runManifest.runId, effectiveProjectRoot));
+						} catch (inputErr) {
+							logger$27.warn({
+								err: inputErr,
+								storyKey
+							}, "reconstruction phase-input capture failed — pipeline continues (commit_sha still recorded)");
+						}
+						try {
+							const dispatchTelemetry = aggregateStoryDispatchTelemetry(_storyAgents.get(storyKey) ?? []);
+							if (dispatchTelemetry.total_turns !== void 0) statePatch.total_turns = dispatchTelemetry.total_turns;
+							if (dispatchTelemetry.total_tokens !== void 0) statePatch.total_tokens = dispatchTelemetry.total_tokens;
+						} catch (telemetryErr) {
+							logger$27.warn({
+								err: telemetryErr,
+								storyKey
+							}, "aggregateStoryDispatchTelemetry failed — pipeline continues (commit_sha still recorded)");
+						}
+						runManifest.patchStoryState(storyKey, statePatch).catch((err) => logger$27.warn({
+							err,
+							storyKey
+						}, "patchStoryState(commit_sha/phase-input/telemetry) failed — pipeline continues"));
+					}
+				}
+				try {
+					const branchSha = execSync(`git rev-parse ${branchName}`, {
+						cwd: effectiveProjectRoot ?? projectRoot,
+						encoding: "utf-8",
+						stdio: [
+							"ignore",
+							"pipe",
+							"pipe"
+						],
+						timeout: 5e3
+					}).trim();
+					const startSha = execSync(`git rev-parse ${_orchestratorStartBranch}`, {
+						cwd: projectRoot,
+						encoding: "utf-8",
+						stdio: [
+							"ignore",
+							"pipe",
+							"pipe"
+						],
+						timeout: 5e3
+					}).trim();
+					if (branchSha === startSha) {
+						logger$27.warn({
+							storyKey,
+							branchSha,
+							startSha,
+							branchName
+						}, "merge-to-main gate: branch did not advance from start commit — escalating instead of running a no-op merge");
+						updateStory(storyKey, {
+							phase: "ESCALATED",
+							error: "dev-story-no-commit",
+							completedAt: new Date().toISOString()
+						});
+						await emitEscalation({
+							storyKey,
+							lastVerdict: "dev-story-no-commit",
+							reviewCycles: completedReviewCycles,
+							issues: [`branch ${branchName} did not advance past start commit ${startSha} — merge-to-main would be a no-op`]
+						});
+						await persistState();
+						return "terminal";
+					}
+				} catch (gateErr) {
+					logger$27.warn({
+						storyKey,
+						err: gateErr instanceof Error ? gateErr.message : String(gateErr)
+					}, "merge-to-main pre-flight verification failed — proceeding with merge phase");
+				}
+				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 "terminal";
+				}
+				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 "terminal";
+				}
+				logger$27.info({
+					storyKey,
+					branchName
+				}, "merge-to-main phase completed successfully");
+			}
+			return "finalized";
+		}
 		while (keepReviewing) {
 			await waitIfPaused();
 			if (_state !== "RUNNING") return;
@@ -16169,6 +16763,13 @@ function createImplementationOrchestrator(deps) {
 				} catch {}
 				updateStory(storyKey, { lastVerdict: verdict });
 				await persistState();
+				if (runManifest !== null) {
+					const persistedVerdict = reviewResult.agentVerdict ?? verdict;
+					runManifest.patchStoryState(storyKey, { verdict: persistedVerdict }).catch((err) => logger$27.warn({
+						err,
+						storyKey
+					}, "patchStoryState(verdict) failed — pipeline continues"));
+				}
 				{
 					const totalTokens = reviewResult.tokenUsage ? reviewResult.tokenUsage.input + reviewResult.tokenUsage.output : 0;
 					const totalTokensK = totalTokens > 0 ? `${Math.round(totalTokens / 1e3)}K` : "0";
@@ -16309,178 +16910,8 @@ function createImplementationOrchestrator(deps) {
 						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 = `${BRANCH_PREFIX}${storyKey}`;
-					if (effectiveProjectRoot !== void 0) {
-						const dirty = await getGitChangedFiles(effectiveProjectRoot);
-						const commitResult = await commitDevStoryOutput(storyKey, _capturedStoryTitle, dirty, effectiveProjectRoot);
-						if (commitResult.status === "no-changes") {
-							logger$27.warn({
-								storyKey,
-								reason: commitResult.reason
-							}, "dev-story produced no committable changes — escalating instead of running merge-to-main on an unchanged branch");
-							updateStory(storyKey, {
-								phase: "ESCALATED",
-								error: `dev-story-no-commit: ${commitResult.reason}`,
-								completedAt: new Date().toISOString()
-							});
-							await emitEscalation({
-								storyKey,
-								lastVerdict: "dev-story-no-commit",
-								reviewCycles: completedReviewCycles,
-								issues: [`dev-story phase reached SHIP_IT but produced no committable changes (reason: ${commitResult.reason})`]
-							});
-							await persistState();
-							return;
-						}
-						if (commitResult.status === "failed") {
-							logger$27.error({
-								storyKey,
-								stderr: commitResult.stderr
-							}, "substrate auto-commit failed — escalating story");
-							updateStory(storyKey, {
-								phase: "ESCALATED",
-								error: "dev-story-commit-failed",
-								completedAt: new Date().toISOString()
-							});
-							await emitEscalation({
-								storyKey,
-								lastVerdict: "dev-story-commit-failed",
-								reviewCycles: completedReviewCycles,
-								issues: [`substrate auto-commit failed: ${commitResult.stderr}`]
-							});
-							await persistState();
-							return;
-						}
-						logger$27.info({
-							storyKey,
-							sha: commitResult.sha,
-							fileCount: commitResult.filesStaged.length
-						}, "substrate auto-committed dev-story output before merge-to-main");
-						if (runManifest !== null && commitResult.sha) {
-							const statePatch = { commit_sha: commitResult.sha };
-							if (storyFilePath !== void 0) try {
-								Object.assign(statePatch, captureReconstructionInput(storyFilePath, storyKey, runManifest.baseDir, runManifest.runId, effectiveProjectRoot));
-							} catch (inputErr) {
-								logger$27.warn({
-									err: inputErr,
-									storyKey
-								}, "reconstruction phase-input capture failed — pipeline continues (commit_sha still recorded)");
-							}
-							runManifest.patchStoryState(storyKey, statePatch).catch((err) => logger$27.warn({
-								err,
-								storyKey
-							}, "patchStoryState(commit_sha/phase-input) failed — pipeline continues"));
-						}
-					}
-					try {
-						const branchSha = execSync(`git rev-parse ${branchName}`, {
-							cwd: effectiveProjectRoot ?? projectRoot,
-							encoding: "utf-8",
-							stdio: [
-								"ignore",
-								"pipe",
-								"pipe"
-							],
-							timeout: 5e3
-						}).trim();
-						const startSha = execSync(`git rev-parse ${_orchestratorStartBranch}`, {
-							cwd: projectRoot,
-							encoding: "utf-8",
-							stdio: [
-								"ignore",
-								"pipe",
-								"pipe"
-							],
-							timeout: 5e3
-						}).trim();
-						if (branchSha === startSha) {
-							logger$27.warn({
-								storyKey,
-								branchSha,
-								startSha,
-								branchName
-							}, "merge-to-main gate: branch did not advance from start commit — escalating instead of running a no-op merge");
-							updateStory(storyKey, {
-								phase: "ESCALATED",
-								error: "dev-story-no-commit",
-								completedAt: new Date().toISOString()
-							});
-							await emitEscalation({
-								storyKey,
-								lastVerdict: "dev-story-no-commit",
-								reviewCycles: completedReviewCycles,
-								issues: [`branch ${branchName} did not advance past start commit ${startSha} — merge-to-main would be a no-op`]
-							});
-							await persistState();
-							return;
-						}
-					} catch (gateErr) {
-						logger$27.warn({
-							storyKey,
-							err: gateErr instanceof Error ? gateErr.message : String(gateErr)
-						}, "merge-to-main pre-flight verification failed — proceeding with merge phase");
-					}
-					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");
-				}
+				const finalizeOutcome = await finalizeStory(completedReviewCycles);
+				if (finalizeOutcome === "terminal") return;
 				keepReviewing = false;
 				return;
 			}
@@ -16607,6 +17038,7 @@ function createImplementationOrchestrator(deps) {
 					}
 				});
 				if (outcome === "verification-failed") return;
+				if (await finalizeStory(finalReviewCycles) === "terminal") return;
 				keepReviewing = false;
 				return;
 			}
@@ -16816,6 +17248,7 @@ function createImplementationOrchestrator(deps) {
 							}
 						});
 						if (outcome === "verification-failed") return;
+						if (await finalizeStory(finalReviewCycles) === "terminal") return;
 						keepReviewing = false;
 						return;
 					}
@@ -16899,6 +17332,64 @@ function createImplementationOrchestrator(deps) {
 	* @param result - The ceiling check result
 	* @param manifest - The current run manifest data
 	*/
+	/**
+	* H0.4 (field finding #10): halt the entire run when a dispatch dies on
+	* authentication. Auth failures are environmental, not story-specific —
+	* every subsequent dispatch fails identically, so continuing burns the
+	* whole batch (the field run lost ~25 minutes and two runs to this).
+	* Mirrors handleCeilingExceeded: routes through the Decision Router
+	* (severity fatal → halts under every --halt-on policy), sweeps PENDING
+	* stories to ESCALATED with a named reason, and reuses _budgetExhausted
+	* to stop the dispatch loop.
+	*/
+	async function triggerAuthFailureHalt(triggeredStoryKey, matchedSignature) {
+		if (_authFailureHalted) return;
+		_authFailureHalted = true;
+		_budgetExhausted = true;
+		const runId = config.pipelineRunId ?? "unknown";
+		const reason = `agent authentication failure on story ${triggeredStoryKey} (matched: "${matchedSignature}") — all subsequent dispatches would fail identically`;
+		let haltPolicy = "critical";
+		if (runManifest !== null) try {
+			const manifest = await runManifest.read();
+			haltPolicy = manifest.cli_flags.halt_on ?? "critical";
+		} catch {}
+		const routeResult = routeDecision("auth-failure", haltPolicy);
+		eventBus.emit("decision:halt", {
+			runId,
+			decisionType: "auth-failure",
+			severity: routeResult.severity,
+			reason
+		});
+		await runInteractivePrompt({
+			runId,
+			decisionType: "auth-failure",
+			severity: routeResult.severity,
+			summary: reason,
+			defaultAction: routeResult.defaultAction,
+			choices: ["abort-run"],
+			onHaltSkipped: (payload) => {
+				eventBus.emit("decision:halt-skipped-non-interactive", payload);
+			}
+		}).catch((err) => {
+			logger$27.warn({ err }, "interactive prompt failed during auth-failure halt — halting anyway");
+		});
+		for (const [key, state] of _stories) if (state.phase === "PENDING" && key !== triggeredStoryKey) {
+			updateStory(key, {
+				phase: "ESCALATED",
+				error: "auth-failure-halt",
+				completedAt: new Date().toISOString()
+			});
+			if (runManifest !== null && runManifest !== void 0) runManifest.patchStoryState(key, {
+				status: "escalated",
+				escalation_reason: "auth-failure-halt"
+			}).catch(() => {});
+		}
+		logger$27.error({
+			runId,
+			triggeredStoryKey,
+			matchedSignature
+		}, "RUN HALTED: agent authentication failure — fix credentials and re-run");
+	}
 	async function handleCeilingExceeded(triggeredStoryKey, remainingInGroup, result, manifest) {
 		const haltPolicy = manifest.cli_flags.halt_on ?? "critical";
 		const routeResult = routeDecision("cost-ceiling-exhausted", haltPolicy);
@@ -47442,7 +47933,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-C7ZhqLX3.js");
+	const { createVersionManager } = await import("./version-manager-impl-HJMonRJi.js");
 	const vm = createVersionManager();
 	const result = await vm.checkForUpdates(true);
 	const gap = classifyVersionGap(currentVersion, result.latestVersion);
@@ -47539,4 +48030,4 @@ 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-Dbwlb4Md.js.map
+//# sourceMappingURL=run-CRvusFIv.js.map