substrate-ai 0.13.1 → 0.15.0

package/dist/{run-DDUeFC-I.js → run-bhGoAbu9.js}

@@ -1,7 +1,7 @@
 import { BMAD_BASELINE_TOKENS_FULL, DoltMergeConflict, FileStateStore, STOP_AFTER_VALID_PHASES, STORY_KEY_PATTERN, VALID_PHASES, WorkGraphRepository, __commonJS, __require, __toESM, buildPipelineStatusOutput, createDatabaseAdapter, formatOutput, formatPipelineSummary, formatTokenTelemetry, inspectProcessTree, parseDbTimestampAsUtc, resolveMainRepoRoot, validateStoryKey } from "./health-DswaC1q5.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, 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, createDecision, createPipelineRun, createRequirement, detectInterfaceChanges, getArtifactByTypeForRun, getArtifactsByRun, getDecisionsByCategory, getDecisionsByPhase, getDecisionsByPhaseForRun, getPipelineRunById, getRunningPipelineRuns, getStoryMetricsForRun, getTokenUsageSummary, initSchema, loadModelRoutingConfig, registerArtifact, updatePipelineRun, updatePipelineRunConfig, upsertDecision, writeRunMetrics, writeStoryMetrics } from "./dist-CLvAwmT7.js";
+import { ADVISORY_NOTES, Categorizer, ConsumerAnalyzer, DEFAULT_GLOBAL_SETTINGS, DispatcherImpl, DoltClient, ESCALATION_DIAGNOSIS, 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, getPipelineRunById, getRunningPipelineRuns, getStoryMetricsForRun, getTokenUsageSummary, initSchema, loadModelRoutingConfig, registerArtifact, updatePipelineRun, updatePipelineRunConfig, upsertDecision, writeRunMetrics, writeStoryMetrics } from "./dist-CLvAwmT7.js";
 import { basename, dirname, extname, join } from "path";
 import { access, readFile, readdir, stat } from "fs/promises";
 import { EventEmitter } from "node:events";
