substrate-ai 0.4.6 → 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-CkYqARL5.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-B_W_-Pp9.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-B_W_-Pp9.js → run-BGgReI0e.js}

@@ -1,8 +1,8 @@
-import { registerRunCommand, runRunAction } from "./run-CkYqARL5.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-CkYqARL5.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");
 	}
 	/**
@@ -12632,6 +12691,7 @@ var Categorizer = class {
 		if (lower.includes("conversation") || lower.includes("history") || lower.includes("chat")) return "conversation_history";
 		if (lower.includes("user") || lower.includes("human")) return "user_prompts";
 		if (toolName !== void 0 && toolName.length > 0) return "tool_outputs";
+		if (lower === "log_turn") return "conversation_history";
 		return "other";
 	}
 	/**
@@ -12665,6 +12725,75 @@ var Categorizer = class {
 		return "stable";
 	}
 	/**
+	* Compute per-category token statistics from TurnAnalysis data (not raw spans).
+	*
+	* All six SemanticCategory values are always present in the result (zero-token
+	* categories are included with totalTokens: 0). Results are sorted by
+	* totalTokens descending.
+	*
+	* Trend is computed by comparing first-half vs second-half turn token attribution
+	* for each category, using the same 1.2×/0.8× thresholds as computeTrend().
+	*
+	* @param turns - TurnAnalysis[] for the story
+	*/
+	computeCategoryStatsFromTurns(turns) {
+		if (turns.length === 0) return ALL_CATEGORIES.map((category) => ({
+			category,
+			totalTokens: 0,
+			percentage: 0,
+			eventCount: 0,
+			avgTokensPerEvent: 0,
+			trend: "stable"
+		}));
+		const grandTotal = turns.reduce((sum, t) => sum + t.inputTokens + t.outputTokens, 0);
+		const buckets = new Map();
+		for (const cat of ALL_CATEGORIES) buckets.set(cat, {
+			total: 0,
+			count: 0,
+			first: 0,
+			second: 0
+		});
+		const half = Math.floor(turns.length / 2);
+		for (let i = 0; i < turns.length; i++) {
+			const turn = turns[i];
+			const cat = this.classify(turn.name, turn.toolName);
+			const bucket = buckets.get(cat);
+			const tokens = turn.inputTokens + turn.outputTokens;
+			bucket.total += tokens;
+			bucket.count += 1;
+			if (i < half) bucket.first += tokens;
+			else bucket.second += tokens;
+		}
+		const results = ALL_CATEGORIES.map((category) => {
+			const bucket = buckets.get(category);
+			const totalTokens = bucket.total;
+			const eventCount = bucket.count;
+			const percentage = grandTotal > 0 ? Math.round(totalTokens / grandTotal * 100 * 1e3) / 1e3 : 0;
+			const avgTokensPerEvent = eventCount > 0 ? totalTokens / eventCount : 0;
+			let trend = "stable";
+			if (turns.length >= 2) {
+				const { first, second } = bucket;
+				if (first === 0 && second === 0) trend = "stable";
+				else if (first === 0) trend = "growing";
+				else if (second > 1.2 * first) trend = "growing";
+				else if (second < .8 * first) trend = "shrinking";
+			}
+			return {
+				category,
+				totalTokens,
+				percentage,
+				eventCount,
+				avgTokensPerEvent,
+				trend
+			};
+		});
+		this._logger.debug({
+			categories: results.length,
+			grandTotal
+		}, "Computed category stats from turns");
+		return results.sort((a, b) => b.totalTokens - a.totalTokens);
+	}
+	/**
 	* Compute per-category token statistics for a complete set of spans.
 	*
 	* All six SemanticCategory values are always present in the result (zero-token
@@ -12794,6 +12923,54 @@ var ConsumerAnalyzer = class {
 		return results.sort((a, b) => b.totalTokens - a.totalTokens);
 	}
 	/**
+	* Group turns by consumer key (model|toolName), rank by totalTokens descending,
+	* and return ConsumerStats for each non-zero-token group.
+	*
+	* @param turns - All TurnAnalysis records for the story
+	*/
+	analyzeFromTurns(turns) {
+		if (turns.length === 0) return [];
+		const grandTotal = turns.reduce((sum, t) => sum + t.inputTokens + t.outputTokens, 0);
+		const groups = new Map();
+		for (const turn of turns) {
+			const key = this._buildConsumerKeyFromTurn(turn);
+			const existing = groups.get(key);
+			if (existing !== void 0) existing.push(turn);
+			else groups.set(key, [turn]);
+		}
+		const results = [];
+		for (const [consumerKey, groupTurns] of groups) {
+			const totalTokens = groupTurns.reduce((sum, t) => sum + t.inputTokens + t.outputTokens, 0);
+			if (totalTokens === 0) continue;
+			const percentage = grandTotal > 0 ? Math.round(totalTokens / grandTotal * 100 * 1e3) / 1e3 : 0;
+			const eventCount = groupTurns.length;
+			const firstTurn = groupTurns[0];
+			const category = this._categorizer.classify(firstTurn.name, firstTurn.toolName);
+			const sorted = groupTurns.slice().sort((a, b) => b.inputTokens + b.outputTokens - (a.inputTokens + a.outputTokens));
+			const topInvocations = sorted.slice(0, 20).map((t) => ({
+				spanId: t.spanId,
+				name: t.name,
+				toolName: t.toolName,
+				totalTokens: t.inputTokens + t.outputTokens,
+				inputTokens: t.inputTokens,
+				outputTokens: t.outputTokens
+			}));
+			results.push({
+				consumerKey,
+				category,
+				totalTokens,
+				percentage,
+				eventCount,
+				topInvocations
+			});
+		}
+		this._logger.debug({
+			consumers: results.length,
+			grandTotal
+		}, "Computed consumer stats from turns");
+		return results.sort((a, b) => b.totalTokens - a.totalTokens);
+	}
+	/**
 	* Build a stable, collision-resistant consumer key from a span.
 	* Format: `operationName|toolName` (tool part is empty string if absent).
 	*/
