substrate-ai 0.6.0 → 0.6.2

package/dist/cli/index.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { AdapterTelemetryPersistence, AppError, DEFAULT_CONFIG, DEFAULT_ROUTING_POLICY, DoltClient, DoltNotInstalled, DoltRepoMapMetaRepository, DoltSymbolRepository, ERR_REPO_MAP_STORAGE_WRITE, FileStateStore, GitClient, GrammarLoader, IngestionServer, RepoMapInjector, RepoMapModule, RepoMapQueryEngine, RepoMapStorage, SUBSTRATE_OWNED_SETTINGS_KEYS, SymbolParser, VALID_PHASES, WorkGraphRepository, buildPipelineStatusOutput, checkDoltInstalled, createConfigSystem, createContextCompiler, createDatabaseAdapter, createDispatcher, createDoltClient, createEventEmitter, createImplementationOrchestrator, createPackLoader, createPhaseOrchestrator, createStateStore, createStopAfterGate, createTelemetryAdvisor, detectCycles, findPackageRoot, formatOutput, formatPhaseCompletionSummary, formatPipelineStatusHuman, formatPipelineSummary, formatTokenTelemetry, getAllDescendantPids, getAutoHealthData, getSubstrateDefaultSettings, initSchema, initializeDolt, isSyncAdapter, parseDbTimestampAsUtc, registerHealthCommand, registerRunCommand, resolveBmadMethodSrcPath, resolveBmadMethodVersion, resolveMainRepoRoot, resolveStoryKeys, runAnalysisPhase, runPlanningPhase, runSolutioningPhase, validateStopAfterFromConflict } from "../run-B1WEe6SY.js";
+import { AdapterTelemetryPersistence, AppError, DEFAULT_CONFIG, DEFAULT_ROUTING_POLICY, DoltClient, DoltNotInstalled, DoltRepoMapMetaRepository, DoltSymbolRepository, ERR_REPO_MAP_STORAGE_WRITE, FileStateStore, GitClient, GrammarLoader, IngestionServer, RepoMapInjector, RepoMapModule, RepoMapQueryEngine, RepoMapStorage, SUBSTRATE_OWNED_SETTINGS_KEYS, SymbolParser, VALID_PHASES, WorkGraphRepository, buildPipelineStatusOutput, checkDoltInstalled, createConfigSystem, createContextCompiler, createDatabaseAdapter, createDispatcher, createDoltClient, createEventEmitter, createImplementationOrchestrator, createPackLoader, createPhaseOrchestrator, createStateStore, createStopAfterGate, createTelemetryAdvisor, detectCycles, findPackageRoot, formatOutput, formatPhaseCompletionSummary, formatPipelineStatusHuman, formatPipelineSummary, formatTokenTelemetry, getAllDescendantPids, getAutoHealthData, getSubstrateDefaultSettings, initSchema, initializeDolt, isSyncAdapter, parseDbTimestampAsUtc, registerHealthCommand, registerRunCommand, resolveBmadMethodSrcPath, resolveBmadMethodVersion, resolveMainRepoRoot, resolveStoryKeys, runAnalysisPhase, runPlanningPhase, runSolutioningPhase, validateStopAfterFromConflict } from "../run-DCmne2q6.js";
 import { createLogger } from "../logger-D2fS2ccL.js";
 import { AdapterRegistry } from "../adapter-registry-D2zdMwVu.js";
 import { CURRENT_CONFIG_FORMAT_VERSION, CURRENT_TASK_GRAPH_VERSION, PartialSubstrateConfigSchema } from "../config-migrator-DtZW1maj.js";
@@ -17,9 +17,11 @@ import { access, mkdir, readFile, writeFile } from "fs/promises";
 import { chmodSync, cpSync, existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, statSync, unlinkSync, writeFileSync } from "fs";
 import yaml from "js-yaml";
 import { createRequire } from "node:module";
+import * as path$2 from "node:path";
 import * as path$1 from "node:path";
 import { isAbsolute, join as join$1 } from "node:path";
 import { existsSync as existsSync$1, mkdirSync as mkdirSync$1, readFileSync as readFileSync$1, writeFileSync as writeFileSync$1 } from "node:fs";
