substrate-ai 0.4.7 → 0.4.8

package/dist/cli/index.js

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
-import { DEFAULT_CONFIG, DEFAULT_ROUTING_POLICY, DatabaseWrapper, DoltClient, DoltNotInstalled, DoltRepoMapMetaRepository, DoltSymbolRepository, FileStateStore, GitClient, GrammarLoader, IngestionServer, RepoMapInjector, RepoMapModule, RepoMapQueryEngine, RepoMapStorage, SUBSTRATE_OWNED_SETTINGS_KEYS, SymbolParser, TelemetryPersistence, VALID_PHASES, buildPipelineStatusOutput, checkDoltInstalled, createConfigSystem, createContextCompiler, createDispatcher, createDoltClient, createImplementationOrchestrator, createPackLoader, createPhaseOrchestrator, createStateStore, createStopAfterGate, findPackageRoot, formatOutput, formatPhaseCompletionSummary, formatPipelineStatusHuman, formatPipelineSummary, formatTokenTelemetry, getAllDescendantPids, getAutoHealthData, getSubstrateDefaultSettings, initializeDolt, parseDbTimestampAsUtc, registerHealthCommand, registerRunCommand, resolveBmadMethodSrcPath, resolveBmadMethodVersion, resolveMainRepoRoot, resolveStoryKeys, runAnalysisPhase, runMigrations, runPlanningPhase, runSolutioningPhase, validateStopAfterFromConflict } from "../run-fWZd8vvq.js";
+import { AppError, DEFAULT_CONFIG, DEFAULT_ROUTING_POLICY, DatabaseWrapper, DoltClient, DoltNotInstalled, DoltRepoMapMetaRepository, DoltSymbolRepository, ERR_REPO_MAP_STORAGE_WRITE, FileStateStore, GitClient, GrammarLoader, IngestionServer, RepoMapInjector, RepoMapModule, RepoMapQueryEngine, RepoMapStorage, SUBSTRATE_OWNED_SETTINGS_KEYS, SymbolParser, TelemetryPersistence, VALID_PHASES, buildPipelineStatusOutput, checkDoltInstalled, createConfigSystem, createContextCompiler, createDispatcher, createDoltClient, createImplementationOrchestrator, createPackLoader, createPhaseOrchestrator, createStateStore, createStopAfterGate, findPackageRoot, formatOutput, formatPhaseCompletionSummary, formatPipelineStatusHuman, formatPipelineSummary, formatTokenTelemetry, getAllDescendantPids, getAutoHealthData, getSubstrateDefaultSettings, initializeDolt, parseDbTimestampAsUtc, registerHealthCommand, registerRunCommand, resolveBmadMethodSrcPath, resolveBmadMethodVersion, resolveMainRepoRoot, resolveStoryKeys, runAnalysisPhase, runMigrations, runPlanningPhase, runSolutioningPhase, validateStopAfterFromConflict } from "../run-CvQCHfTV.js";
 import { createLogger } from "../logger-D2fS2ccL.js";
 import { AdapterRegistry } from "../adapter-registry-Cd-7lG5v.js";
 import { CURRENT_CONFIG_FORMAT_VERSION, CURRENT_TASK_GRAPH_VERSION, PartialSubstrateConfigSchema } from "../config-migrator-DtZW1maj.js";
 import { ConfigError, createEventBus } from "../helpers-BihqWgVe.js";
-import { RoutingRecommender } from "../routing-CZfJB3y9.js";
+import { RoutingRecommender } from "../routing-BUE9pIxW.js";
 import { addTokenUsage, createDecision, createPipelineRun, getDecisionsByCategory, getDecisionsByPhaseForRun, getLatestRun, getTokenUsageSummary, listRequirements, updatePipelineRun } from "../decisions-Db8GTbH2.js";
 import { ESCALATION_DIAGNOSIS, EXPERIMENT_RESULT, OPERATIONAL_FINDING, STORY_METRICS, aggregateTokenUsageForRun, compareRunMetrics, getBaselineRunMetrics, getRunMetrics, getStoryMetricsForRun, incrementRunRestarts, listRunMetrics, tagRunAsBaseline } from "../operational-C0_y8DAs.js";
 import { abortMerge, createWorktree, getConflictingFiles, getMergedFiles, getOrphanedWorktrees, performMerge, removeBranch, removeWorktree, simulateMerge, verifyGitVersion } from "../git-utils-C-fdrHF_.js";
