substrate-ai 0.5.10 → 0.6.0

package/dist/cli/index.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { AdapterTelemetryPersistence, AppError, DEFAULT_CONFIG, DEFAULT_ROUTING_POLICY, DoltClient, DoltNotInstalled, DoltRepoMapMetaRepository, DoltSymbolRepository, ERR_REPO_MAP_STORAGE_WRITE, FileStateStore, GitClient, GrammarLoader, IngestionServer, RepoMapInjector, RepoMapModule, RepoMapQueryEngine, RepoMapStorage, SUBSTRATE_OWNED_SETTINGS_KEYS, SymbolParser, VALID_PHASES, WorkGraphRepository, buildPipelineStatusOutput, checkDoltInstalled, createConfigSystem, createContextCompiler, createDatabaseAdapter, createDispatcher, createDoltClient, createEventEmitter, createImplementationOrchestrator, createPackLoader, createPhaseOrchestrator, createStateStore, createStopAfterGate, createTelemetryAdvisor, detectCycles, findPackageRoot, formatOutput, formatPhaseCompletionSummary, formatPipelineStatusHuman, formatPipelineSummary, formatTokenTelemetry, getAllDescendantPids, getAutoHealthData, getSubstrateDefaultSettings, initSchema, initializeDolt, isSyncAdapter, parseDbTimestampAsUtc, registerHealthCommand, registerRunCommand, resolveBmadMethodSrcPath, resolveBmadMethodVersion, resolveMainRepoRoot, resolveStoryKeys, runAnalysisPhase, runPlanningPhase, runSolutioningPhase, validateStopAfterFromConflict } from "../run-BWmiveTZ.js";
+import { AdapterTelemetryPersistence, AppError, DEFAULT_CONFIG, DEFAULT_ROUTING_POLICY, DoltClient, DoltNotInstalled, DoltRepoMapMetaRepository, DoltSymbolRepository, ERR_REPO_MAP_STORAGE_WRITE, FileStateStore, GitClient, GrammarLoader, IngestionServer, RepoMapInjector, RepoMapModule, RepoMapQueryEngine, RepoMapStorage, SUBSTRATE_OWNED_SETTINGS_KEYS, SymbolParser, VALID_PHASES, WorkGraphRepository, buildPipelineStatusOutput, checkDoltInstalled, createConfigSystem, createContextCompiler, createDatabaseAdapter, createDispatcher, createDoltClient, createEventEmitter, createImplementationOrchestrator, createPackLoader, createPhaseOrchestrator, createStateStore, createStopAfterGate, createTelemetryAdvisor, detectCycles, findPackageRoot, formatOutput, formatPhaseCompletionSummary, formatPipelineStatusHuman, formatPipelineSummary, formatTokenTelemetry, getAllDescendantPids, getAutoHealthData, getSubstrateDefaultSettings, initSchema, initializeDolt, isSyncAdapter, parseDbTimestampAsUtc, registerHealthCommand, registerRunCommand, resolveBmadMethodSrcPath, resolveBmadMethodVersion, resolveMainRepoRoot, resolveStoryKeys, runAnalysisPhase, runPlanningPhase, runSolutioningPhase, validateStopAfterFromConflict } from "../run-B1WEe6SY.js";
 import { createLogger } from "../logger-D2fS2ccL.js";
 import { AdapterRegistry } from "../adapter-registry-D2zdMwVu.js";
 import { CURRENT_CONFIG_FORMAT_VERSION, CURRENT_TASK_GRAPH_VERSION, PartialSubstrateConfigSchema } from "../config-migrator-DtZW1maj.js";
