substrate-ai 0.20.63 → 0.20.65

package/dist/{run-CHUFlRbH.js → run-DzB4rgkj.js}

@@ -1,7 +1,12 @@
-import { BMAD_BASELINE_TOKENS_FULL, DoltMergeConflict, FileStateStore, FindingsInjector, RunManifest, RuntimeProbeListSchema, STOP_AFTER_VALID_PHASES, STORY_KEY_PATTERN, VALID_PHASES, WorkGraphRepository, __commonJS, __require, __toESM, applyConfigToGraph, buildPipelineStatusOutput, createDatabaseAdapter, createDefaultVerificationPipeline, createGraphOrchestrator, createSdlcCodeReviewHandler, createSdlcCreateStoryHandler, createSdlcDevStoryHandler, createSdlcPhaseHandler, detectCycles, detectsEventDrivenAC, detectsStateIntegratingAC, extractTargetFilesFromStoryContent, formatOutput, formatPipelineSummary, formatTokenTelemetry, inspectProcessTree, parseDbTimestampAsUtc, renderFindings, resolveGraphPath, resolveMainRepoRoot, runStaleVerificationRecovery, validateStoryKey } from "./health-C-KOZrFJ.js";
+import { BMAD_BASELINE_TOKENS_FULL, DoltMergeConflict, FileStateStore, STOP_AFTER_VALID_PHASES, STORY_KEY_PATTERN, VALID_PHASES, __commonJS, __require, __toESM, buildPipelineStatusOutput, createDatabaseAdapter, formatOutput, formatPipelineSummary, formatTokenTelemetry, inspectProcessTree, parseDbTimestampAsUtc, validateStoryKey } from "./health-DC3y-sR6.js";
 import { createLogger } from "./logger-KeHncl-f.js";
 import { TypedEventBusImpl, createEventBus, createTuiApp, isTuiCapable, printNonTtyWarning, sleep } from "./helpers-CElYrONe.js";
-import { ADVISORY_NOTES, Categorizer, ConsumerAnalyzer, DEFAULT_GLOBAL_SETTINGS, DispatcherImpl, DoltClient, ESCALATION_DIAGNOSIS, EXPERIMENT_RESULT, EfficiencyScorer, IngestionServer, LogTurnAnalyzer, OPERATIONAL_FINDING, Recommender, RoutingRecommender, RoutingResolver, RoutingTelemetry, RoutingTokenAccumulator, RoutingTuner, STORY_METRICS, STORY_OUTCOME, SubstrateConfigSchema, TEST_EXPANSION_FINDING, TEST_PLAN, TelemetryNormalizer, TelemetryPipeline, TurnAnalyzer, addTokenUsage, aggregateTokenUsageForRun, aggregateTokenUsageForStory, callLLM, createConfigSystem, createDatabaseAdapter$1, createDecision, createPipelineRun, createRequirement, detectInterfaceChanges, getArtifactByTypeForRun, getArtifactsByRun, getDecisionsByCategory, getDecisionsByPhase, getDecisionsByPhaseForRun, getLatestRun, getPipelineRunById, getRunMetrics, getRunningPipelineRuns, getStoryMetricsForRun, getTokenUsageSummary, initSchema, listRequirements, loadModelRoutingConfig, registerArtifact, updatePipelineRun, updatePipelineRunConfig, upsertDecision, writeRunMetrics, writeStoryMetrics } from "./dist-W2emvN3F.js";
+import { ADVISORY_NOTES, Categorizer, ConsumerAnalyzer, DEFAULT_GLOBAL_SETTINGS, DispatcherImpl, DoltClient, ESCALATION_DIAGNOSIS, EXPERIMENT_RESULT, EfficiencyScorer, IngestionServer, LogTurnAnalyzer, OPERATIONAL_FINDING, Recommender, RoutingRecommender, RoutingResolver, RoutingTelemetry, RoutingTokenAccumulator, RoutingTuner, STORY_METRICS, STORY_OUTCOME, SubstrateConfigSchema, TEST_EXPANSION_FINDING, TEST_PLAN, TelemetryNormalizer, TelemetryPipeline, TurnAnalyzer, addTokenUsage, aggregateTokenUsageForRun, aggregateTokenUsageForStory, callLLM, createConfigSystem, createDatabaseAdapter$1, createDecision, createPipelineRun, createRequirement, detectInterfaceChanges, getArtifactByTypeForRun, getArtifactsByRun, getDecisionsByCategory, getDecisionsByPhase, getDecisionsByPhaseForRun, getLatestRun, getPipelineRunById, getRunMetrics, getRunningPipelineRuns, getStoryMetricsForRun, getTokenUsageSummary, initSchema, listRequirements, loadModelRoutingConfig, registerArtifact, updatePipelineRun, updatePipelineRunConfig, upsertDecision, writeRunMetrics, writeStoryMetrics } from "./dist-K_RRWnBX.js";
+import { FindingsInjector, RunManifest, RuntimeProbeListSchema, applyConfigToGraph, createDefaultVerificationPipeline, createGraphOrchestrator, createSdlcCodeReviewHandler, createSdlcCreateStoryHandler, createSdlcDevStoryHandler, createSdlcPhaseHandler, detectsEventDrivenAC, detectsStateIntegratingAC, extractTargetFilesFromStoryContent, renderFindings, resolveGraphPath, resolveMainRepoRoot, runStaleVerificationRecovery } from "./manifest-read-DDkXC3L_.js";
+import { WorkGraphRepository, detectCycles } from "./work-graph-repository-DZyJv5pV.js";
+import { deriveExitCode, routeDecision } from "./decision-router-DblHY8se.js";
+import { runInteractivePrompt } from "./interactive-prompt-C7wpE4z4.js";
+import { runRecoveryEngine } from "./recovery-engine-BKGBeBnW.js";
 import { basename, dirname, extname, join } from "path";
 import { access, readFile, readdir, stat } from "fs/promises";
 import { EventEmitter } from "node:events";
