substrate-ai 0.14.0 → 0.15.1

package/dist/cli/index.js

@@ -4,7 +4,7 @@ import { createLogger } from "../logger-KeHncl-f.js";
 import { createEventBus } from "../helpers-CElYrONe.js";
 import { AdapterRegistry, BudgetConfigSchema, CURRENT_CONFIG_FORMAT_VERSION, CURRENT_TASK_GRAPH_VERSION, ConfigError, CostTrackerConfigSchema, DEFAULT_CONFIG, DoltClient, DoltNotInstalled, EXPERIMENT_RESULT, GlobalSettingsSchema, IngestionServer, MonitorDatabaseImpl, OPERATIONAL_FINDING, PartialGlobalSettingsSchema, PartialProviderConfigSchema, ProvidersSchema, RoutingRecommender, STORY_METRICS, TelemetryConfigSchema, addTokenUsage, aggregateTokenUsageForRun, checkDoltInstalled, compareRunMetrics, createAmendmentRun, createConfigSystem, createDecision, createDoltClient, createPipelineRun, getActiveDecisions, getAllCostEntriesFiltered, getBaselineRunMetrics, getDecisionsByCategory, getDecisionsByPhaseForRun, getLatestCompletedRun, getLatestRun, getPipelineRunById, getPlanningCostTotal, getRetryableEscalations, getRunMetrics, getSessionCostSummary, getSessionCostSummaryFiltered, getStoryMetricsForRun, getTokenUsageSummary, incrementRunRestarts, initSchema, initializeDolt, listRequirements, listRunMetrics, loadParentRunDecisions, supersedeDecision, tagRunAsBaseline, updatePipelineRun } from "../dist-CLvAwmT7.js";
 import "../adapter-registry-DXLMTmfD.js";
-import { 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, registerFactoryCommand, registerRunCommand, registerScenariosCommand, resolveStoryKeys, runAnalysisPhase, runPlanningPhase, runSolutioningPhase, validateStopAfterFromConflict } from "../run-CUMPhuVq.js";
+import { 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, registerFactoryCommand, registerRunCommand, registerScenariosCommand, resolveStoryKeys, runAnalysisPhase, runPlanningPhase, runSolutioningPhase, validateStopAfterFromConflict } from "../run-CRP9jiCz.js";
 import "../errors-D1LU8CZ9.js";
 import "../routing-CcBOCuC9.js";
 import "../decisions-C0pz9Clx.js";