@@ -12803,6 +12980,15 @@ var ConsumerAnalyzer = class {
 		return `${operationPart}|${toolPart}`;
 	}
 	/**
+	* Build a stable consumer key from a turn.
+	* Format: `model|toolName` (tool part is empty string if absent).
+	*/
+	_buildConsumerKeyFromTurn(turn) {
+		const modelPart = (turn.model ?? "unknown").slice(0, 200);
+		const toolPart = (turn.toolName ?? "").slice(0, 100);
+		return `${modelPart}|${toolPart}`;
+	}
+	/**
 	* Extract a tool name from span attributes, checking three known attribute keys
 	* in priority order.
 	*/
@@ -13200,6 +13386,99 @@ var TurnAnalyzer = class {
 	}
 };
 
+//#endregion
+//#region src/modules/telemetry/log-turn-analyzer.ts
+var LogTurnAnalyzer = class {
+	_logger;
+	constructor(logger$27) {
+		this._logger = logger$27;
+	}
+	/**
+	* Analyze a list of NormalizedLog records and produce TurnAnalysis[].
+	*
+	* Returns an empty array immediately when logs is empty or on any error.
+	*
+	* @param logs - All log records for a story
+	*/
+	analyze(logs) {
+		try {
+			if (!Array.isArray(logs) || logs.length === 0) return [];
+			const validLogs = logs.filter((log$2) => log$2 != null && typeof log$2 === "object" && ((log$2.inputTokens ?? 0) > 0 || (log$2.outputTokens ?? 0) > 0));
+			if (validLogs.length === 0) {
+				this._logger.debug("LogTurnAnalyzer: no LLM logs with tokens to analyze");
+				return [];
+			}
+			const grouped = new Map();
+			for (const log$2 of validLogs) {
+				const key = log$2.traceId != null && log$2.spanId != null ? `${log$2.traceId}:${log$2.spanId}` : log$2.logId;
+				const group = grouped.get(key) ?? [];
+				group.push(log$2);
+				grouped.set(key, group);
+			}
+			const merged = [];
+			for (const group of grouped.values()) {
+				const sorted = [...group].sort((a, b) => a.timestamp - b.timestamp);
+				const representative = sorted[0];
+				let inputTokens = 0;
+				let outputTokens = 0;
+				let cacheReadTokens = 0;
+				let costUsd = 0;
+				for (const log$2 of group) {
+					inputTokens += log$2.inputTokens ?? 0;
+					outputTokens += log$2.outputTokens ?? 0;
+					cacheReadTokens += log$2.cacheReadTokens ?? 0;
+					costUsd += log$2.costUsd ?? 0;
+				}
+				merged.push({
+					representative,
+					inputTokens,
+					outputTokens,
+					cacheReadTokens,
+					costUsd
+				});
+			}
+			merged.sort((a, b) => a.representative.timestamp - b.representative.timestamp);
+			let runningContext = 0;
+			const turns = merged.map(({ representative: log$2, inputTokens, outputTokens, cacheReadTokens, costUsd }, idx) => {
+				const prevContext = runningContext;
+				runningContext += inputTokens;
+				const freshTokens = inputTokens - cacheReadTokens;
+				const cacheHitRate = inputTokens > 0 ? cacheReadTokens / inputTokens : 0;
+				return {
+					spanId: log$2.spanId ?? log$2.logId,
+					turnNumber: idx + 1,
+					name: log$2.eventName ?? "log_turn",
+					timestamp: log$2.timestamp,
+					source: "claude-code",
+					model: log$2.model,
+					inputTokens,
+					outputTokens,
+					cacheReadTokens,
+					freshTokens,
+					cacheHitRate,
+					costUsd,
+					durationMs: 0,
+					contextSize: runningContext,
+					contextDelta: runningContext - prevContext,
+					toolName: log$2.toolName,
+					isContextSpike: false,
+					childSpans: []
+				};
+			});
+			const avg = turns.reduce((sum, t) => sum + t.inputTokens, 0) / turns.length;
+			for (const turn of turns) turn.isContextSpike = avg > 0 && turn.inputTokens > 2 * avg;
+			this._logger.debug({
+				turnCount: turns.length,
+				avg
+			}, "LogTurnAnalyzer.analyze complete");
+			return turns;
+		} catch (err) {
+			this._logger.warn({ err }, "LogTurnAnalyzer.analyze failed — returning empty array");
+			return [];
+		}
+	}
+};
+
 //#endregion
 //#region src/modules/telemetry/cost-table.ts
 /**
@@ -13764,6 +14043,7 @@ const logger$6 = createLogger("telemetry:pipeline");
 var TelemetryPipeline = class {
 	_normalizer;
 	_turnAnalyzer;
+	_logTurnAnalyzer;
 	_categorizer;
 	_consumerAnalyzer;
 	_efficiencyScorer;
@@ -13772,6 +14052,7 @@ var TelemetryPipeline = class {
 	constructor(deps) {
 		this._normalizer = deps.normalizer;
 		this._turnAnalyzer = deps.turnAnalyzer;
+		this._logTurnAnalyzer = deps.logTurnAnalyzer;
 		this._categorizer = deps.categorizer;
 		this._consumerAnalyzer = deps.consumerAnalyzer;
 		this._efficiencyScorer = deps.efficiencyScorer;
@@ -13781,8 +14062,14 @@ var TelemetryPipeline = class {
 	/**
 	* Process a batch of raw OTLP payloads through the full analysis pipeline.
 	*
-	* Each payload is normalized independently. Spans are then grouped by storyKey
-	* for per-story analysis. Items that fail normalization are skipped with a warning.
+	* Each payload is normalized independently. Spans and logs are grouped by
+	* storyKey for per-story analysis. Items that fail normalization are skipped
+	* with a warning.
+	*
+	* Dual-track analysis (Story 27-15):
+	*   - Span-derived turns via TurnAnalyzer
+	*   - Log-derived turns via LogTurnAnalyzer
+	*   - Merged (deduplicated by spanId) before downstream analysis
 	*/
 	async processBatch(items) {
 		if (items.length === 0) return;
@@ -13807,25 +14094,46 @@ var TelemetryPipeline = class {
 			spans: allSpans.length,
 			logs: allLogs.length
 		}, "TelemetryPipeline: normalized batch");