@@ -2969,7 +2969,7 @@ async function runSupervisorAction(options, deps = {}) {
 								await initSchema(expAdapter);
 								const { runRunAction: runPipeline } = await import(
 									/* @vite-ignore */
-									"../run-DZGdLF4h.js"
+									"../run-IU38JGTV.js"
 );
 								const runStoryFn = async (opts) => {
 									const exitCode = await runPipeline({
@@ -3430,7 +3430,8 @@ async function runMetricsAction(options) {
 					compositeScore: scoreB.compositeScore - scoreA.compositeScore,
 					cacheHitSubScore: scoreB.cacheHitSubScore - scoreA.cacheHitSubScore,
 					ioRatioSubScore: scoreB.ioRatioSubScore - scoreA.ioRatioSubScore,
-					contextManagementSubScore: scoreB.contextManagementSubScore - scoreA.contextManagementSubScore
+					contextManagementSubScore: scoreB.contextManagementSubScore - scoreA.contextManagementSubScore,
+					tokenDensitySubScore: (scoreB.tokenDensitySubScore ?? 0) - (scoreA.tokenDensitySubScore ?? 0)
 				};
 				if (outputFormat === "json") process.stdout.write(formatOutput({
 					storyA: scoreA,
@@ -3447,6 +3448,7 @@ async function runMetricsAction(options) {
 					process.stdout.write(`  ${"Cache Hit Sub-Score".padEnd(30)} ${scoreA.cacheHitSubScore.toFixed(1).padStart(12)} ${scoreB.cacheHitSubScore.toFixed(1).padStart(12)} ${`${sign(delta.cacheHitSubScore)}${delta.cacheHitSubScore.toFixed(1)}`.padStart(10)}\n`);
 					process.stdout.write(`  ${"I/O Ratio Sub-Score".padEnd(30)} ${scoreA.ioRatioSubScore.toFixed(1).padStart(12)} ${scoreB.ioRatioSubScore.toFixed(1).padStart(12)} ${`${sign(delta.ioRatioSubScore)}${delta.ioRatioSubScore.toFixed(1)}`.padStart(10)}\n`);
 					process.stdout.write(`  ${"Context Mgmt Sub-Score".padEnd(30)} ${scoreA.contextManagementSubScore.toFixed(1).padStart(12)} ${scoreB.contextManagementSubScore.toFixed(1).padStart(12)} ${`${sign(delta.contextManagementSubScore)}${delta.contextManagementSubScore.toFixed(1)}`.padStart(10)}\n`);
+					process.stdout.write(`  ${"Token Density Sub-Score".padEnd(30)} ${(scoreA.tokenDensitySubScore ?? 0).toFixed(1).padStart(12)} ${(scoreB.tokenDensitySubScore ?? 0).toFixed(1).padStart(12)} ${`${sign(delta.tokenDensitySubScore)}${delta.tokenDensitySubScore.toFixed(1)}`.padStart(10)}\n`);
 				}
 				return 0;
 			}

package/dist/{run-BWmiveTZ.js → run-B1WEe6SY.js}

@@ -12194,10 +12194,12 @@ const EfficiencyScoreSchema = z.object({
 	cacheHitSubScore: z.number().min(0).max(100),
 	ioRatioSubScore: z.number().min(0).max(100),
 	contextManagementSubScore: z.number().min(0).max(100),
+	tokenDensitySubScore: z.number().min(0).max(100).default(0),
 	avgCacheHitRate: z.number(),
 	avgIoRatio: z.number(),
 	contextSpikeCount: z.number().int().nonnegative(),
 	totalTurns: z.number().int().nonnegative(),
+	coldStartTurnsExcluded: z.number().int().nonnegative().default(0),
 	perModelBreakdown: z.array(ModelEfficiencySchema),
 	perSourceBreakdown: z.array(SourceEfficiencySchema),
 	dispatchId: z.string().optional(),
@@ -12297,6 +12299,8 @@ var AdapterTelemetryPersistence = class {
         total_turns                   INTEGER      NOT NULL DEFAULT 0,
         per_model_json                TEXT         NOT NULL DEFAULT '[]',
         per_source_json               TEXT         NOT NULL DEFAULT '[]',
+        token_density_sub_score       DOUBLE       NOT NULL DEFAULT 0,
+        cold_start_turns_excluded     INTEGER      NOT NULL DEFAULT 0,
         dispatch_id                   TEXT,
         task_type                     TEXT,
         phase                         TEXT,
@@ -12307,6 +12311,12 @@ var AdapterTelemetryPersistence = class {
       CREATE INDEX IF NOT EXISTS idx_efficiency_story
         ON efficiency_scores (story_key, timestamp DESC)
     `);
+		try {
+			await this._adapter.exec(`ALTER TABLE efficiency_scores ADD COLUMN token_density_sub_score DOUBLE NOT NULL DEFAULT 0`);
+		} catch {}
+		try {
+			await this._adapter.exec(`ALTER TABLE efficiency_scores ADD COLUMN cold_start_turns_excluded INTEGER NOT NULL DEFAULT 0`);
+		} catch {}
 		await this._adapter.exec(`
       CREATE TABLE IF NOT EXISTS recommendations (
         id                       VARCHAR(16)   NOT NULL,
@@ -12443,13 +12453,17 @@ var AdapterTelemetryPersistence = class {
 		await this._adapter.query(`INSERT INTO efficiency_scores (
         story_key, timestamp, composite_score,
         cache_hit_sub_score, io_ratio_sub_score, context_management_sub_score,
+        token_density_sub_score,
         avg_cache_hit_rate, avg_io_ratio, context_spike_count, total_turns,
+        cold_start_turns_excluded,
         per_model_json, per_source_json,
         dispatch_id, task_type, phase
       ) VALUES (
         ?, ?, ?,
         ?, ?, ?,
+        ?,
         ?, ?, ?, ?,
+        ?,
         ?, ?,
         ?, ?, ?
       )`, [
@@ -12459,10 +12473,12 @@ var AdapterTelemetryPersistence = class {
 			score.cacheHitSubScore,
 			score.ioRatioSubScore,
 			score.contextManagementSubScore,
+			score.tokenDensitySubScore ?? 0,
 			score.avgCacheHitRate,
 			score.avgIoRatio,
 			score.contextSpikeCount,
 			score.totalTurns,
+			score.coldStartTurnsExcluded ?? 0,
 			JSON.stringify(score.perModelBreakdown),
 			JSON.stringify(score.perSourceBreakdown),
 			score.dispatchId ?? null,
@@ -12482,10 +12498,12 @@ var AdapterTelemetryPersistence = class {
 			cacheHitSubScore: row.cache_hit_sub_score,
 			ioRatioSubScore: row.io_ratio_sub_score,
 			contextManagementSubScore: row.context_management_sub_score,
+			tokenDensitySubScore: row.token_density_sub_score ?? 0,
 			avgCacheHitRate: row.avg_cache_hit_rate,
 			avgIoRatio: row.avg_io_ratio,
 			contextSpikeCount: row.context_spike_count,
 			totalTurns: row.total_turns,
+			coldStartTurnsExcluded: row.cold_start_turns_excluded ?? 0,
 			perModelBreakdown: JSON.parse(row.per_model_json),
 			perSourceBreakdown: JSON.parse(row.per_source_json),
 			...row.dispatch_id != null && { dispatchId: row.dispatch_id },
@@ -13119,8 +13137,53 @@ var IngestionServer = class {
 	}
 };
 
+//#endregion
+//#region src/modules/telemetry/task-baselines.ts
+const TASK_BASELINES = {
+	"dev-story": {
+		expectedOutputPerTurn: 550,
+		targetIoRatio: 100
+	},
+	"create-story": {
+		expectedOutputPerTurn: 1500,
+		targetIoRatio: 100
+	},
+	"code-review": {
+		expectedOutputPerTurn: 3900,
+		targetIoRatio: 50
+	},
+	"minor-fixes": {
+		expectedOutputPerTurn: 700,
+		targetIoRatio: 100
+	},
+	"test-plan": {
+		expectedOutputPerTurn: 1600,
+		targetIoRatio: 30
+	},
+	"test-expansion": {
+		expectedOutputPerTurn: 1950,
+		targetIoRatio: 15
+	}
+};
+const DEFAULT_BASELINE = {
+	expectedOutputPerTurn: 800,
+	targetIoRatio: 100
+};
+/**
+* Get the baseline for a task type, falling back to DEFAULT_BASELINE
+* when taskType is undefined, empty, or unknown.
+*/
+function getBaseline(taskType) {
+	if (taskType === void 0 || taskType === "") return DEFAULT_BASELINE;
+	return TASK_BASELINES[taskType] ?? DEFAULT_BASELINE;
+}
+
 //#endregion
 //#region src/modules/telemetry/efficiency-scorer.ts
+const W_CACHE = .25;
+const W_IO_RATIO = .25;
+const W_CONTEXT = .25;
+const W_TOKEN_DENSITY = .25;
 var EfficiencyScorer = class {
 	_logger;
 	constructor(logger$27) {
@@ -13142,27 +13205,36 @@ var EfficiencyScorer = class {
 			cacheHitSubScore: 0,
 			ioRatioSubScore: 0,
 			contextManagementSubScore: 0,
+			tokenDensitySubScore: 0,
 			avgCacheHitRate: 0,
 			avgIoRatio: 0,
 			contextSpikeCount: 0,
 			totalTurns: 0,
+			coldStartTurnsExcluded: 0,
 			perModelBreakdown: [],
 			perSourceBreakdown: []
 		};
-		const avgCacheHitRate = this._computeAvgCacheHitRate(turns);
-		const avgIoRatio = this._computeAvgIoRatio(turns);
+		const taskType = this._inferTaskType(turns);
+		const baseline = getBaseline(taskType);
+		const coldStartIds = this._identifyColdStartTurns(turns);
+		let scoringTurns = turns.filter((t) => !coldStartIds.has(t.spanId));
+		if (scoringTurns.length === 0) scoringTurns = turns;
+		const avgCacheHitRate = this._computeAvgCacheHitRate(scoringTurns);
+		const avgIoRatio = this._computeAvgIoRatio(scoringTurns);
 		const contextSpikeCount = turns.filter((t) => t.isContextSpike).length;
 		const totalTurns = turns.length;
-		const cacheHitSubScore = this._computeCacheHitSubScore(turns);
-		const ioRatioSubScore = this._computeIoRatioSubScore(turns);
-		const contextManagementSubScore = this._computeContextManagementSubScore(turns);
-		const compositeScore = Math.round(cacheHitSubScore * .4 + ioRatioSubScore * .3 + contextManagementSubScore * .3);
-		const perModelBreakdown = this._buildPerModelBreakdown(turns);
-		const perSourceBreakdown = this._buildPerSourceBreakdown(turns);
+		const cacheHitSubScore = this._computeCacheHitSubScore(scoringTurns);
+		const ioRatioSubScore = this._computeIoRatioSubScore(scoringTurns, baseline.targetIoRatio);
+		const contextManagementSubScore = this._computeContextManagementSubScore(scoringTurns);
+		const tokenDensitySubScore = this._computeTokenDensitySubScore(scoringTurns, baseline.expectedOutputPerTurn);
+		const compositeScore = Math.round(cacheHitSubScore * W_CACHE + ioRatioSubScore * W_IO_RATIO + contextManagementSubScore * W_CONTEXT + tokenDensitySubScore * W_TOKEN_DENSITY);
+		const perModelBreakdown = this._buildPerModelBreakdown(scoringTurns);
+		const perSourceBreakdown = this._buildPerSourceBreakdown(scoringTurns, baseline.targetIoRatio, baseline.expectedOutputPerTurn);
 		this._logger.info({
 			storyKey,
 			compositeScore,
-			contextSpikeCount
+			contextSpikeCount,
+			coldStartTurnsExcluded: coldStartIds.size
 		}, "Computed efficiency score");
 		return {
 			storyKey,
@@ -13171,15 +13243,41 @@ var EfficiencyScorer = class {
 			cacheHitSubScore,
 			ioRatioSubScore,
 			contextManagementSubScore,
+			tokenDensitySubScore,
 			avgCacheHitRate,
 			avgIoRatio,
 			contextSpikeCount,
 			totalTurns,
+			coldStartTurnsExcluded: coldStartIds.size,
 			perModelBreakdown,
 			perSourceBreakdown
 		};
 	}
 	/**
+	* Identify cold-start turns: the first turn per dispatchId.
+	* Returns a set of spanIds that should be excluded from scoring.
+	* Only considers turns with a non-empty dispatchId.
+	*/
+	_identifyColdStartTurns(turns) {
+		const coldStarts = new Set();
+		const seenDispatches = new Set();
+		for (const turn of turns) if (turn.dispatchId !== void 0 && turn.dispatchId !== "" && !seenDispatches.has(turn.dispatchId)) {
+			seenDispatches.add(turn.dispatchId);
+			coldStarts.add(turn.spanId);
+		}
+		return coldStarts;
+	}
+	/**
+	* Infer the task type from turns. Returns the task type only when all turns
+	* with a taskType agree (unanimous). For mixed task types (story-level
+	* scoring across dispatches), returns undefined → default baseline.
+	*/
+	_inferTaskType(turns) {
+		const types$1 = new Set();
+		for (const turn of turns) if (turn.taskType !== void 0 && turn.taskType !== "") types$1.add(turn.taskType);
+		return types$1.size === 1 ? [...types$1][0] : void 0;
+	}
+	/**
 	* Average cache hit rate across all turns, clamped to [0, 100].
 	* Formula: clamp(avgCacheHitRate × 100, 0, 100)
 	*/
@@ -13188,23 +13286,26 @@ var EfficiencyScorer = class {
 		return this._clamp(avg * 100, 0, 100);
 	}
 	/**
-	* I/O ratio sub-score: measures output productivity.
+	* I/O ratio sub-score: logarithmic output/freshInput productivity curve (Story 35-1).
 	*
-	* For code generation workloads, high context-to-output ratio is normal and
-	* desirable (agent reads large cached context, produces substantial code).
-	* The old formula penalized this. New formula uses output-to-fresh-input ratio:
-	*   - outputTokens / max(freshInputTokens, 1) per turn
-	*   - Ratio > 1 means productive (more output than fresh input) → score 100
-	*   - Ratio < 1 → scaled linearly: ratio * 100
-	*   - Averaged across turns
+	* Replaces the old binary threshold (>=1 → 100) with a logarithmic curve
+	* that provides gradient across the observed range:
+	*   - score = clamp(log10(ratio) / log10(targetRatio) * 100, 0, 100)
+	*   - ratio = avg(outputTokens / max(freshInputTokens, 1)) across turns
+	*   - targetRatio is calibrated per task type (Story 35-2)
+	*
+	* Examples (TARGET=100): ratio 1→0, 10→50, 50→85, 100→100, 200→100(clamped)
 	*/
-	_computeIoRatioSubScore(turns) {
+	_computeIoRatioSubScore(turns, targetRatio) {
 		if (turns.length === 0) return 0;
 		const avg = turns.reduce((acc, t) => {
 			const freshInput = Math.max(t.inputTokens, 1);
 			return acc + t.outputTokens / freshInput;
 		}, 0) / turns.length;
-		return this._clamp(avg >= 1 ? 100 : avg * 100, 0, 100);
+		if (avg <= 0) return 0;
+		const logTarget = Math.log10(Math.max(targetRatio, 2));
+		const score = Math.log10(avg) / logTarget * 100;
+		return this._clamp(score, 0, 100);
 	}
 	/**
 	* Context management sub-score: penalizes context spike frequency.
@@ -13217,6 +13318,22 @@ var EfficiencyScorer = class {
 		const spikeRatio = spikeCount / totalTurns;
 		return this._clamp(100 - spikeRatio * 100, 0, 100);
 	}
+	/**
+	* Token density sub-score: output tokens per turn vs task-type baseline (Story 35-4).
+	*
+	* Measures whether the agent is producing useful output or spinning:
+	*   - score = clamp(avgOutputPerTurn / expectedOutputPerTurn * 100, 0, 100)
+	*   - expectedOutputPerTurn is calibrated per task type (Story 35-2)
+	*
+	* Below-baseline dispatches get proportionally lower scores.
+	* At-or-above-baseline dispatches score 100.
+	*/
+	_computeTokenDensitySubScore(turns, expectedOutputPerTurn) {
+		if (turns.length === 0) return 0;
+		const avgOutput = turns.reduce((acc, t) => acc + t.outputTokens, 0) / turns.length;
+		const ratio = avgOutput / Math.max(expectedOutputPerTurn, 1);
+		return this._clamp(ratio * 100, 0, 100);
+	}
 	_computeAvgCacheHitRate(turns) {
 		if (turns.length === 0) return 0;
 		const sum = turns.reduce((acc, t) => acc + t.cacheHitRate, 0);
@@ -13269,7 +13386,7 @@ var EfficiencyScorer = class {
 	* Group turns by source, computing a per-group composite score using the
 	* same formula as the overall score. Sources with zero turns are excluded.
 	*/
-	_buildPerSourceBreakdown(turns) {
+	_buildPerSourceBreakdown(turns, targetIoRatio, expectedOutputPerTurn) {
 		const groups = new Map();
 		for (const turn of turns) {
 			const key = turn.source;
@@ -13280,10 +13397,11 @@ var EfficiencyScorer = class {
 		const result = [];
 		for (const [source, groupTurns] of groups) {
 			if (groupTurns.length === 0) continue;
-			const cacheHitSub = this._computeCacheHitSubScoreForGroup(groupTurns);
-			const ioRatioSub = this._computeIoRatioSubScoreForGroup(groupTurns);
-			const contextSub = this._computeContextManagementSubScoreForGroup(groupTurns);
-			const compositeScore = Math.round(cacheHitSub * .4 + ioRatioSub * .3 + contextSub * .3);
+			const cacheHitSub = this._computeCacheHitSubScore(groupTurns);
+			const ioRatioSub = this._computeIoRatioSubScore(groupTurns, targetIoRatio);
+			const contextSub = this._computeContextManagementSubScore(groupTurns);
+			const tokenDensitySub = this._computeTokenDensitySubScore(groupTurns, expectedOutputPerTurn);
+			const compositeScore = Math.round(cacheHitSub * W_CACHE + ioRatioSub * W_IO_RATIO + contextSub * W_CONTEXT + tokenDensitySub * W_TOKEN_DENSITY);
 			result.push({
 				source,
 				compositeScore,
@@ -13292,25 +13410,6 @@ var EfficiencyScorer = class {
 		}
 		return result;
 	}
-	_computeCacheHitSubScoreForGroup(turns) {
-		if (turns.length === 0) return 0;
-		const avg = turns.reduce((acc, t) => acc + t.cacheHitRate, 0) / turns.length;
-		return this._clamp(avg * 100, 0, 100);
-	}
-	_computeIoRatioSubScoreForGroup(turns) {
-		if (turns.length === 0) return 0;
-		const avg = turns.reduce((acc, t) => {
-			const freshInput = Math.max(t.inputTokens, 1);
-			return acc + t.outputTokens / freshInput;
-		}, 0) / turns.length;
-		return this._clamp(avg >= 1 ? 100 : avg * 100, 0, 100);
-	}
-	_computeContextManagementSubScoreForGroup(turns) {
-		if (turns.length === 0) return 0;
-		const spikeCount = turns.filter((t) => t.isContextSpike).length;
-		const spikeRatio = spikeCount / turns.length;
-		return this._clamp(100 - spikeRatio * 100, 0, 100);
-	}
 	_clamp(value, min, max) {
 		return Math.max(min, Math.min(max, value));
 	}
@@ -13963,13 +14062,20 @@ var Recommender = class Recommender {
 		});
 	}
 	/**
+	* Categories whose growth is inherent to normal agentic work and not actionable.
+	* tool_outputs grows as the agent reads files, runs commands, etc. — expected behavior.
+	* conversation_history grows naturally as conversations progress.
+	*/
+	static EXPECTED_GROWTH_CATEGORIES = new Set(["tool_outputs", "conversation_history"]);
+	/**
 	* Flag semantic categories with trend === 'growing'.
 	* Severity is 'info' by default; 'warning' if percentage > 25%.
+	* Skips categories whose growth is inherent to normal agentic work.
 	*/
 	_runGrowingCategories(ctx) {
 		const { categories, storyKey, sprintId, generatedAt } = ctx;
 		if (categories.length === 0) return [];
-		const growing = categories.filter((c) => c.trend === "growing");
+		const growing = categories.filter((c) => c.trend === "growing" && !Recommender.EXPECTED_GROWTH_CATEGORIES.has(c.category));
 		return growing.map((cat, index) => {
 			const severity = cat.percentage > 25 ? "warning" : "info";
 			const actionTarget = cat.category;
@@ -14029,8 +14135,15 @@ var Recommender = class Recommender {
 		}];
 	}
 	/**
+	* Models known to be intentionally routed for lightweight tasks.
+	* These should not be flagged as "underperforming" — the orchestrator chose them
+	* deliberately for cost/speed reasons, not as a performance optimization target.
+	*/
+	static INTENTIONAL_LIGHTWEIGHT_MODELS = new Set(["claude-haiku-4-5-20251001", "claude-haiku-4-5"]);
+	/**
 	* If more than one model is present, flag the underperforming model.
 	* Severity is 'info' by default; 'warning' if cache efficiency gap > 20pp.
+	* Skips flagging models that are intentionally routed for lightweight tasks.
 	*/
 	_runModelComparison(ctx) {
 		const { efficiencyScore, storyKey, sprintId, generatedAt } = ctx;
@@ -14039,6 +14152,7 @@ var Recommender = class Recommender {
 		const sorted = [...models].sort((a, b) => b.cacheHitRate - a.cacheHitRate);
 		const best = sorted[0];
 		const worst = sorted[sorted.length - 1];
+		if (Recommender.INTENTIONAL_LIGHTWEIGHT_MODELS.has(worst.model)) return [];
 		if (best.model === worst.model) return [];
 		const gapPP = (best.cacheHitRate - worst.cacheHitRate) * 100;
 		const severity = gapPP > 20 ? "warning" : "info";
@@ -15150,8 +15264,10 @@ var TelemetryAdvisor = class {
 				cacheHitSubScore: score.cacheHitSubScore,
 				ioRatioSubScore: score.ioRatioSubScore,
 				contextManagementSubScore: score.contextManagementSubScore,
+				tokenDensitySubScore: score.tokenDensitySubScore ?? 0,
 				totalTurns: score.totalTurns,
-				contextSpikeCount: score.contextSpikeCount
+				contextSpikeCount: score.contextSpikeCount,
+				coldStartTurnsExcluded: score.coldStartTurnsExcluded ?? 0
 			};
 		} catch (err) {
 			logger$6.warn({
@@ -16626,7 +16742,7 @@ function createImplementationOrchestrator(deps) {
 						const fixTemplate = await pack.getPrompt("fix-story");
 						const storyContent = await readFile$1(storyFilePath ?? "", "utf-8");
 						const complexity = computeStoryComplexity(storyContent);
-						autoApproveMaxTurns = resolveFixStoryMaxTurns(complexity.complexityScore);
+						autoApproveMaxTurns = Math.max(15, Math.floor(resolveFixStoryMaxTurns(complexity.complexityScore) / 2));
 						logComplexityResult(storyKey, complexity, autoApproveMaxTurns);
 						let reviewFeedback;
 						if (issueList.length === 0) reviewFeedback = `Verdict: ${verdict}\nIssues: Minor issues flagged but no specifics provided. Review the story ACs and fix any remaining gaps.`;
@@ -16730,7 +16846,8 @@ function createImplementationOrchestrator(deps) {
 					const storyContent = await readFile$1(storyFilePath ?? "", "utf-8");
 					{
 						const complexity = computeStoryComplexity(storyContent);
-						fixMaxTurns = resolveFixStoryMaxTurns(complexity.complexityScore);
+						const fullBudget = resolveFixStoryMaxTurns(complexity.complexityScore);
+						fixMaxTurns = taskType === "minor-fixes" ? Math.max(15, Math.floor(fullBudget / 2)) : fullBudget;
 						logComplexityResult(storyKey, complexity, fixMaxTurns);
 					}
 					let reviewFeedback;
@@ -22675,4 +22792,4 @@ function registerRunCommand(program, _version = "0.0.0", projectRoot = process.c
 
 //#endregion
 export { AdapterTelemetryPersistence, AppError, DEFAULT_CONFIG, DEFAULT_ROUTING_POLICY, DoltClient, DoltNotInstalled, DoltRepoMapMetaRepository, DoltSymbolRepository, ERR_REPO_MAP_STORAGE_WRITE, FileStateStore, GitClient, GrammarLoader, IngestionServer, RepoMapInjector, RepoMapModule, RepoMapQueryEngine, RepoMapStorage, SUBSTRATE_OWNED_SETTINGS_KEYS, SymbolParser, VALID_PHASES, WorkGraphRepository, buildPipelineStatusOutput, checkDoltInstalled, createConfigSystem, createContextCompiler, createDatabaseAdapter, createDispatcher, createDoltClient, createEventEmitter, createImplementationOrchestrator, createPackLoader, createPhaseOrchestrator, createStateStore, createStopAfterGate, createTelemetryAdvisor, detectCycles, findPackageRoot, formatOutput, formatPhaseCompletionSummary, formatPipelineStatusHuman, formatPipelineSummary, formatTokenTelemetry, getAllDescendantPids, getAutoHealthData, getSubstrateDefaultSettings, initSchema, initializeDolt, isSyncAdapter, parseDbTimestampAsUtc, registerHealthCommand, registerRunCommand, resolveBmadMethodSrcPath, resolveBmadMethodVersion, resolveMainRepoRoot, resolveStoryKeys, runAnalysisPhase, runPlanningPhase, runRunAction, runSolutioningPhase, validateStopAfterFromConflict };
-//# sourceMappingURL=run-BWmiveTZ.js.map
+//# sourceMappingURL=run-B1WEe6SY.js.map

package/dist/{run-DZGdLF4h.js → run-IU38JGTV.js}

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

package/package.json

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