@@ -2709,7 +2709,7 @@ async function runSupervisorAction(options, deps = {}) {
 								const expDb = expDbWrapper.db;
 								const { runRunAction: runPipeline } = await import(
 									/* @vite-ignore */
-									"../run-RerrMpM1.js"
+									"../run-BGgReI0e.js"
 );
 								const runStoryFn = async (opts) => {
 									const exitCode = await runPipeline({
@@ -3194,7 +3194,7 @@ async function runMetricsAction(options) {
 			const routingConfigPath = join(dbDir, "routing.yml");
 			let routingConfig = null;
 			if (existsSync(routingConfigPath)) try {
-				const { loadModelRoutingConfig } = await import("../routing-DWCBjrt7.js");
+				const { loadModelRoutingConfig } = await import("../routing-DbR9FPmj.js");
 				routingConfig = loadModelRoutingConfig(routingConfigPath);
 			} catch {}
 			if (routingConfig === null) routingConfig = {
@@ -7540,6 +7540,15 @@ function registerRepoMapCommand(program) {
 			return;
 		}
 		const doltClient = new DoltClient({ repoPath: statePath });
+		try {
+			const colRows = await doltClient.query(`SHOW COLUMNS FROM repo_map_symbols LIKE 'dependencies'`);
+			if (colRows.length === 0) {
+				await doltClient.query(`ALTER TABLE repo_map_symbols ADD COLUMN dependencies JSON`);
+				logger$2.info("Applied migration: added dependencies column to repo_map_symbols");
+			}
+		} catch {
+			logger$2.debug("Skipping repo_map_symbols migration: table not yet created");
+		}
 		const symbolRepo = new DoltSymbolRepository(doltClient, logger$2);
 		const metaRepo = new DoltRepoMapMetaRepository(doltClient);
 		const repoMapModule = new RepoMapModule(metaRepo, logger$2);
@@ -7572,19 +7581,41 @@ function registerRepoMapCommand(program) {
 			logger$2.info("repo-map --update: triggering incremental update");
 			const gitClient = new GitClient(logger$2);
 			const grammarLoader = new GrammarLoader(logger$2);
+			if (grammarLoader.getGrammar(".ts") === null) {
+				const msg = "tree-sitter grammars not installed. Run `npm install tree-sitter tree-sitter-typescript tree-sitter-javascript tree-sitter-python` in the substrate installation directory.";
+				if (options.outputFormat === "json") console.log(JSON.stringify({
+					result: "error",
+					error: msg
+				}));
+				else process.stderr.write(`Error: ${msg}\n`);
+				process.exitCode = 1;
+				return;
+			}
 			const parser = new SymbolParser(grammarLoader, logger$2);
 			const storage = new RepoMapStorage(symbolRepo, metaRepo, gitClient, logger$2);
-			await storage.incrementalUpdate(dbRoot, parser);
+			let updateWarning;
+			try {
+				await storage.incrementalUpdate(dbRoot, parser);
+			} catch (err) {
+				if (err instanceof AppError && err.code === ERR_REPO_MAP_STORAGE_WRITE) {
+					updateWarning = err.message;
+					logger$2.warn({ err }, "repo-map --update: storage write error (partial update)");
+				} else throw err;
+			}
 			const meta = await metaRepo.getMeta();
 			const symbolCount = (await symbolRepo.getSymbols()).length;
 			if (options.outputFormat === "json") console.log(JSON.stringify({
-				result: "updated",
+				result: updateWarning ? "partial" : "updated",
 				symbolCount,
 				fileCount: meta?.fileCount ?? 0,
 				commitSha: meta?.commitSha ?? null,
-				updatedAt: meta?.updatedAt?.toISOString() ?? null
+				updatedAt: meta?.updatedAt?.toISOString() ?? null,
+				...updateWarning ? { warning: updateWarning } : {}
 			}));
-			else console.log(`Repo-map updated: ${symbolCount} symbols across ${meta?.fileCount ?? 0} files`);
+			else if (updateWarning) {
+				console.log(`Repo-map partially updated: ${symbolCount} symbols across ${meta?.fileCount ?? 0} files`);
+				console.log(`Warning: ${updateWarning}`);
+			} else console.log(`Repo-map updated: ${symbolCount} symbols across ${meta?.fileCount ?? 0} files`);
 			return;
 		}
 		if (options.query !== void 0) {

package/dist/{routing-CZfJB3y9.js → routing-BUE9pIxW.js}

@@ -1,5 +1,5 @@
 import { createLogger } from "./logger-D2fS2ccL.js";
-import { load } from "js-yaml";
+import { dump, load } from "js-yaml";
 import { z } from "zod";
 import { readFileSync, writeFileSync } from "node:fs";
 
@@ -280,13 +280,142 @@ var RoutingResolver = class RoutingResolver {
 	}
 };
 
+//#endregion
+//#region src/modules/routing/routing-token-accumulator.ts
+/**
+* Accumulates per-dispatch routing decisions and agent token usage, then
+* flushes an aggregated `PhaseTokenBreakdown` to the StateStore at run end.
+*
+* Thread-safety: all methods are synchronous accumulators; `flush` is async
+* but should only be called once per run after all dispatches settle.
+*/
+var RoutingTokenAccumulator = class {
+	_config;
+	_stateStore;
+	_logger;
+	/** Maps dispatchId → { phase, model } registered from routing:model-selected events */
+	_dispatchMap = new Map();
+	/**
+	* Bucket key = `"${phase}::${model}"`.
+	* Separate entries per (phase, model) combination so mixed-model runs
+	* produce distinct rows in the breakdown.
+	*/
+	_buckets = new Map();
+	constructor(config, stateStore, logger$1) {
+		this._config = config;
+		this._stateStore = stateStore;
+		this._logger = logger$1;
+	}
+	/**
+	* Register the routing decision for a dispatch.
+	* A second event for the same `dispatchId` overwrites the prior entry (last-writer-wins).
+	*
+	* @param event - payload from `routing:model-selected`
+	*/
+	onRoutingSelected(event) {
+		this._dispatchMap.set(event.dispatchId, {
+			phase: event.phase,
+			model: event.model
+		});
+		this._logger.debug({
+			dispatchId: event.dispatchId,
+			phase: event.phase,
+			model: event.model
+		}, "routing:model-selected registered");
+	}
+	/**
+	* Attribute token usage to the phase bucket for this dispatch.
+	* Unknown `dispatchId` values are attributed to `phase: 'default', model: 'unknown'`.
+	*
+	* @param event - payload from `agent:completed` (must include inputTokens / outputTokens)
+	*/
+	onAgentCompleted(event) {
+		const mapping = this._dispatchMap.get(event.dispatchId);
+		const phase = mapping?.phase ?? "default";
+		const model = mapping?.model ?? "unknown";
+		this._upsertBucket(phase, model, event.inputTokens, event.outputTokens);
+		this._logger.debug({
+			dispatchId: event.dispatchId,
+			phase,
+			model,
+			inputTokens: event.inputTokens
+		}, "agent:completed attributed");
+	}
+	/**
+	* Construct the `PhaseTokenBreakdown` from the accumulated buckets and
+	* persist it to the StateStore via `setMetric`.
+	* Clears all in-memory state afterwards so a second call writes an empty entry.
+	*
+	* @param runId - the pipeline run ID used to scope the metric key
+	*/
+	async flush(runId) {
+		const entries = Array.from(this._buckets.values());
+		const breakdown = {
+			entries,
+			baselineModel: this._config.baseline_model,
+			runId
+		};
+		await this._stateStore.setMetric(runId, "phase_token_breakdown", breakdown);
+		this._logger.debug({
+			runId,
+			entryCount: entries.length
+		}, "Phase token breakdown flushed to StateStore");
+		this._dispatchMap.clear();
+		this._buckets.clear();
+	}
+	_upsertBucket(phase, model, inputTokens, outputTokens) {
+		const key = `${phase}::${model}`;
+		const existing = this._buckets.get(key);
+		if (existing) {
+			existing.inputTokens += inputTokens;
+			existing.outputTokens += outputTokens;
+			existing.dispatchCount += 1;
+		} else this._buckets.set(key, {
+			phase,
+			model,
+			inputTokens,
+			outputTokens,
+			dispatchCount: 1
+		});
+	}
+};
+
+//#endregion
+//#region src/modules/routing/routing-telemetry.ts
+/**
+* Emits `routing.model_resolved` OTEL spans via a TelemetryPersistence instance.
+*
+* Injected into the run command alongside RoutingResolver. When telemetry is
+* not configured, pass null to the run command; no spans are emitted.
+*/
+var RoutingTelemetry = class {
+	_telemetry;
+	_logger;
+	constructor(telemetry, logger$1) {
+		this._telemetry = telemetry;
+		this._logger = logger$1;
+	}
+	/**
+	* Emit a `routing.model_resolved` span for a single routing decision.
+	*
+	* @param attrs - span attributes including dispatchId, taskType, phase, model, source, latencyMs
+	*/
+	recordModelResolved(attrs) {
+		this._telemetry.recordSpan({
+			name: "routing.model_resolved",
+			attributes: attrs
+		});
+		this._logger.debug(attrs, "routing.model_resolved span emitted");
+	}
+};
+
 //#endregion
 //#region src/modules/routing/routing-recommender.ts
 /**
 * Ordered tier list: index 0 = cheapest / smallest, index N = most expensive / largest.
 * Tiers are determined by substring matching — e.g. 'claude-haiku-4-5' → tier 1.
 */
-const TIER_KEYWORDS = [
+const TIER_KEYWORDS$1 = [
 	{
 		keyword: "haiku",
 		tier: 1
@@ -330,7 +459,7 @@ var RoutingRecommender = class {
 	*/
 	_getTier(model) {
 		const lower = model.toLowerCase();
-		for (const { keyword, tier } of TIER_KEYWORDS) if (lower.includes(keyword)) return tier;
+		for (const { keyword, tier } of TIER_KEYWORDS$1) if (lower.includes(keyword)) return tier;
 		return 2;
 	}
 	/**
@@ -473,5 +602,231 @@ var RoutingRecommender = class {
 };
 
 //#endregion
-export { ModelRoutingConfigSchema, ProviderPolicySchema, RoutingConfigError, RoutingRecommender, RoutingResolver, TASK_TYPE_PHASE_MAP, loadModelRoutingConfig };
-//# sourceMappingURL=routing-CZfJB3y9.js.map
+//#region src/modules/routing/model-tier.ts
+/**
+* Shared model tier resolution utility.
+*
+* Determines whether a model string belongs to the haiku (1), sonnet (2),
+* or opus (3) tier based on substring matching against well-known keywords.
+*
+* Used by both RoutingRecommender and RoutingTuner to ensure consistent
+* tier comparisons — in particular the one-step guard in RoutingTuner.
+*/
+/** Ordered tier keywords: index 0 = cheapest, index N = most expensive. */
+const TIER_KEYWORDS = [
+	{
+		keyword: "haiku",
+		tier: 1
+	},
+	{
+		keyword: "sonnet",
+		tier: 2
+	},
+	{
+		keyword: "opus",
+		tier: 3
+	}
+];
+/**
+* Get the model tier for a given model name string.
+*
+* Returns:
+*  - 1  for haiku-tier models
+*  - 2  for sonnet-tier models (also the default when unrecognized)
+*  - 3  for opus-tier models
+*
+* Matching is case-insensitive substring search.
+*/
+function getModelTier(model) {
+	const lower = model.toLowerCase();
+	for (const { keyword, tier } of TIER_KEYWORDS) if (lower.includes(keyword)) return tier;
+	return 2;
+}
+
+//#endregion
+//#region src/modules/routing/routing-tuner.ts
+/** Minimum number of breakdowns required before auto-tuning is attempted. */
+const MIN_BREAKDOWNS_FOR_TUNING = 5;
+/** Key used to store the list of known run IDs in the StateStore. */
+const RUN_INDEX_KEY = "phase_token_breakdown_runs";
+/** Key used to store the tune log in the StateStore. */
+const TUNE_LOG_KEY = "routing_tune_log";
+/**
+* Auto-applies a single conservative model downgrade per invocation when
+* `config.auto_tune` is `true` and sufficient historical data is available.
+*
+* The tuner reads the current routing YAML config, applies the change in memory,
+* and writes it back to disk synchronously. It also appends a `TuneLogEntry`
+* to the StateStore for audit purposes, and emits a `routing:auto-tuned` event.
+*/
+var RoutingTuner = class {
+	_stateStore;
+	_recommender;
+	_eventEmitter;
+	_configPath;
+	_logger;
+	constructor(stateStore, recommender, eventEmitter, configPath, logger$1) {
+		this._stateStore = stateStore;
+		this._recommender = recommender;
+		this._eventEmitter = eventEmitter;
+		this._configPath = configPath;
+		this._logger = logger$1;
+	}
+	/**
+	* Called at the end of a pipeline run. When auto_tune is enabled and sufficient
+	* historical data exists, applies a single conservative model downgrade to the
+	* routing config YAML file.
+	*
+	* @param runId  - ID of the just-completed pipeline run
+	* @param config - Current model routing config (already loaded from disk)
+	*/
+	async maybeAutoTune(runId, config) {
+		if (config.auto_tune !== true) {
+			this._logger.debug({ runId }, "auto_tune_disabled — skipping RoutingTuner");
+			return;
+		}
+		await this._registerRunId(runId);
+		const breakdowns = await this._loadRecentBreakdowns(10);
+		if (breakdowns.length < MIN_BREAKDOWNS_FOR_TUNING) {
+			this._logger.debug({
+				runId,
+				available: breakdowns.length,
+				required: MIN_BREAKDOWNS_FOR_TUNING
+			}, "insufficient_data — not enough breakdowns for auto-tuning");
+			return;
+		}
+		const analysis = this._recommender.analyze(breakdowns, config);
+		if (analysis.insufficientData) {
+			this._logger.debug({ runId }, "Recommender returned insufficientData");
+			return;
+		}
+		const downgradeCandidates = analysis.recommendations.filter((rec) => {
+			if (rec.direction !== "downgrade") return false;
+			const tierDiff = Math.abs(getModelTier(rec.currentModel) - getModelTier(rec.suggestedModel));
+			return tierDiff === 1;
+		});
+		if (downgradeCandidates.length === 0) {
+			this._logger.debug({ runId }, "no_safe_recommendation");
+			return;
+		}
+		const topRec = downgradeCandidates.sort((a, b) => b.confidence - a.confidence)[0];
+		let rawContent;
+		try {
+			rawContent = readFileSync(this._configPath, "utf-8");
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			this._logger.warn({
+				err: msg,
+				configPath: this._configPath
+			}, "Failed to read routing config for auto-tune");
+			return;
+		}
+		let rawObject;
+		try {
+			rawObject = load(rawContent);
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			this._logger.warn({ err: msg }, "Failed to parse routing config YAML for auto-tune");
+			return;
+		}
+		const configObj = rawObject;
+		if (configObj.phases === void 0) configObj.phases = {};
+		const existingPhase = configObj.phases[topRec.phase];
+		if (existingPhase !== void 0) existingPhase.model = topRec.suggestedModel;
+		else configObj.phases[topRec.phase] = { model: topRec.suggestedModel };
+		try {
+			writeFileSync(this._configPath, dump(rawObject, { lineWidth: 120 }), "utf-8");
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			this._logger.warn({
+				err: msg,
+				configPath: this._configPath
+			}, "Failed to write updated routing config");
+			return;
+		}
+		const tuneEntry = {
+			id: crypto.randomUUID(),
+			runId,
+			phase: topRec.phase,
+			oldModel: topRec.currentModel,
+			newModel: topRec.suggestedModel,
+			estimatedSavingsPct: topRec.estimatedSavingsPct,
+			appliedAt: new Date().toISOString()
+		};
+		await this._appendTuneLog(tuneEntry);
+		this._eventEmitter.emit("routing:auto-tuned", {
+			runId,
+			phase: topRec.phase,
+			oldModel: topRec.currentModel,
+			newModel: topRec.suggestedModel,
+			estimatedSavingsPct: topRec.estimatedSavingsPct
+		});
+		this._logger.info({
+			runId,
+			phase: topRec.phase,
+			oldModel: topRec.currentModel,
+			newModel: topRec.suggestedModel
+		}, "Auto-tuned routing config — applied downgrade");
+	}
+	/**
+	* Register a run ID in the stored run index so future calls can discover
+	* all historical breakdowns without a separate run listing endpoint.
+	*/
+	async _registerRunId(runId) {
+		const existing = await this._stateStore.getMetric("__global__", RUN_INDEX_KEY);
+		const runIds = Array.isArray(existing) ? existing : [];
+		if (!runIds.includes(runId)) {
+			runIds.push(runId);
+			await this._stateStore.setMetric("__global__", RUN_INDEX_KEY, runIds);
+		}
+	}
+	/**
+	* Load the most recent `lookback` PhaseTokenBreakdown records from the StateStore.
+	*
+	* Each breakdown is stored by RoutingTokenAccumulator under the key
+	* `'phase_token_breakdown'` scoped to the run ID. The run IDs themselves are
+	* tracked in a global index stored under `('__global__', RUN_INDEX_KEY)`.
+	*
+	* @param lookback - Maximum number of recent runs to inspect
+	*/
+	async _loadRecentBreakdowns(lookback) {
+		const existing = await this._stateStore.getMetric("__global__", RUN_INDEX_KEY);
+		const allRunIds = Array.isArray(existing) ? existing : [];
+		const recentRunIds = allRunIds.slice(-lookback);
+		const breakdowns = [];
+		for (const runId of recentRunIds) try {
+			const raw = await this._stateStore.getMetric(runId, "phase_token_breakdown");
+			if (raw !== void 0 && raw !== null) {
+				const parsed = typeof raw === "string" ? JSON.parse(raw) : raw;
+				breakdowns.push(parsed);
+			}
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			this._logger.debug({
+				runId,
+				err: msg
+			}, "Failed to load breakdown for run — skipping");
+		}
+		return breakdowns;
+	}
+	/**
+	* Append a TuneLogEntry to the persisted tune log in the StateStore.
+	*
+	* NOTE: This uses `'__global__'` as the scope key (codebase convention) rather
+	* than the literal `'global'` mentioned in AC6. The tune log is stored as a raw
+	* array (not a JSON-stringified string) for internal consistency with how other
+	* array values are stored in this StateStore. Story 28-9's
+	* `substrate routing --history` command MUST use the same `'__global__'` scope
+	* key and `'routing_tune_log'` metric key when reading this log.
+	*/
+	async _appendTuneLog(entry) {
+		const existing = await this._stateStore.getMetric("__global__", TUNE_LOG_KEY);
+		const log = Array.isArray(existing) ? existing : [];
+		log.push(entry);
+		await this._stateStore.setMetric("__global__", TUNE_LOG_KEY, log);
+	}
+};
+
+//#endregion
+export { ModelRoutingConfigSchema, ProviderPolicySchema, RoutingConfigError, RoutingRecommender, RoutingResolver, RoutingTelemetry, RoutingTokenAccumulator, RoutingTuner, TASK_TYPE_PHASE_MAP, getModelTier, loadModelRoutingConfig };
+//# sourceMappingURL=routing-BUE9pIxW.js.map

package/dist/routing-DbR9FPmj.js

@@ -0,0 +1,4 @@
+import "./logger-D2fS2ccL.js";
+import { ModelRoutingConfigSchema, ProviderPolicySchema, RoutingConfigError, RoutingRecommender, RoutingResolver, RoutingTelemetry, RoutingTokenAccumulator, RoutingTuner, TASK_TYPE_PHASE_MAP, getModelTier, loadModelRoutingConfig } from "./routing-BUE9pIxW.js";
+
+export { loadModelRoutingConfig };

package/dist/{run-RerrMpM1.js → run-BGgReI0e.js}

@@ -1,8 +1,8 @@
-import { registerRunCommand, runRunAction } from "./run-fWZd8vvq.js";
+import { registerRunCommand, runRunAction } from "./run-CvQCHfTV.js";
 import "./logger-D2fS2ccL.js";
 import "./config-migrator-DtZW1maj.js";
 import "./helpers-BihqWgVe.js";
-import "./routing-CZfJB3y9.js";
+import "./routing-BUE9pIxW.js";
 import "./decisions-Db8GTbH2.js";
 import "./operational-C0_y8DAs.js";
 

package/dist/{run-fWZd8vvq.js → run-CvQCHfTV.js}

@@ -1,7 +1,7 @@
 import { createLogger, deepMask } from "./logger-D2fS2ccL.js";
 import { CURRENT_CONFIG_FORMAT_VERSION, PartialSubstrateConfigSchema, SUPPORTED_CONFIG_FORMAT_VERSIONS, SubstrateConfigSchema, defaultConfigMigrator } from "./config-migrator-DtZW1maj.js";
 import { ConfigError, ConfigIncompatibleFormatError, createEventBus, createTuiApp, isTuiCapable, printNonTtyWarning, sleep } from "./helpers-BihqWgVe.js";
-import { RoutingResolver } from "./routing-CZfJB3y9.js";
+import { RoutingRecommender, RoutingResolver, RoutingTelemetry, RoutingTokenAccumulator, RoutingTuner, loadModelRoutingConfig } from "./routing-BUE9pIxW.js";
 import { addTokenUsage, createDecision, createPipelineRun, createRequirement, getArtifactByTypeForRun, getArtifactsByRun, getDecisionsByCategory, getDecisionsByPhase, getDecisionsByPhaseForRun, getLatestRun, getPipelineRunById, getRunningPipelineRuns, getTokenUsageSummary, registerArtifact, updatePipelineRun, updatePipelineRunConfig, upsertDecision } from "./decisions-Db8GTbH2.js";
 import { ADVISORY_NOTES, ESCALATION_DIAGNOSIS, OPERATIONAL_FINDING, STORY_METRICS, STORY_OUTCOME, TEST_EXPANSION_FINDING, TEST_PLAN, aggregateTokenUsageForRun, aggregateTokenUsageForStory, getStoryMetricsForRun, writeRunMetrics, writeStoryMetrics } from "./operational-C0_y8DAs.js";
 import { createRequire } from "module";
@@ -3832,10 +3832,12 @@ var DoltSymbolRepository = class {
 				this._logger.debug({ filePath }, "upsertFileSymbols: cleared symbols for deleted/empty file");
 				return;
 			}
-			const placeholders = symbols.map(() => "(?, ?, ?, ?, ?, ?, ?)").join(", ");
+			const deps = symbols.filter((s) => s.kind === "import").map((s) => s.name);
+			const depsJson = JSON.stringify(deps);
+			const placeholders = symbols.map(() => "(?, ?, ?, ?, ?, ?, ?, ?)").join(", ");
 			const params = [];
-			for (const sym of symbols) params.push(filePath, sym.name, sym.kind, sym.signature ?? "", sym.lineNumber, sym.exported ? 1 : 0, fileHash);
-			await this._client.query(`INSERT INTO repo_map_symbols (file_path, symbol_name, symbol_kind, signature, line_number, exported, file_hash) VALUES ${placeholders}`, params);
+			for (const sym of symbols) params.push(filePath, sym.name, sym.kind, sym.signature ?? "", sym.lineNumber, sym.exported ? 1 : 0, fileHash, depsJson);
+			await this._client.query(`INSERT INTO repo_map_symbols (file_path, symbol_name, symbol_kind, signature, line_number, exported, file_hash, dependencies) VALUES ${placeholders}`, params);
 			this._logger.debug({
 				filePath,
 				count: symbols.length
@@ -3899,7 +3901,7 @@ var DoltSymbolRepository = class {
 		if (filePaths.length === 0) return [];
 		try {
 			const placeholders = filePaths.map(() => "?").join(", ");
-			const rows = await this._client.query(`SELECT file_path, symbol_name, symbol_kind, signature, line_number, exported, file_hash FROM repo_map_symbols WHERE file_path IN (${placeholders})`, filePaths);
+			const rows = await this._client.query(`SELECT file_path, symbol_name, symbol_kind, signature, line_number, exported, file_hash, dependencies FROM repo_map_symbols WHERE file_path IN (${placeholders})`, filePaths);
 			return rows.map((r) => this._rowToRepoMapSymbol(r));
 		} catch (err) {
 			const detail = err instanceof Error ? err.message : String(err);
@@ -3910,7 +3912,7 @@ var DoltSymbolRepository = class {
 		if (names.length === 0) return [];
 		try {
 			const placeholders = names.map(() => "?").join(", ");
-			const rows = await this._client.query(`SELECT file_path, symbol_name, symbol_kind, signature, line_number, exported, file_hash FROM repo_map_symbols WHERE symbol_name IN (${placeholders})`, names);
+			const rows = await this._client.query(`SELECT file_path, symbol_name, symbol_kind, signature, line_number, exported, file_hash, dependencies FROM repo_map_symbols WHERE symbol_name IN (${placeholders})`, names);
 			return rows.map((r) => this._rowToRepoMapSymbol(r));
 		} catch (err) {
 			const detail = err instanceof Error ? err.message : String(err);
@@ -3921,7 +3923,7 @@ var DoltSymbolRepository = class {
 		if (types$1.length === 0) return [];
 		try {
 			const placeholders = types$1.map(() => "?").join(", ");
-			const rows = await this._client.query(`SELECT file_path, symbol_name, symbol_kind, signature, line_number, exported, file_hash FROM repo_map_symbols WHERE symbol_kind IN (${placeholders})`, types$1);
+			const rows = await this._client.query(`SELECT file_path, symbol_name, symbol_kind, signature, line_number, exported, file_hash, dependencies FROM repo_map_symbols WHERE symbol_kind IN (${placeholders})`, types$1);
 			return rows.map((r) => this._rowToRepoMapSymbol(r));
 		} catch (err) {
 			const detail = err instanceof Error ? err.message : String(err);
@@ -3929,16 +3931,20 @@ var DoltSymbolRepository = class {
 		}
 	}
 	/**
-	* Returns symbols from files whose dependencies contain the given symbol name.
-	* Currently returns [] — the repo_map_symbols schema does not yet include a
-	* `dependencies` JSON column. A future migration will add it.
+	* Returns symbols from files whose dependencies array contains symbolName.
 	*/
-	async findByDependedBy(_symbolName) {
-		return [];
+	async findByDependedBy(symbolName) {
+		try {
+			const rows = await this._client.query(`SELECT file_path, symbol_name, symbol_kind, signature, line_number, exported, file_hash, dependencies FROM repo_map_symbols WHERE JSON_CONTAINS(dependencies, JSON_QUOTE(?), '$')`, [symbolName]);
+			return rows.map((r) => this._rowToRepoMapSymbol(r));
+		} catch (err) {
+			const detail = err instanceof Error ? err.message : String(err);
+			throw new AppError(ERR_REPO_MAP_STORAGE_READ, 2, `findByDependedBy failed: ${detail}`);
+		}
 	}
 	async findAll() {
 		try {
-			const rows = await this._client.query("SELECT file_path, symbol_name, symbol_kind, signature, line_number, exported, file_hash FROM repo_map_symbols");
+			const rows = await this._client.query("SELECT file_path, symbol_name, symbol_kind, signature, line_number, exported, file_hash, dependencies FROM repo_map_symbols");
 			return rows.map((r) => this._rowToRepoMapSymbol(r));
 		} catch (err) {
 			const detail = err instanceof Error ? err.message : String(err);
@@ -3946,13 +3952,18 @@ var DoltSymbolRepository = class {
 		}
 	}
 	_rowToRepoMapSymbol(row) {
+		let deps = [];
+		if (row.dependencies) try {
+			const parsed = typeof row.dependencies === "string" ? JSON.parse(row.dependencies) : row.dependencies;
+			if (Array.isArray(parsed)) deps = parsed;
+		} catch {}
 		return {
 			filePath: row.file_path,
 			symbolName: row.symbol_name,
 			symbolType: row.symbol_kind,
 			signature: row.signature ?? void 0,
 			lineNumber: row.line_number,
-			dependencies: [],
+			dependencies: deps,
 			fileHash: row.file_hash
 		};
 	}
@@ -3978,7 +3989,7 @@ var DoltRepoMapMetaRepository = class {
            updated_at = VALUES(updated_at),
            file_count = VALUES(file_count)`, [
 				meta.commitSha,
-				meta.updatedAt,
+				meta.updatedAt.toISOString(),
 				meta.fileCount
 			]);
 		} catch (err) {
@@ -4050,15 +4061,18 @@ var RepoMapStorage = class {
 		const changedFiles = await this._gitClient.getChangedFiles(projectRoot, meta.commitSha);
 		this._logger.debug({ count: changedFiles.length }, "incrementalUpdate: changed files");
 		const supported = changedFiles.filter((f) => SUPPORTED_EXTENSIONS.has(extname(f)));
+		let parsedCount = 0;
 		for (const filePath of supported) try {
 			const exists = await fileExists(filePath);
 			if (!exists) {
 				await this._symbolRepo.upsertFileSymbols(filePath, [], "");
+				parsedCount++;
 				continue;
 			}
 			const symbols = await parser.parseFile(filePath);
 			const hash = await computeFileHash(filePath);
 			await this._symbolRepo.upsertFileSymbols(filePath, symbols, hash);
+			parsedCount++;
 		} catch (err) {
 			this._logger.warn({
 				filePath,
@@ -4069,7 +4083,7 @@ var RepoMapStorage = class {
 		await this._metaRepo.updateMeta({
 			commitSha: currentSha,
 			updatedAt: new Date(),
-			fileCount: supported.length
+			fileCount: parsedCount
 		});
 	}
 	/**
@@ -5699,6 +5713,36 @@ var RepoMapFormatter = class {
 	}
 };
 
+//#endregion
+//#region src/modules/repo-map/repo-map-telemetry.ts
+/**
+* Emits `repo_map.query` OTEL spans via a TelemetryPersistence instance.
+*
+* Constructed with an `ITelemetryPersistence` and a logger. Pass an instance
+* to `RepoMapQueryEngine` constructor to enable query telemetry; omit it to
+* skip telemetry without changing existing query behaviour.
+*/
+var RepoMapTelemetry = class {
+	_telemetry;
+	_logger;
+	constructor(telemetry, logger$27) {
+		this._telemetry = telemetry;
+		this._logger = logger$27;
+	}
+	/**
+	* Emit a `repo_map.query` span.
+	*
+	* @param attrs - query telemetry attributes
+	*/
+	recordQuery(attrs) {
+		this._telemetry.recordSpan({
+			name: "repo_map.query",
+			attributes: attrs
+		});
+		this._logger.debug(attrs, "repo_map.query span emitted");
+	}
+};
+
 //#endregion
 //#region src/modules/repo-map/RepoMapModule.ts
 /**
@@ -7061,6 +7105,21 @@ var DoltStateStore = class DoltStateStore {
       )`
 		];
 		for (const sql of ddl) await this._client.query(sql);
+		try {
+			const colRows = await this._client.query(`SHOW COLUMNS FROM repo_map_symbols LIKE 'dependencies'`);
+			if (colRows.length === 0) {
+				await this._client.query(`ALTER TABLE repo_map_symbols ADD COLUMN dependencies JSON`);
+				await this._client.query(`INSERT IGNORE INTO _schema_version (version, description) VALUES (6, 'Add dependencies JSON column to repo_map_symbols (Epic 28-3)')`);
+				log$1.info({
+					component: "dolt-state",
+					migration: "v5-to-v6",
+					column: "dependencies",
+					table: "repo_map_symbols"
+				}, "Applied migration v5-to-v6: added dependencies column to repo_map_symbols");
+			}
+		} catch {
+			log$1.debug("Skipping repo_map_symbols migration: table not yet created");
+		}
 		log$1.debug("Schema migrations applied");
 	}
 	/**
@@ -20478,6 +20537,7 @@ async function runRunAction(options) {
 			return 1;
 		}
 		const db = dbWrapper.db;
+		const telemetryPersistence = telemetryEnabled ? new TelemetryPersistence(db) : void 0;
 		const packLoader = createPackLoader();
 		let pack;
 		try {
@@ -20547,6 +20607,33 @@ async function runRunAction(options) {
 		if (!injectedRegistry) throw new Error("AdapterRegistry is required — must be initialized at CLI startup");
 		const routingConfigPath = join(projectRoot, "substrate.routing.yml");
 		const routingResolver = RoutingResolver.createWithFallback(routingConfigPath, logger);
+		let routingTokenAccumulator;
+		let routingConfig;
+		try {
+			routingConfig = loadModelRoutingConfig(routingConfigPath);
+		} catch {
+			logger.debug("Routing config not loadable — RoutingTokenAccumulator skipped");
+		}
+		let routingTuner;
+		if (routingConfig !== void 0) {
+			const kvStateStore = new FileStateStore({ basePath: join(dbRoot, ".substrate") });
+			routingTokenAccumulator = new RoutingTokenAccumulator(routingConfig, kvStateStore, logger);
+			eventBus.on("routing:model-selected", (payload) => {
+				routingTokenAccumulator.onRoutingSelected({
+					dispatchId: payload.dispatchId,
+					phase: payload.phase,
+					model: payload.model
+				});
+			});
+			eventBus.on("agent:completed", (payload) => {
+				routingTokenAccumulator.onAgentCompleted({
+					dispatchId: payload.dispatchId,
+					inputTokens: payload.inputTokens ?? 0,
+					outputTokens: payload.outputTokens ?? 0
+				});
+			});
+			if (routingConfig.auto_tune === true) routingTuner = new RoutingTuner(kvStateStore, new RoutingRecommender(logger), eventBus, routingConfigPath, logger);
+		}
 		const statePath = join(dbRoot, ".substrate", "state");
 		const isDoltAvailable = existsSync(join(statePath, ".dolt"));
 		let repoMapInjector;
@@ -20556,7 +20643,8 @@ async function runRunAction(options) {
 			const doltClient = new DoltClient({ repoPath: statePath });
 			const symbolRepo = new DoltSymbolRepository(doltClient, logger);
 			const metaRepo = new DoltRepoMapMetaRepository(doltClient);
-			const queryEngine = new RepoMapQueryEngine(symbolRepo, logger);
+			const repoMapTelemetry = telemetryPersistence !== void 0 ? new RepoMapTelemetry(telemetryPersistence, logger) : void 0;
+			const queryEngine = new RepoMapQueryEngine(symbolRepo, logger, repoMapTelemetry);
 			repoMapInjector = new RepoMapInjector(queryEngine, logger);
 			repoMapModule = new RepoMapModule(metaRepo, logger);
 			logger.debug("repo-map injector constructed (Dolt backend detected)");
@@ -20810,6 +20898,17 @@ async function runRunAction(options) {
 					});
 				}
 			});
+			eventBus.on("routing:model-selected", (payload) => {
+				ndjsonEmitter.emit({
+					type: "routing:model-selected",
+					ts: new Date().toISOString(),
+					dispatch_id: payload.dispatchId,
+					task_type: payload.taskType,
+					phase: payload.phase,
+					model: payload.model,
+					source: payload.source
+				});
+			});
 			eventBus.on("orchestrator:story-complete", (payload) => {
 				ndjsonEmitter.emit({
 					type: "story:done",
@@ -20944,7 +21043,19 @@ async function runRunAction(options) {
 			});
 		}
 		const ingestionServer = telemetryEnabled ? new IngestionServer({ port: telemetryPort }) : void 0;
-		const telemetryPersistence = telemetryEnabled ? new TelemetryPersistence(db) : void 0;
+		if (telemetryPersistence !== void 0) {
+			const routingTelemetry = new RoutingTelemetry(telemetryPersistence, logger);
+			eventBus.on("routing:model-selected", (payload) => {
+				routingTelemetry.recordModelResolved({
+					dispatchId: payload.dispatchId,
+					taskType: payload.taskType,
+					phase: payload.phase,
+					model: payload.model,
+					source: payload.source,
+					latencyMs: 0
+				});
+			});
+		}
 		if (repoMapModule !== void 0) try {
 			const stale = await repoMapModule.checkStaleness();
 			if (stale !== null) {
@@ -20982,6 +21093,17 @@ async function runRunAction(options) {
 			process.stdout.write(`Stories: ${storyKeys.join(", ")}\n`);
 		}
 		const status = await orchestrator.run(storyKeys);
+		if (routingTokenAccumulator !== void 0) try {
+			await routingTokenAccumulator.flush(pipelineRun.id);
+			logger.debug({ runId: pipelineRun.id }, "Phase token breakdown flushed");
+		} catch (flushErr) {
+			logger.warn({ err: flushErr }, "Failed to flush phase token breakdown (best-effort)");
+		}
+		if (routingTuner !== void 0 && routingConfig !== void 0) try {
+			await routingTuner.maybeAutoTune(pipelineRun.id, routingConfig);
+		} catch (tuneErr) {
+			logger.warn({ err: tuneErr }, "RoutingTuner.maybeAutoTune failed (best-effort)");
+		}
 		const succeededKeys = [];
 		const failedKeys = [];
 		const escalatedKeys = [];
@@ -21425,5 +21547,5 @@ function registerRunCommand(program, _version = "0.0.0", projectRoot = process.c
 }
 
 //#endregion
-export { DEFAULT_CONFIG, DEFAULT_ROUTING_POLICY, DatabaseWrapper, DoltClient, DoltNotInstalled, DoltRepoMapMetaRepository, DoltSymbolRepository, FileStateStore, GitClient, GrammarLoader, IngestionServer, RepoMapInjector, RepoMapModule, RepoMapQueryEngine, RepoMapStorage, SUBSTRATE_OWNED_SETTINGS_KEYS, SymbolParser, TelemetryPersistence, VALID_PHASES, buildPipelineStatusOutput, checkDoltInstalled, createConfigSystem, createContextCompiler, createDispatcher, createDoltClient, createImplementationOrchestrator, createPackLoader, createPhaseOrchestrator, createStateStore, createStopAfterGate, findPackageRoot, formatOutput, formatPhaseCompletionSummary, formatPipelineStatusHuman, formatPipelineSummary, formatTokenTelemetry, getAllDescendantPids, getAutoHealthData, getSubstrateDefaultSettings, initializeDolt, parseDbTimestampAsUtc, registerHealthCommand, registerRunCommand, resolveBmadMethodSrcPath, resolveBmadMethodVersion, resolveMainRepoRoot, resolveStoryKeys, runAnalysisPhase, runMigrations, runPlanningPhase, runRunAction, runSolutioningPhase, validateStopAfterFromConflict };
-//# sourceMappingURL=run-fWZd8vvq.js.map
+export { AppError, DEFAULT_CONFIG, DEFAULT_ROUTING_POLICY, DatabaseWrapper, DoltClient, DoltNotInstalled, DoltRepoMapMetaRepository, DoltSymbolRepository, ERR_REPO_MAP_STORAGE_WRITE, FileStateStore, GitClient, GrammarLoader, IngestionServer, RepoMapInjector, RepoMapModule, RepoMapQueryEngine, RepoMapStorage, SUBSTRATE_OWNED_SETTINGS_KEYS, SymbolParser, TelemetryPersistence, VALID_PHASES, buildPipelineStatusOutput, checkDoltInstalled, createConfigSystem, createContextCompiler, createDispatcher, createDoltClient, createImplementationOrchestrator, createPackLoader, createPhaseOrchestrator, createStateStore, createStopAfterGate, findPackageRoot, formatOutput, formatPhaseCompletionSummary, formatPipelineStatusHuman, formatPipelineSummary, formatTokenTelemetry, getAllDescendantPids, getAutoHealthData, getSubstrateDefaultSettings, initializeDolt, parseDbTimestampAsUtc, registerHealthCommand, registerRunCommand, resolveBmadMethodSrcPath, resolveBmadMethodVersion, resolveMainRepoRoot, resolveStoryKeys, runAnalysisPhase, runMigrations, runPlanningPhase, runRunAction, runSolutioningPhase, validateStopAfterFromConflict };
+//# sourceMappingURL=run-CvQCHfTV.js.map

package/dist/schema.sql

@@ -215,7 +215,8 @@ CREATE TABLE IF NOT EXISTS repo_map_symbols (
   signature   TEXT,
   line_number INT                   NOT NULL DEFAULT 0,
   exported    TINYINT(1)            NOT NULL DEFAULT 0,
-  file_hash   VARCHAR(64)           NOT NULL,
+  file_hash     VARCHAR(64)           NOT NULL,
+  dependencies  JSON,
   PRIMARY KEY (id)
 );
 
@@ -234,3 +235,4 @@ CREATE TABLE IF NOT EXISTS repo_map_meta (
 );
 
 INSERT IGNORE INTO _schema_version (version, description) VALUES (5, 'Add repo_map_symbols and repo_map_meta tables (Epic 28-2)');
+INSERT IGNORE INTO _schema_version (version, description) VALUES (6, 'Add dependencies JSON column to repo_map_symbols (Epic 28-3)');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "substrate-ai",
-  "version": "0.4.7",
+  "version": "0.4.8",
   "description": "Substrate — multi-agent orchestration daemon for AI coding agents",
   "type": "module",
   "license": "MIT",
@@ -75,9 +75,9 @@
   },
   "optionalDependencies": {
     "tree-sitter": "^0.21.1",
-    "tree-sitter-typescript": "^0.21.2",
     "tree-sitter-javascript": "^0.21.4",
-    "tree-sitter-python": "^0.21.0"
+    "tree-sitter-python": "^0.21.0",
+    "tree-sitter-typescript": "^0.21.2"
   },
   "devDependencies": {
     "@eslint/js": "^9.17.0",

package/dist/routing-DWCBjrt7.js

@@ -1,4 +0,0 @@
-import "./logger-D2fS2ccL.js";
-import { ModelRoutingConfigSchema, ProviderPolicySchema, RoutingConfigError, RoutingRecommender, RoutingResolver, TASK_TYPE_PHASE_MAP, loadModelRoutingConfig } from "./routing-CZfJB3y9.js";
-
-export { loadModelRoutingConfig };