-		if (allSpans.length === 0) {
-			logger$6.debug("TelemetryPipeline: no spans normalized from batch");
+		if (allSpans.length === 0 && allLogs.length === 0) {
+			logger$6.debug("TelemetryPipeline: no spans or logs normalized from batch");
 			return;
 		}
-		const spansByStory = new Map();
 		const unknownStoryKey = "__unknown__";
+		const spansByStory = new Map();
 		for (const span of allSpans) {
 			const key = span.storyKey ?? unknownStoryKey;
 			const existing = spansByStory.get(key);
 			if (existing !== void 0) existing.push(span);
 			else spansByStory.set(key, [span]);
 		}
-		for (const [storyKey, spans] of spansByStory) {
+		const logsByStory = new Map();
+		for (const log$2 of allLogs) {
+			const key = log$2.storyKey ?? unknownStoryKey;
+			const existing = logsByStory.get(key);
+			if (existing !== void 0) existing.push(log$2);
+			else logsByStory.set(key, [log$2]);
+		}
+		const allStoryKeys = new Set();
+		for (const key of spansByStory.keys()) allStoryKeys.add(key);
+		for (const key of logsByStory.keys()) allStoryKeys.add(key);
+		for (const storyKey of allStoryKeys) {
 			if (storyKey === unknownStoryKey) {
-				logger$6.debug({ spanCount: spans.length }, "TelemetryPipeline: spans without storyKey — skipping analysis");
+				const spanCount = spansByStory.get(unknownStoryKey)?.length ?? 0;
+				const logCount = logsByStory.get(unknownStoryKey)?.length ?? 0;
+				logger$6.debug({
+					spanCount,
+					logCount
+				}, "TelemetryPipeline: data without storyKey — skipping analysis");
 				continue;
 			}
 			try {
-				await this._processStory(storyKey, spans);
+				const spans = spansByStory.get(storyKey) ?? [];
+				const logs = logsByStory.get(storyKey) ?? [];
+				const spanTurns = spans.length > 0 ? this._turnAnalyzer.analyze(spans) : [];
+				const logTurns = logs.length > 0 ? this._logTurnAnalyzer.analyze(logs) : [];
+				const mergedTurns = this._mergeTurns(spanTurns, logTurns);
+				if (spans.length > 0) await this._processStory(storyKey, spans, mergedTurns);
+				else await this._processStoryFromTurns(storyKey, mergedTurns);
 			} catch (err) {
 				logger$6.warn({
 					err,
@@ -13833,10 +14141,29 @@ var TelemetryPipeline = class {
 				}, "TelemetryPipeline: story processing failed — skipping");
 			}
 		}
-		logger$6.debug({ storyCount: spansByStory.size }, "TelemetryPipeline.processBatch complete");
+		logger$6.debug({ storyCount: allStoryKeys.size }, "TelemetryPipeline.processBatch complete");
 	}
-	async _processStory(storyKey, spans) {
-		const turns = this._turnAnalyzer.analyze(spans);
+	/**
+	* Merge span-derived and log-derived turns, deduplicating by spanId.
+	* When a span and a log share the same spanId, the span-derived turn is preferred
+	* (richer data). The merged result is sorted chronologically and renumbered.
+	*/
+	_mergeTurns(spanTurns, logTurns) {
+		if (logTurns.length === 0) return spanTurns;
+		if (spanTurns.length === 0) return logTurns;
+		const spanTurnIds = new Set(spanTurns.map((t) => t.spanId));
+		const uniqueLogTurns = logTurns.filter((t) => !spanTurnIds.has(t.spanId));
+		return [...spanTurns, ...uniqueLogTurns].sort((a, b) => a.timestamp - b.timestamp).map((t, i) => ({
+			...t,
+			turnNumber: i + 1
+		}));
+	}
+	/**
+	* Full span-based analysis path (unchanged behavior when no logs present — AC4).
+	* When mergedTurns is provided, uses those instead of computing from spans alone.
+	*/
+	async _processStory(storyKey, spans, mergedTurns) {
+		const turns = mergedTurns;
 		const categories = this._categorizer.computeCategoryStats(spans, turns);
 		const consumers = this._consumerAnalyzer.analyze(spans);
 		const efficiencyScore = this._efficiencyScorer.score(storyKey, turns);
@@ -13880,6 +14207,28 @@ var TelemetryPipeline = class {
 			recommendations: recommendations.length
 		}, "TelemetryPipeline: story analysis complete");
 	}
+	/**
+	* Log-only analysis path (AC3, AC6): processes turns from LogTurnAnalyzer
+	* through efficiency scoring and persistence.
+	*
+	* Categorizer and consumer analyzer remain span-only for now (story 27-16).
+	*/
+	async _processStoryFromTurns(storyKey, turns) {
+		if (turns.length === 0) return;
+		const efficiencyScore = this._efficiencyScorer.score(storyKey, turns);
+		await Promise.all([this._persistence.storeTurnAnalysis(storyKey, turns).catch((err) => logger$6.warn({
+			err,
+			storyKey
+		}, "Failed to store turn analysis")), this._persistence.storeEfficiencyScore(efficiencyScore).catch((err) => logger$6.warn({
+			err,
+			storyKey
+		}, "Failed to store efficiency score"))]);
+		logger$6.info({
+			storyKey,
+			turns: turns.length,
+			compositeScore: efficiencyScore.compositeScore
+		}, "TelemetryPipeline: story analysis from turns complete");
+	}
 };
 
 //#endregion
@@ -15130,13 +15479,12 @@ function createImplementationOrchestrator(deps) {
 				}
 				if (telemetryPersistence !== void 0) try {
 					const turns = await telemetryPersistence.getTurnAnalysis(storyKey);
-					const spans = [];
-					if (spans.length === 0) logger$27.debug({ storyKey }, "No spans for telemetry categorization — skipping");
+					if (turns.length === 0) logger$27.debug({ storyKey }, "No turn analysis data for telemetry categorization — skipping");
 					else {
 						const categorizer = new Categorizer(logger$27);
 						const consumerAnalyzer = new ConsumerAnalyzer(categorizer, logger$27);
-						const categoryStats = categorizer.computeCategoryStats(spans, turns);
-						const consumerStats = consumerAnalyzer.analyze(spans);
+						const categoryStats = categorizer.computeCategoryStatsFromTurns(turns);
+						const consumerStats = consumerAnalyzer.analyzeFromTurns(turns);
 						await telemetryPersistence.storeCategoryStats(storyKey, categoryStats);
 						await telemetryPersistence.storeConsumerStats(storyKey, consumerStats);
 						const growingCount = categoryStats.filter((c) => c.trend === "growing").length;
@@ -15617,6 +15965,7 @@ function createImplementationOrchestrator(deps) {
 					const telemetryPipeline = new TelemetryPipeline({
 						normalizer: new TelemetryNormalizer(pipelineLogger),
 						turnAnalyzer: new TurnAnalyzer(pipelineLogger),
+						logTurnAnalyzer: new LogTurnAnalyzer(pipelineLogger),
 						categorizer: new Categorizer(pipelineLogger),
 						consumerAnalyzer: new ConsumerAnalyzer(new Categorizer(pipelineLogger), pipelineLogger),
 						efficiencyScorer: new EfficiencyScorer(pipelineLogger),
@@ -20188,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 {
@@ -20257,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;
@@ -20266,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)");
@@ -20520,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",
@@ -20654,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) {
@@ -20692,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 = [];
@@ -21135,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-CkYqARL5.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.6",
+  "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 };