+import * as fs from "node:fs/promises";
 import { access as access$1, readFile as readFile$1 } from "node:fs/promises";
 import { createInterface } from "node:readline";
 import { homedir } from "os";
@@ -257,6 +259,417 @@ function registerAdaptersCommand(program, version, registry) {
 	});
 }
 
+//#endregion
+//#region src/modules/project-profile/detect.ts
+/**
+* Ordered array of build system markers. Detection checks them in priority
+* order — the first matching marker wins at the single-project level.
+*/
+const STACK_MARKERS = [
+	{
+		file: "go.mod",
+		language: "go",
+		buildTool: "go",
+		buildCommand: "go build ./...",
+		testCommand: "go test ./..."
+	},
+	{
+		file: "build.gradle.kts",
+		language: "kotlin",
+		buildTool: "gradle",
+		buildCommand: "./gradlew build",
+		testCommand: "./gradlew test"
+	},
+	{
+		file: "build.gradle",
+		language: "java",
+		buildTool: "gradle",
+		buildCommand: "./gradlew build",
+		testCommand: "./gradlew test"
+	},
+	{
+		file: "pom.xml",
+		language: "java",
+		buildTool: "maven",
+		buildCommand: "mvn compile",
+		testCommand: "mvn test"
+	},
+	{
+		file: "Cargo.toml",
+		language: "rust",
+		buildTool: "cargo",
+		buildCommand: "cargo build",
+		testCommand: "cargo test"
+	},
+	{
+		file: "pyproject.toml",
+		language: "python",
+		buildTool: "pip",
+		buildCommand: "pip install -e .",
+		testCommand: "pytest"
+	},
+	{
+		file: "package.json",
+		language: "typescript",
+		buildTool: "npm",
+		buildCommand: "npm run build",
+		testCommand: "npm test"
+	}
+];
+async function fileExists(filePath) {
+	try {
+		await fs.access(filePath);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* Derives the Node.js build tool from lock file markers.
+* Mirrors the existing package manager detection logic (dispatcher-impl.ts).
+*/
+async function detectNodeBuildTool(dir) {
+	if (await fileExists(path$2.join(dir, "pnpm-lock.yaml"))) return {
+		buildTool: "pnpm",
+		buildCommand: "pnpm run build",
+		testCommand: "pnpm test"
+	};
+	if (await fileExists(path$2.join(dir, "yarn.lock"))) return {
+		buildTool: "yarn",
+		buildCommand: "yarn build",
+		testCommand: "yarn test"
+	};
+	if (await fileExists(path$2.join(dir, "bun.lockb"))) return {
+		buildTool: "bun",
+		buildCommand: "bun run build",
+		testCommand: "bun test"
+	};
+	return {
+		buildTool: "npm",
+		buildCommand: "npm run build",
+		testCommand: "npm test"
+	};
+}
+/**
+* Detects the language and build tool for a single project directory.
+*
+* Iterates `STACK_MARKERS` in priority order, calling `fs.access()` for each
+* marker file. Returns the first match, or falls back to TypeScript/npm if no
+* marker file is found.
+*
+* @param dir - Absolute path to the directory to inspect.
+* @returns A `PackageEntry` describing the detected stack.
+*/
+async function detectSingleProjectStack(dir) {
+	for (const marker of STACK_MARKERS) {
+		const markerPath = path$2.join(dir, marker.file);
+		if (!await fileExists(markerPath)) continue;
+		if (marker.file === "package.json") {
+			const nodeInfo = await detectNodeBuildTool(dir);
+			return {
+				path: dir,
+				language: "typescript",
+				buildTool: nodeInfo.buildTool,
+				buildCommand: nodeInfo.buildCommand,
+				testCommand: nodeInfo.testCommand
+			};
+		}
+		if (marker.file === "pyproject.toml") {
+			const hasPoetry = await fileExists(path$2.join(dir, "poetry.lock"));
+			return {
+				path: dir,
+				language: "python",
+				buildTool: hasPoetry ? "poetry" : "pip",
+				buildCommand: hasPoetry ? "poetry build" : "pip install -e .",
+				testCommand: "pytest"
+			};
+		}
+		return {
+			path: dir,
+			language: marker.language,
+			buildTool: marker.buildTool,
+			buildCommand: marker.buildCommand,
+			testCommand: marker.testCommand
+		};
+	}
+	return {
+		path: dir,
+		language: "typescript",
+		buildTool: "npm",
+		buildCommand: "npm run build",
+		testCommand: "npm test"
+	};
+}
+/**
+* Detects if the project root is a Turborepo monorepo.
+*
+* Checks for `turbo.json` at the root, then enumerates package directories
+* under `apps/` and `packages/`, calling `detectSingleProjectStack()` for each.
+*
+* @param rootDir - Absolute path to the project root.
+* @returns A `ProjectProfile` if Turborepo is detected, otherwise `null`.
+*/
+async function detectMonorepoProfile(rootDir) {
+	const turboJsonPath = path$2.join(rootDir, "turbo.json");
+	if (!await fileExists(turboJsonPath)) return null;
+	const packageDirs = [];
+	for (const subdir of ["apps", "packages"]) {
+		const fullSubdir = path$2.join(rootDir, subdir);
+		try {
+			const entries = await fs.readdir(fullSubdir, { withFileTypes: true });
+			for (const entry of entries) if (entry.isDirectory()) packageDirs.push(path$2.join(subdir, entry.name));
+		} catch {}
+	}
+	const packages = [];
+	for (const relPath of packageDirs) {
+		const absPath = path$2.join(rootDir, relPath);
+		const stackEntry = await detectSingleProjectStack(absPath);
+		packages.push({
+			...stackEntry,
+			path: relPath
+		});
+	}
+	return { project: {
+		type: "monorepo",
+		tool: "turborepo",
+		buildCommand: "turbo build",
+		testCommand: "turbo test",
+		packages
+	} };
+}
+/**
+* Auto-detects the project profile for the given root directory.
+*
+* First attempts Turborepo monorepo detection. If `turbo.json` is not found,
+* falls back to single-project stack detection.
+*
+* The result is NOT written to disk — detection is purely in-memory.
+*
+* @param rootDir - Absolute path to the project root.
+* @returns A fully populated `ProjectProfile`, or `null` if no recognizable
+*   stack markers are found (enabling callers to implement AC7-style
+*   graceful no-detection behaviour).
+*/
+async function detectProjectProfile(rootDir) {
+	const monorepoProfile = await detectMonorepoProfile(rootDir);
+	if (monorepoProfile !== null) return monorepoProfile;
+	let anyMarkerFound = false;
+	for (const marker of STACK_MARKERS) if (await fileExists(path$2.join(rootDir, marker.file))) {
+		anyMarkerFound = true;
+		break;
+	}
+	if (!anyMarkerFound) return null;
+	const stackEntry = await detectSingleProjectStack(rootDir);
+	return { project: {
+		type: "single",
+		tool: null,
+		language: stackEntry.language,
+		buildTool: stackEntry.buildTool,
+		framework: stackEntry.framework,
+		buildCommand: stackEntry.buildCommand ?? "npm run build",
+		testCommand: stackEntry.testCommand ?? "npm test",
+		packages: []
+	} };
+}
+
+//#endregion
+//#region src/modules/project-profile/writer.ts
+const PROFILE_HEADER = "# Substrate Project Profile\n# Generated by `substrate init`\n# Edit to override auto-detected settings.\n\n";
+/**
+* Serializes the given `ProjectProfile` to YAML and writes it to `profilePath`.
+*
+* The generated file begins with a human-readable comment header so users can
+* understand the file's purpose at a glance. The YAML content is produced by
+* `js-yaml`'s `dump()` function for consistent formatting.
+*
+* @param profilePath - Absolute path to write the profile YAML file.
+* @param profile - The `ProjectProfile` object to serialize.
+*/
+async function writeProjectProfile(profilePath, profile) {
+	const yamlContent = yaml.dump(profile);
+	await writeFile(profilePath, PROFILE_HEADER + yamlContent, "utf-8");
+}
+
+//#endregion
+//#region src/cli/templates/build-dev-notes.ts
+const DEV_WORKFLOW_START_MARKER = "<!-- dev-workflow:start -->";
+const DEV_WORKFLOW_END_MARKER = "<!-- dev-workflow:end -->";
+function detectPackageManager(buildCommand) {
+	if (buildCommand.includes("pnpm")) return "pnpm";
+	if (buildCommand.includes("yarn")) return "yarn";
+	if (buildCommand.includes("bun")) return "bun";
+	return "npm";
+}
+function getBuildCmd(pm) {
+	switch (pm) {
+		case "pnpm": return "pnpm run build";
+		case "yarn": return "yarn build";
+		case "bun": return "bun run build";
+		default: return "npm run build";
+	}
+}
+function getTestCmd(pm) {
+	switch (pm) {
+		case "pnpm": return "pnpm test";
+		case "yarn": return "yarn test";
+		case "bun": return "bun test";
+		default: return "npm test";
+	}
+}
+function stackDefaultTestCommand(pkg) {
+	if (pkg.testCommand) return pkg.testCommand;
+	switch (pkg.language) {
+		case "go": return "go test ./...";
+		case "rust": return "cargo test";
+		case "java":
+		case "kotlin":
+			if (pkg.buildTool === "maven") return "mvn test";
+			return "./gradlew test";
+		case "python": return "pytest";
+		default: {
+			const buildToolPm = pkg.buildTool;
+			if (buildToolPm === "pnpm") return "pnpm test";
+			if (buildToolPm === "yarn") return "yarn test";
+			if (buildToolPm === "bun") return "bun test";
+			return "npm test";
+		}
+	}
+}
+function buildNodeSection(buildCommand) {
+	const pm = detectPackageManager(buildCommand);
+	const buildCmd = getBuildCmd(pm);
+	const testCmd = getTestCmd(pm);
+	return [
+		"## Dev Workflow",
+		"",
+		"**Build:** `" + buildCmd + "`",
+		"**Test:** `" + testCmd + "`",
+		"",
+		"### Testing Notes",
+		"- Run targeted tests during development to avoid slow feedback loops",
+		"- Run the full suite before merging"
+	].join("\n");
+}
+function buildGoSection() {
+	return [
+		"## Dev Workflow",
+		"",
+		"**Build:** `go build ./...`",
+		"**Test:** `go test ./...`",
+		"",
+		"### Testing Notes",
+		"- Run targeted tests: `go test ./pkg/... -v -run TestFunctionName`",
+		"- Run with short flag to skip long-running tests: `go test ./... -short`",
+		"- Verbose output: `go test ./... -v`"
+	].join("\n");
+}
+function buildGradleSection() {
+	return [
+		"## Dev Workflow",
+		"",
+		"**Build:** `./gradlew build`",
+		"**Test:** `./gradlew test`",
+		"",
+		"### Testing Notes",
+		"- Run a specific test class: `./gradlew test --tests \"com.example.ClassName\"`",
+		"- Run a specific method: `./gradlew test --tests \"com.example.ClassName.methodName\"`"
+	].join("\n");
+}
+function buildMavenSection() {
+	return [
+		"## Dev Workflow",
+		"",
+		"**Build:** `mvn compile`",
+		"**Test:** `mvn test`",
+		"",
+		"### Testing Notes",
+		"- Run a specific test class: `mvn test -Dtest=ClassName`",
+		"- Run a specific method: `mvn test -Dtest=\"ClassName#methodName\"`"
+	].join("\n");
+}
+function buildCargoSection() {
+	return [
+		"## Dev Workflow",
+		"",
+		"**Build:** `cargo build`",
+		"**Test:** `cargo test`",
+		"",
+		"### Testing Notes",
+		"- Show test output: `cargo test -- --nocapture`",
+		"- Run a specific test: `cargo test test_function_name`",
+		"- Run tests in a module: `cargo test --lib test_module`"
+	].join("\n");
+}
+function buildPythonSection(buildCommand) {
+	let installCmd;
+	if (buildCommand.includes("poetry")) installCmd = "poetry install";
+	else installCmd = "pip install -e .";
+	return [
+		"## Dev Workflow",
+		"",
+		"**Install:** `" + installCmd + "`",
+		"**Test:** `pytest -v`",
+		"",
+		"### Testing Notes",
+		"- Run targeted tests: `pytest -k \"test_name\" -v`",
+		"- Run a specific file and test: `pytest tests/test_foo.py::test_bar -v`"
+	].join("\n");
+}
+function buildMonorepoSection(profile) {
+	const { project } = profile;
+	const lines = [
+		"## Dev Workflow",
+		"",
+		`**Root build:** \`${project.buildCommand}\``,
+		`**Root test:** \`${project.testCommand}\``
+	];
+	const packages = project.packages ?? [];
+	if (packages.length > 0) {
+		lines.push("");
+		lines.push("### Package Structure");
+		lines.push("");
+		lines.push("| Package | Language | Framework | Test Command |");
+		lines.push("|---------|----------|-----------|--------------|");
+		for (const pkg of packages) {
+			const lang = pkg.language;
+			const framework = pkg.framework ?? "—";
+			const testCmd = stackDefaultTestCommand(pkg);
+			lines.push(`| ${pkg.path} | ${lang} | ${framework} | ${testCmd} |`);
+		}
+	}
+	return lines.join("\n");
+}
+/**
+* Generates a stack-aware "Dev Workflow" section for inclusion in CLAUDE.md.
+*
+* Returns an empty string when `profile` is null (backward-compatible — the
+* caller should skip prepending the dev workflow block in that case).
+*
+* When a profile is present, returns a string wrapped in
+* `<!-- dev-workflow:start -->` / `<!-- dev-workflow:end -->` markers.
+*/
+function buildStackAwareDevNotes(profile) {
+	if (!profile) return "";
+	const { project } = profile;
+	let body;
+	if (project.type === "monorepo") body = buildMonorepoSection(profile);
+	else {
+		const buildTool = project.buildTool;
+		const language = project.language;
+		if (buildTool === "go" || language === "go") body = buildGoSection();
+		else if (buildTool === "gradle") body = buildGradleSection();
+		else if (buildTool === "maven") body = buildMavenSection();
+		else if (buildTool === "cargo" || language === "rust") body = buildCargoSection();
+		else if (language === "python") body = buildPythonSection(project.buildCommand);
+		else body = buildNodeSection(project.buildCommand);
+	}
+	return [
+		DEV_WORKFLOW_START_MARKER,
+		body,
+		DEV_WORKFLOW_END_MARKER
+	].join("\n");
+}
+
 //#endregion
 //#region src/cli/commands/init.ts
 const logger$18 = createLogger("init");
@@ -314,7 +727,7 @@ async function scaffoldBmadFramework(projectRoot, force, outputFormat) {
 }
 const CLAUDE_MD_START_MARKER = "<!-- substrate:start -->";
 const CLAUDE_MD_END_MARKER = "<!-- substrate:end -->";
-async function scaffoldClaudeMd(projectRoot) {
+async function scaffoldClaudeMd(projectRoot, profile) {
 	const claudeMdPath = join(projectRoot, "CLAUDE.md");
 	const pkgRoot = findPackageRoot(__dirname);
 	const templateName = "claude-md-substrate-section.md";
@@ -328,6 +741,7 @@ async function scaffoldClaudeMd(projectRoot) {
 		return;
 	}
 	if (!sectionContent.endsWith("\n")) sectionContent += "\n";
+	const devNotesSection = buildStackAwareDevNotes(profile ?? null);
 	let existingContent = "";
 	let claudeMdExists = false;
 	try {
@@ -335,11 +749,23 @@ async function scaffoldClaudeMd(projectRoot) {
 		claudeMdExists = true;
 	} catch {}
 	let newContent;
-	if (!claudeMdExists) newContent = sectionContent;
-	else if (existingContent.includes(CLAUDE_MD_START_MARKER)) newContent = existingContent.replace(new RegExp(`${CLAUDE_MD_START_MARKER.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}[\\s\\S]*?${CLAUDE_MD_END_MARKER.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}`), sectionContent.trimEnd());
+	if (!claudeMdExists) if (devNotesSection) newContent = devNotesSection + "\n\n" + sectionContent;
+	else newContent = sectionContent;
 	else {
-		const separator = existingContent.endsWith("\n") ? "\n" : "\n\n";
-		newContent = existingContent + separator + sectionContent;
+		let updatedExisting;
+		if (existingContent.includes(CLAUDE_MD_START_MARKER)) updatedExisting = existingContent.replace(new RegExp(`${CLAUDE_MD_START_MARKER.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}[\\s\\S]*?${CLAUDE_MD_END_MARKER.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}`), sectionContent.trimEnd());
+		else {
+			const separator = existingContent.endsWith("\n") ? "\n" : "\n\n";
+			updatedExisting = existingContent + separator + sectionContent;
+		}
+		if (devNotesSection) if (updatedExisting.includes(DEV_WORKFLOW_START_MARKER)) newContent = updatedExisting.replace(new RegExp(`${DEV_WORKFLOW_START_MARKER.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}[\\s\\S]*?${DEV_WORKFLOW_END_MARKER.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}`), devNotesSection);
+		else if (updatedExisting.includes(CLAUDE_MD_START_MARKER)) newContent = updatedExisting.replace(CLAUDE_MD_START_MARKER, devNotesSection + "\n\n" + CLAUDE_MD_START_MARKER);
+		else {
+			const sep = updatedExisting.endsWith("\n") ? "\n" : "\n\n";
+			newContent = devNotesSection + sep + updatedExisting;
+		}
+		else if (updatedExisting.includes(DEV_WORKFLOW_START_MARKER)) newContent = updatedExisting.replace(new RegExp(`${DEV_WORKFLOW_START_MARKER.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}[\\s\\S]*?${DEV_WORKFLOW_END_MARKER.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\n?`), "");
+		else newContent = updatedExisting;
 	}
 	await writeFile(claudeMdPath, newContent, "utf8");
 	logger$18.info({ claudeMdPath }, "Wrote substrate section to CLAUDE.md");
@@ -486,6 +912,22 @@ async function scaffoldClaudeCommands(projectRoot, outputFormat) {
 		const TaskToolCommandGenerator = resolveExport(taskToolMod, "TaskToolCommandGenerator");
 		const manifestMod = _require(join(installerLibPath, "core", "manifest-generator.js"));
 		const ManifestGenerator = resolveExport(manifestMod, "ManifestGenerator");
+		const pathUtilsMod = _require(join(installerLibPath, "ide", "shared", "path-utils.js"));
+		const pathUtils = { toDashPath: pathUtilsMod.toDashPath ?? pathUtilsMod.default?.toDashPath };
+		const writeDashFallback = async (baseDir, artifacts, acceptTypes) => {
+			let written = 0;
+			for (const artifact of artifacts) {
+				if (!acceptTypes.includes(artifact.type)) continue;
+				const content = artifact.content;
+				if (!content || !artifact.relativePath) continue;
+				const flatName = pathUtils.toDashPath(artifact.relativePath);
+				const dest = join(baseDir, flatName);
+				mkdirSync(dirname(dest), { recursive: true });
+				writeFileSync(dest, content, "utf-8");
+				written++;
+			}
+			return written;
+		};
 		const nonCoreModules = scanBmadModules(bmadDir);
 		const allModules = ["core", ...nonCoreModules];
 		try {
@@ -499,13 +941,13 @@ async function scaffoldClaudeCommands(projectRoot, outputFormat) {
 		clearBmadCommandFiles(commandsDir);
 		const agentGen = new AgentCommandGenerator("_bmad");
 		const { artifacts: agentArtifacts } = await agentGen.collectAgentArtifacts(bmadDir, nonCoreModules);
-		const agentCount = await agentGen.writeDashArtifacts(commandsDir, agentArtifacts);
+		const agentCount = typeof agentGen.writeDashArtifacts === "function" ? await agentGen.writeDashArtifacts(commandsDir, agentArtifacts) : await writeDashFallback(commandsDir, agentArtifacts, ["agent-launcher"]);
 		const workflowGen = new WorkflowCommandGenerator("_bmad");
 		const { artifacts: workflowArtifacts } = await workflowGen.collectWorkflowArtifacts(bmadDir);
-		const workflowCount = await workflowGen.writeDashArtifacts(commandsDir, workflowArtifacts);
+		const workflowCount = typeof workflowGen.writeDashArtifacts === "function" ? await workflowGen.writeDashArtifacts(commandsDir, workflowArtifacts) : await writeDashFallback(commandsDir, workflowArtifacts, ["workflow-command", "workflow-launcher"]);
 		const taskToolGen = new TaskToolCommandGenerator("_bmad");
 		const { artifacts: taskToolArtifacts } = await taskToolGen.collectTaskToolArtifacts(bmadDir);
-		const taskToolCount = await taskToolGen.writeDashArtifacts(commandsDir, taskToolArtifacts);
+		const taskToolCount = typeof taskToolGen.writeDashArtifacts === "function" ? await taskToolGen.writeDashArtifacts(commandsDir, taskToolArtifacts) : await writeDashFallback(commandsDir, taskToolArtifacts, ["task", "tool"]);
 		const total = agentCount + workflowCount + taskToolCount;
 		if (outputFormat !== "json") process.stdout.write(`Generated ${String(total)} Claude Code commands (${String(agentCount)} agents, ${String(workflowCount)} workflows, ${String(taskToolCount)} tasks/tools)\n`);
 		logger$18.info({
@@ -543,6 +985,51 @@ function buildProviderConfig(adapterId, cliPath, subscriptionRouting) {
 		subscription_routing: subscriptionRouting
 	};
 }
+/**
+* Formats a detected project profile as a human-readable string.
+* For single projects: shows stack, build, and test commands.
+* For monorepos: shows the tool, root commands, and per-package breakdown.
+*/
+function formatProjectProfile(profile) {
+	const lines = ["", "  Detected project profile:"];
+	const { project } = profile;
+	if (project.type === "monorepo") {
+		lines.push(`  Type:  monorepo (${project.tool ?? "unknown"})`);
+		lines.push(`  Build: ${project.buildCommand}`);
+		lines.push(`  Test:  ${project.testCommand}`);
+		if (project.packages && project.packages.length > 0) {
+			lines.push("  Packages:");
+			for (const pkg of project.packages) lines.push(`    ${pkg.path}  ${pkg.language}`);
+		}
+	} else {
+		const lang = project.language ?? "unknown";
+		const stackStr = project.framework ? `${lang} (${project.framework})` : lang;
+		lines.push(`  Stack: ${stackStr}`);
+		lines.push(`  Build: ${project.buildCommand}`);
+		lines.push(`  Test:  ${project.testCommand}`);
+	}
+	return lines.join("\n");
+}
+/**
+* Prompts the user to accept or decline the detected project profile.
+* In non-interactive mode, always returns true (auto-accept).
+*/
+async function promptProfileConfirmation(nonInteractive) {
+	if (nonInteractive) return true;
+	const readline = await import("readline");
+	const rl = readline.createInterface({
+		input: process.stdin,
+		output: process.stdout
+	});
+	return new Promise((resolve$2) => {
+		rl.question("\n  Accept detected project profile? [Y/n]: ", (answer) => {
+			rl.close();
+			const trimmed = answer.trim().toLowerCase();
+			if (trimmed === "" || trimmed === "y" || trimmed === "yes") resolve$2(true);
+			else resolve$2(false);
+		});
+	});
+}
 async function promptSubscriptionRouting(providerName, nonInteractive) {
 	if (nonInteractive) return "auto";
 	const readline = await import("readline");
@@ -559,9 +1046,9 @@ async function promptSubscriptionRouting(providerName, nonInteractive) {
 		});
 	});
 }
-async function directoryExists(path$2) {
+async function directoryExists(path$3) {
 	try {
-		await access(path$2);
+		await access(path$3);
 		return true;
 	} catch {
 		return false;
@@ -630,6 +1117,33 @@ async function runInitAction(options) {
 		await writeFile(configPath, configHeader + yaml.dump(config), "utf-8");
 		const routingHeader = "# Substrate Routing Policy\n# Defines how tasks are routed to AI providers.\n# Customize rules to match your workflow and available agents.\n\n";
 		await writeFile(routingPolicyPath, routingHeader + yaml.dump(routingPolicy), "utf-8");
+		const projectProfilePath = join(substrateDir, "project-profile.yaml");
+		let detectedProfile = null;
+		let projectProfileWritten = false;
+		try {
+			detectedProfile = await detectProjectProfile(dbRoot);
+		} catch (err) {
+			logger$18.warn({ err }, "Project profile detection failed; skipping");
+		}
+		if (detectedProfile === null) {
+			if (outputFormat !== "json") process.stdout.write("  No project stack detected. Create .substrate/project-profile.yaml manually to enable polyglot support.\n");
+		} else {
+			if (outputFormat !== "json") process.stdout.write(formatProjectProfile(detectedProfile) + "\n");
+			let profileExists = false;
+			try {
+				await access(projectProfilePath);
+				profileExists = true;
+			} catch {}
+			if (profileExists && !force) {
+				if (outputFormat !== "json") process.stdout.write("  .substrate/project-profile.yaml already exists — skipping (use --force to overwrite)\n");
+			} else {
+				const accepted = await promptProfileConfirmation(nonInteractive);
+				if (accepted) {
+					await writeProjectProfile(projectProfilePath, detectedProfile);
+					projectProfileWritten = true;
+				} else if (outputFormat !== "json") process.stdout.write("  Profile not written. Create .substrate/project-profile.yaml manually to enable polyglot support.\n");
+			}
+		}
 		await scaffoldBmadFramework(projectRoot, force, outputFormat);
 		const localManifest = join(packPath, "manifest.yaml");
 		let scaffolded = false;
@@ -671,7 +1185,7 @@ async function runInitAction(options) {
 		});
 		await initSchema(dbAdapter);
 		await dbAdapter.close();
-		await scaffoldClaudeMd(projectRoot);
+		await scaffoldClaudeMd(projectRoot, detectedProfile);
 		await scaffoldStatuslineScript(projectRoot);
 		await scaffoldClaudeSettings(projectRoot);
 		await scaffoldClaudeCommands(projectRoot, outputFormat);
@@ -705,7 +1219,9 @@ async function runInitAction(options) {
 			scaffolded,
 			configPath,
 			routingPolicyPath,
-			doltInitialized
+			doltInitialized,
+			projectProfile: detectedProfile ?? null,
+			projectProfileWritten
 		}, "json", true) + "\n");
 		else {
 			process.stdout.write(`\n  Substrate initialized successfully!\n\n`);
@@ -2969,7 +3485,7 @@ async function runSupervisorAction(options, deps = {}) {
 								await initSchema(expAdapter);
 								const { runRunAction: runPipeline } = await import(
 									/* @vite-ignore */
-									"../run-IU38JGTV.js"
+									"../run-CcUT8-DF.js"
 );
 								const runStoryFn = async (opts) => {
 									const exitCode = await runPipeline({
@@ -3817,8 +4333,8 @@ function registerMetricsCommand(program, _version = "0.0.0", projectRoot = proce
 * This function now always returns an empty snapshot.
 */
 async function readSqliteSnapshot(dbPath) {
-	const { existsSync: fileExists } = await import("node:fs");
-	if (fileExists(dbPath)) process.stderr.write(`Warning: Legacy SQLite database found at ${dbPath} but SQLite support has been\nremoved in Epic 29. To migrate historical data, downgrade to Substrate v0.4.x,\nrun 'substrate migrate', then upgrade back to this version.\n`);
+	const { existsSync: fileExists$1 } = await import("node:fs");
+	if (fileExists$1(dbPath)) process.stderr.write(`Warning: Legacy SQLite database found at ${dbPath} but SQLite support has been\nremoved in Epic 29. To migrate historical data, downgrade to Substrate v0.4.x,\nrun 'substrate migrate', then upgrade back to this version.\n`);
 	return { storyMetrics: [] };
 }
 const BATCH_SIZE = 100;