substrate-ai 0.5.11 → 0.6.1

package/dist/{run-DCW67EQW.js → run-IDOmPys1.js}

@@ -7059,17 +7059,35 @@ var DispatcherImpl = class {
 /**
 * Detect the package manager / build system used in a project.
 *
-* Checks for language-specific markers in priority order:
-*   1. Node.js lockfiles → corresponding `<pm> run build`
-*   2. Python markers (pyproject.toml, poetry.lock, setup.py) → skip (no universal build step)
-*   3. Rust (Cargo.toml) → cargo build
-*   4. Go (go.mod) → go build ./...
-*   5. No markers found → skip (empty command)
+* Checks for build system markers in priority order:
+*   0. `.substrate/project-profile.yaml` → `project.buildCommand` field (most explicit, wins)
+*   1. `turbo.json` → `turbo build`
+*   2. Node.js lockfiles → corresponding `<pm> run build`
+*   3. Python markers (pyproject.toml, poetry.lock, setup.py) → skip (no universal build step)
+*   4. Rust (Cargo.toml) → skip
+*   5. Go (go.mod) → skip
+*   6. No markers found → skip (empty command)
 *
 * When a non-Node.js project is detected (or nothing is recognized), the
 * returned command is '' which causes runBuildVerification() to skip.
 */
 function detectPackageManager(projectRoot) {
+	const profilePath = join$1(projectRoot, ".substrate", "project-profile.yaml");
+	if (existsSync$1(profilePath)) try {
+		const raw = readFileSync$1(profilePath, "utf-8");
+		const parsed = yaml.load(raw);
+		const buildCommand = parsed?.project?.buildCommand;
+		if (typeof buildCommand === "string" && buildCommand.length > 0) return {
+			packageManager: "none",
+			lockfile: "project-profile.yaml",
+			command: buildCommand
+		};
+	} catch {}
+	if (existsSync$1(join$1(projectRoot, "turbo.json"))) return {
+		packageManager: "none",
+		lockfile: "turbo.json",
+		command: "turbo build"
+	};
 	const nodeCandidates = [
 		{
 			file: "pnpm-lock.yaml",
@@ -8938,6 +8956,11 @@ async function getImplementationDecisions(deps) {
 *
 * Returns the matched section content (from heading to next story heading or end),
 * or null if no matching section is found (caller falls back to full shard).
+*
+* @deprecated Used only as a migration shim for pre-37-0 projects that have
+* per-epic (key=epicId) shards in the decision store. Post-37-0 shards are
+* keyed by storyKey directly and do not need extraction. Do not delete until
+* all per-epic shards have been superseded by per-story shards (AC6).
 */
 function extractStorySection(shardContent, storyKey) {
 	if (!shardContent || !storyKey) return null;
@@ -8955,13 +8978,26 @@ function extractStorySection(shardContent, storyKey) {
 }
 /**
 * Retrieve the epic shard from the pre-fetched implementation decisions.
-* Looks for decisions with category='epic-shard', key=epicId.
-* Falls back to reading _bmad-output/epics.md on disk if decisions are empty.
 *
-* When storyKey is provided, extracts only the section for that story (AC3).
+* Lookup order (post-37-0 schema):
+*   1. Direct per-story lookup: category='epic-shard', key=storyKey  → AC4
+*      If found, return content immediately — no extractStorySection() needed.
+*   2. Migration shim (pre-37-0 fallback): category='epic-shard', key=epicId
+*      + extractStorySection() to narrow to the requested story.            → AC6
+*   3. File-based fallback: read epics.md from disk + extractStorySection(). → AC6
 */
 function getEpicShard(decisions, epicId, projectRoot, storyKey) {
 	try {
+		if (storyKey) {
+			const perStoryShard = decisions.find((d) => d.category === "epic-shard" && d.key === storyKey);
+			if (perStoryShard?.value) {
+				logger$20.debug({
+					epicId,
+					storyKey
+				}, "Found per-story epic shard (direct lookup)");
+				return perStoryShard.value;
+			}
+		}
 		const epicShard = decisions.find((d) => d.category === "epic-shard" && d.key === epicId);
 		const shardContent = epicShard?.value;
 		if (shardContent) {
@@ -8971,7 +9007,7 @@ function getEpicShard(decisions, epicId, projectRoot, storyKey) {
 					logger$20.debug({
 						epicId,
 						storyKey
-					}, "Extracted per-story section from epic shard");
+					}, "Extracted per-story section from epic shard (pre-37-0 fallback)");
 					return storySection;
 				}
 				logger$20.debug({
@@ -9525,12 +9561,9 @@ function detectDeprecatedStatusField(content) {
 }
 
 //#endregion
-//#region src/modules/compiled-workflows/dev-story.ts
-const logger$16 = createLogger("compiled-workflows:dev-story");
-/** Default timeout for dev-story dispatches in milliseconds (30 min) */
-const DEFAULT_TIMEOUT_MS$1 = 18e5;
-/** Default Vitest test patterns injected when no test-pattern decisions exist */
-const DEFAULT_VITEST_PATTERNS = `## Test Patterns (defaults)
+//#region src/modules/compiled-workflows/default-test-patterns.ts
+/** Default test patterns for Vitest/Jest/Mocha (Node.js ecosystem) */
+const VITEST_DEFAULT_PATTERNS = `## Test Patterns (defaults)
 - Framework: Vitest (NOT jest — --testPathPattern flag does not work, use -- "pattern")
 - Mock approach: vi.mock() with hoisting for module-level mocks
 - Assertion style: expect().toBe(), expect().toEqual(), expect().toThrow()
@@ -9540,6 +9573,105 @@ const DEFAULT_VITEST_PATTERNS = `## Test Patterns (defaults)
   npx vitest run --no-coverage -- "your-module-name"
 - Final validation ONLY: npm test 2>&1 | grep -E "Test Files|Tests " | tail -3
 - Do NOT run the full suite (npm test) repeatedly — it consumes excessive memory when multiple agents run in parallel`;
+/** Default test patterns for Go (stdlib testing) */
+const GO_DEFAULT_PATTERNS = `## Test Patterns (defaults)
+- Framework: Go test (stdlib)
+- Test file naming: <module>_test.go alongside source files
+- Test structure: table-driven tests using t.Run() subtests
+- Run all tests: go test ./...
+- Run specific test: go test ./... -v -run TestFunctionName
+- IMPORTANT: Run targeted tests during development: go test ./pkg/... -v -run TestSpecific
+- Assertion style: t.Errorf(), t.Fatalf(); use testify if already in go.mod (require.Equal, assert.NoError)`;
+/** Default test patterns for Gradle (JUnit 5) */
+const GRADLE_DEFAULT_PATTERNS = `## Test Patterns (defaults)
+- Framework: JUnit 5 (Gradle)
+- Test structure: @Test annotated methods in class under src/test/
+- Run all tests: ./gradlew test
+- Run specific test: ./gradlew test --tests "com.example.ClassName.methodName"
+- IMPORTANT: Run targeted tests during development: ./gradlew test --tests "ClassName"
+- Assertion style: assertThat(...).isEqualTo(...) (AssertJ) or assertEquals (JUnit)`;
+/** Default test patterns for Maven (JUnit 5) */
+const MAVEN_DEFAULT_PATTERNS = `## Test Patterns (defaults)
+- Framework: JUnit 5 (Maven)
+- Test structure: @Test annotated methods in class under src/test/
+- Run all tests: mvn test
+- Run specific test: mvn test -Dtest="ClassName#methodName"
+- IMPORTANT: Run targeted tests during development: mvn test -Dtest="ClassName"
+- Assertion style: assertThat(...).isEqualTo(...) (AssertJ) or assertEquals (JUnit)`;
+/** Default test patterns for Cargo (Rust) */
+const CARGO_DEFAULT_PATTERNS = `## Test Patterns (defaults)
+- Framework: Rust test (cargo)
+- Test file naming: #[cfg(test)] module in same file, or tests/ directory for integration tests
+- Test structure: #[test] annotated functions
+- Run all tests: cargo test
+- Run specific test: cargo test test_function_name
+- IMPORTANT: Run targeted tests during development: cargo test --lib test_module
+- Assertion style: assert_eq!, assert!, assert_ne! macros`;
+/** Default test patterns for pytest (Python) */
+const PYTEST_DEFAULT_PATTERNS = `## Test Patterns (defaults)
+- Framework: pytest
+- Test file naming: test_<module>.py or <module>_test.py
+- Test structure: test_* functions or Test* classes with test_* methods
+- Run all tests: pytest
+- Run specific test: pytest tests/test_foo.py::test_bar -v
+- IMPORTANT: Run targeted tests during development: pytest -k "test_name" -v
+- Assertion style: plain assert statements; use pytest.raises() for exceptions`;
+/**
+* Resolve the appropriate default test pattern block for the project.
+*
+* Algorithm:
+* 1. If projectRoot is undefined or empty → return VITEST_DEFAULT_PATTERNS
+* 2. Build profile path: join(projectRoot, '.substrate/project-profile.yaml')
+* 3. If file does not exist → return VITEST_DEFAULT_PATTERNS
+* 4. Parse YAML; on error → return VITEST_DEFAULT_PATTERNS
+* 5. Match project.testCommand (case-insensitive substring):
+*    go test → GO, gradlew/gradle → GRADLE, mvn → MAVEN,
+*    cargo test → CARGO, pytest → PYTEST, vitest/jest/mocha/npm → VITEST
+* 6. If testCommand unmatched, try project.language:
+*    go → GO, kotlin/java → GRADLE, rust → CARGO, python → PYTEST,
+*    typescript/javascript → VITEST
+* 7. Nothing matched → return VITEST_DEFAULT_PATTERNS
+*
+* @param projectRoot - Absolute path to the project root (or undefined)
+* @returns Stack-appropriate test pattern block string
+*/
+function resolveDefaultTestPatterns(projectRoot) {
+	if (!projectRoot) return VITEST_DEFAULT_PATTERNS;
+	const profilePath = join$1(projectRoot, ".substrate/project-profile.yaml");
+	if (!existsSync$1(profilePath)) return VITEST_DEFAULT_PATTERNS;
+	let profile = null;
+	try {
+		const content = readFileSync$1(profilePath, "utf-8");
+		profile = yaml.load(content);
+	} catch {
+		return VITEST_DEFAULT_PATTERNS;
+	}
+	if (!profile) return VITEST_DEFAULT_PATTERNS;
+	const project = profile["project"];
+	if (!project) return VITEST_DEFAULT_PATTERNS;
+	const testCommand = (project["testCommand"] ?? "").toLowerCase();
+	if (testCommand) {
+		if (testCommand.includes("cargo test")) return CARGO_DEFAULT_PATTERNS;
+		if (testCommand.includes("go test")) return GO_DEFAULT_PATTERNS;
+		if (testCommand.includes("gradlew") || testCommand.includes("gradle")) return GRADLE_DEFAULT_PATTERNS;
+		if (testCommand.includes("mvn")) return MAVEN_DEFAULT_PATTERNS;
+		if (testCommand.includes("pytest")) return PYTEST_DEFAULT_PATTERNS;
+		if (testCommand.includes("vitest") || testCommand.includes("jest") || testCommand.includes("mocha") || testCommand.includes("npm")) return VITEST_DEFAULT_PATTERNS;
+	}
+	const language = (project["language"] ?? "").toLowerCase();
+	if (language === "go") return GO_DEFAULT_PATTERNS;
+	if (language === "kotlin" || language === "java") return GRADLE_DEFAULT_PATTERNS;
+	if (language === "rust") return CARGO_DEFAULT_PATTERNS;
+	if (language === "python") return PYTEST_DEFAULT_PATTERNS;
+	if (language === "typescript" || language === "javascript") return VITEST_DEFAULT_PATTERNS;
+	return VITEST_DEFAULT_PATTERNS;
+}
+
+//#endregion
+//#region src/modules/compiled-workflows/dev-story.ts
+const logger$16 = createLogger("compiled-workflows:dev-story");
+/** Default timeout for dev-story dispatches in milliseconds (30 min) */
+const DEFAULT_TIMEOUT_MS$1 = 18e5;
 /**
 * Execute the compiled dev-story workflow.
 *
@@ -9654,8 +9786,8 @@ async function runDevStory(deps, params) {
 				count: testPatternDecisions.length
 			}, "Loaded test patterns from decision store");
 		} else {
-			testPatternsContent = DEFAULT_VITEST_PATTERNS;
-			logger$16.debug({ storyKey }, "No test-pattern decisions found — using default Vitest patterns");
+			testPatternsContent = resolveDefaultTestPatterns(deps.projectRoot);
+			logger$16.debug({ storyKey }, "No test-pattern decisions — using stack-aware defaults");
 		}
 	} catch (err) {
 		const error = err instanceof Error ? err.message : String(err);
@@ -9663,7 +9795,7 @@ async function runDevStory(deps, params) {
 			storyKey,
 			error
 		}, "Failed to load test patterns — using defaults");
-		testPatternsContent = DEFAULT_VITEST_PATTERNS;
+		testPatternsContent = resolveDefaultTestPatterns(deps.projectRoot);
 	}
 	const taskScopeContent = taskScope !== void 0 && taskScope.trim().length > 0 ? `## Task Scope for This Batch\n\nImplement ONLY the following tasks from the story:\n\n${taskScope}\n\nDo NOT implement tasks outside this list. Other tasks will be handled in separate batch dispatches.` : "";
 	const priorFilesContent = priorFiles !== void 0 && priorFiles.length > 0 ? `## Files Modified by Previous Batches\n\nThe following files were created or modified by prior batch dispatches. Review them for context before implementing:\n\n${priorFiles.map((f) => `- ${f}`).join("\n")}` : "";
@@ -10362,15 +10494,40 @@ async function runTestPlan(deps, params) {
 		return makeTestPlanFailureResult(`story_file_read_error: ${error}`);
 	}
 	const archConstraintsContent = await getArchConstraints$1(deps);
-	const { prompt, tokenCount, truncated } = assemblePrompt(template, [{
-		name: "story_content",
-		content: storyContent,
-		priority: "required"
-	}, {
-		name: "architecture_constraints",
-		content: archConstraintsContent,
-		priority: "optional"
-	}], TOKEN_CEILING);
+	let testPatternsContent = "";
+	try {
+		const solutioningDecisions = await getDecisionsByPhase(deps.db, "solutioning");
+		const testPatternDecisions = solutioningDecisions.filter((d) => d.category === "test-patterns");
+		if (testPatternDecisions.length > 0) {
+			testPatternsContent = "## Test Patterns\n" + testPatternDecisions.map((d) => `- ${d.key}: ${d.value}`).join("\n");
+			logger$14.debug({
+				storyKey,
+				count: testPatternDecisions.length
+			}, "Loaded test patterns from decision store");
+		} else {
+			testPatternsContent = resolveDefaultTestPatterns(deps.projectRoot);
+			logger$14.debug({ storyKey }, "No test-pattern decisions — using stack-aware defaults");
+		}
+	} catch {
+		testPatternsContent = resolveDefaultTestPatterns(deps.projectRoot);
+	}
+	const { prompt, tokenCount, truncated } = assemblePrompt(template, [
+		{
+			name: "story_content",
+			content: storyContent,
+			priority: "required"
+		},
+		{
+			name: "architecture_constraints",
+			content: archConstraintsContent,
+			priority: "optional"
+		},
+		{
+			name: "test_patterns",
+			content: testPatternsContent,
+			priority: "optional"
+		}
+	], TOKEN_CEILING);
 	logger$14.info({
 		storyKey,
 		tokenCount,
@@ -10575,6 +10732,23 @@ async function runTestExpansion(deps, params) {
 		});
 	}
 	const archConstraintsContent = await getArchConstraints(deps);
+	let testPatternsContent = "";
+	try {
+		const solutioningDecisions = await getDecisionsByPhase(deps.db, "solutioning");
+		const testPatternDecisions = solutioningDecisions.filter((d) => d.category === "test-patterns");
+		if (testPatternDecisions.length > 0) {
+			testPatternsContent = "## Test Patterns\n" + testPatternDecisions.map((d) => `- ${d.key}: ${d.value}`).join("\n");
+			logger$13.debug({
+				storyKey,
+				count: testPatternDecisions.length
+			}, "Loaded test patterns from decision store");
+		} else {
+			testPatternsContent = resolveDefaultTestPatterns(deps.projectRoot);
+			logger$13.debug({ storyKey }, "No test-pattern decisions — using stack-aware defaults");
+		}
+	} catch {
+		testPatternsContent = resolveDefaultTestPatterns(deps.projectRoot);
+	}
 	let gitDiffContent = "";
 	if (filesModified && filesModified.length > 0) try {
 		const templateTokens = countTokens(template);
@@ -10611,6 +10785,11 @@ async function runTestExpansion(deps, params) {
 			content: gitDiffContent,
 			priority: "important"
 		},
+		{
+			name: "test_patterns",
+			content: testPatternsContent,
+			priority: "optional"
+		},
 		{
 			name: "arch_constraints",
 			content: archConstraintsContent,
@@ -11517,7 +11696,7 @@ function registerHealthCommand(program, _version = "0.0.0", projectRoot = proces
 const logger$11 = createLogger("implementation-orchestrator:seed");
 /** Max chars for the architecture summary seeded into decisions */
 const MAX_ARCH_CHARS = 6e3;
-/** Max chars per epic shard (fallback when per-story extraction returns null) */
+/** Max chars per epic-shard decision value (per-story or per-epic fallback) */
 const MAX_EPIC_SHARD_CHARS = 12e3;
 /** Max chars for test patterns */
 const MAX_TEST_PATTERNS_CHARS = 2e3;
@@ -11634,15 +11813,18 @@ async function seedEpicShards(db, projectRoot) {
 	const shards = parseEpicShards(content);
 	let count = 0;
 	for (const shard of shards) {
-		await createDecision(db, {
-			pipeline_run_id: null,
-			phase: "implementation",
-			category: "epic-shard",
-			key: shard.epicId,
-			value: shard.content.slice(0, MAX_EPIC_SHARD_CHARS),
-			rationale: "Seeded from planning artifacts at orchestrator startup"
-		});
-		count++;
+		const subsections = parseStorySubsections(shard.epicId, shard.content);
+		for (const subsection of subsections) {
+			await createDecision(db, {
+				pipeline_run_id: null,
+				phase: "implementation",
+				category: "epic-shard",
+				key: subsection.key,
+				value: subsection.content.slice(0, MAX_EPIC_SHARD_CHARS),
+				rationale: "Seeded from planning artifacts at orchestrator startup"
+			});
+			count++;
+		}
 	}
 	await db.exec("DELETE FROM decisions WHERE phase = 'implementation' AND category = 'epic-shard-hash' AND key = 'epics-file'");
 	await createDecision(db, {
@@ -11751,13 +11933,99 @@ function parseEpicShards(content) {
 	return shards;
 }
 /**
+* Parse an epic section's content into per-story subsections.
+*
+* Matches story headings using three patterns:
+*   - Markdown headings: #{2,6} Story \d+-\d+  (e.g., ### Story 37-1: Title)
+*   - Bold:              **Story \d+-\d+**       (e.g., **Story 37-1**)
+*   - Bare key:          \d+-\d+:\s              (e.g., 37-1: Title — must start at line start)
+*
+* Each subsection spans from its heading to the next matching heading or EOF.
+*
+* AC3: If no story headings are found, returns a single per-epic fallback entry
+* keyed by epicId — preserving backward-compatible behaviour for unstructured epics.
+*/
+function parseStorySubsections(epicId, epicContent) {
+	const storyPattern = /(?:^#{2,6}\s+Story\s+(\d+-\d+)|^\*\*Story\s+(\d+-\d+)\*\*|^(\d+-\d+):\s)/gim;
+	const matches = [];
+	let match$1;
+	while ((match$1 = storyPattern.exec(epicContent)) !== null) {
+		const storyKey = match$1[1] ?? match$1[2] ?? match$1[3];
+		if (storyKey !== void 0) matches.push({
+			storyKey,
+			startIdx: match$1.index
+		});
+	}
+	if (matches.length === 0) return [{
+		key: epicId,
+		content: epicContent
+	}];
+	const result = [];
+	for (let i = 0; i < matches.length; i++) {
+		const entry = matches[i];
+		const nextEntry = matches[i + 1];
+		const start = entry.startIdx;
+		const end = nextEntry !== void 0 ? nextEntry.startIdx : epicContent.length;
+		const sectionContent = epicContent.slice(start, end).trim();
+		if (sectionContent.length > 0) result.push({
+			key: entry.storyKey,
+			content: sectionContent
+		});
+	}
+	return result;
+}
+/**
+* Read the project profile YAML synchronously.
+* Returns null on missing file, parse error, or unexpected shape.
+* Does NOT import from src/modules/project-profile/ — inline parse only.
+*
+* @internal
+*/
+function readProfileSync(projectRoot) {
+	const profilePath = join$1(projectRoot, ".substrate", "project-profile.yaml");
+	if (!existsSync$1(profilePath)) return null;
+	try {
+		const content = readFileSync$1(profilePath, "utf-8");
+		const parsed = yaml.load(content);
+		if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) return parsed;
+		return null;
+	} catch {
+		return null;
+	}
+}
+/**
 * Detect test framework and patterns from project configuration.
-* Reads package.json to determine vitest/jest/mocha and generates pattern docs.
+*
+* Detection priority:
+*   1. Profile present + packages[] non-empty  → buildMonorepoTestPatterns(packages)
+*   2. Profile present + testCommand non-empty  → mapTestCommandToPatterns(testCommand)
+*   3. No profile / profile fallthrough:
+*      a. package.json present                  → existing vitest/jest/mocha detection
+*      b. go.mod present                        → buildGoTestPatterns(projectRoot)
+*      c. build.gradle.kts or build.gradle      → buildGradleTestPatterns(projectRoot)
+*      d. pom.xml                               → buildMavenTestPatterns()
+*      e. Cargo.toml                            → buildCargoTestPatterns()
+*      f. pyproject.toml OR conftest.py         → buildPytestPatterns(projectRoot)
+*   4. Nothing matched → undefined
+*
+* @internal exported for direct unit testing
 */
 function detectTestPatterns(projectRoot) {
+	const profile = readProfileSync(projectRoot);
+	if (profile !== null) {
+		const project = profile["project"];
+		if (project !== void 0) {
+			const packages = project["packages"];
+			if (Array.isArray(packages) && packages.length > 0) return buildMonorepoTestPatterns(packages);
+			const testCommand = project["testCommand"];
+			if (typeof testCommand === "string" && testCommand.length > 0) {
+				const mapped = mapTestCommandToPatterns(testCommand);
+				if (mapped !== void 0) return mapped;
+			}
+		}
+	}
 	const pkgPath = join$1(projectRoot, "package.json");
-	if (!existsSync$1(pkgPath)) return void 0;
-	try {
+	if (existsSync$1(pkgPath)) try {
 		const pkg = JSON.parse(readFileSync$1(pkgPath, "utf-8"));
 		const allDeps = {
 			...pkg.dependencies,
@@ -11777,9 +12045,17 @@ function detectTestPatterns(projectRoot) {
 			if (firstTest.includes("@jest") || firstTest.includes("jest.mock")) return buildJestPatterns(testScript);
 		}
 		return void 0;
-	} catch {
-		return void 0;
-	}
+	} catch {}
+	if (existsSync$1(join$1(projectRoot, "go.mod"))) return buildGoTestPatterns(projectRoot);
+	if (existsSync$1(join$1(projectRoot, "build.gradle.kts")) || existsSync$1(join$1(projectRoot, "build.gradle"))) return buildGradleTestPatterns(projectRoot);
+	if (existsSync$1(join$1(projectRoot, "pom.xml"))) return buildMavenTestPatterns();
+	if (existsSync$1(join$1(projectRoot, "Cargo.toml"))) return buildCargoTestPatterns();
+	if (existsSync$1(join$1(projectRoot, "conftest.py"))) return buildPytestPatterns(projectRoot);
+	if (existsSync$1(join$1(projectRoot, "pyproject.toml"))) try {
+		const pyprojectContent = readFileSync$1(join$1(projectRoot, "pyproject.toml"), "utf-8");
+		if (pyprojectContent.includes("[tool.pytest")) return buildPytestPatterns(projectRoot);
+	} catch {}
+	return void 0;
 }
 function buildVitestPatterns(testScript) {
 	const runCmd = testScript || "npx vitest run";
@@ -11816,6 +12092,196 @@ function buildMochaPatterns() {
 	].join("\n");
 }
 /**
+* Build Go test patterns.
+* Optionally detects testify from go.mod if projectRoot is non-empty.
+*
+* @internal
+*/
+function buildGoTestPatterns(projectRoot) {
+	let hasTestify = false;
+	if (projectRoot.length > 0) try {
+		const goModPath = join$1(projectRoot, "go.mod");
+		if (existsSync$1(goModPath)) {
+			const content = readFileSync$1(goModPath, "utf-8");
+			hasTestify = content.includes("github.com/stretchr/testify");
+		}
+	} catch {}
+	return [
+		"## Test Patterns",
+		"- Framework: Go test (stdlib)",
+		"- Test file naming: <module>_test.go alongside source files",
+		"- Test structure: table-driven tests with t.Run() subtests",
+		"- Run all tests: go test ./...",
+		"- Run specific test: go test ./... -v -run TestFunctionName",
+		"- Assertion style: t.Errorf(), t.Fatalf()",
+		hasTestify ? "- testify available: use require.Equal(), assert.NoError(), etc." : ""
+	].filter(Boolean).join("\n");
+}
+/**
+* Build Gradle (JVM) test patterns.
+* Detects JUnit5 vs JUnit4 if projectRoot is non-empty.
+*
+* @internal
+*/
+function buildGradleTestPatterns(projectRoot) {
+	let hasJunit5 = false;
+	if (projectRoot.length > 0) try {
+		const ktsPath = join$1(projectRoot, "build.gradle.kts");
+		const groovyPath = join$1(projectRoot, "build.gradle");
+		const buildFilePath = existsSync$1(ktsPath) ? ktsPath : groovyPath;
+		if (existsSync$1(buildFilePath)) {
+			const content = readFileSync$1(buildFilePath, "utf-8");
+			hasJunit5 = content.includes("junit-jupiter");
+		}
+	} catch {}
+	return [
+		"## Test Patterns",
+		`- Framework: ${hasJunit5 ? "JUnit 5" : "JUnit"}`,
+		"- Run all tests: ./gradlew test",
+		"- Run specific test: ./gradlew test --tests \"com.example.ClassName\"",
+		"- Test annotation: @Test",
+		hasJunit5 ? "- Assertion style: assertThat() (AssertJ), assertEquals()" : "- Assertion style: assertEquals(), assertThat()"
+	].join("\n");
+}
+/**
+* Build Maven (JVM) test patterns.
+*
+* @internal
+*/
+function buildMavenTestPatterns() {
+	return [
+		"## Test Patterns",
+		"- Framework: JUnit (Maven)",
+		"- Run all tests: mvn test",
+		"- Run specific test: mvn test -Dtest=ClassName",
+		"- Test annotation: @Test",
+		"- Assertion style: assertEquals(), assertThat()"
+	].join("\n");
+}
+/**
+* Build Cargo/Rust test patterns.
+*
+* @internal
+*/
+function buildCargoTestPatterns() {
+	return [
+		"## Test Patterns",
+		"- Framework: Rust built-in test harness (cargo test)",
+		"- Run all tests: cargo test",
+		"- Run specific test: cargo test module_name",
+		"- Test annotation: #[test]",
+		"- Assertion macros: assert_eq!(), assert!(), assert_ne!()",
+		"- Test module structure: #[cfg(test)] mod tests { ... }"
+	].join("\n");
+}
+/**
+* Build pytest (Python) test patterns.
+* Checks for conftest.py and pyproject.toml for context.
+*
+* @internal
+*/
+function buildPytestPatterns(projectRoot) {
+	let hasConftest = false;
+	if (projectRoot.length > 0) try {
+		hasConftest = existsSync$1(join$1(projectRoot, "conftest.py"));
+	} catch {}
+	return [
+		"## Test Patterns",
+		"- Framework: pytest",
+		"- Run all tests: pytest",
+		"- Run specific test: pytest tests/test_file.py -v -k \"test_name\"",
+		"- Fixture pattern: @pytest.fixture (define in conftest.py for sharing)",
+		"- Assertion style: assert statement (plain Python)",
+		hasConftest ? "- conftest.py detected: shared fixtures available" : ""
+	].filter(Boolean).join("\n");
+}
+/**
+* Map a profile testCommand string to appropriate pattern builder output.
+* Returns undefined for unrecognized commands.
+*
+* @internal
+*/
+function mapTestCommandToPatterns(testCommand) {
+	if (testCommand.includes("go test")) return buildGoTestPatterns("");
+	if (testCommand.includes("gradlew") || testCommand.includes("gradle")) return buildGradleTestPatterns("");
+	if (testCommand.includes("mvn")) return buildMavenTestPatterns();
+	if (testCommand.includes("cargo test")) return buildCargoTestPatterns();
+	if (testCommand.includes("pytest")) return buildPytestPatterns("");
+	if (testCommand.includes("vitest")) return buildVitestPatterns(testCommand);
+	if (testCommand.includes("jest")) return buildJestPatterns(testCommand);
+	if (testCommand.includes("mocha")) return buildMochaPatterns();
+	return void 0;
+}
+/**
+* Build combined test patterns for a monorepo with multiple language packages.
+* Emits a concise per-language block for each distinct language, prefixed with package path.
+*
+* @internal
+*/
+function buildMonorepoTestPatterns(packages) {
+	const seen = new Set();
+	const entries = [];
+	for (const pkg of packages) if (typeof pkg.language === "string" && pkg.language.length > 0 && !seen.has(pkg.language)) {
+		seen.add(pkg.language);
+		entries.push({
+			language: pkg.language,
+			path: pkg.path ?? ""
+		});
+	}
+	const blocks = [];
+	for (const entry of entries) {
+		const header = entry.path.length > 0 ? `# ${entry.path} (${entry.language})` : `# ${entry.language}`;
+		let block;
+		switch (entry.language) {
+			case "go":
+				block = [
+					header,
+					"- go test ./...",
+					"- go test ./... -v -run TestName",
+					"- File naming: _test.go"
+				].join("\n");
+				break;
+			case "typescript":
+			case "javascript":
+				block = [
+					header,
+					"- npx vitest run (or npm test)",
+					"- vi.mock() for mocking",
+					"- describe/it structure"
+				].join("\n");
+				break;
+			case "java":
+			case "kotlin":
+				block = [
+					header,
+					"- ./gradlew test",
+					"- @Test annotation",
+					"- assertEquals() / assertThat()"
+				].join("\n");
+				break;
+			case "rust":
+				block = [
+					header,
+					"- cargo test",
+					"- #[test] attribute",
+					"- assert_eq!() / assert!()"
+				].join("\n");
+				break;
+			case "python":
+				block = [
+					header,
+					"- pytest",
+					"- @pytest.fixture",
+					"- assert statement style"
+				].join("\n");
+				break;
+			default: block = [header, `- Run tests for ${entry.language} package`].join("\n");
+		}
+		blocks.push(block);
+	}
+	return ["## Test Patterns", ...blocks].join("\n\n");
+}
+/**
 * Find a few test files in the project to help detect the test framework.
 */
 function findTestFiles(projectRoot) {
@@ -11992,6 +12458,47 @@ function parseInterfaceContracts(storyContent, storyKey) {
 //#endregion
 //#region src/modules/implementation-orchestrator/contract-verifier.ts
 /**
+* Reads .substrate/project-profile.yaml (Story 37-1) and determines whether
+* TypeScript type-checking is appropriate for this project.
+*
+* Detection order:
+*   1. No profile → true (preserve pre-37-4 behavior)
+*   2. `packages` array non-empty → true iff any package is typescript/javascript
+*   3. `packages` empty/absent → infer from `buildCommand` — true for npm/pnpm/yarn/bun/turbo/tsc
+*   4. Parse error → true (conservative, allow tsc)
+*
+* Uses synchronous I/O to avoid making verifyContracts async (Story 37-3 pattern).
+* Does NOT import from src/modules/project-profile/ to avoid circular-dependency risk.
+*/
+function shouldRunTscCheck(projectRoot) {
+	const profilePath = join$1(projectRoot, ".substrate", "project-profile.yaml");
+	if (!existsSync$1(profilePath)) return true;
+	try {
+		const raw = readFileSync$1(profilePath, "utf-8");
+		const parsed = yaml.load(raw);
+		if (!parsed) return true;
+		const project = parsed?.project;
+		if (!project) return true;
+		const packages = project["packages"];
+		if (Array.isArray(packages) && packages.length > 0) return packages.some((p) => p.language === "typescript" || p.language === "javascript");
+		const buildCommand = project["buildCommand"];
+		if (typeof buildCommand === "string" && buildCommand.length > 0) {
+			const tsIndicators = [
+				"npm",
+				"pnpm",
+				"yarn",
+				"bun",
+				"tsc",
+				"turbo"
+			];
+			return tsIndicators.some((ind) => buildCommand.includes(ind));
+		}
+		return true;
+	} catch {
+		return true;
+	}
+}
+/**
 * Verify all declared contract export/import pairs after sprint completion.
 *
 * @param declarations - All ContractDeclaration entries from the decision store
@@ -12023,80 +12530,82 @@ function verifyContracts(declarations, projectRoot) {
 			});
 		}
 	}
-	const tsconfigPath = join$1(projectRoot, "tsconfig.json");
-	const tscBinPath = join$1(projectRoot, "node_modules", ".bin", "tsc");
-	if (existsSync$1(tsconfigPath) && existsSync$1(tscBinPath)) {
-		let tscOutput = "";
-		let tscFailed = false;
-		try {
-			execSync(`"${tscBinPath}" --noEmit`, {
-				cwd: projectRoot,
-				timeout: 12e4,
-				encoding: "utf-8",
-				stdio: [
-					"pipe",
-					"pipe",
-					"pipe"
-				]
-			});
-		} catch (err) {
-			tscFailed = true;
-			if (err != null && typeof err === "object") {
-				const e = err;
-				const stdoutStr = typeof e.stdout === "string" ? e.stdout : Buffer.isBuffer(e.stdout) ? e.stdout.toString("utf-8") : "";
-				const stderrStr = typeof e.stderr === "string" ? e.stderr : Buffer.isBuffer(e.stderr) ? e.stderr.toString("utf-8") : "";
-				tscOutput = [stdoutStr, stderrStr].filter((s) => s.length > 0).join("\n");
-				if (!tscOutput && e.message) tscOutput = e.message;
-			}
-		}
-		if (tscFailed) {
-			const truncatedOutput = tscOutput.slice(0, 1e3);
-			const matchedExports = new Set();
-			for (const exp of exports) {
-				if (!exp.filePath) continue;
-				if (tscOutput.includes(exp.filePath)) {
-					matchedExports.add(exp.contractName);
-					const importers = imports.filter((i) => i.contractName === exp.contractName);
-					if (importers.length > 0) for (const imp of importers) mismatches.push({
-						exporter: exp.storyKey,
-						importer: imp.storyKey,
-						contractName: exp.contractName,
-						mismatchDescription: `TypeScript type-check failed for ${exp.filePath}: ${truncatedOutput}`
-					});
-					else mismatches.push({
-						exporter: exp.storyKey,
-						importer: null,
-						contractName: exp.contractName,
-						mismatchDescription: `TypeScript type-check failed for ${exp.filePath}: ${truncatedOutput}`
-					});
+	if (shouldRunTscCheck(projectRoot)) {
+		const tsconfigPath = join$1(projectRoot, "tsconfig.json");
+		const tscBinPath = join$1(projectRoot, "node_modules", ".bin", "tsc");
+		if (existsSync$1(tsconfigPath) && existsSync$1(tscBinPath)) {
+			let tscOutput = "";
+			let tscFailed = false;
+			try {
+				execSync(`"${tscBinPath}" --noEmit`, {
+					cwd: projectRoot,
+					timeout: 12e4,
+					encoding: "utf-8",
+					stdio: [
+						"pipe",
+						"pipe",
+						"pipe"
+					]
+				});
+			} catch (err) {
+				tscFailed = true;
+				if (err != null && typeof err === "object") {
+					const e = err;
+					const stdoutStr = typeof e.stdout === "string" ? e.stdout : Buffer.isBuffer(e.stdout) ? e.stdout.toString("utf-8") : "";
+					const stderrStr = typeof e.stderr === "string" ? e.stderr : Buffer.isBuffer(e.stderr) ? e.stderr.toString("utf-8") : "";
+					tscOutput = [stdoutStr, stderrStr].filter((s) => s.length > 0).join("\n");
+					if (!tscOutput && e.message) tscOutput = e.message;
 				}
 			}
-			if (matchedExports.size === 0) {
-				const reportedPairs = new Set();
+			if (tscFailed) {
+				const truncatedOutput = tscOutput.slice(0, 1e3);
+				const matchedExports = new Set();
 				for (const exp of exports) {
-					const importers = imports.filter((i) => i.contractName === exp.contractName);
-					if (importers.length > 0) for (const imp of importers) {
-						const pairKey = `${exp.storyKey}:${imp.storyKey}:${exp.contractName}`;
-						if (!reportedPairs.has(pairKey)) {
-							reportedPairs.add(pairKey);
-							mismatches.push({
-								exporter: exp.storyKey,
-								importer: imp.storyKey,
-								contractName: exp.contractName,
-								mismatchDescription: `TypeScript type-check failed: ${truncatedOutput}`
-							});
-						}
+					if (!exp.filePath) continue;
+					if (tscOutput.includes(exp.filePath)) {
+						matchedExports.add(exp.contractName);
+						const importers = imports.filter((i) => i.contractName === exp.contractName);
+						if (importers.length > 0) for (const imp of importers) mismatches.push({
+							exporter: exp.storyKey,
+							importer: imp.storyKey,
+							contractName: exp.contractName,
+							mismatchDescription: `TypeScript type-check failed for ${exp.filePath}: ${truncatedOutput}`
+						});
+						else mismatches.push({
+							exporter: exp.storyKey,
+							importer: null,
+							contractName: exp.contractName,
+							mismatchDescription: `TypeScript type-check failed for ${exp.filePath}: ${truncatedOutput}`
+						});
 					}
-					else {
-						const pairKey = `${exp.storyKey}:null:${exp.contractName}`;
-						if (!reportedPairs.has(pairKey)) {
-							reportedPairs.add(pairKey);
-							mismatches.push({
-								exporter: exp.storyKey,
-								importer: null,
-								contractName: exp.contractName,
-								mismatchDescription: `TypeScript type-check failed: ${truncatedOutput}`
-							});
+				}
+				if (matchedExports.size === 0) {
+					const reportedPairs = new Set();
+					for (const exp of exports) {
+						const importers = imports.filter((i) => i.contractName === exp.contractName);
+						if (importers.length > 0) for (const imp of importers) {
+							const pairKey = `${exp.storyKey}:${imp.storyKey}:${exp.contractName}`;
+							if (!reportedPairs.has(pairKey)) {
+								reportedPairs.add(pairKey);
+								mismatches.push({
+									exporter: exp.storyKey,
+									importer: imp.storyKey,
+									contractName: exp.contractName,
+									mismatchDescription: `TypeScript type-check failed: ${truncatedOutput}`
+								});
+							}
+						}
+						else {
+							const pairKey = `${exp.storyKey}:null:${exp.contractName}`;
+							if (!reportedPairs.has(pairKey)) {
+								reportedPairs.add(pairKey);
+								mismatches.push({
+									exporter: exp.storyKey,
+									importer: null,
+									contractName: exp.contractName,
+									mismatchDescription: `TypeScript type-check failed: ${truncatedOutput}`
+								});
+							}
 						}
 					}
 				}
@@ -12194,10 +12703,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 +12808,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 +12820,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 +12962,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 +12982,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 +13007,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 +13646,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 +13714,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 +13752,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 +13795,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).
+	*
+	* 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)
 	*
-	* 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
+	* 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 +13827,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 +13895,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 +13906,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 +13919,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));
 	}
@@ -15165,8 +15773,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({
@@ -22691,4 +23301,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-DCW67EQW.js.map
+//# sourceMappingURL=run-IDOmPys1.js.map