substrate-ai 0.6.0 → 0.6.2

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

@@ -325,7 +325,8 @@ var InMemoryDatabaseAdapter = class {
 			if (!m$1) return [];
 			return [this._evalSelectExprs(m$1[1].trim())];
 		}
-		const m = /SELECT\s+(.+?)\s+FROM\s+(\w+)(?:\s+WHERE\s+(.+))?$/is.exec(sql);
+		const stripped = sql.replace(/\s+ORDER\s+BY\s+.+?(?=\s+LIMIT\s|\s*$)/is, "").replace(/\s+LIMIT\s+\d+\s*$/is, "");
+		const m = /SELECT\s+(.+?)\s+FROM\s+(\w+)(?:\s+WHERE\s+(.+))?$/is.exec(stripped);
 		if (!m) return [];
 		const colsStr = m[1].trim();
 		const tableName = m[2];
@@ -334,6 +335,7 @@ var InMemoryDatabaseAdapter = class {
 		let rows = table.map((r) => ({ ...r }));
 		if (whereStr) rows = rows.filter((row) => this._matchWhere(whereStr.trim(), row));
 		if (colsStr === "*") return rows;
+		if (/\b(?:SUM|COALESCE|COUNT|AVG|MIN|MAX)\s*\(/i.test(colsStr)) return [this._evalAggregate(colsStr, rows)];
 		return rows.map((row) => this._projectCols(colsStr, row));
 	}
 	_update(sql) {
@@ -393,12 +395,22 @@ var InMemoryDatabaseAdapter = class {
 				if (row[notNullM[1]] === null || row[notNullM[1]] === void 0) return false;
 				continue;
 			}
+			const likeM = /^(\w+)\s+LIKE\s+'(.*)'$/is.exec(trimmed);
+			if (likeM) {
+				const colVal = row[likeM[1]];
+				if (colVal === null || colVal === void 0) return false;
+				const pattern = likeM[2].replace(/''/g, "'");
+				const escaped = pattern.replace(/[.*+?^${}()|[\]\\]/g, (ch) => ch === "%" || ch === "_" ? ch : "\\" + ch);
+				const regex = new RegExp("^" + escaped.replace(/%/g, ".*").replace(/_/g, ".") + "$", "s");
+				if (!regex.test(String(colVal))) return false;
+				continue;
+			}
 		}
 		return true;
 	}
 	_projectCols(colsStr, row) {
 		const result = {};
-		const cols = colsStr.split(",").map((c) => c.trim());
+		const cols = this._splitTopLevelCommas(colsStr);
 		for (const col of cols) {
 			const aliasM = /^(.+?)\s+AS\s+(\w+)$/i.exec(col);
 			if (aliasM) result[aliasM[2]] = this._evalExprAgainstRow(aliasM[1].trim(), row);
@@ -408,7 +420,7 @@ var InMemoryDatabaseAdapter = class {
 	}
 	_evalSelectExprs(exprs) {
 		const result = {};
-		const parts = exprs.split(",").map((p) => p.trim());
+		const parts = this._splitTopLevelCommas(exprs);
 		for (const part of parts) {
 			const aliasM = /^(.+?)\s+AS\s+(\w+)$/i.exec(part);
 			if (aliasM) result[aliasM[2]] = this._evalLiteral(aliasM[1].trim());
@@ -431,6 +443,87 @@ var InMemoryDatabaseAdapter = class {
 		return literal;
 	}
 	/**
+	* Split a string by commas that are NOT inside parentheses.
+	* E.g. "COALESCE(SUM(x), 0) as a, y" → ["COALESCE(SUM(x), 0) as a", "y"]
+	*/
+	_splitTopLevelCommas(str) {
+		const parts = [];
+		let current = "";
+		let depth = 0;
+		let inStr = false;
+		for (let i = 0; i < str.length; i++) {
+			const ch = str[i];
+			if (ch === "'" && !inStr) {
+				inStr = true;
+				current += ch;
+			} else if (ch === "'" && inStr) if (str[i + 1] === "'") {
+				current += "''";
+				i++;
+			} else {
+				inStr = false;
+				current += ch;
+			}
+			else if (!inStr && ch === "(") {
+				depth++;
+				current += ch;
+			} else if (!inStr && ch === ")") {
+				depth--;
+				current += ch;
+			} else if (!inStr && ch === "," && depth === 0) {
+				parts.push(current.trim());
+				current = "";
+			} else current += ch;
+		}
+		if (current.trim() !== "") parts.push(current.trim());
+		return parts;
+	}
+	/**
+	* Evaluate aggregate SELECT expressions (SUM, COALESCE, COUNT) across
+	* a set of filtered rows, returning a single result row.
+	*/
+	_evalAggregate(colsStr, rows) {
+		const result = {};
+		const cols = this._splitTopLevelCommas(colsStr);
+		for (const col of cols) {
+			const aliasM = /^(.+?)\s+AS\s+(\w+)$/i.exec(col);
+			const expr = aliasM ? aliasM[1].trim() : col.trim();
+			const alias = aliasM ? aliasM[2] : col.trim();
+			result[alias] = this._evalAggregateExpr(expr, rows);
+		}
+		return result;
+	}
+	/**
+	* Evaluate a single aggregate expression against a set of rows.
+	* Supports: SUM(col), COALESCE(expr, default), COUNT(*).
+	*/
+	_evalAggregateExpr(expr, rows) {
+		const trimmed = expr.trim();
+		const coalesceM = /^COALESCE\((.+)\)$/i.exec(trimmed);
+		if (coalesceM) {
+			const args = this._splitTopLevelCommas(coalesceM[1]);
+			for (const arg of args) {
+				const val = this._evalAggregateExpr(arg.trim(), rows);
+				if (val !== null && val !== void 0) return val;
+			}
+			return null;
+		}
+		const sumM = /^SUM\((\w+)\)$/i.exec(trimmed);
+		if (sumM) {
+			const col = sumM[1];
+			if (rows.length === 0) return null;
+			let total = 0;
+			for (const row of rows) total += Number(row[col] ?? 0);
+			return total;
+		}
+		if (/^COUNT\(\*\)$/i.test(trimmed)) return rows.length;
+		const countM = /^COUNT\((\w+)\)$/i.exec(trimmed);
+		if (countM) {
+			const col = countM[1];
+			return rows.filter((r) => r[col] !== null && r[col] !== void 0).length;
+		}
+		return this._evalLiteral(trimmed);
+	}
+	/**
 	* Parse a comma-separated list of SQL literal values.
 	* Handles: NULL, numbers, single-quoted strings.
 	* Simple split by comma (assumes no commas inside string values).
@@ -1829,8 +1922,8 @@ function resolveBmadMethodVersion(fromDir = __dirname) {
 const BMAD_BASELINE_TOKENS_FULL = 56800;
 /** BMAD baseline token total for create+dev+review comparison */
 const BMAD_BASELINE_TOKENS = 23800;
-/** Story key pattern: <epic>-<story> e.g. "10-1" */
-const STORY_KEY_PATTERN$1 = /^\d+-\d+$/;
+/** Story key pattern: <epic>-<story> e.g. "10-1", "1-1a", "NEW-26" */
+const STORY_KEY_PATTERN$1 = /^[A-Za-z0-9]+-[A-Za-z0-9]+$/;
 /**
 * Top-level keys in .claude/settings.json that substrate owns.
 * On init, these are set/updated unconditionally.
@@ -3441,6 +3534,28 @@ const PIPELINE_EVENT_METADATA = [
 				description: "Overall verification result."
 			}
 		]
+	},
+	{
+		type: "pipeline:profile-stale",
+		description: "Project profile may be outdated. Non-blocking warning — run `substrate init --force` to re-detect.",
+		when: "After all stories complete, before pipeline:complete. Emitted when staleness indicators are found.",
+		fields: [
+			{
+				name: "ts",
+				type: "string",
+				description: "Timestamp."
+			},
+			{
+				name: "message",
+				type: "string",
+				description: "Human-readable staleness warning message."
+			},
+			{
+				name: "indicators",
+				type: "string[]",
+				description: "List of staleness indicators (e.g., \"turbo.json exists but profile says type: single\")."
+			}
+		]
 	}
 ];
 /**
@@ -6338,7 +6453,8 @@ var DispatcherShuttingDownError = class extends Error {
 const YAML_ANCHOR_KEYS = [
 	"result:",
 	"verdict:",
-	"story_file:"
+	"story_file:",
+	"expansion_priority:"
 ];
 /**
 * Extract the YAML result block from sub-agent output.
@@ -7059,17 +7175,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",
@@ -7170,6 +7304,16 @@ function runBuildVerification(options) {
 				output: combinedOutput,
 				reason: "build-verification-timeout"
 			};
+			const missingScriptPattern = /Missing script[:\s]|No script found|Command "build" not found/i;
+			if (missingScriptPattern.test(combinedOutput)) {
+				logger$23.warn("Build script not found — skipping pre-flight (greenfield repo)");
+				return {
+					status: "skipped",
+					exitCode,
+					output: combinedOutput,
+					reason: "build-script-not-found"
+				};
+			}
 			return {
 				status: "failed",
 				exitCode,
@@ -7647,12 +7791,12 @@ var FileStateStore = class {
 //#region src/modules/state/dolt-store.ts
 const log = createLogger("modules:state:dolt");
 /**
-* Validate that a story key matches the expected pattern (e.g. "26-7").
+* Validate that a story key matches the expected pattern (e.g. "26-7", "1-1a", "NEW-26").
 * Prevents SQL injection via string-interpolated identifiers.
 */
-const STORY_KEY_PATTERN = /^[0-9]+-[0-9]+$/;
+const STORY_KEY_PATTERN = /^[A-Za-z0-9]+-[A-Za-z0-9]+$/;
 function assertValidStoryKey(storyKey) {
-	if (!STORY_KEY_PATTERN.test(storyKey)) throw new DoltQueryError("assertValidStoryKey", `Invalid story key: '${storyKey}'. Must match pattern <number>-<number>.`);
+	if (!STORY_KEY_PATTERN.test(storyKey)) throw new DoltQueryError("assertValidStoryKey", `Invalid story key: '${storyKey}'. Must match pattern <segment>-<segment> (e.g. "10-1", "1-1a", "NEW-26").`);
 }
 /**
 * Dolt-backed implementation of the StateStore interface.
@@ -8938,6 +9082,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 +9104,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 +9133,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({
@@ -9059,9 +9221,17 @@ function readEpicShardFromFile(projectRoot, epicId) {
 		if (!epicsPath) return "";
 		const content = readFileSync$1(epicsPath, "utf-8");
 		const epicNum = epicId.replace(/^epic-/i, "");
-		const pattern = new RegExp(`^#{2,4}\\s+(?:Epic\\s+)?${epicNum}[.:\\s].*?(?=\\n#{2,4}\\s|$)`, "ms");
-		const match$1 = pattern.exec(content);
-		return match$1 ? match$1[0].trim() : "";
+		const headingPattern = new RegExp(`^(#{2,4})\\s+(?:Epic\\s+)?${epicNum}[.:\\s]`, "m");
+		const headingMatch = headingPattern.exec(content);
+		if (!headingMatch) return "";
+		const startIdx = headingMatch.index;
+		const headingLevel = headingMatch[1].length;
+		const hashes = "#".repeat(headingLevel);
+		const endPattern = new RegExp(`\\n${hashes}\\s`, "g");
+		endPattern.lastIndex = startIdx + headingMatch[0].length;
+		const endMatch = endPattern.exec(content);
+		const endIdx = endMatch ? endMatch.index : content.length;
+		return content.slice(startIdx, endIdx).trim();
 	} catch (err) {
 		logger$20.warn({
 			epicId,
@@ -9320,9 +9490,9 @@ async function getProjectFindings(db) {
 			sections.push("**Prior escalations:**");
 			for (const d of diagnoses.slice(-3)) try {
 				const val = JSON.parse(d.value);
-				sections.push(`- ${d.key.split(":")[0]}: ${val.recommendedAction} — ${val.rationale}`);
+				sections.push(`- ${(d.key ?? "").split(":")[0]}: ${val.recommendedAction} — ${val.rationale}`);
 			} catch {
-				sections.push(`- ${d.key}: escalated`);
+				sections.push(`- ${d.key ?? "unknown"}: escalated`);
 			}
 		}
 		const highCycleStories = metrics.filter((m) => {
@@ -9337,16 +9507,16 @@ async function getProjectFindings(db) {
 			sections.push("**Stories with high review cycles:**");
 			for (const m of highCycleStories) try {
 				const val = JSON.parse(m.value);
-				sections.push(`- ${m.key.split(":")[0]}: ${val.review_cycles} cycles`);
+				sections.push(`- ${(m.key ?? "").split(":")[0]}: ${val.review_cycles} cycles`);
 			} catch {}
 		}
-		const stalls = operational.filter((o) => o.key.startsWith("stall:"));
+		const stalls = operational.filter((o) => o.key?.startsWith("stall:"));
 		if (stalls.length > 0) sections.push(`**Prior stalls:** ${stalls.length} stall event(s) recorded`);
 		if (advisoryNotes.length > 0) {
 			sections.push("**Advisory notes from prior reviews (LGTM_WITH_NOTES):**");
 			for (const n of advisoryNotes.slice(-3)) try {
 				const val = JSON.parse(n.value);
-				const storyId = n.key.split(":")[0];
+				const storyId = (n.key ?? "").split(":")[0];
 				if (typeof val.notes === "string" && val.notes.length > 0) sections.push(`- ${storyId}: ${val.notes}`);
 			} catch {
 				sections.push(`- ${n.key}: advisory notes available`);
@@ -9525,12 +9695,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 +9707,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 +9920,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 +9929,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 +10628,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 +10866,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 +10919,11 @@ async function runTestExpansion(deps, params) {
 			content: gitDiffContent,
 			priority: "important"
 		},
+		{
+			name: "test_patterns",
+			content: testPatternsContent,
+			priority: "optional"
+		},
 		{
 			name: "arch_constraints",
 			content: archConstraintsContent,
@@ -11517,7 +11830,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 +11947,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 +12067,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 +12179,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 +12226,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 +12592,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 +12664,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}`
+								});
+							}
 						}
 					}
 				}
@@ -15393,6 +16036,69 @@ function buildTargetedFilesContent(issueList) {
 	return lines.join("\n");
 }
 /**
+* Normalize a title string into a set of meaningful words for comparison.
+* Strips punctuation, lowercases, and filters out very short words (<=2 chars)
+* and common stop words to focus on content-bearing terms.
+*/
+function titleToWordSet(title) {
+	const stopWords = new Set([
+		"the",
+		"and",
+		"for",
+		"with",
+		"from",
+		"into",
+		"that",
+		"this",
+		"via"
+	]);
+	return new Set(title.toLowerCase().replace(/[^a-z0-9\s-]/g, " ").split(/[\s-]+/).filter((w) => w.length > 2 && !stopWords.has(w)));
+}
+/**
+* Compute the word overlap ratio between two titles.
+* Returns a value between 0 and 1, where 1 means all words in the smaller set
+* are present in the larger set.
+*
+* Uses the smaller set as the denominator so that a generated title that is a
+* reasonable subset or superset of the expected title still scores well.
+*/
+function computeTitleOverlap(titleA, titleB) {
+	const wordsA = titleToWordSet(titleA);
+	const wordsB = titleToWordSet(titleB);
+	if (wordsA.size === 0 || wordsB.size === 0) return 0;
+	let shared = 0;
+	for (const w of wordsA) if (wordsB.has(w)) shared++;
+	const denominator = Math.min(wordsA.size, wordsB.size);
+	return shared / denominator;
+}
+/**
+* Extract the expected story title from the epic shard content.
+*
+* Looks for patterns like:
+*   - "### Story 37-1: Turborepo monorepo scaffold"
+*   - "Story 37-1: Turborepo monorepo scaffold"
+*   - "**37-1**: Turborepo monorepo scaffold"
+*   - "37-1: Turborepo monorepo scaffold"
+*
+* Returns the title portion after the story key, or null if no match.
+*/
+function extractExpectedStoryTitle(shardContent, storyKey) {
+	if (!shardContent || !storyKey) return null;
+	const escaped = storyKey.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+	const patterns = [
+		new RegExp(`^#{2,4}\\s+Story\\s+${escaped}[:\\s]+\\s*(.+)$`, "mi"),
+		new RegExp(`^Story\\s+${escaped}[:\\s]+\\s*(.+)$`, "mi"),
+		new RegExp(`^\\*\\*${escaped}\\*\\*[:\\s]+\\s*(.+)$`, "mi"),
+		new RegExp(`^${escaped}[:\\s]+\\s*(.+)$`, "mi")
+	];
+	for (const pattern of patterns) {
+		const match$1 = pattern.exec(shardContent);
+		if (match$1?.[1]) return match$1[1].replace(/\*+$/, "").trim();
+	}
+	return null;
+}
+const TITLE_OVERLAP_WARNING_THRESHOLD = .3;
+/**
 * Map a StoryPhase to the corresponding WgStoryStatus for wg_stories writes.
 * Returns null for PENDING (no write needed).
 */
@@ -15409,6 +16115,55 @@ function wgStatusForPhase(phase) {
 	}
 }
 /**
+* Check whether `.substrate/project-profile.yaml` is stale relative to
+* the actual project structure.
+*
+* Returns an array of human-readable indicator strings. An empty array
+* means the profile appears current (or doesn't exist).
+*
+* Staleness indicators checked:
+* - Profile says `type: single` but `turbo.json` exists (should be monorepo)
+* - Profile has no Go language but `go.mod` exists
+* - Profile has no Python language but `pyproject.toml` exists
+* - Profile has no Rust language but `Cargo.toml` exists
+*/
+function checkProfileStaleness(projectRoot) {
+	const profilePath = join$1(projectRoot, ".substrate", "project-profile.yaml");
+	if (!existsSync$1(profilePath)) return [];
+	let profile;
+	try {
+		const raw = readFileSync$1(profilePath, "utf-8");
+		profile = yaml.load(raw) ?? {};
+	} catch {
+		return [];
+	}
+	const project = profile.project;
+	if (project === void 0) return [];
+	const indicators = [];
+	const declaredLanguages = new Set();
+	if (typeof project.language === "string") declaredLanguages.add(project.language);
+	if (Array.isArray(project.packages)) {
+		for (const pkg of project.packages) if (typeof pkg.language === "string") declaredLanguages.add(pkg.language);
+	}
+	if (project.type === "single" && existsSync$1(join$1(projectRoot, "turbo.json"))) indicators.push("turbo.json exists but profile says type: single (should be monorepo)");
+	const languageMarkers = [
+		{
+			file: "go.mod",
+			language: "go"
+		},
+		{
+			file: "pyproject.toml",
+			language: "python"
+		},
+		{
+			file: "Cargo.toml",
+			language: "rust"
+		}
+	];
+	for (const marker of languageMarkers) if (existsSync$1(join$1(projectRoot, marker.file)) && !declaredLanguages.has(marker.language)) indicators.push(`${marker.file} exists but profile does not declare ${marker.language}`);
+	return indicators;
+}
+/**
 * Factory function that creates an ImplementationOrchestrator instance.
 *
 * @param deps - Injected dependencies (db, pack, contextCompiler, dispatcher,
@@ -15765,8 +16520,7 @@ function createImplementationOrchestrator(deps) {
 			for (const s of _stories.values()) if (s.phase === "COMPLETE" || s.phase === "ESCALATED") completed++;
 			else if (s.phase === "PENDING") queued++;
 			else active++;
-			const timeSinceProgress = Date.now() - _lastProgressTs;
-			if (timeSinceProgress >= HEARTBEAT_INTERVAL_MS) eventBus.emit("orchestrator:heartbeat", {
+			eventBus.emit("orchestrator:heartbeat", {
 				runId: config.pipelineRunId ?? "",
 				activeDispatches: active,
 				completedDispatches: completed,
@@ -16010,6 +16764,46 @@ function createImplementationOrchestrator(deps) {
 				return;
 			}
 			storyFilePath = createResult.story_file;
+			if (createResult.story_title) try {
+				const epicId = storyKey.split("-")[0] ?? storyKey;
+				const implDecisions = await getDecisionsByPhase(db, "implementation");
+				let shardContent;
+				const perStoryShard = implDecisions.find((d) => d.category === "epic-shard" && d.key === storyKey);
+				if (perStoryShard?.value) shardContent = perStoryShard.value;
+				else {
+					const epicShard = implDecisions.find((d) => d.category === "epic-shard" && d.key === epicId);
+					if (epicShard?.value) shardContent = extractStorySection(epicShard.value, storyKey) ?? epicShard.value;
+				}
+				if (shardContent) {
+					const expectedTitle = extractExpectedStoryTitle(shardContent, storyKey);
+					if (expectedTitle) {
+						const overlap = computeTitleOverlap(expectedTitle, createResult.story_title);
+						if (overlap < TITLE_OVERLAP_WARNING_THRESHOLD) {
+							const msg = `Story title mismatch: expected "${expectedTitle}" but got "${createResult.story_title}" (word overlap: ${Math.round(overlap * 100)}%). This may indicate the create-story agent received truncated context.`;
+							logger$27.warn({
+								storyKey,
+								expectedTitle,
+								generatedTitle: createResult.story_title,
+								overlap
+							}, msg);
+							eventBus.emit("orchestrator:story-warn", {
+								storyKey,
+								msg
+							});
+						} else logger$27.debug({
+							storyKey,
+							expectedTitle,
+							generatedTitle: createResult.story_title,
+							overlap
+						}, "Story title validation passed");
+					}
+				}
+			} catch (titleValidationErr) {
+				logger$27.debug({
+					storyKey,
+					err: titleValidationErr
+				}, "Story title validation skipped due to error");
+			}
 		} catch (err) {
 			const errMsg = err instanceof Error ? err.message : String(err);
 			endPhase(storyKey, "create-story");
@@ -16532,6 +17326,28 @@ function createImplementationOrchestrator(deps) {
 					}, "Phantom review detected (0 issues + error) — retrying review once");
 					continue;
 				}
+				if (isPhantomReview && timeoutRetried) {
+					logger$27.warn({
+						storyKey,
+						reviewCycles,
+						error: reviewResult.error
+					}, "Consecutive review timeouts detected (original + retry both failed) — escalating immediately");
+					endPhase(storyKey, "code-review");
+					updateStory(storyKey, {
+						phase: "ESCALATED",
+						error: "consecutive-review-timeouts",
+						completedAt: new Date().toISOString()
+					});
+					await writeStoryMetricsBestEffort(storyKey, "escalated", reviewCycles + 1);
+					await emitEscalation({
+						storyKey,
+						lastVerdict: "consecutive-review-timeouts",
+						reviewCycles: reviewCycles + 1,
+						issues: ["Review dispatch failed twice consecutively (original + phantom-retry). Likely resource-constrained or diff too large for reviewer."]
+					});
+					await persistState();
+					return;
+				}
 				verdict = reviewResult.verdict;
 				issueList = reviewResult.issue_list ?? [];
 				if (verdict === "NEEDS_MAJOR_REWORK" && reviewCycles > 0 && previousIssueList.length > 0 && issueList.length < previousIssueList.length) {
@@ -17327,6 +18143,19 @@ function createImplementationOrchestrator(deps) {
 			} catch (err) {
 				logger$27.error({ err }, "Post-sprint contract verification threw an error — skipping");
 			}
+			if (projectRoot !== void 0) try {
+				const indicators = checkProfileStaleness(projectRoot);
+				if (indicators.length > 0) {
+					const message = "Project profile may be outdated — consider running `substrate init --force` to re-detect";
+					eventBus.emit("pipeline:profile-stale", {
+						message,
+						indicators
+					});
+					logger$27.warn({ indicators }, message);
+				}
+			} catch (err) {
+				logger$27.debug({ err }, "Profile staleness check failed (best-effort)");
+			}
 			let completed = 0;
 			let escalated = 0;
 			let failed = 0;
@@ -17457,14 +18286,14 @@ async function resolveStoryKeys(db, projectRoot, opts) {
 function parseStoryKeysFromEpics(content) {
 	if (content.length === 0) return [];
 	const keys = new Set();
-	const explicitKeyPattern = /\*\*Story key:\*\*\s*`?(\d+-\d+)(?:-[^`\s]*)?`?/g;
+	const explicitKeyPattern = /\*\*Story key:\*\*\s*`?([A-Za-z0-9]+-[A-Za-z0-9]+)(?:-[^`\s]*)?`?/g;
 	let match$1;
 	while ((match$1 = explicitKeyPattern.exec(content)) !== null) if (match$1[1] !== void 0) keys.add(match$1[1]);
-	const headingPattern = /^###\s+Story\s+(\d+)[.\-](\d+)/gm;
+	const headingPattern = /^###\s+Story\s+([A-Za-z0-9]+)[.\-]([A-Za-z0-9]+)/gm;
 	while ((match$1 = headingPattern.exec(content)) !== null) if (match$1[1] !== void 0 && match$1[2] !== void 0) keys.add(`${match$1[1]}-${match$1[2]}`);
-	const inlineStoryPattern = /Story\s+(\d+)-(\d+)[:\s]/g;
+	const inlineStoryPattern = /Story\s+([A-Za-z0-9]+)-([A-Za-z0-9]+)[:\s]/g;
 	while ((match$1 = inlineStoryPattern.exec(content)) !== null) if (match$1[1] !== void 0 && match$1[2] !== void 0) keys.add(`${match$1[1]}-${match$1[2]}`);
-	const filePathPattern = /_bmad-output\/implementation-artifacts\/(\d+-\d+)-/g;
+	const filePathPattern = /_bmad-output\/implementation-artifacts\/([A-Za-z0-9]+-[A-Za-z0-9]+)-/g;
 	while ((match$1 = filePathPattern.exec(content)) !== null) if (match$1[1] !== void 0) keys.add(match$1[1]);
 	return sortStoryKeys(Array.from(keys));
 }
@@ -17510,6 +18339,12 @@ function discoverPendingStoryKeys(projectRoot, epicNumber) {
 			allKeys = sortStoryKeys([...new Set(allKeys)]);
 		}
 	}
+	const sprintKeys = parseStoryKeysFromSprintStatus(projectRoot);
+	if (sprintKeys.length > 0) {
+		const merged = new Set(allKeys);
+		for (const k of sprintKeys) merged.add(k);
+		allKeys = sortStoryKeys([...merged]);
+	}
 	if (allKeys.length === 0) return [];
 	const existingKeys = collectExistingStoryKeys(projectRoot);
 	return allKeys.filter((k) => !existingKeys.has(k));
@@ -17560,7 +18395,7 @@ function collectExistingStoryKeys(projectRoot) {
 	} catch {
 		return existing;
 	}
-	const filePattern = /^(\d+-\d+)-/;
+	const filePattern = /^([A-Za-z0-9]+-[A-Za-z0-9]+)-/;
 	for (const entry of entries) {
 		if (!entry.endsWith(".md")) continue;
 		const m = filePattern.exec(entry);
@@ -17569,6 +18404,33 @@ function collectExistingStoryKeys(projectRoot) {
 	return existing;
 }
 /**
+* Parse story keys from sprint-status.yaml.
+* Reads the development_status map and extracts keys that match the
+* alphanumeric story key pattern (e.g., 1-1a, NEW-26, E5-accessibility).
+* Filters out epic status entries (epic-N) and retrospective entries.
+*/
+function parseStoryKeysFromSprintStatus(projectRoot) {
+	const candidates = [join$1(projectRoot, "_bmad-output", "implementation-artifacts", "sprint-status.yaml"), join$1(projectRoot, "_bmad-output", "sprint-status.yaml")];
+	const statusPath = candidates.find((p) => existsSync$1(p));
+	if (!statusPath) return [];
+	try {
+		const content = readFileSync$1(statusPath, "utf-8");
+		const keys = [];
+		const linePattern = /^\s{2}([A-Za-z0-9]+-[A-Za-z0-9]+(?:-[A-Za-z0-9-]*)?)\s*:/gm;
+		let match$1;
+		while ((match$1 = linePattern.exec(content)) !== null) {
+			const fullKey = match$1[1];
+			if (/^epic-\d+$/.test(fullKey)) continue;
+			if (fullKey.includes("retrospective")) continue;
+			const segments = fullKey.split("-");
+			if (segments.length >= 2) keys.push(`${segments[0]}-${segments[1]}`);
+		}
+		return [...new Set(keys)];
+	} catch {
+		return [];
+	}
+}
+/**
 * Collect story keys already completed in previous pipeline runs.
 * Scans pipeline_runs with status='completed' and extracts story keys
 * with phase='COMPLETE' from their token_usage_json state.
@@ -17587,16 +18449,26 @@ async function getCompletedStoryKeys(db) {
 	return completed;
 }
 /**
-* Sort story keys numerically by epic number (primary) then story number (secondary).
-* E.g. ["10-1", "1-2", "2-1"] → ["1-2", "2-1", "10-1"]
+* Sort story keys: numeric keys first (by epic then story number),
+* then alphabetic-prefix keys (NEW-*, E-*) sorted lexicographically.
+* E.g. ["10-1", "1-2a", "1-2", "NEW-26", "E5-acc"] → ["1-2", "1-2a", "10-1", "E5-acc", "NEW-26"]
 */
 function sortStoryKeys(keys) {
 	return keys.slice().sort((a, b) => {
-		const [ae, as_] = a.split("-").map(Number);
-		const [be, bs] = b.split("-").map(Number);
-		const epicDiff = (ae ?? 0) - (be ?? 0);
-		if (epicDiff !== 0) return epicDiff;
-		return (as_ ?? 0) - (bs ?? 0);
+		const aParts = a.split("-");
+		const bParts = b.split("-");
+		const aNum = Number(aParts[0]);
+		const bNum = Number(bParts[0]);
+		if (!isNaN(aNum) && !isNaN(bNum)) {
+			if (aNum !== bNum) return aNum - bNum;
+			const aStory = Number(aParts[1]);
+			const bStory = Number(bParts[1]);
+			if (!isNaN(aStory) && !isNaN(bStory) && aStory !== bStory) return aStory - bStory;
+			return (aParts[1] ?? "").localeCompare(bParts[1] ?? "");
+		}
+		if (!isNaN(aNum)) return -1;
+		if (!isNaN(bNum)) return 1;
+		return a.localeCompare(b);
 	});
 }
 
@@ -21687,7 +22559,7 @@ async function runRunAction(options) {
 	if (storiesArg !== void 0 && storiesArg !== "") {
 		parsedStoryKeys = storiesArg.split(",").map((k) => k.trim()).filter((k) => k.length > 0);
 		for (const key of parsedStoryKeys) if (!validateStoryKey(key)) {
-			const errorMsg = `Story key '${key}' is not a valid format. Expected: <epic>-<story> (e.g., 10-1)`;
+			const errorMsg = `Story key '${key}' is not a valid format. Expected: <epic>-<story> (e.g., 10-1, 1-1a, NEW-26)`;
 			if (outputFormat === "json") process.stdout.write(formatOutput(null, "json", false, errorMsg) + "\n");
 			else process.stderr.write(`Error: ${errorMsg}\n`);
 			return 1;
@@ -22268,6 +23140,14 @@ async function runRunAction(options) {
 					verdict: payload.verdict
 				});
 			});
+			eventBus.on("pipeline:profile-stale", (payload) => {
+				ndjsonEmitter.emit({
+					type: "pipeline:profile-stale",
+					ts: new Date().toISOString(),
+					message: payload.message,
+					indicators: payload.indicators
+				});
+			});
 		}
 		const ingestionServer = telemetryEnabled ? new IngestionServer({ port: telemetryPort }) : void 0;
 		if (telemetryPersistence !== void 0) {
@@ -22792,4 +23672,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-B1WEe6SY.js.map
+//# sourceMappingURL=run-DCmne2q6.js.map