@@ -4359,7 +4359,7 @@ async function runSupervisorAction(options, deps = {}) {
 								await initSchema(expAdapter);
 								const { runRunAction: runPipeline } = await import(
 									/* @vite-ignore */
-									"../run-CZo7hpsh.js"
+									"../run-BPSzSeU8.js"
 );
 								const runStoryFn = async (opts) => {
 									const exitCode = await runPipeline({
@@ -4696,8 +4696,22 @@ function printCategoryTable(stats, label) {
 		process.stdout.write(`  ${c.category.padEnd(22)} ${c.totalTokens.toLocaleString().padStart(12)} ${pct.padStart(8)} ${String(c.eventCount).padStart(8)} ${avg.padStart(10)} ${c.trend}\n`);
 	}
 }
+function printFactoryRunTable(runs) {
+	process.stdout.write(`\nFactory Runs (${runs.length} records)\n`);
+	process.stdout.write("─".repeat(80) + "\n");
+	process.stdout.write(`  ${"run_id".padEnd(10)} ${"score".padStart(7)} ${"passes".padStart(7)} ${"started_at".padEnd(20)} ${"cost_usd".padStart(10)} ${"status".padEnd(16)}\n`);
+	process.stdout.write("  " + "─".repeat(74) + "\n");
+	for (const run of runs) {
+		const scoreStr = run.satisfaction_score !== null ? `${(run.satisfaction_score * 100).toFixed(1)}%` : "—";
+		const passesStr = run.passes !== null ? run.passes ? "✓" : "✗" : "—";
+		const startedAt = run.started_at.slice(0, 19);
+		const costStr = `$${run.total_cost_usd.toFixed(4)}`;
+		const statusStr = run.convergence_status ?? "—";
+		process.stdout.write(`  ${run.run_id.slice(0, 8).padEnd(10)} ${scoreStr.padStart(7)} ${passesStr.padStart(7)} ${startedAt.padEnd(20)} ${costStr.padStart(10)} ${statusStr.padEnd(16)}\n`);
+	}
+}
 async function runMetricsAction(options) {
-	const { outputFormat, projectRoot, limit = 10, compare, tagBaseline, analysis, sprint, story, taskType, since, aggregate, efficiency, recommendations, turns, consumers, categories, compareStories, routingRecommendations } = options;
+	const { outputFormat, projectRoot, limit = 10, compare, tagBaseline, analysis, sprint, story, taskType, since, aggregate, efficiency, recommendations, turns, consumers, categories, compareStories, routingRecommendations, run, factory } = options;
 	const telemetryModes = [
 		efficiency,
 		recommendations,
@@ -4931,7 +4945,7 @@ async function runMetricsAction(options) {
 	}
 	const dbRoot = await resolveMainRepoRoot(projectRoot);
 	const doltStateDir = join(dbRoot, ".substrate", "state", ".dolt");
-	if (!existsSync$1(doltStateDir)) {
+	if (!existsSync$1(doltStateDir) && factory !== true && run === void 0) {
 		if (outputFormat === "json") process.stdout.write(formatOutput({
 			runs: [],
 			message: "No metrics yet — no pipeline database found. Initialize Dolt with `substrate init`."
@@ -4945,6 +4959,60 @@ async function runMetricsAction(options) {
 	});
 	try {
 		await initSchema(adapter);
+		if (run !== void 0) {
+			let rows = [];
+			let resolvedRunId = run;
+			try {
+				rows = await getScenarioResultsForRun(adapter, run);
+				if (rows.length === 0 && run.length < 36) {
+					const allRuns = await listGraphRuns(adapter, 100);
+					const matching = allRuns.filter((r) => r.id.startsWith(run));
+					if (matching.length === 1 && matching[0] !== void 0) {
+						resolvedRunId = matching[0].id;
+						rows = await getScenarioResultsForRun(adapter, resolvedRunId);
+					}
+				}
+			} catch (err) {
+				logger$10.debug({ err }, "getScenarioResultsForRun failed");
+			}
+			if (rows.length === 0) {
+				const msg = `No factory run found with id: ${run}`;
+				if (outputFormat === "json") process.stdout.write(formatOutput({ message: msg }, "json", true) + "\n");
+				else process.stderr.write(`Error: ${msg}\n`);
+				return 1;
+			}
+			if (outputFormat === "json") process.stdout.write(formatOutput({
+				run_id: resolvedRunId,
+				type: "factory",
+				iterations: rows
+			}, "json", true) + "\n");
+			else {
+				process.stdout.write(`\nFactory Run: ${resolvedRunId}\n`);
+				process.stdout.write("─".repeat(80) + "\n");
+				process.stdout.write(`  ${"#".padStart(3)} ${"score".padStart(7)} ${"passes".padStart(7)} ${"passed/total".padStart(13)} ${"executed_at".padEnd(20)}\n`);
+				process.stdout.write("  " + "─".repeat(54) + "\n");
+				for (const r of rows) {
+					const scoreStr = `${(r.satisfaction_score * 100).toFixed(1)}%`;
+					const passesStr = r.passes ? "✓" : "✗";
+					const passedTotal = `${r.passed}/${r.total_scenarios}`;
+					const execAt = String(r.executed_at).slice(0, 19);
+					process.stdout.write(`  ${String(r.iteration).padStart(3)} ${scoreStr.padStart(7)} ${passesStr.padStart(7)} ${passedTotal.padStart(13)} ${execAt.padEnd(20)}\n`);
+				}
+			}
+			return 0;
+		}
+		if (factory === true) {
+			let factoryRuns$1 = [];
+			try {
+				factoryRuns$1 = await getFactoryRunSummaries(adapter, limit);
+			} catch (err) {
+				logger$10.debug({ err }, "getFactoryRunSummaries failed in factory-only mode");
+			}
+			if (outputFormat === "json") process.stdout.write(formatOutput({ graph_runs: factoryRuns$1 }, "json", true) + "\n");
+			else if (factoryRuns$1.length === 0) process.stdout.write("No factory runs recorded yet.\n");
+			else printFactoryRunTable(factoryRuns$1);
+			return 0;
+		}
 		if (tagBaseline !== void 0) {
 			const row = await getRunMetrics(adapter, tagBaseline);
 			if (!row) {
@@ -5033,18 +5101,26 @@ async function runMetricsAction(options) {
 		const phaseBreakdownMap = {};
 		try {
 			const kvStore = new FileStateStore({ basePath: join(dbRoot, ".substrate") });
-			for (const run of runs) {
-				const raw = await kvStore.getMetric(run.run_id, "phase_token_breakdown");
-				phaseBreakdownMap[run.run_id] = raw !== void 0 ? raw : null;
+			for (const run$1 of runs) {
+				const raw = await kvStore.getMetric(run$1.run_id, "phase_token_breakdown");
+				phaseBreakdownMap[run$1.run_id] = raw !== void 0 ? raw : null;
 			}
 		} catch {}
+		let factoryRuns = [];
+		try {
+			factoryRuns = await getFactoryRunSummaries(adapter, limit);
+		} catch (err) {
+			logger$10.debug({ err }, "getFactoryRunSummaries failed — table may not exist in older databases");
+		}
 		if (outputFormat === "json") {
-			const runsWithBreakdown = runs.map((run) => ({
-				...run,
-				phase_token_breakdown: phaseBreakdownMap[run.run_id] ?? null
+			const runsWithBreakdown = runs.map((run$1) => ({
+				...run$1,
+				type: "sdlc",
+				phase_token_breakdown: phaseBreakdownMap[run$1.run_id] ?? null
 			}));
 			const jsonPayload = {
 				runs: runsWithBreakdown,
+				graph_runs: factoryRuns,
 				story_metrics: storyMetrics
 			};
 			if (doltMetrics !== void 0) if (aggregate) {
@@ -5066,23 +5142,23 @@ async function runMetricsAction(options) {
 			} else jsonPayload.dolt_metrics = doltMetrics;
 			process.stdout.write(formatOutput(jsonPayload, "json", true) + "\n");
 		} else {
-			if (runs.length === 0 && storyMetrics.length === 0 && (doltMetrics === void 0 || doltMetrics.length === 0)) {
+			if (runs.length === 0 && storyMetrics.length === 0 && (doltMetrics === void 0 || doltMetrics.length === 0) && factoryRuns.length === 0) {
 				process.stdout.write("No run metrics recorded yet. Run `substrate run` to generate metrics.\n");
 				return 0;
 			}
 			if (runs.length > 0) {
 				process.stdout.write(`\nPipeline Run Metrics (last ${runs.length} runs)\n`);
 				process.stdout.write("─".repeat(80) + "\n");
-				for (const run of runs) {
-					const isBaseline = run.is_baseline ? " [BASELINE]" : "";
-					process.stdout.write(`\nRun: ${run.run_id}${isBaseline}\n`);
-					process.stdout.write(`  Status:    ${run.status}  |  Methodology: ${run.methodology}\n`);
-					process.stdout.write(`  Started:   ${run.started_at}\n`);
-					if (run.completed_at) process.stdout.write(`  Completed: ${run.completed_at}  (${run.wall_clock_seconds}s)\n`);
-					process.stdout.write(`  Stories:   attempted=${run.stories_attempted} succeeded=${run.stories_succeeded} failed=${run.stories_failed} escalated=${run.stories_escalated}\n`);
-					process.stdout.write(`  Tokens:    ${(run.total_input_tokens ?? 0).toLocaleString()} in / ${(run.total_output_tokens ?? 0).toLocaleString()} out  $${(run.total_cost_usd ?? 0).toFixed(4)}\n`);
-					process.stdout.write(`  Cycles:    ${run.total_review_cycles}  |  Dispatches: ${run.total_dispatches}  |  Concurrency: ${run.concurrency_setting}\n`);
-					const breakdown = phaseBreakdownMap[run.run_id];
+				for (const run$1 of runs) {
+					const isBaseline = run$1.is_baseline ? " [BASELINE]" : "";
+					process.stdout.write(`\nRun: ${run$1.run_id}${isBaseline}\n`);
+					process.stdout.write(`  Status:    ${run$1.status}  |  Methodology: ${run$1.methodology}\n`);
+					process.stdout.write(`  Started:   ${run$1.started_at}\n`);
+					if (run$1.completed_at) process.stdout.write(`  Completed: ${run$1.completed_at}  (${run$1.wall_clock_seconds}s)\n`);
+					process.stdout.write(`  Stories:   attempted=${run$1.stories_attempted} succeeded=${run$1.stories_succeeded} failed=${run$1.stories_failed} escalated=${run$1.stories_escalated}\n`);
+					process.stdout.write(`  Tokens:    ${(run$1.total_input_tokens ?? 0).toLocaleString()} in / ${(run$1.total_output_tokens ?? 0).toLocaleString()} out  $${(run$1.total_cost_usd ?? 0).toFixed(4)}\n`);
+					process.stdout.write(`  Cycles:    ${run$1.total_review_cycles}  |  Dispatches: ${run$1.total_dispatches}  |  Concurrency: ${run$1.concurrency_setting}\n`);
+					const breakdown = phaseBreakdownMap[run$1.run_id];
 					if (breakdown !== null && breakdown !== void 0 && breakdown.entries.length > 0) {
 						process.stdout.write("  Phase Token Breakdown:\n");
 						for (const entry of breakdown.entries) process.stdout.write(`    ${entry.phase.padEnd(10)} | ${entry.model.padEnd(30)} | in: ${entry.inputTokens} | out: ${entry.outputTokens} | dispatches: ${entry.dispatchCount}\n`);
@@ -5136,6 +5212,7 @@ async function runMetricsAction(options) {
 					process.stdout.write(`  ${m.storyKey.padEnd(16)} ${m.taskType.padEnd(16)} ${tokIn.padStart(10)} ${tokOut.padStart(11)} ${wall.padStart(10)} ${res.padEnd(12)}\n`);
 				}
 			}
+			if (factoryRuns.length > 0) printFactoryRunTable(factoryRuns);
 		}
 		return 0;
 	} catch (err) {
@@ -5151,7 +5228,7 @@ async function runMetricsAction(options) {
 	}
 }
 function registerMetricsCommand(program, _version = "0.0.0", projectRoot = process.cwd()) {
-	program.command("metrics").description("Show historical pipeline run metrics and cross-run comparison").option("--project-root <path>", "Project root directory", projectRoot).option("--output-format <format>", "Output format: human (default) or json", "human").option("--limit <n>", "Number of runs to show (default: 10)", (v) => parseInt(v, 10), 10).option("--compare <run-id-a,run-id-b>", "Compare two runs side-by-side (comma-separated IDs, e.g. abc123,def456)").option("--tag-baseline <run-id>", "Mark a run as the performance baseline").option("--analysis <run-id>", "Read and output the analysis report for the specified run (AC5 of Story 17-3)").option("--sprint <sprint>", "Filter StateStore metrics by sprint (e.g. sprint-1)").option("--story <story-key>", "Filter StateStore metrics by story key (e.g. 26-1)").option("--task-type <type>", "Filter StateStore metrics by task type (e.g. dev-story)").option("--since <iso-date>", "Filter StateStore metrics at or after this ISO timestamp").option("--aggregate", "Aggregate StateStore metrics grouped by task_type").option("--efficiency", "Show telemetry efficiency scores for recent stories").option("--recommendations", "Show all telemetry recommendations across stories").option("--turns <storyKey>", "Show per-turn analysis for a specific story").option("--consumers <storyKey>", "Show consumer stats for a specific story").option("--categories", "Show category stats (optionally scoped by --story <storyKey>)").option("--compare-stories <storyA,storyB>", "Compare efficiency scores of two stories side-by-side (comma-separated keys)").option("--routing-recommendations", "Show routing recommendations derived from phase token breakdown history").action(async (opts) => {
+	program.command("metrics").description("Show historical pipeline run metrics and cross-run comparison").option("--project-root <path>", "Project root directory", projectRoot).option("--output-format <format>", "Output format: human (default) or json", "human").option("--limit <n>", "Number of runs to show (default: 10)", (v) => parseInt(v, 10), 10).option("--compare <run-id-a,run-id-b>", "Compare two runs side-by-side (comma-separated IDs, e.g. abc123,def456)").option("--tag-baseline <run-id>", "Mark a run as the performance baseline").option("--analysis <run-id>", "Read and output the analysis report for the specified run (AC5 of Story 17-3)").option("--sprint <sprint>", "Filter StateStore metrics by sprint (e.g. sprint-1)").option("--story <story-key>", "Filter StateStore metrics by story key (e.g. 26-1)").option("--task-type <type>", "Filter StateStore metrics by task type (e.g. dev-story)").option("--since <iso-date>", "Filter StateStore metrics at or after this ISO timestamp").option("--aggregate", "Aggregate StateStore metrics grouped by task_type").option("--efficiency", "Show telemetry efficiency scores for recent stories").option("--recommendations", "Show all telemetry recommendations across stories").option("--turns <storyKey>", "Show per-turn analysis for a specific story").option("--consumers <storyKey>", "Show consumer stats for a specific story").option("--categories", "Show category stats (optionally scoped by --story <storyKey>)").option("--compare-stories <storyA,storyB>", "Compare efficiency scores of two stories side-by-side (comma-separated keys)").option("--routing-recommendations", "Show routing recommendations derived from phase token breakdown history").option("--run <run-id>", "Show per-iteration score history for a specific factory run").option("--factory", "Show only factory graph run metrics (excludes SDLC runs)").action(async (opts) => {
 		const outputFormat = opts.outputFormat === "json" ? "json" : "human";
 		let compareIds;
 		if (opts.compare !== void 0) {
@@ -5186,7 +5263,9 @@ function registerMetricsCommand(program, _version = "0.0.0", projectRoot = proce
 			...opts.consumers !== void 0 && { consumers: opts.consumers },
 			...opts.categories !== void 0 && { categories: opts.categories },
 			...compareStoriesIds !== void 0 && { compareStories: compareStoriesIds },
-			...opts.routingRecommendations !== void 0 && { routingRecommendations: opts.routingRecommendations }
+			...opts.routingRecommendations !== void 0 && { routingRecommendations: opts.routingRecommendations },
+			...opts.run !== void 0 && { run: opts.run },
+			...opts.factory !== void 0 && { factory: opts.factory }
 		};
 		const exitCode = await runMetricsAction(metricsOpts);
 		process.exitCode = exitCode;

package/dist/{run-CZo7hpsh.js → run-BPSzSeU8.js}

@@ -2,7 +2,7 @@ import "./health-DswaC1q5.js";
 import "./logger-KeHncl-f.js";
 import "./helpers-CElYrONe.js";
 import "./dist-CLvAwmT7.js";
-import { normalizeGraphSummaryToStatus, registerRunCommand, runRunAction } from "./run-CUMPhuVq.js";
+import { normalizeGraphSummaryToStatus, registerRunCommand, runRunAction } from "./run-CRP9jiCz.js";
 import "./routing-CcBOCuC9.js";
 import "./decisions-C0pz9Clx.js";
 

package/dist/{run-CUMPhuVq.js → run-CRP9jiCz.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";
@@ -22182,18 +22182,30 @@ function createConvergenceController() {
 				failingNodes
 			};
 		},
-		checkGoalGates(graph, runId, eventBus) {
+		checkGoalGates(graph, runId, eventBus, options) {
 			const failedGates = [];
 			for (const [id, node] of graph.nodes) {
 				if (!node.goalGate) continue;
-				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);
+				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,
@@ -22562,6 +22574,263 @@ 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
 /**
@@ -22666,6 +22935,24 @@ function createGraphExecutor() {
 			...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();
@@ -22679,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);
@@ -22712,6 +23033,7 @@ function createGraphExecutor() {
 					level: "session",
 					reason: sessionResult.reason
 				});
+				await persistExit("failed", `Session budget exceeded: ${sessionResult.reason}`);
 				return {
 					status: "FAIL",
 					failureReason: `Session budget exceeded: ${sessionResult.reason}`
@@ -22724,6 +23046,7 @@ function createGraphExecutor() {
 					level: "pipeline",
 					reason: pipelineResult.reason
 				});
+				await persistExit("failed", `Pipeline budget exceeded: ${pipelineResult.reason}`);
 				return {
 					status: "FAIL",
 					failureReason: `Pipeline budget exceeded: ${pipelineResult.reason}`
@@ -22731,15 +23054,35 @@ function createGraphExecutor() {
 			}
 			const exitNode = graph.exitNode();
 			if (currentNode.id === exitNode.id) {
-				const gateResult = controller.checkGoalGates(graph, config.runId, config.eventBus);
+				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.failedGates[0];
 					const failingGateNode = graph.nodes.get(failingNodeId);
 					const retryTargetId = failingGateNode ? controller.resolveRetryTarget(failingGateNode, graph) : null;
-					if (!retryTargetId) return {
-						status: "FAIL",
-						failureReason: "Goal gate failed: no retry target"
-					};
+					if (!retryTargetId) {
+						await persistExit("failed", "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++;
@@ -22750,10 +23093,13 @@ function createGraphExecutor() {
 						nodeId: retryTargetId,
 						...config.eventBus ? { eventBus: config.eventBus } : {}
 					});
-					if (plateauResult.plateaued) return {
-						status: "FAIL",
-						failureReason: `Convergence plateau detected after ${convergenceIteration} iteration(s): scores plateaued at [${plateauResult.scores.join(", ")}]`
-					};
+					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,
@@ -22764,14 +23110,18 @@ function createGraphExecutor() {
 					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,
@@ -22799,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(", ")}`
@@ -22810,6 +23161,7 @@ function createGraphExecutor() {
 					scenarioCount: scenarioManifest.scenarios.length
 				});
 			}
+			lastScenarioNodeId = currentNode.id;
 			config.eventBus?.emit("graph:node-started", {
 				runId: config.runId,
 				nodeId: currentNode.id,
@@ -22822,6 +23174,7 @@ function createGraphExecutor() {
 			firstResumedFidelity = "";
 			const startedAt = Date.now();
 			let outcome = await dispatchWithRetry(nodeToDispatch, context, graph, config, nodeRetries);
+			if (Date.now() - startedAt < 50) await new Promise((r) => setTimeout(r, 50));
 			if (outcome.status === "PARTIAL_SUCCESS" && !nodeToDispatch.allowPartial) outcome = {
 				...outcome,
 				status: "FAIL",
@@ -22861,6 +23214,22 @@ function createGraphExecutor() {
 			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, {
@@ -22883,16 +23252,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,
@@ -23126,33 +23499,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
 /**
@@ -23203,7 +23549,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 }
@@ -28155,10 +28501,16 @@ const FactoryConfigSchema = z.object({
 	scenario_dir: z.string().default(".substrate/scenarios/"),
 	satisfaction_threshold: z.number().min(0).max(1).default(.8),
 	budget_cap_usd: z.number().min(0).default(0),
-	wall_clock_cap_seconds: z.number().min(0).default(0),
+	wall_clock_cap_seconds: z.number().min(0).default(3600),
 	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.
@@ -28196,6 +28548,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
 /**
@@ -28225,10 +28642,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");
@@ -28273,6 +28697,11 @@ function registerFactoryCommand(program) {
 			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,
@@ -28280,10 +28709,13 @@ function registerFactoryCommand(program) {
 				handlerRegistry: createDefaultRegistry(),
 				eventBus,
 				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
+				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);
@@ -28291,6 +28723,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
@@ -29765,5 +30244,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-CUMPhuVq.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-CRP9jiCz.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "substrate-ai",
-  "version": "0.14.0",
+  "version": "0.15.1",
   "description": "Substrate — multi-agent orchestration daemon for AI coding agents",
   "type": "module",
   "license": "MIT",