@@ -14,7 +19,7 @@ import path, { basename as basename$1, dirname as dirname$1, extname as extname$
 import { tmpdir } from "node:os";
 import { createHash, randomUUID } from "node:crypto";
 import { z } from "zod";
-import { access as access$1, lstat, mkdir as mkdir$1, readFile as readFile$1, readdir as readdir$1, readlink, realpath, rename, stat as stat$1, unlink, 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";
@@ -1764,7 +1769,7 @@ const PIPELINE_EVENT_METADATA = [
 			{
 				name: "action",
 				type: "string",
-				description: "Action taken (always stopped in this story; interactive prompt is Epic 54 scope)."
+				description: "Action taken — stopped when policy requires halt, or the defaultAction when proceeding autonomously."
 			},
 			{
 				name: "skipped_stories",
@@ -1774,10 +1779,47 @@ const PIPELINE_EVENT_METADATA = [
 			{
 				name: "severity",
 				type: "string",
-				description: "critical when halt_on is all or critical; absent when none.",
+				description: "Severity from routeDecision (critical for cost-ceiling-exhausted).",
 				optional: true
 			}
 		]
+	},
+	{
+		type: "decision:halt-skipped-non-interactive",
+		description: "A critical halt decision was skipped under --non-interactive mode; default action was applied autonomously.",
+		when: "Emitted when --non-interactive suppresses an operator prompt and applies the default action. Story 72-2.",
+		fields: [
+			{
+				name: "ts",
+				type: "string",
+				description: "Timestamp."
+			},
+			{
+				name: "run_id",
+				type: "string",
+				description: "Pipeline run ID."
+			},
+			{
+				name: "decision_type",
+				type: "string",
+				description: "Halt decision type that was skipped (e.g., halt:escalation)."
+			},
+			{
+				name: "severity",
+				type: "string",
+				description: "Severity of the skipped halt (e.g., critical)."
+			},
+			{
+				name: "default_action",
+				type: "string",
+				description: "Action applied in place of the operator prompt."
+			},
+			{
+				name: "reason",
+				type: "string",
+				description: "Human-readable reason for skipping."
+			}
+		]
 	}
 ];
 /**
@@ -14284,6 +14326,49 @@ function createImplementationOrchestrator(deps) {
 						}, "Build-fix dispatch failed — escalating");
 					}
 					if (!buildFixPassed) {
+						let buildHaltPolicy = "critical";
+						if (runManifest !== null && runManifest !== void 0) try {
+							const manifestData = await runManifest.read();
+							buildHaltPolicy = manifestData.cli_flags.halt_on ?? "critical";
+						} catch {}
+						const buildRouteResult = routeDecision("build-verification-failure", buildHaltPolicy);
+						const buildRunId = config.pipelineRunId ?? "unknown";
+						const buildReason = `build verification failed for story ${storyKey}`;
+						if (buildRouteResult.halt) {
+							eventBus.emit("decision:halt", {
+								runId: buildRunId,
+								decisionType: "build-verification-failure",
+								severity: buildRouteResult.severity,
+								reason: buildReason
+							});
+							await runInteractivePrompt({
+								runId: buildRunId,
+								decisionType: "build-verification-failure",
+								severity: buildRouteResult.severity,
+								summary: buildReason,
+								defaultAction: buildRouteResult.defaultAction,
+								choices: [
+									"escalate-without-halt",
+									"retry-with-custom-context",
+									"propose-re-scope",
+									"abort-run"
+								],
+								onHaltSkipped: (payload) => {
+									eventBus.emit("decision:halt-skipped-non-interactive", payload);
+								}
+							}).catch((err) => {
+								logger$26.warn({
+									err,
+									storyKey
+								}, "interactive prompt failed — continuing with default action");
+							});
+						} else eventBus.emit("decision:autonomous", {
+							runId: buildRunId,
+							decisionType: "build-verification-failure",
+							severity: buildRouteResult.severity,
+							defaultAction: buildRouteResult.defaultAction,
+							reason: buildReason
+						});
 						eventBus.emit("story:build-verification-failed", {
 							storyKey,
 							exitCode: buildVerifyResult.exitCode ?? 1,
@@ -14292,7 +14377,9 @@ function createImplementationOrchestrator(deps) {
 						logger$26.warn({
 							storyKey,
 							reason,
-							exitCode: buildVerifyResult.exitCode
+							exitCode: buildVerifyResult.exitCode,
+							routedHalt: buildRouteResult.halt,
+							defaultAction: buildRouteResult.defaultAction
 						}, "Build verification failed — escalating story");
 						updateStory(storyKey, {
 							phase: "ESCALATED",
@@ -14381,17 +14468,165 @@ function createImplementationOrchestrator(deps) {
 				verificationStore.set(storyKey, verifSummary);
 				await persistVerificationResult(storyKey, verifSummary, runManifest);
 				if (verifSummary.status === "fail") {
-					updateStory(storyKey, {
-						phase: "VERIFICATION_FAILED",
-						completedAt: new Date().toISOString()
-					});
-					persistStoryState(storyKey, _stories.get(storyKey)).catch((err) => logger$26.warn({
-						err,
-						storyKey
-					}, "StateStore write failed after verification-failed"));
-					await writeStoryMetricsBestEffort(storyKey, "verification-failed", finalReviewCycles);
-					await persistState();
-					return "verification-failed";
+					let shouldFallThroughToComplete = false;
+					if (runManifest != null) {
+						const failFindings = (verifSummary.checks ?? []).flatMap((c) => c.findings ?? []);
+						const hasBuildFail = (verifSummary.checks ?? []).some((c) => (c.checkName === "build" || c.checkName === "typecheck") && c.status === "fail");
+						const recoveryRootCause = hasBuildFail ? "build-failure" : "ac-missing-evidence";
+						const recoveryBudget = {
+							max: config.maxReviewCycles,
+							remaining: Math.max(0, config.maxReviewCycles - finalReviewCycles)
+						};
+						const recoveryResult = await runRecoveryEngine({
+							runId: config.pipelineRunId ?? storyKey,
+							storyKey,
+							failure: {
+								rootCause: recoveryRootCause,
+								findings: failFindings
+							},
+							budget: recoveryBudget,
+							bus: toSdlcEventBus(eventBus),
+							manifest: runManifest,
+							adapter: db,
+							engine: "linear"
+						}).catch((recoveryErr) => {
+							logger$26.warn({
+								storyKey,
+								err: recoveryErr instanceof Error ? recoveryErr.message : String(recoveryErr)
+							}, "Recovery Engine invocation failed — falling through to VERIFICATION_FAILED (best-effort)");
+							return null;
+						});
+						if (recoveryResult?.action === "halt-entire-run") {
+							logger$26.error({
+								storyKey,
+								pendingProposalsCount: recoveryResult.pendingProposalsCount
+							}, "Recovery Engine safety valve: halting entire run due to >= 5 pending proposals");
+							_budgetExhausted = true;
+						} else if (recoveryResult?.action === "retry") {
+							logger$26.info({
+								storyKey,
+								attempt: recoveryResult.attempt,
+								retryBudgetRemaining: recoveryResult.retryBudgetRemaining
+							}, "Recovery Engine Tier A: re-dispatching dev-story with enriched prompt");
+							try {
+								incrementDispatches(storyKey);
+								const retryDevResult = await runDevStory({
+									db,
+									pack,
+									contextCompiler,
+									dispatcher,
+									projectRoot,
+									tokenCeilings,
+									otlpEndpoint: _otlpEndpoint,
+									repoMapInjector,
+									maxRepoMapTokens,
+									agentId
+								}, {
+									storyKey,
+									storyFilePath: storyFilePath ?? "",
+									pipelineRunId: config.pipelineRunId,
+									findingsPrompt: recoveryResult.enrichedPrompt
+								});
+								replaceDevStorySignals(retryDevResult);
+								await persistDevStorySignals(storyKey, devStorySignals, runManifest);
+								const retryVerifContext = assembleVerificationContext({
+									storyKey,
+									workingDir: projectRoot ?? process.cwd(),
+									reviewResult: latestReviewSignals,
+									storyContent: storyContentForVerification,
+									devStoryResult: devStorySignals,
+									outputTokenCount: devOutputTokenCount,
+									sourceEpicContent
+								});
+								const retryVerifSummary = await verificationPipeline.run(retryVerifContext, "A");
+								verificationStore.set(storyKey, retryVerifSummary);
+								await persistVerificationResult(storyKey, retryVerifSummary, runManifest);
+								if (retryVerifSummary.status !== "fail") {
+									logger$26.info({ storyKey }, "Recovery Engine Tier A retry succeeded — story proceeding to COMPLETE");
+									shouldFallThroughToComplete = true;
+								} else logger$26.warn({ storyKey }, "Recovery Engine Tier A retry still failed — falling through to VERIFICATION_FAILED");
+							} catch (retryErr) {
+								logger$26.warn({
+									storyKey,
+									err: retryErr instanceof Error ? retryErr.message : String(retryErr)
+								}, "Recovery Engine Tier A re-dispatch threw — falling through to VERIFICATION_FAILED");
+							}
+						} else if (recoveryResult?.action === "propose") {
+							logger$26.info({ storyKey }, "Recovery Engine Tier B: proposal appended — marking story ESCALATED for operator re-scope");
+							updateStory(storyKey, {
+								phase: "ESCALATED",
+								completedAt: new Date().toISOString(),
+								error: "recovery-engine-propose"
+							});
+							persistStoryState(storyKey, _stories.get(storyKey)).catch((err) => logger$26.warn({
+								err,
+								storyKey
+							}, "StateStore write failed after recovery-propose"));
+							await emitEscalation({
+								storyKey,
+								lastVerdict: "recovery-propose",
+								reviewCycles: finalReviewCycles,
+								issues: failFindings
+							});
+							await writeStoryMetricsBestEffort(storyKey, "escalated", finalReviewCycles);
+							await persistState();
+							return "verification-failed";
+						} else if (recoveryResult?.action === "halt") {
+							logger$26.warn({ storyKey }, "Recovery Engine Tier C: halt — invoking interactive prompt for operator decision");
+							const haltRunId = config.pipelineRunId ?? storyKey;
+							await runInteractivePrompt({
+								runId: haltRunId,
+								decisionType: "verification-failure",
+								severity: "critical",
+								summary: `Verification failed (Tier C halt) on story ${storyKey}: ${recoveryRootCause}`,
+								defaultAction: "escalate",
+								choices: [
+									"escalate-without-halt",
+									"propose-re-scope",
+									"abort-run"
+								],
+								onHaltSkipped: (haltPayload) => {
+									eventBus.emit("decision:halt-skipped-non-interactive", haltPayload);
+								}
+							}).catch((err) => {
+								logger$26.warn({
+									err,
+									storyKey
+								}, "Recovery Engine Tier C: interactive prompt failed — escalating anyway");
+							});
+							updateStory(storyKey, {
+								phase: "ESCALATED",
+								completedAt: new Date().toISOString(),
+								error: "recovery-engine-halt"
+							});
+							persistStoryState(storyKey, _stories.get(storyKey)).catch((err) => logger$26.warn({
+								err,
+								storyKey
+							}, "StateStore write failed after recovery-halt"));
+							await emitEscalation({
+								storyKey,
+								lastVerdict: "recovery-halt",
+								reviewCycles: finalReviewCycles,
+								issues: failFindings
+							});
+							await writeStoryMetricsBestEffort(storyKey, "escalated", finalReviewCycles);
+							await persistState();
+							return "verification-failed";
+						}
+					}
+					if (!shouldFallThroughToComplete) {
+						updateStory(storyKey, {
+							phase: "VERIFICATION_FAILED",
+							completedAt: new Date().toISOString()
+						});
+						persistStoryState(storyKey, _stories.get(storyKey)).catch((err) => logger$26.warn({
+							err,
+							storyKey
+						}, "StateStore write failed after verification-failed"));
+						await writeStoryMetricsBestEffort(storyKey, "verification-failed", finalReviewCycles);
+						await persistState();
+						return "verification-failed";
+					}
 				}
 			}
 			if (autoApprove !== void 0) eventBus.emit("story:auto-approved", {
@@ -15234,7 +15469,42 @@ function createImplementationOrchestrator(deps) {
 	* @param manifest - The current run manifest data
 	*/
 	async function handleCeilingExceeded(triggeredStoryKey, remainingInGroup, result, manifest) {
-		const haltOn = manifest.cli_flags.halt_on ?? "none";
+		const haltPolicy = manifest.cli_flags.halt_on ?? "critical";
+		const routeResult = routeDecision("cost-ceiling-exhausted", haltPolicy);
+		const runId = config.pipelineRunId ?? "unknown";
+		const reason = `cost ceiling exceeded: ${result.cumulative.toFixed(4)} USD >= ${result.ceiling} USD`;
+		if (routeResult.halt) {
+			eventBus.emit("decision:halt", {
+				runId,
+				decisionType: "cost-ceiling-exhausted",
+				severity: routeResult.severity,
+				reason
+			});
+			await runInteractivePrompt({
+				runId,
+				decisionType: "cost-ceiling-exhausted",
+				severity: routeResult.severity,
+				summary: reason,
+				defaultAction: routeResult.defaultAction,
+				choices: [
+					"skip-remaining",
+					"retry-with-custom-context",
+					"propose-re-scope",
+					"abort-run"
+				],
+				onHaltSkipped: (payload) => {
+					eventBus.emit("decision:halt-skipped-non-interactive", payload);
+				}
+			}).catch((err) => {
+				logger$26.warn({ err }, "interactive prompt failed during cost-ceiling halt — continuing with default action");
+			});
+		} else eventBus.emit("decision:autonomous", {
+			runId,
+			decisionType: "cost-ceiling-exhausted",
+			severity: routeResult.severity,
+			defaultAction: routeResult.defaultAction,
+			reason
+		});
 		const allSkipped = [triggeredStoryKey, ...remainingInGroup];
 		for (const [key, state] of _stories) if (state.phase === "PENDING" && !allSkipped.includes(key)) allSkipped.push(key);
 		for (const key of allSkipped) {
@@ -15248,16 +15518,18 @@ function createImplementationOrchestrator(deps) {
 		eventBus.emit("cost:ceiling-reached", {
 			cumulative_cost: result.cumulative,
 			ceiling: result.ceiling,
-			halt_on: haltOn,
-			action: "stopped",
+			halt_on: haltPolicy,
+			action: routeResult.halt ? "stopped" : routeResult.defaultAction,
 			skipped_stories: allSkipped,
-			...haltOn !== "none" ? { severity: "critical" } : {}
+			severity: routeResult.severity
 		});
 		_budgetExhausted = true;
 		logger$26.warn({
 			skipped: allSkipped.length,
 			cumulative: result.cumulative,
-			ceiling: result.ceiling
+			ceiling: result.ceiling,
+			routedHalt: routeResult.halt,
+			defaultAction: routeResult.defaultAction
 		}, "Cost ceiling reached — stopping dispatch");
 	}
 	/**
@@ -43246,7 +43518,7 @@ async function writeRunState(projectDir, state) {
 async function clearRunState(projectDir) {
 	const filePath = runStatePath(projectDir);
 	try {
-		await unlink(filePath);
+		await unlink$1(filePath);
 	} catch (err) {
 		if (err.code !== "ENOENT") throw err;
 	}
@@ -44204,6 +44476,17 @@ function wireNdjsonEmitter(eventBus, ndjsonEmitter) {
 			...payload.severity !== void 0 ? { severity: payload.severity } : {}
 		});
 	});
+	eventBus.on("decision:halt-skipped-non-interactive", (payload) => {
+		ndjsonEmitter.emit({
+			type: "decision:halt-skipped-non-interactive",
+			ts: new Date().toISOString(),
+			run_id: payload.runId,
+			decision_type: payload.decisionType,
+			severity: payload.severity,
+			default_action: payload.defaultAction,
+			reason: payload.reason
+		});
+	});
 }
 /**
 * Resolve the `probeAuthorStateIntegrating` boolean from CLI flag and env var.
@@ -44220,8 +44503,20 @@ function resolveProbeAuthorStateIntegrating(cliFlag) {
 	if (envVal !== void 0) return envVal === "on";
 	return true;
 }
+/**
+* Story 72-2: --non-interactive + Machine-Readable Exit Codes.
+*
+* Phase D Story 54-6 (2026-04-05): original headless CI/CD spec.
+* Story 72-1: Decision Router providing routeDecision defaultAction authority.
+* Story 72-2 (this code): --non-interactive flag that suppresses stdin reads,
+*   auto-applies default actions via routeDecision, and returns exit codes 0/1/2.
+*
+* Enables strata + agent-mesh cross-project CI/CD invocation:
+*   substrate run --non-interactive --halt-on none --events --output-format json
+*/
 async function runRunAction(options) {
-	const { pack: packName, from: startPhase, stopAfter, concept: conceptArg, conceptFile, stories: storiesArg, concurrency, outputFormat, projectRoot, events: eventsFlag, verbose: verboseFlag, tui: tuiFlag, skipUx, research: researchFlag, skipResearch: skipResearchFlag, skipPreflight, skipVerification, epic: epicNumber, dryRun, maxReviewCycles = 2, engine, agent: agentId, registry: injectedRegistry, haltOn, costCeiling, probeAuthor, probeAuthorStateIntegrating: probeAuthorStateIntegratingFlag } = options;
+	const { pack: packName, from: startPhase, stopAfter, concept: conceptArg, conceptFile, stories: storiesArg, concurrency, outputFormat, projectRoot, events: eventsFlag, verbose: verboseFlag, tui: tuiFlag, skipUx, research: researchFlag, skipResearch: skipResearchFlag, skipPreflight, skipVerification, epic: epicNumber, dryRun, maxReviewCycles = 2, engine, agent: agentId, registry: injectedRegistry, haltOn: haltOnOpt, costCeiling, probeAuthor, probeAuthorStateIntegrating: probeAuthorStateIntegratingFlag, nonInteractive } = options;
+	const haltOn = haltOnOpt;
 	const VALID_PROBE_AUTHOR_MODES = [
 		"enabled",
 		"disabled",
@@ -44534,11 +44829,12 @@ async function runRunAction(options) {
 			const runsDir = join(dbDir, "runs");
 			const cliFlags = {
 				...parsedStoryKeys.length > 0 ? { stories: parsedStoryKeys } : {},
-				halt_on: haltOn ?? "none",
+				halt_on: haltOn ?? "critical",
 				...costCeiling !== void 0 ? { cost_ceiling: costCeiling } : {},
 				...agentId !== void 0 ? { agent: agentId } : {},
 				...skipVerification === true ? { skip_verification: true } : {},
-				...eventsFlag === true ? { events: true } : {}
+				...eventsFlag === true ? { events: true } : {},
+				...nonInteractive === true ? { non_interactive: true } : {}
 			};
 			const manifest = RunManifest.open(pipelineRun.id, runsDir);
 			await manifest.patchCLIFlags(cliFlags);
@@ -44565,6 +44861,14 @@ async function runRunAction(options) {
 			});
 		} catch {}
 		const eventBus = createEventBus();
+		let _costCeilingExhausted = false;
+		let _fatalHaltReached = false;
+		eventBus.on("cost:ceiling-reached", () => {
+			_costCeilingExhausted = true;
+		});
+		eventBus.on("decision:halt", (payload) => {
+			if (payload.severity === "fatal") _fatalHaltReached = true;
+		});
 		const contextCompiler = createContextCompiler({ db: adapter });
 		if (!injectedRegistry) throw new Error("AdapterRegistry is required — must be initialized at CLI startup");
 		const routingConfigPath = join(projectRoot, "substrate.routing.yml");
@@ -44705,7 +45009,7 @@ async function runRunAction(options) {
 		if (tuiFlag === true && !isTuiCapable()) printNonTtyWarning();
 		if (verboseFlag !== true && eventsFlag !== true) process.env.LOG_LEVEL = "silent";
 		let tuiApp;
-		if (tuiFlag === true && isTuiCapable() && eventsFlag !== true && outputFormat === "human") {
+		if (tuiFlag === true && nonInteractive !== true && isTuiCapable() && eventsFlag !== true && outputFormat === "human") {
 			tuiApp = createTuiApp(process.stdout, process.stdin);
 			tuiApp.handleEvent({
 				type: "pipeline:start",
@@ -45098,13 +45402,52 @@ async function runRunAction(options) {
 			engineType: resolvedEngine,
 			concurrency
 		});
+		if (nonInteractive === true) {
+			if (escalatedKeys.length > 0 || _costCeilingExhausted || _fatalHaltReached) {
+				const haltPolicy = haltOn ?? "critical";
+				const routeResult = routeDecision("pipeline-escalation", haltPolicy);
+				eventBus.emit("decision:halt-skipped-non-interactive", {
+					runId: pipelineRun.id,
+					decisionType: "pipeline-escalation",
+					severity: routeResult.severity,
+					defaultAction: routeResult.defaultAction,
+					reason: "non-interactive: stdin prompt suppressed"
+				});
+				try {
+					const runsDir = join(dbDir, "runs");
+					const runManifestForHalt = RunManifest.open(pipelineRun.id, runsDir);
+					await runManifestForHalt.update({ cli_flags: {
+						halt_on: haltPolicy,
+						halt_skipped: true,
+						halt_skipped_decisions: [{
+							decisionType: "pipeline-escalation",
+							severity: routeResult.severity,
+							defaultAction: routeResult.defaultAction,
+							reason: "non-interactive: stdin prompt suppressed",
+							skippedAt: new Date().toISOString()
+						}]
+					} });
+				} catch (haltManifestErr) {
+					logger.warn({ err: haltManifestErr }, "Failed to write halt-skipped to manifest (best-effort)");
+				}
+			}
+			const derivedCode = deriveExitCode({
+				succeeded: succeededKeys,
+				escalated: escalatedKeys,
+				failed: failedKeys,
+				total: storyKeys.length,
+				costCeilingExhausted: _costCeilingExhausted,
+				fatalHaltReached: _fatalHaltReached
+			});
+			return derivedCode;
+		}
 		return 0;
 	} catch (err) {
 		const msg = err instanceof Error ? err.message : String(err);
 		if (outputFormat === "json") process.stdout.write(formatOutput(null, "json", false, msg) + "\n");
 		else process.stderr.write(`Error: ${msg}\n`);
 		logger.error({ err }, "run failed");
-		return 1;
+		return nonInteractive === true ? 2 : 1;
 	} finally {
 		try {
 			await adapter.close();
@@ -45578,7 +45921,22 @@ async function runFullPipeline(options) {
 	}
 }
 function registerRunCommand(program, _version = "0.0.0", projectRoot = process.cwd(), registry) {
-	program.command("run").description("Run the autonomous pipeline (use --from to start from a specific phase)").option("--pack <name>", "Methodology pack name", "bmad").option("--from <phase>", "Start from this phase: analysis, planning, solutioning, implementation").option("--stop-after <phase>", "Stop pipeline after this phase completes").option("--concept <text>", "Inline concept text (required when --from analysis)").option("--concept-file <path>", "Path to a file containing the concept text").option("--stories <keys>", "Comma-separated story keys (e.g., 10-1,10-2)").option("--epic <n>", "Scope story discovery to a single epic number (e.g., 27)", (v) => parseInt(v, 10)).option("--concurrency <n>", "Maximum parallel conflict groups", (v) => parseInt(v, 10), 3).option("--project-root <path>", "Project root directory", projectRoot).option("--output-format <format>", "Output format: human (default) or json", "human").option("--events", "Emit structured NDJSON events on stdout for programmatic consumption").option("--verbose", "Show detailed pino log output").option("--help-agent", "Print a machine-optimized prompt fragment for AI agents and exit").option("--tui", "Show TUI dashboard").option("--skip-ux", "Skip the UX design phase even if enabled in the pack manifest").option("--research", "Enable the research phase even if not set in the pack manifest").option("--skip-research", "Skip the research phase even if enabled in the pack manifest").option("--skip-preflight", "Skip the pre-flight build check (escape hatch for known-broken projects)").option("--skip-verification", "Skip the post-dispatch verification pipeline (Story 51-5)").option("--max-review-cycles <n>", "Maximum review cycles per story (default: 2)", (v) => parseInt(v, 10), 2).option("--dry-run", "Preview routing and repo-map injection without dispatching (Story 28-9)").option("--engine <type>", "Execution engine: linear (default) or graph").option("--agent <id>", "Agent backend: claude-code (default), codex, or gemini").option("--halt-on <severity>", "Halt pipeline on escalation severity: all | critical | none (default: none)", "none").option("--cost-ceiling <amount>", "Maximum cost ceiling in USD (positive number); halts pipeline when exceeded", parseFloat).option("--probe-author <mode>", "probe-author phase mode: enabled | disabled | auto (default: auto = SUBSTRATE_PROBE_AUTHOR_ENABLED env, default true) (Story 60-14)", "auto").option("--probe-author-state-integrating <value>", "Disable probe-author dispatch for state-integrating ACs (Phase 3). Use to ramp DOWN if catch rate drops below the GREEN threshold. Values: on | off (default: on)").action(async (opts) => {
+	program.command("run").description("Run the autonomous pipeline (use --from to start from a specific phase)").option("--pack <name>", "Methodology pack name", "bmad").option("--from <phase>", "Start from this phase: analysis, planning, solutioning, implementation").option("--stop-after <phase>", "Stop pipeline after this phase completes").option("--concept <text>", "Inline concept text (required when --from analysis)").option("--concept-file <path>", "Path to a file containing the concept text").option("--stories <keys>", "Comma-separated story keys (e.g., 10-1,10-2)").option("--epic <n>", "Scope story discovery to a single epic number (e.g., 27)", (v) => parseInt(v, 10)).option("--concurrency <n>", "Maximum parallel conflict groups", (v) => parseInt(v, 10), 3).option("--project-root <path>", "Project root directory", projectRoot).option("--output-format <format>", "Output format: human (default) or json", "human").option("--events", "Emit structured NDJSON events on stdout for programmatic consumption").option("--verbose", "Show detailed pino log output").option("--help-agent", "Print a machine-optimized prompt fragment for AI agents and exit").option("--tui", "Show TUI dashboard").option("--skip-ux", "Skip the UX design phase even if enabled in the pack manifest").option("--research", "Enable the research phase even if not set in the pack manifest").option("--skip-research", "Skip the research phase even if enabled in the pack manifest").option("--skip-preflight", "Skip the pre-flight build check (escape hatch for known-broken projects)").option("--skip-verification", "Skip the post-dispatch verification pipeline (Story 51-5)").option("--max-review-cycles <n>", "Maximum review cycles per story (default: 2)", (v) => parseInt(v, 10), 2).option("--dry-run", "Preview routing and repo-map injection without dispatching (Story 28-9)").option("--engine <type>", "Execution engine: linear (default) or graph").option("--agent <id>", "Agent backend: claude-code (default), codex, or gemini").option("--halt-on <severity>", "Halt pipeline on escalation severity: all | critical | none (default: critical)", "critical").option("--cost-ceiling <amount>", "Maximum cost ceiling in USD (positive number); halts pipeline when exceeded", parseFloat).option("--probe-author <mode>", "probe-author phase mode: enabled | disabled | auto (default: auto = SUBSTRATE_PROBE_AUTHOR_ENABLED env, default true) (Story 60-14)", "auto").option("--probe-author-state-integrating <value>", "Disable probe-author dispatch for state-integrating ACs (Phase 3). Use to ramp DOWN if catch rate drops below the GREEN threshold. Values: on | off (default: on)").option("--non-interactive", [
+		"Run without operator prompts (CI/CD mode). Suppresses all stdin reads,",
+		"auto-applies default actions for halt decisions, and returns machine-readable",
+		"exit codes: 0=all stories succeeded, 1=some escalated, 2=run-level failure.",
+		"",
+		"Canonical CI/CD invocation:",
+		"  substrate run --non-interactive --halt-on none --events --output-format json",
+		"",
+		"Exit code semantics:",
+		"  0  All stories succeeded (or recovered cleanly)",
+		"  1  Some stories escalated; run completed",
+		"  2  Run-level failure (cost ceiling exhausted, fatal halt, orchestrator died)",
+		"",
+		"--halt-on defaults to critical. Skipped halt decisions are recorded as",
+		"decision:halt-skipped-non-interactive events in --non-interactive mode."
+	].join("\n      ")).action(async (opts) => {
 		if (opts.helpAgent) {
 			process.exitCode = await runHelpAgent();
 			return;
@@ -45622,12 +45980,14 @@ function registerRunCommand(program, _version = "0.0.0", projectRoot = process.c
 			haltOn: opts.haltOn,
 			costCeiling: opts.costCeiling,
 			probeAuthor: opts.probeAuthor,
-			probeAuthorStateIntegrating: opts.probeAuthorStateIntegrating
+			probeAuthorStateIntegrating: opts.probeAuthorStateIntegrating,
+			nonInteractive: opts.nonInteractive
 		});
+		if (opts.nonInteractive === true) process.exit(exitCode);
 		process.exitCode = exitCode;
 	});
 }
 
 //#endregion
 export { AdapterTelemetryPersistence, AppError, DoltRepoMapMetaRepository, DoltSymbolRepository, ERR_REPO_MAP_STORAGE_WRITE, EpicIngester, GLOBSTAR$1 as GLOBSTAR, GitClient, GrammarLoader, Minimatch$1 as Minimatch, Minipass, RepoMapInjector, RepoMapModule, RepoMapQueryEngine, RepoMapStorage, SymbolParser, createContextCompiler, createDispatcher, createEventEmitter, createImplementationOrchestrator, createPackLoader, createPhaseOrchestrator, createStopAfterGate, createTelemetryAdvisor, escape$1 as escape, formatPhaseCompletionSummary, getFactoryRunSummaries, getScenarioResultsForRun, getTwinRunsForRun, listGraphRuns, normalizeGraphSummaryToStatus, registerExportCommand, registerFactoryCommand, registerRunCommand, registerScenariosCommand, resolveMaxReviewCycles, resolveProbeAuthorStateIntegrating, resolveStoryKeys, runAnalysisPhase, runPlanningPhase, runProbeAuthor, runRunAction, runSolutioningPhase, unescape$1 as unescape, validateStopAfterFromConflict, wireNdjsonEmitter };
-//# sourceMappingURL=run-CHUFlRbH.js.map
+//# sourceMappingURL=run-DzB4rgkj.js.map

package/dist/src/modules/decision-router/index.d.ts

@@ -0,0 +1,88 @@
+//#region src/modules/decision-router/index.d.ts
+/**
+ * Decision Router — Phase D Story 54-2 (2026-04-05): original autonomy-gradient spec.
+ * Story 72-1: --halt-on flag + Decision Router (this file).
+ *   Classifies every halt-able decision by severity and enforces the chosen autonomy policy.
+ *   Exports routeDecision(decision, policy) pure function for orchestrator consumption.
+ * Epic 70: cross-story-race decision types (cross-story-race-recovered,
+ *   cross-story-race-still-failed) motivate the registry pattern — different halt semantics
+ *   based on severity (info vs critical).
+ * Epic 73 (Recovery Engine) will register additional decision types via DECISION_SEVERITY_MAP.
+ *
+ * Story 72-2: --non-interactive flag consuming routeDecision for stdin suppression.
+ * Enables strata + agent-mesh cross-project CI/CD invocation.
+ */
+/**
+ * Severity of a halt-able decision.
+ * Controls which autonomy policies trigger a halt.
+ */
+type Severity = 'info' | 'warning' | 'critical' | 'fatal';
+/**
+ * All known halt-able decision types (AC1).
+ * Epic 73 (Recovery Engine) will extend this union with additional types.
+ */
+type DecisionType = 'cost-ceiling-exhausted' | 'build-verification-failure' | 'recovery-retry-attempt' | 're-scope-proposal' | 'scope-violation' | 'cross-story-race-recovered' | 'cross-story-race-still-failed' | 'pipeline-escalation';
+/**
+ * Maps each known decision type to its severity level.
+ *
+ * Epic 70: cross-story-race-recovered (info — log only, no halt) and
+ * cross-story-race-still-failed (critical — recovery exhausted, halt for operator)
+ * motivate the registry pattern. Epic 73 (Recovery Engine) will register
+ * additional decision types here.
+ */
+declare const DECISION_SEVERITY_MAP: Record<DecisionType, Severity>;
+/**
+ * Route a halt-able decision through the autonomy policy.
+ *
+ * Pure function — no I/O, no side effects. All orchestrator state interactions
+ * remain in orchestrator-impl.ts.
+ *
+ * Halt policy logic (AC4):
+ * - 'all':      halts on info | warning | critical | fatal
+ * - 'critical': halts on critical | fatal  (default)
+ * - 'none':     halts ONLY on fatal (scope violations bypass the autonomy-gradient
+ *               policy — they are always halts regardless of the chosen policy)
+ *
+ * Fatal always halts regardless of policy — hard safety invariant, not configurable.
+ *
+ * Unknown decision types default to severity 'critical' (safe default, AC9e).
+ *
+ * @param decision - The decision type string to route
+ * @param policy   - The autonomy policy from the --halt-on CLI flag
+ * @returns { halt: boolean, defaultAction: string, severity: Severity }
+ */
+declare function routeDecision(decision: string, policy: 'all' | 'critical' | 'none'): {
+  halt: boolean;
+  defaultAction: string;
+  severity: Severity;
+};
+/**
+ * Inputs for exit code derivation from pipeline completion results.
+ * Used by the CLI layer to derive the machine-readable exit code (0/1/2)
+ * for non-interactive CI/CD invocations.
+ */
+interface PipelineOutcome {
+  succeeded: string[];
+  recovered?: string[];
+  escalated: string[];
+  failed: string[];
+  total: number;
+  costCeilingExhausted?: boolean;
+  fatalHaltReached?: boolean;
+  orchestratorDied?: boolean;
+}
+/**
+ * Derive the machine-readable exit code from pipeline completion results.
+ *
+ * - Exit `0` when all stories succeeded (or recovered cleanly)
+ * - Exit `1` when some stories escalated; run completed
+ * - Exit `2` when run-level failure (cost ceiling, fatal halt, orchestrator died, stories failed)
+ *
+ * @param outcome - Pipeline completion outcome data
+ * @returns 0 (success), 1 (escalated), or 2 (failure)
+ */
+declare function deriveExitCode(outcome: PipelineOutcome): 0 | 1 | 2; //#endregion
+
+//# sourceMappingURL=index.d.ts.map
+export { DECISION_SEVERITY_MAP, DecisionType, PipelineOutcome, Severity, deriveExitCode, routeDecision };
+//# sourceMappingURL=index.d.ts.map