substrate-ai 0.4.6 → 0.4.7

package/dist/cli/index.js

@@ -1,5 +1,5 @@
 #!/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 { 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 { 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";
@@ -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-RerrMpM1.js"
 );
 								const runStoryFn = async (opts) => {
 									const exitCode = await runPipeline({

package/dist/{run-B_W_-Pp9.js → run-RerrMpM1.js}

@@ -1,4 +1,4 @@
-import { registerRunCommand, runRunAction } from "./run-CkYqARL5.js";
+import { registerRunCommand, runRunAction } from "./run-fWZd8vvq.js";
 import "./logger-D2fS2ccL.js";
 import "./config-migrator-DtZW1maj.js";
 import "./helpers-BihqWgVe.js";

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

@@ -12632,6 +12632,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 +12666,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 +12864,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 +12921,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 +13327,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 +13984,7 @@ const logger$6 = createLogger("telemetry:pipeline");
 var TelemetryPipeline = class {
 	_normalizer;
 	_turnAnalyzer;
+	_logTurnAnalyzer;
 	_categorizer;
 	_consumerAnalyzer;
 	_efficiencyScorer;
@@ -13772,6 +13993,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 +14003,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 +14035,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 +14082,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 +14148,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 +15420,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 +15906,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),
@@ -21136,4 +21426,4 @@ 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
+//# sourceMappingURL=run-fWZd8vvq.js.map

package/package.json

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