@@ -22162,6 +22162,10 @@ var RunStateManager = class {
 */
 function createConvergenceController() {
 	const outcomes = new Map();
+	/** Returns true only when id is non-empty AND exists in graph.nodes. */
+	function isValidTarget(id, graph) {
+		return id !== "" && graph.nodes.has(id);
+	}
 	return {
 		recordOutcome(nodeId, status) {
 			outcomes.set(nodeId, status);
@@ -22177,10 +22181,656 @@ function createConvergenceController() {
 				satisfied: failingNodes.length === 0,
 				failingNodes
 			};
+		},
+		checkGoalGates(graph, runId, eventBus, options) {
+			const failedGates = [];
+			for (const [id, node] of graph.nodes) {
+				if (!node.goalGate) continue;
+				if (options?.satisfactionThreshold !== void 0 && options?.context !== void 0) {
+					const score = options.context.getNumber("satisfaction_score", 0);
+					const satisfied = score >= options.satisfactionThreshold;
+					eventBus?.emit("graph:goal-gate-checked", {
+						runId,
+						nodeId: id,
+						satisfied,
+						score
+					});
+					if (!satisfied) failedGates.push(id);
+				} else {
+					const status = outcomes.get(id);
+					const satisfied = status === "SUCCESS" || status === "PARTIAL_SUCCESS";
+					eventBus?.emit("graph:goal-gate-checked", {
+						runId,
+						nodeId: id,
+						satisfied
+					});
+					if (!satisfied) failedGates.push(id);
+				}
+			}
+			return {
+				satisfied: failedGates.length === 0,
+				failedGates
+			};
+		},
+		resolveRetryTarget(failedNode, graph) {
+			const candidates = [
+				failedNode.retryTarget,
+				failedNode.fallbackRetryTarget,
+				graph.retryTarget,
+				graph.fallbackRetryTarget
+			];
+			for (const candidate of candidates) if (isValidTarget(candidate, graph)) return candidate;
+			return null;
 		}
 	};
 }
 
+//#endregion
+//#region packages/factory/dist/convergence/budget.js
+const DEFAULT_BACKOFF = {
+	initialDelay: 200,
+	factor: 2,
+	maxDelay: 6e4,
+	jitterFactor: .5
+};
+/**
+* Compute the delay (in milliseconds) before the next retry attempt.
+*
+* Formula (before jitter):
+*   `baseDelay = initialDelay * factor^attemptIndex`
+*   `cappedDelay = Math.min(baseDelay, maxDelay)`
+*
+* Jitter:
+*   `jitter = (Math.random() * 2 - 1) * jitterFactor * cappedDelay`
+*   `delay = Math.max(0, Math.round(cappedDelay + jitter))`
+*
+* Passing `{ jitterFactor: 0 }` disables jitter for deterministic tests.
+*
+* @param attemptIndex - Zero-based index of the current attempt (0 = first retry).
+* @param options      - Optional overrides for the backoff parameters.
+*/
+function computeBackoffDelay(attemptIndex, options) {
+	const { initialDelay, factor, maxDelay, jitterFactor } = {
+		...DEFAULT_BACKOFF,
+		...options
+	};
+	const baseDelay = initialDelay * Math.pow(factor, attemptIndex);
+	const cappedDelay = Math.min(baseDelay, maxDelay);
+	const jitter = (Math.random() * 2 - 1) * jitterFactor * cappedDelay;
+	return Math.max(0, Math.round(cappedDelay + jitter));
+}
+/**
+* Determine whether a pipeline is permitted to dispatch the next node.
+*
+* **Unlimited mode:** When `cap === 0` the function returns `{ allowed: true }`
+* immediately, regardless of `accumulatedCost`. This matches the
+* `FactoryConfigSchema` default of `budget_cap_usd: 0` which means "no limit".
+*
+* **Strict greater-than boundary:** Enforcement triggers only when
+* `accumulatedCost > cap`. A cost that exactly equals the cap is still allowed,
+* consistent with the PRD wording "halts *before* dispatching further nodes
+* when accumulated cost **exceeds** the cap."
+*
+* @param accumulatedCost - Total cost (USD) spent so far during this pipeline run.
+* @param cap             - Maximum allowed cost (USD). `0` disables enforcement.
+* @returns `{ allowed: true }` when the pipeline may continue, or
+*          `{ allowed: false, reason: '...' }` when the budget is exhausted.
+*/
+function checkPipelineBudget(accumulatedCost, cap) {
+	if (cap === 0) return { allowed: true };
+	if (accumulatedCost > cap) return {
+		allowed: false,
+		reason: `pipeline budget exhausted: $${accumulatedCost.toFixed(2)} > $${cap.toFixed(2)}`
+	};
+	return { allowed: true };
+}
+/**
+* Tracks accumulated cost for a single pipeline run and enforces a configurable
+* spending cap via `checkPipelineBudget`.
+*
+* **Lifecycle:** Create one instance per pipeline run. Story 45-8 will call
+* `addCost()` after each node dispatch completes and `checkBudget()` before
+* the next dispatch. Call `reset()` between pipeline runs or in tests to clear
+* accumulated state.
+*/
+var PipelineBudgetManager = class {
+	totalCost = 0;
+	/**
+	* Add `amount` USD to the running total for this pipeline run.
+	*
+	* @param amount - Cost (USD) for the just-completed node dispatch.
+	*/
+	addCost(amount) {
+		this.totalCost += amount;
+	}
+	/**
+	* Return the total cost (USD) accumulated so far during this pipeline run.
+	*/
+	getTotalCost() {
+		return this.totalCost;
+	}
+	/**
+	* Reset the accumulated cost to zero.
+	* Useful for test isolation and future pipeline reuse scenarios.
+	*/
+	reset() {
+		this.totalCost = 0;
+	}
+	/**
+	* Determine whether the pipeline may dispatch the next node, delegating to
+	* `checkPipelineBudget` with the current accumulated cost.
+	*
+	* @param cap - Maximum allowed cost (USD). `0` disables enforcement.
+	*/
+	checkBudget(cap) {
+		return checkPipelineBudget(this.totalCost, cap);
+	}
+};
+/**
+* Determine whether a pipeline session is permitted to dispatch the next node
+* based on wall-clock elapsed time.
+*
+* **Unlimited mode:** When `capMs === 0` the function returns `{ allowed: true }`
+* immediately, regardless of `elapsedMs`. This matches the `FactoryConfigSchema`
+* default of `wall_clock_cap_seconds: 0` which means "no limit".
+*
+* **Strict greater-than boundary:** Enforcement triggers only when
+* `elapsedMs > capMs`. An elapsed time that exactly equals the cap is still
+* allowed, consistent with the PRD wording "halts *before* dispatching further
+* nodes when elapsed time **exceeds** the cap."
+*
+* @param elapsedMs - Milliseconds elapsed since the pipeline session started.
+* @param capMs     - Maximum allowed elapsed time in milliseconds. `0` disables
+*                    enforcement (unlimited mode).
+* @returns `{ allowed: true }` when the session may continue, or
+*          `{ allowed: false, reason: 'wall clock budget exhausted' }` when the
+*          cap has been exceeded.
+*/
+function checkSessionBudget(elapsedMs, capMs) {
+	if (capMs === 0) return { allowed: true };
+	if (elapsedMs > capMs) return {
+		allowed: false,
+		reason: "wall clock budget exhausted"
+	};
+	return { allowed: true };
+}
+/**
+* Tracks wall-clock elapsed time for a single pipeline session and enforces a
+* configurable time cap via `checkSessionBudget`.
+*
+* **Lifecycle:** Create one instance per pipeline run, constructed at pipeline
+* launch. Story 45-8 will call `checkBudget()` before each node dispatch as
+* the highest-priority budget check (before `PipelineBudgetManager`).
+* Call `reset()` between pipeline runs or in tests for
+* isolation.
+*
+* **Cap 0 means unlimited:** A `capSeconds` value of `0` passed to `checkBudget`
+* disables all wall-clock enforcement and always returns `{ allowed: true }`.
+*/
+var SessionBudgetManager = class {
+	startTime;
+	constructor() {
+		this.startTime = Date.now();
+	}
+	/**
+	* Return the number of milliseconds elapsed since this manager was constructed
+	* (or since the last `reset()` call). Always returns a non-negative number.
+	*/
+	getElapsedMs() {
+		return Date.now() - this.startTime;
+	}
+	/**
+	* Reset the session start timestamp to the current time. Subsequent calls to
+	* `getElapsedMs()` will measure from this new baseline. Useful for test
+	* isolation and future pipeline reuse scenarios.
+	*/
+	reset() {
+		this.startTime = Date.now();
+	}
+	/**
+	* Determine whether the pipeline session may dispatch the next node, delegating
+	* to `checkSessionBudget` with the current elapsed time converted from seconds
+	* to milliseconds.
+	*
+	* @param capSeconds - Maximum allowed elapsed time in **seconds** (as stored in
+	*                     `FactoryConfig.wall_clock_cap_seconds`). A value of `0`
+	*                     disables enforcement.
+	*/
+	checkBudget(capSeconds) {
+		return checkSessionBudget(this.getElapsedMs(), capSeconds * 1e3);
+	}
+};
+
+//#endregion
+//#region packages/factory/dist/convergence/plateau.js
+/**
+* Plateau detection for the convergence loop.
+* Story 45-6: provides pure plateau detection primitives — no I/O, no side effects.
+*
+* Algorithm: Track the last N satisfaction scores (N = `window`, default 3).
+* If max−min of the window falls strictly below threshold, declare plateau.
+*
+* Consumed by:
+*   - Story 45-8 (convergence controller integration)
+*/
+const DEFAULT_WINDOW = 3;
+const DEFAULT_THRESHOLD = .05;
+/**
+* Create a new PlateauDetector with the given options.
+*
+* **Defaults:** `window=3`, `threshold=0.05` — matching `FactoryConfigSchema.plateau_window`
+* and `FactoryConfigSchema.plateau_threshold`. Story 45-8 will read these values from
+* `FactoryConfig` and pass them in.
+*
+* **Insufficient-data guard:** `isPlateaued()` always returns `false` when fewer than
+* `window` scores have been recorded. A plateau can only be declared once the window is full.
+*
+* @param options - Optional configuration for window size and threshold.
+*/
+function createPlateauDetector(options) {
+	const window = options?.window ?? DEFAULT_WINDOW;
+	const threshold = options?.threshold ?? DEFAULT_THRESHOLD;
+	let scores = [];
+	return {
+		recordScore(_iteration, score) {
+			scores.push(score);
+			scores = scores.slice(-window);
+		},
+		isPlateaued() {
+			if (scores.length < window) return false;
+			const delta = Math.max(...scores) - Math.min(...scores);
+			return delta < threshold;
+		},
+		getWindow() {
+			return window;
+		},
+		getScores() {
+			return [...scores];
+		}
+	};
+}
+/**
+* Check whether the detector has reached a plateau and, if so, emit the
+* `convergence:plateau-detected` event on the provided event bus.
+*
+* This mirrors the `checkGoalGates()` pattern:
+* - Pure detection is isolated in `PlateauDetector` (no side effects).
+* - Event emission is isolated here in this wrapper.
+* - Callers may omit `eventBus` for pure check behavior (no event is emitted).
+*
+* @param detector - A `PlateauDetector` instance.
+* @param context  - Run/node identifiers and an optional event bus.
+* @returns `{ plateaued: true, scores }` with event emitted when plateaued;
+*          `{ plateaued: false, scores }` with no event emitted otherwise.
+*/
+function checkPlateauAndEmit(detector, context) {
+	const { runId, nodeId, eventBus } = context;
+	const scores = detector.getScores();
+	if (detector.isPlateaued()) {
+		eventBus?.emit("convergence:plateau-detected", {
+			runId,
+			nodeId,
+			scores,
+			window: detector.getWindow()
+		});
+		return {
+			plateaued: true,
+			scores
+		};
+	}
+	return {
+		plateaued: false,
+		scores
+	};
+}
+
+//#endregion
+//#region packages/factory/dist/convergence/remediation.js
+/**
+* Remediation context injection for the convergence loop.
+* Story 45-7: builds structured remediation context from failure data and
+* injects it into a retried node's IGraphContext.
+*
+* Architecture reference: Section 6.5 — Remediation Context fields
+*
+* Pure functions (`formatScenarioDiff`, `deriveFixScope`, `buildRemediationContext`)
+* have no I/O and no side effects.
+* Only `injectRemediationContext` mutates state (the IGraphContext).
+*
+* Consumed by:
+*   - Story 45-8 (convergence controller integration with executor)
+*   - CodergenBackend handlers (via `getRemediationContext`)
+*/
+/**
+* The agreed key under which remediation context is stored in `IGraphContext`.
+* Namespaced under `convergence.` to avoid collision with user-defined context keys.
+* Story 45-8 writes this key; CodergenBackend handlers read it via `getRemediationContext()`.
+*/
+const REMEDIATION_CONTEXT_KEY = "convergence.remediation";
+/**
+* Formats a human-readable diff of failed scenarios from a ScenarioRunResult.
+*
+* This is a pure formatting function with no side effects. For each failed
+* scenario it produces a line `"- {name}: {stderr || stdout || '(no output)'}"`,
+* preferring stderr (most useful for debugging), falling back to stdout
+* (some tools write errors to stdout), then to the literal `'(no output)'`.
+*
+* Returns `"All scenarios passed"` when there are no failures.
+*/
+function formatScenarioDiff(results) {
+	const failed = results.scenarios.filter((s$1) => s$1.status === "fail");
+	if (failed.length === 0) return "All scenarios passed";
+	const lines = failed.map((s$1) => {
+		const output = s$1.stderr || s$1.stdout || "(no output)";
+		return `- ${s$1.name}: ${output}`;
+	});
+	return lines.join("\n");
+}
+/**
+* Derives a focused fix instruction string from failed scenarios.
+*
+* This function produces human-readable fix instructions for the retried agent.
+* Returns `"Fix {n} failing scenario{s}: {name1}, {name2}, ..."` when there are
+* failures, or `""` when all scenarios pass.
+*
+* Pluralization: singular "scenario" when n === 1, plural "scenarios" otherwise.
+*/
+function deriveFixScope(results) {
+	const failed = results.scenarios.filter((s$1) => s$1.status === "fail");
+	if (failed.length === 0) return "";
+	const n$1 = failed.length;
+	const plural = n$1 === 1 ? "scenario" : "scenarios";
+	const names = failed.map((s$1) => s$1.name).join(", ");
+	return `Fix ${n$1} failing ${plural}: ${names}`;
+}
+/**
+* Builds a complete `RemediationContext` from the provided parameters.
+*
+* `scenarioResults` is optional — first-iteration retries may not have scenario
+* data yet. When omitted, `scenarioDiff` defaults to
+* `"No scenario results available"` and `fixScope` defaults to `""`.
+*
+* Stores `satisfactionScoreHistory` as a defensive copy (`[...params.satisfactionScoreHistory]`)
+* so external mutation of the caller's array does not corrupt the stored history.
+*/
+function buildRemediationContext(params) {
+	const scenarioDiff = params.scenarioResults ? formatScenarioDiff(params.scenarioResults) : "No scenario results available";
+	const fixScope = params.scenarioResults ? deriveFixScope(params.scenarioResults) : "";
+	return {
+		previousFailureReason: params.previousFailureReason,
+		scenarioDiff,
+		iterationCount: params.iterationCount,
+		satisfactionScoreHistory: [...params.satisfactionScoreHistory],
+		fixScope
+	};
+}
+/**
+* Injects a `RemediationContext` into an `IGraphContext` under `REMEDIATION_CONTEXT_KEY`.
+*
+* Called by the executor's retry loop before dispatching to the retried node —
+* story 45-8 wires this call into the graph executor.
+*/
+function injectRemediationContext(context, remediation) {
+	context.set(REMEDIATION_CONTEXT_KEY, remediation);
+}
+
+//#endregion
+//#region packages/factory/dist/convergence/dual-signal.js
+/**
+* Dual-signal coordinator — evaluates code review and scenario signals together.
+*
+* Code review is the authoritative Phase 2 decision-maker.
+* Scenario score is a parallel signal used for monitoring and agreement tracking.
+*
+* Story 46-5.
+*/
+/**
+* Context key under which code review handlers store their verdict.
+* Used by the executor to read the verdict when emitting advisory events.
+* Story 46-6.
+*/
+const CONTEXT_KEY_CODE_REVIEW_VERDICT = "factory.codeReviewVerdict";
+/**
+* Evaluate dual signals without side effects.
+*
+* `SHIP_IT` and `LGTM_WITH_NOTES` are treated as code review passes.
+* Code review verdict is always the authoritative decision.
+*/
+function evaluateDualSignal(verdict, score, threshold) {
+	const codeReviewPassed = verdict === "SHIP_IT" || verdict === "LGTM_WITH_NOTES";
+	const scenarioPassed = score >= threshold;
+	const agreement = codeReviewPassed === scenarioPassed ? "AGREE" : "DISAGREE";
+	return {
+		codeReviewPassed,
+		scenarioPassed,
+		agreement,
+		authoritativeDecision: verdict,
+		score,
+		threshold
+	};
+}
+/**
+* Create a DualSignalCoordinator that evaluates signals and emits
+* `scenario:score-computed` events on each call.
+*
+* When `options.qualityMode === 'scenario-primary'`, also emits
+* `scenario:advisory-computed` with the code review verdict as advisory info.
+* Story 46-6.
+*/
+function createDualSignalCoordinator(options) {
+	return { evaluate(verdict, score, runId) {
+		const result = evaluateDualSignal(verdict, score, options.threshold);
+		options.eventBus.emit("scenario:score-computed", {
+			runId,
+			score: result.score,
+			threshold: result.threshold,
+			passes: result.scenarioPassed,
+			agreement: result.agreement,
+			codeReviewPassed: result.codeReviewPassed,
+			scenarioPassed: result.scenarioPassed,
+			authoritativeDecision: result.authoritativeDecision
+		});
+		if (options.qualityMode === "scenario-primary") options.eventBus.emit("scenario:advisory-computed", {
+			runId,
+			verdict: result.authoritativeDecision,
+			codeReviewPassed: result.codeReviewPassed,
+			score: result.score,
+			threshold: result.threshold,
+			agreement: result.agreement
+		});
+		return result;
+	} };
+}
+
+//#endregion
+//#region packages/factory/dist/scenarios/scorer.js
+/**
+* Compute a satisfaction score from a ScenarioRunResult.
+*
+* All scenarios are weighted equally (weight 1.0). The result includes a
+* `breakdown` array with one entry per scenario (added in Epic 46, story 46-1).
+*
+* @param result    - The aggregated scenario run result.
+* @param threshold - Minimum score to consider passing (default 0.8).
+* @returns A SatisfactionScore with score, passes, threshold, and breakdown.
+*/
+function computeSatisfactionScore(result, threshold = .8) {
+	const scenarios = result.scenarios;
+	const totalWeight = scenarios.length;
+	const breakdown = scenarios.map((s$1) => {
+		const passed$1 = s$1.status === "pass";
+		const contribution = totalWeight > 0 ? passed$1 ? 1 / totalWeight : 0 : 0;
+		return {
+			name: s$1.name,
+			passed: passed$1,
+			weight: 1,
+			contribution
+		};
+	});
+	const { total, passed } = result.summary;
+	const score = total === 0 ? 0 : passed / total;
+	return {
+		score,
+		passes: score >= threshold,
+		threshold,
+		breakdown
+	};
+}
+
+//#endregion
+//#region packages/factory/dist/persistence/factory-queries.js
+/**
+* Factory persistence query functions for graph runs, node results, and scenario results.
+*
+* All functions accept a DatabaseAdapter as first argument, follow the established
+* pattern from @substrate-ai/core's metrics queries, and use portable SQL patterns
+* (select-then-delete-then-insert in transactions) compatible with both
+* InMemoryDatabaseAdapter and DoltDatabaseAdapter.
+*
+* Story 46-3: Score Persistence to Database.
+*/
+/**
+* Insert or replace a graph_runs row.
+*
+* Uses portable select-then-delete-then-insert pattern inside a transaction
+* (not INSERT OR REPLACE which is SQLite-specific).
+*
+* - First call (status: 'running'): inserts the row.
+* - Second call (status: 'completed'/'failed'): deletes the old row and inserts
+*   the updated row with completion details.
+*/
+async function upsertGraphRun(adapter, input) {
+	await adapter.transaction(async (tx) => {
+		const existing = await tx.query("SELECT id FROM graph_runs WHERE id = ?", [input.id]);
+		if (existing.length > 0) await tx.query("DELETE FROM graph_runs WHERE id = ?", [input.id]);
+		await tx.query(`INSERT INTO graph_runs (
+        id, graph_file, graph_goal, status, started_at, completed_at,
+        total_cost_usd, node_count, final_outcome, checkpoint_path
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+			input.id,
+			input.graph_file,
+			input.graph_goal ?? null,
+			input.status,
+			input.started_at,
+			input.completed_at ?? null,
+			input.total_cost_usd ?? 0,
+			input.node_count ?? 0,
+			input.final_outcome ?? null,
+			input.checkpoint_path ?? null
+		]);
+	});
+}
+/**
+* Append a graph_node_results row for a single node execution attempt.
+*
+* Each attempt is a distinct row — no upsert needed since run_id + node_id + attempt
+* together uniquely identify each record.
+*/
+async function insertGraphNodeResult(adapter, input) {
+	await adapter.transaction(async (tx) => {
+		await tx.query(`INSERT INTO graph_node_results (
+        run_id, node_id, attempt, status, started_at, completed_at,
+        duration_ms, cost_usd, failure_reason, context_snapshot
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+			input.run_id,
+			input.node_id,
+			input.attempt,
+			input.status,
+			input.started_at,
+			input.completed_at ?? null,
+			input.duration_ms ?? null,
+			input.cost_usd ?? 0,
+			input.failure_reason ?? null,
+			input.context_snapshot ?? null
+		]);
+	});
+}
+/**
+* Append a scenario_results row for a single scenario run iteration.
+*
+* The `details` field (score breakdown) should be serialized as JSON string
+* before calling this function, or passed raw if already serialized.
+*/
+async function insertScenarioResult(adapter, input) {
+	await adapter.transaction(async (tx) => {
+		await tx.query(`INSERT INTO scenario_results (
+        run_id, node_id, iteration, total_scenarios, passed, failed,
+        satisfaction_score, threshold, passes, details, executed_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+			input.run_id,
+			input.node_id,
+			input.iteration,
+			input.total_scenarios,
+			input.passed,
+			input.failed,
+			input.satisfaction_score,
+			input.threshold,
+			input.passes ? 1 : 0,
+			input.details ?? null,
+			input.executed_at ?? new Date().toISOString()
+		]);
+	});
+}
+/**
+* Retrieve all scenario results for a given run, ordered by iteration ascending.
+*
+* @returns Array of ScenarioResultRow ordered by iteration. Empty array if none exist.
+*/
+async function getScenarioResultsForRun(adapter, runId) {
+	const rows = await adapter.query("SELECT * FROM scenario_results WHERE run_id = ? ORDER BY iteration ASC", [runId]);
+	return rows.map((row) => ({
+		...row,
+		passes: Boolean(row.passes)
+	}));
+}
+/**
+* List graph run records in descending started_at order.
+*
+* @param limit - Maximum number of rows to return (default 20).
+*/
+async function listGraphRuns(adapter, limit = 20) {
+	return adapter.query("SELECT * FROM graph_runs ORDER BY started_at DESC LIMIT ?", [limit]);
+}
+/**
+* Retrieve a summarized list of factory graph runs, enriched with per-run
+* iteration counts and latest satisfaction scores from `scenario_results`.
+*
+* Uses two queries (not a JOIN) for portability across adapters:
+* 1. SELECT from graph_runs ordered by started_at DESC
+* 2. GROUP BY aggregation on scenario_results for iteration counts and scores
+*
+* @param adapter - Database adapter (already opened)
+* @param limit   - Maximum number of graph runs to return (default 20)
+* @returns Array of FactoryRunSummary ordered by started_at DESC; empty array on error
+*/
+async function getFactoryRunSummaries(adapter, limit = 20) {
+	const runs = await adapter.query("SELECT id, started_at, completed_at, total_cost_usd, final_outcome FROM graph_runs ORDER BY started_at DESC LIMIT ?", [limit]);
+	if (runs.length === 0) return [];
+	const scenarioAgg = await adapter.query("SELECT run_id, COUNT(*) as iterations, MAX(satisfaction_score) as satisfaction_score FROM scenario_results GROUP BY run_id", []);
+	const latestPassesRows = await adapter.query("SELECT s.run_id, s.passes FROM scenario_results s INNER JOIN (SELECT run_id, MAX(iteration) AS max_iter FROM scenario_results GROUP BY run_id) latest ON s.run_id = latest.run_id AND s.iteration = latest.max_iter", []);
+	const scenarioMap = new Map();
+	for (const row of scenarioAgg) scenarioMap.set(row.run_id, {
+		iterations: row.iterations,
+		satisfaction_score: row.satisfaction_score
+	});
+	const latestPassesMap = new Map();
+	for (const row of latestPassesRows) latestPassesMap.set(row.run_id, row.passes !== 0);
+	return runs.map((run) => {
+		const agg = scenarioMap.get(run.id);
+		return {
+			run_id: run.id,
+			satisfaction_score: agg !== void 0 ? agg.satisfaction_score : null,
+			iterations: agg !== void 0 ? agg.iterations : 0,
+			convergence_status: run.final_outcome,
+			started_at: run.started_at,
+			completed_at: run.completed_at,
+			total_cost_usd: run.total_cost_usd,
+			type: "factory",
+			passes: latestPassesMap.has(run.id) ? latestPassesMap.get(run.id) ?? null : null
+		};
+	});
+}
+
 //#endregion
 //#region packages/factory/dist/graph/executor.js
 /**
@@ -22220,17 +22870,6 @@ function normalizeOutcomeStatus(raw) {
 	};
 }
 /**
-* Compute exponential backoff delay with ±50% jitter.
-*
-* @param attempt - Zero-indexed attempt number (0 = first retry, 1 = second, etc.)
-* @returns Delay in milliseconds, floored at 0 and capped at 60,000ms
-*/
-function computeBackoffDelay(attempt) {
-	const rawDelay = Math.min(200 * Math.pow(2, attempt), 6e4);
-	const jitter = rawDelay * .5 * (2 * Math.random() - 1);
-	return Math.max(0, rawDelay + jitter);
-}
-/**
 * Dispatch a node handler with exponential backoff retry on FAIL outcomes.
 *
 * Emits `graph:node-retried` before each retry attempt.
@@ -22289,6 +22928,31 @@ function createGraphExecutor() {
 		const checkpointManager = new CheckpointManager();
 		const checkpointFilePath = path.join(config.logsRoot, "checkpoint.json");
 		const controller = createConvergenceController();
+		const sessionManager = new SessionBudgetManager();
+		const pipelineManager = new PipelineBudgetManager();
+		const plateauDetector = createPlateauDetector({
+			...config.plateauWindow !== void 0 ? { window: config.plateauWindow } : {},
+			...config.plateauThreshold !== void 0 ? { threshold: config.plateauThreshold } : {}
+		});
+		let convergenceIteration = 0;
+		const runStartedAt = new Date().toISOString();
+		let lastScenarioNodeId = "";
+		const persistExit = async (finalStatus, finalOutcome) => {
+			if (!config.adapter) return;
+			try {
+				await upsertGraphRun(config.adapter, {
+					id: config.runId,
+					graph_file: graph.id || config.runId,
+					...graph.goal ? { graph_goal: graph.goal } : {},
+					status: finalStatus,
+					started_at: runStartedAt,
+					completed_at: new Date().toISOString(),
+					final_outcome: finalOutcome,
+					total_cost_usd: pipelineManager.getTotalCost(),
+					node_count: graph.nodes.size
+				});
+			} catch {}
+		};
 		let completedNodes = [];
 		let nodeRetries = {};
 		let context = new GraphContext();
@@ -22302,6 +22966,40 @@ function createGraphExecutor() {
 		if (config.scenarioStore) scenarioManifest = await config.scenarioStore.discover();
 		const runStateManager = config.dotSource ? new RunStateManager({ runDir: config.logsRoot }) : null;
 		if (runStateManager) await runStateManager.initRun(config.dotSource);
+		if (config.adapter && config.eventBus) {
+			const persistAdapter = config.adapter;
+			const scenarioHandler = (payload) => {
+				const threshold = config.satisfactionThreshold ?? .8;
+				const scored = computeSatisfactionScore(payload.results, threshold);
+				insertScenarioResult(persistAdapter, {
+					run_id: config.runId,
+					node_id: lastScenarioNodeId || "unknown",
+					iteration: payload.iteration,
+					total_scenarios: payload.results.summary.total,
+					passed: payload.results.summary.passed,
+					failed: payload.results.summary.failed,
+					satisfaction_score: scored.score,
+					threshold: scored.threshold,
+					passes: scored.passes,
+					details: JSON.stringify(scored.breakdown),
+					executed_at: new Date().toISOString()
+				}).catch((err) => {
+					const msg = err instanceof Error ? err.message : String(err);
+					console.debug(`[executor] scenario:completed persistence failed for run ${config.runId}: ${msg}`);
+				});
+			};
+			config.eventBus.on("scenario:completed", scenarioHandler);
+		}
+		if (config.adapter) try {
+			await upsertGraphRun(config.adapter, {
+				id: config.runId,
+				graph_file: graph.id || config.runId,
+				...graph.goal ? { graph_goal: graph.goal } : {},
+				status: "running",
+				started_at: runStartedAt,
+				node_count: graph.nodes.size
+			});
+		} catch {}
 		let currentNode;
 		if (config.checkpointPath) {
 			const checkpoint = await checkpointManager.load(config.checkpointPath);
@@ -22328,32 +23026,102 @@ function createGraphExecutor() {
 			}
 		} else currentNode = graph.startNode();
 		while (true) {
+			const sessionResult = sessionManager.checkBudget((config.wallClockCapMs ?? 0) / 1e3);
+			if (!sessionResult.allowed) {
+				config.eventBus?.emit("convergence:budget-exhausted", {
+					runId: config.runId,
+					level: "session",
+					reason: sessionResult.reason
+				});
+				await persistExit("failed", `Session budget exceeded: ${sessionResult.reason}`);
+				return {
+					status: "FAIL",
+					failureReason: `Session budget exceeded: ${sessionResult.reason}`
+				};
+			}
+			const pipelineResult = pipelineManager.checkBudget(config.pipelineBudgetCapUsd ?? 0);
+			if (!pipelineResult.allowed) {
+				config.eventBus?.emit("convergence:budget-exhausted", {
+					runId: config.runId,
+					level: "pipeline",
+					reason: pipelineResult.reason
+				});
+				await persistExit("failed", `Pipeline budget exceeded: ${pipelineResult.reason}`);
+				return {
+					status: "FAIL",
+					failureReason: `Pipeline budget exceeded: ${pipelineResult.reason}`
+				};
+			}
 			const exitNode = graph.exitNode();
 			if (currentNode.id === exitNode.id) {
-				const gateResult = controller.evaluateGates(graph);
+				const useScenarioPrimary = config.qualityMode === "scenario-primary";
+				const gateResult = controller.checkGoalGates(graph, config.runId, config.eventBus, useScenarioPrimary || config.satisfactionThreshold !== void 0 ? {
+					context,
+					satisfactionThreshold: config.satisfactionThreshold ?? .8
+				} : void 0);
+				if (useScenarioPrimary && config.eventBus) {
+					const rawVerdict = context.getString(CONTEXT_KEY_CODE_REVIEW_VERDICT, "");
+					if (rawVerdict !== "") {
+						const codeReviewVerdict = rawVerdict;
+						const coordinator = createDualSignalCoordinator({
+							eventBus: config.eventBus,
+							threshold: config.satisfactionThreshold ?? .8,
+							qualityMode: "scenario-primary"
+						});
+						const score = context.getNumber("satisfaction_score", 0);
+						coordinator.evaluate(codeReviewVerdict, score, config.runId);
+					}
+				}
 				if (!gateResult.satisfied) {
-					const failingNodeId = gateResult.failingNodes[0];
+					const failingNodeId = gateResult.failedGates[0];
 					const failingGateNode = graph.nodes.get(failingNodeId);
-					const retryTarget = failingGateNode?.retryTarget || failingGateNode?.fallbackRetryTarget || graph.retryTarget || graph.fallbackRetryTarget;
-					if (retryTarget) {
-						const retryNode = graph.nodes.get(retryTarget);
-						if (!retryNode) throw new Error(`Retry target node "${retryTarget}" not found in graph`);
-						currentNode = retryNode;
-						continue;
+					const retryTargetId = failingGateNode ? controller.resolveRetryTarget(failingGateNode, graph) : null;
+					if (!retryTargetId) {
+						await persistExit("failed", "Goal gate failed: no retry target");
+						return {
+							status: "FAIL",
+							failureReason: "Goal gate failed: no retry target"
+						};
 					}
-					return {
-						status: "FAIL",
-						failureReason: "Goal gate failed: no retry target"
-					};
+					const retryNode = graph.nodes.get(retryTargetId);
+					if (!retryNode) throw new Error(`Retry target node "${retryTargetId}" not found in graph`);
+					convergenceIteration++;
+					const satisfactionScore = context.getNumber("satisfaction_score", 0);
+					plateauDetector.recordScore(convergenceIteration, satisfactionScore);
+					const plateauResult = checkPlateauAndEmit(plateauDetector, {
+						runId: config.runId,
+						nodeId: retryTargetId,
+						...config.eventBus ? { eventBus: config.eventBus } : {}
+					});
+					if (plateauResult.plateaued) {
+						await persistExit("failed", `Convergence plateau detected after ${convergenceIteration} iteration(s)`);
+						return {
+							status: "FAIL",
+							failureReason: `Convergence plateau detected after ${convergenceIteration} iteration(s): scores plateaued at [${plateauResult.scores.join(", ")}]`
+						};
+					}
+					const remediation = buildRemediationContext({
+						previousFailureReason: `Goal gate unsatisfied: ${gateResult.failedGates.join(", ")}`,
+						iterationCount: convergenceIteration,
+						satisfactionScoreHistory: plateauResult.scores
+					});
+					injectRemediationContext(context, remediation);
+					skipCycleCheck = true;
+					currentNode = retryNode;
+					continue;
 				}
+				await persistExit("completed", "SUCCESS");
 				return { status: "SUCCESS" };
 			}
 			if (resumeCompletedSet?.has(currentNode.id)) {
 				const skipEdge = selectEdge(currentNode, { status: "SUCCESS" }, context, graph);
-				if (!skipEdge) return {
-					status: "FAIL",
-					failureReason: `No outgoing edge from node ${currentNode.id}`
-				};
+				if (!skipEdge) {
+					await persistExit("failed", `No outgoing edge from node ${currentNode.id}`);
+					return {
+						status: "FAIL",
+						failureReason: `No outgoing edge from node ${currentNode.id}`
+					};
+				}
 				config.eventBus?.emit("graph:edge-selected", {
 					runId: config.runId,
 					fromNode: currentNode.id,
@@ -22381,6 +23149,7 @@ function createGraphExecutor() {
 						nodeId: currentNode.id,
 						tampered: integrityResult.tampered
 					});
+					await persistExit("failed", `Scenario integrity violation before node "${currentNode.id}"`);
 					return {
 						status: "FAIL",
 						failureReason: `Scenario integrity violation detected before node "${currentNode.id}": tampered files: ${integrityResult.tampered.join(", ")}`
@@ -22392,6 +23161,7 @@ function createGraphExecutor() {
 					scenarioCount: scenarioManifest.scenarios.length
 				});
 			}
+			lastScenarioNodeId = currentNode.id;
 			config.eventBus?.emit("graph:node-started", {
 				runId: config.runId,
 				nodeId: currentNode.id,
@@ -22441,6 +23211,24 @@ function createGraphExecutor() {
 				controller.recordOutcome(nodeToDispatch.id, controllerStatus);
 			}
 			if (outcome.contextUpdates) for (const [key, value] of Object.entries(outcome.contextUpdates)) context.set(key, value);
+			const nodeCost = context.getNumber("factory.lastNodeCostUsd", 0);
+			if (nodeCost > 0) pipelineManager.addCost(nodeCost);
+			if (config.adapter) {
+				const nodeCompletedAt = Date.now();
+				try {
+					await insertGraphNodeResult(config.adapter, {
+						run_id: config.runId,
+						node_id: nodeToDispatch.id,
+						attempt: (nodeRetries[nodeToDispatch.id] ?? 0) + 1,
+						status: outcome.status,
+						started_at: new Date(startedAt).toISOString(),
+						completed_at: new Date(nodeCompletedAt).toISOString(),
+						duration_ms: nodeCompletedAt - startedAt,
+						cost_usd: nodeCost,
+						...outcome.failureReason !== void 0 ? { failure_reason: outcome.failureReason } : {}
+					});
+				} catch {}
+			}
 			if (!skipCompletedPush) completedNodes.push(currentNode.id);
 			skipCompletedPush = false;
 			await checkpointManager.save(config.logsRoot, {
@@ -22455,7 +23243,7 @@ function createGraphExecutor() {
 				checkpointPath: checkpointFilePath
 			});
 			if (outcome.status === "FAIL") {
-				const retryTarget = currentNode.retryTarget || currentNode.fallbackRetryTarget || graph.retryTarget || graph.fallbackRetryTarget;
+				const retryTarget = controller.resolveRetryTarget(currentNode, graph);
 				if (retryTarget) {
 					const retryNode = graph.nodes.get(retryTarget);
 					if (!retryNode) throw new Error(`Retry target node "${retryTarget}" not found in graph`);
@@ -22463,16 +23251,20 @@ function createGraphExecutor() {
 					currentNode = retryNode;
 					continue;
 				}
+				await persistExit("failed", outcome.failureReason ?? "FAIL");
 				return {
 					status: "FAIL",
 					...outcome.failureReason !== void 0 && { failureReason: outcome.failureReason }
 				};
 			}
 			const edge = selectEdge(currentNode, outcome, context, graph);
-			if (!edge) return {
-				status: "FAIL",
-				failureReason: `No outgoing edge from node ${currentNode.id}`
-			};
+			if (!edge) {
+				await persistExit("failed", `No outgoing edge from node ${currentNode.id}`);
+				return {
+					status: "FAIL",
+					failureReason: `No outgoing edge from node ${currentNode.id}`
+				};
+			}
 			config.eventBus?.emit("graph:edge-selected", {
 				runId: config.runId,
 				fromNode: currentNode.id,
@@ -22706,33 +23498,6 @@ function createCodergenHandler(options) {
 	};
 }
 
-//#endregion
-//#region packages/factory/dist/scenarios/scorer.js
-/**
-* SatisfactionScorer — computes a satisfaction score from ScenarioRunResult.
-*
-* Score = passed / total (0.0 when total === 0).
-* Passes = score >= threshold (default 0.8).
-*
-* Story 44-5.
-*/
-/**
-* Compute a satisfaction score from a ScenarioRunResult.
-*
-* @param result    - The aggregated scenario run result.
-* @param threshold - Minimum score to consider passing (default 0.8).
-* @returns A SatisfactionScore with score, passes, and threshold.
-*/
-function computeSatisfactionScore(result, threshold = .8) {
-	const { total, passed } = result.summary;
-	const score = total === 0 ? 0 : passed / total;
-	return {
-		score,
-		passes: score >= threshold,
-		threshold
-	};
-}
-
 //#endregion
 //#region packages/factory/dist/handlers/tool.js
 /**
@@ -22783,7 +23548,7 @@ function createToolHandler(options) {
 						parsed = JSON.parse(stdoutBuf.trim());
 					} catch {}
 					if (isScenarioRunResult(parsed)) {
-						const scored = computeSatisfactionScore(parsed);
+						const scored = computeSatisfactionScore(parsed, options?.satisfactionThreshold);
 						resolve$2({
 							status: "SUCCESS",
 							contextUpdates: { satisfaction_score: scored.score }
@@ -27738,7 +28503,13 @@ const FactoryConfigSchema = z.object({
 	wall_clock_cap_seconds: z.number().min(0).default(0),
 	plateau_window: z.number().int().min(2).default(3),
 	plateau_threshold: z.number().min(0).max(1).default(.05),
-	backend: z.enum(["cli", "direct"]).default("cli")
+	backend: z.enum(["cli", "direct"]).default("cli"),
+	quality_mode: z.enum([
+		"code-review",
+		"dual-signal",
+		"scenario-primary",
+		"scenario-only"
+	]).default("dual-signal")
 }).strict();
 /**
 * Extends SubstrateConfigSchema with an optional `factory:` section.
@@ -27776,6 +28547,71 @@ async function loadFactoryConfig(projectDir, explicitConfigPath) {
 	});
 }
 
+//#endregion
+//#region packages/factory/dist/persistence/factory-schema.js
+/**
+* Factory schema DDL for graph execution and scenario validation tables.
+* Companion to `@substrate-ai/core`'s `initSchema` — call both during factory initialization.
+*/
+/**
+* Initialize all factory-specific persistence tables on the given adapter.
+* Idempotent — safe to call multiple times.
+*
+* Creates:
+*   - graph_runs: top-level graph execution run records
+*   - graph_node_results: per-node execution results within a run
+*   - scenario_results: scenario validation outcomes within a run
+*/
+async function factorySchema(adapter) {
+	await adapter.exec(`
+    CREATE TABLE IF NOT EXISTS graph_runs (
+      id              VARCHAR(255) PRIMARY KEY,
+      graph_file      TEXT NOT NULL,
+      graph_goal      TEXT,
+      status          VARCHAR(32) NOT NULL DEFAULT 'running',
+      started_at      DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+      completed_at    DATETIME,
+      total_cost_usd  DOUBLE NOT NULL DEFAULT 0.0,
+      node_count      INTEGER NOT NULL DEFAULT 0,
+      final_outcome   VARCHAR(32),
+      checkpoint_path TEXT
+    )
+  `);
+	await adapter.exec(`
+    CREATE TABLE IF NOT EXISTS graph_node_results (
+      id               INTEGER PRIMARY KEY AUTOINCREMENT,
+      run_id           VARCHAR(255) NOT NULL REFERENCES graph_runs(id),
+      node_id          VARCHAR(255) NOT NULL,
+      attempt          INTEGER NOT NULL DEFAULT 1,
+      status           VARCHAR(32) NOT NULL,
+      started_at       DATETIME NOT NULL,
+      completed_at     DATETIME,
+      duration_ms      INTEGER,
+      cost_usd         DOUBLE NOT NULL DEFAULT 0.0,
+      failure_reason   TEXT,
+      context_snapshot TEXT
+    )
+  `);
+	await adapter.exec("CREATE INDEX IF NOT EXISTS idx_graph_node_results_run ON graph_node_results(run_id)");
+	await adapter.exec(`
+    CREATE TABLE IF NOT EXISTS scenario_results (
+      id                 INTEGER PRIMARY KEY AUTOINCREMENT,
+      run_id             VARCHAR(255) NOT NULL REFERENCES graph_runs(id),
+      node_id            VARCHAR(255) NOT NULL,
+      iteration          INTEGER NOT NULL DEFAULT 1,
+      total_scenarios    INTEGER NOT NULL,
+      passed             INTEGER NOT NULL,
+      failed             INTEGER NOT NULL,
+      satisfaction_score DOUBLE NOT NULL,
+      threshold          DOUBLE NOT NULL DEFAULT 0.8,
+      passes             BOOLEAN NOT NULL,
+      details            TEXT,
+      executed_at        DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+    )
+  `);
+	await adapter.exec("CREATE INDEX IF NOT EXISTS idx_scenario_results_run ON scenario_results(run_id)");
+}
+
 //#endregion
 //#region packages/factory/dist/factory-command.js
 /**
@@ -27805,10 +28641,17 @@ async function resolveGraphPath(opts, projectDir) {
 	return null;
 }
 /**
+* Total number of validation rules loaded by `createValidator()`.
+* 8 error rules + 5 warning rules = 13 total (stories 42-4, 42-5).
+* This is a fixed constant — the GraphValidator interface does not expose a rule count.
+*/
+const TOTAL_RULE_COUNT = 13;
+/**
 * Register the `factory` command group on the provided Commander program.
 *
 * Story 44-8: registers the `scenarios` subcommand.
 * Story 44-9: registers the `run` subcommand.
+* Story 46-7: registers the `validate` subcommand.
 */
 function registerFactoryCommand(program) {
 	const factoryCmd = program.command("factory").description("Factory pipeline and scenario management commands");
@@ -27851,13 +28694,27 @@ function registerFactoryCommand(program) {
 			const logsRoot = path.join(projectDir, ".substrate", "runs", runId);
 			const stateManager = new RunStateManager({ runDir: logsRoot });
 			await stateManager.initRun(dotSource);
+			/** wallClockCapMs: FactoryConfig.wall_clock_cap_seconds × 1000 (story 45-10) */
+			const factoryConfig = await loadFactoryConfig(projectDir, opts.config);
+			const adapter = createDatabaseAdapter$1({
+				backend: "auto",
+				basePath: projectDir
+			});
+			await factorySchema(adapter);
 			const executor = createGraphExecutor();
 			await executor.run(graph, {
 				runId,
 				logsRoot,
 				handlerRegistry: createDefaultRegistry(),
 				eventBus,
-				dotSource
+				dotSource,
+				adapter,
+				wallClockCapMs: (factoryConfig.factory?.wall_clock_cap_seconds ?? 0) * 1e3,
+				pipelineBudgetCapUsd: factoryConfig.factory?.budget_cap_usd ?? 0,
+				plateauWindow: factoryConfig.factory?.plateau_window ?? 3,
+				plateauThreshold: factoryConfig.factory?.plateau_threshold ?? .05,
+				satisfactionThreshold: factoryConfig.factory?.satisfaction_threshold ?? .8,
+				qualityMode: factoryConfig.factory?.quality_mode ?? "dual-signal"
 			});
 		} catch (err) {
 			const msg = err instanceof Error ? err.message : String(err);
@@ -27865,6 +28722,53 @@ function registerFactoryCommand(program) {
 			process.exit(1);
 		}
 	});
+	factoryCmd.command("validate <graph-file>").description("Parse and lint a DOT graph against all 13 validation rules").option("--output-format <format>", "Output format: json | text", "text").action(async (graphFile, opts) => {
+		let source;
+		try {
+			source = await readFile$1(graphFile, "utf-8");
+		} catch (err) {
+			const isEnoent = err instanceof Error && err.code === "ENOENT";
+			if (isEnoent) process.stderr.write(`Error: file not found: ${graphFile}\n`);
+			else {
+				const msg = err instanceof Error ? err.message : String(err);
+				process.stderr.write(`Error: file not found: ${graphFile} (${msg})\n`);
+			}
+			process.exit(2);
+			return;
+		}
+		let graph;
+		try {
+			graph = parseGraph(source);
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			process.stderr.write(`Error: failed to parse graph: ${msg}\n`);
+			process.exit(2);
+			return;
+		}
+		const diagnostics = createValidator().validate(graph);
+		const errors = diagnostics.filter((d) => d.severity === "error");
+		const warnings = diagnostics.filter((d) => d.severity === "warning");
+		const firedRuleIds = new Set(diagnostics.map((d) => d.ruleId));
+		const passedCount = TOTAL_RULE_COUNT - firedRuleIds.size;
+		if (opts.outputFormat === "json") {
+			process.stdout.write(JSON.stringify(diagnostics, null, 2) + "\n");
+			if (errors.length > 0) process.exit(1);
+			return;
+		}
+		if (diagnostics.length > 0) {
+			for (const d of diagnostics) {
+				const nodeStr = d.nodeId ? ` [node: ${d.nodeId}]` : "";
+				const edgeStr = d.edgeIndex !== void 0 ? ` [edge: ${d.edgeIndex}]` : "";
+				process.stdout.write(`  ${d.severity.padEnd(7)}  ${d.ruleId.padEnd(24)}  ${d.message}${nodeStr}${edgeStr}\n`);
+			}
+			process.stdout.write("\n");
+		}
+		const errLabel = errors.length !== 1 ? "errors" : "error";
+		const warnLabel = warnings.length !== 1 ? "warnings" : "warning";
+		if (diagnostics.length === 0) process.stdout.write(`✓ ${TOTAL_RULE_COUNT}/${TOTAL_RULE_COUNT} rules passed, 0 errors, 0 warnings\n`);
+		else process.stdout.write(`✗ ${passedCount}/${TOTAL_RULE_COUNT} rules passed, ${errors.length} ${errLabel}, ${warnings.length} ${warnLabel}\n`);
+		if (errors.length > 0) process.exit(1);
+	});
 }
 
 //#endregion
@@ -29339,5 +30243,5 @@ function registerRunCommand(program, _version = "0.0.0", projectRoot = process.c
 }
 
 //#endregion
-export { AdapterTelemetryPersistence, AppError, DoltRepoMapMetaRepository, DoltSymbolRepository, ERR_REPO_MAP_STORAGE_WRITE, GitClient, GrammarLoader, RepoMapInjector, RepoMapModule, RepoMapQueryEngine, RepoMapStorage, SymbolParser, createContextCompiler, createDispatcher, createEventEmitter, createImplementationOrchestrator, createPackLoader, createPhaseOrchestrator, createStopAfterGate, createTelemetryAdvisor, formatPhaseCompletionSummary, normalizeGraphSummaryToStatus, registerFactoryCommand, registerRunCommand, registerScenariosCommand, resolveStoryKeys, runAnalysisPhase, runPlanningPhase, runRunAction, runSolutioningPhase, validateStopAfterFromConflict };
-//# sourceMappingURL=run-DDUeFC-I.js.map
+export { AdapterTelemetryPersistence, AppError, DoltRepoMapMetaRepository, DoltSymbolRepository, ERR_REPO_MAP_STORAGE_WRITE, GitClient, GrammarLoader, RepoMapInjector, RepoMapModule, RepoMapQueryEngine, RepoMapStorage, SymbolParser, createContextCompiler, createDispatcher, createEventEmitter, createImplementationOrchestrator, createPackLoader, createPhaseOrchestrator, createStopAfterGate, createTelemetryAdvisor, formatPhaseCompletionSummary, getFactoryRunSummaries, getScenarioResultsForRun, listGraphRuns, normalizeGraphSummaryToStatus, registerFactoryCommand, registerRunCommand, registerScenariosCommand, resolveStoryKeys, runAnalysisPhase, runPlanningPhase, runRunAction, runSolutioningPhase, validateStopAfterFromConflict };
+//# sourceMappingURL=run-bhGoAbu9.js.map