@voybio/ace-swarm 0.2.5 → 2.4.1

package/dist/helpers/bootstrap.js

@@ -0,0 +1,894 @@
+import { copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync, } from "node:fs";
+import { homedir } from "node:os";
+import { basename, dirname, join, resolve } from "node:path";
+import { buildHostInstructionText } from "../ace-server-instructions.js";
+import { buildProviderDoctorCommands, buildOpenAiCompatibleBaseUrl, defaultModelForProvider, normalizeLocalBaseUrl, normalizeProvider, } from "../tui/provider-discovery.js";
+import { ALL_LLM_PROVIDERS, ALL_MCP_CLIENTS, ACE_BUNDLE_ROOT_REL, ACE_CLAUDE_ROOT_REL, ACE_CURSOR_ROOT_REL, ACE_GITHUB_ROOT_REL, ACE_HOST_AGENTS_REL, ACE_HOST_CLAUDE_REL, ACE_HOST_CURSOR_RULES_REL, ACE_LLM_ROOT_REL, ACE_ROOT_REL, ACE_SCRIPTS_ROOT_REL, ACE_TASKS_ROOT_REL, ACE_VSCODE_ROOT_REL, COMPOSABLE_AGENTS, DEFAULTS_AGENT_STATE_ROOT, DEFAULTS_GITHUB_ROOT, DEFAULTS_ROOT, DEFAULTS_SCRIPTS_ROOT, DEFAULTS_SKILLS_ROOT, DEFAULT_TASK_FILES, DEFAULTS_TASKS_ROOT, SWARM_AGENTS, } from "./constants.js";
+import { acePath, wsPath } from "./path-utils.js";
+import { resolveWorkspaceRoot } from "./workspace-root.js";
+function ensureDir(dirPath, result) {
+    if (existsSync(dirPath))
+        return;
+    mkdirSync(dirPath, { recursive: true });
+    result.created.push(dirPath);
+}
+function copyTree(srcRoot, destRoot, result, force = false) {
+    if (!existsSync(srcRoot))
+        return;
+    const entries = readdirSync(srcRoot, { withFileTypes: true });
+    for (const entry of entries) {
+        const src = resolve(srcRoot, entry.name);
+        const dest = resolve(destRoot, entry.name);
+        if (entry.isDirectory()) {
+            ensureDir(dest, result);
+            copyTree(src, dest, result, force);
+            continue;
+        }
+        if (!existsSync(dest)) {
+            mkdirSync(dirname(dest), { recursive: true });
+            copyFileSync(src, dest);
+            result.created.push(dest);
+            continue;
+        }
+        if (force) {
+            copyFileSync(src, dest);
+            result.updated.push(dest);
+        }
+        else {
+            result.skipped.push(dest);
+        }
+    }
+}
+function writeIfMissingOrForced(path, content, result, force = false) {
+    if (!existsSync(path)) {
+        mkdirSync(dirname(path), { recursive: true });
+        writeFileSync(path, content, "utf-8");
+        result.created.push(path);
+        return;
+    }
+    if (force) {
+        writeFileSync(path, content, "utf-8");
+        result.updated.push(path);
+    }
+    else {
+        result.skipped.push(path);
+    }
+}
+function quotePosixShell(value) {
+    return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function quoteCmdExe(value) {
+    return `"${value.replace(/"/g, '""')}"`;
+}
+function getNodeBinDir() {
+    const execPath = process.execPath?.trim();
+    if (!execPath)
+        return undefined;
+    const binDir = dirname(execPath);
+    return existsSync(join(binDir, "node")) ? binDir : undefined;
+}
+function getLocalCliEntry() {
+    return resolve(DEFAULTS_ROOT, "..", "dist", "cli.js");
+}
+function buildPosixProfileFallback(shellPath) {
+    const shellName = basename(shellPath);
+    if (shellName === "zsh") {
+        return [
+            '[ -s "$HOME/.zprofile" ] && . "$HOME/.zprofile"',
+            '[ -s "$HOME/.zshrc" ] && . "$HOME/.zshrc"',
+        ].join("; ");
+    }
+    if (shellName === "bash") {
+        return [
+            '[ -s "$HOME/.bash_profile" ] && . "$HOME/.bash_profile"',
+            '[ -s "$HOME/.profile" ] && . "$HOME/.profile"',
+            '[ -s "$HOME/.bashrc" ] && . "$HOME/.bashrc"',
+        ].join("; ");
+    }
+    return [
+        '[ -s "$HOME/.profile" ] && . "$HOME/.profile"',
+        '[ -s "$HOME/.zprofile" ] && . "$HOME/.zprofile"',
+        '[ -s "$HOME/.zshrc" ] && . "$HOME/.zshrc"',
+    ].join("; ");
+}
+function buildPosixMcpLaunchCommand(workspaceRoot, shellPath) {
+    const quotedWorkspaceRoot = quotePosixShell(workspaceRoot);
+    const quotedCliEntry = quotePosixShell(getLocalCliEntry());
+    const launchSteps = [];
+    const nodeBinDir = getNodeBinDir();
+    if (nodeBinDir) {
+        launchSteps.push(`export PATH=${quotePosixShell(nodeBinDir)}:"$PATH"`);
+    }
+    launchSteps.push(`if ! command -v node >/dev/null 2>&1; then ${buildPosixProfileFallback(shellPath)}; fi`);
+    launchSteps.push(`cd ${quotedWorkspaceRoot}`);
+    launchSteps.push(`ACE_WORKSPACE_ROOT=${quotedWorkspaceRoot} node ${quotedCliEntry} mcp`);
+    return launchSteps.join(" && ");
+}
+function buildWindowsMcpLaunchCommand(workspaceRoot) {
+    const cliEntry = getLocalCliEntry().replace(/"/g, '""');
+    return [
+        `cd /d ${quoteCmdExe(workspaceRoot)}`,
+        `set "ACE_WORKSPACE_ROOT=${workspaceRoot.replace(/"/g, '""')}"`,
+        `node ${quoteCmdExe(cliEntry)} mcp`,
+    ].join(" && ");
+}
+function getMcpCommandSpec(workspaceRoot = resolveWorkspaceRoot()) {
+    if (process.platform !== "win32") {
+        const shell = process.env.SHELL || "/bin/zsh";
+        return {
+            command: shell,
+            args: ["-lc", buildPosixMcpLaunchCommand(workspaceRoot, shell)],
+        };
+    }
+    return {
+        command: "cmd.exe",
+        args: ["/d", "/s", "/c", buildWindowsMcpLaunchCommand(workspaceRoot)],
+    };
+}
+const ACE_HOOK_EVENTS = [
+    "SessionStart",
+    "UserPromptSubmit",
+    "PreToolUse",
+    "PostToolUse",
+    "PreCompact",
+    "SubagentStart",
+    "SubagentStop",
+    "Stop",
+];
+const ACE_HOOK_DISPATCH_REL = `${ACE_SCRIPTS_ROOT_REL}/ace-hook-dispatch.mjs`;
+const ACE_HOOK_DISPATCH_COMMAND = `node ./${ACE_HOOK_DISPATCH_REL}`;
+function buildCopilotHookSettings() {
+    const hook = {
+        type: "command",
+        command: ACE_HOOK_DISPATCH_COMMAND,
+        windows: "node .\\\\.agents\\\\ACE\\\\scripts\\\\ace\\\\ace-hook-dispatch.mjs",
+        timeout: 10,
+    };
+    const hooks = Object.fromEntries(ACE_HOOK_EVENTS.map((event) => [event, [hook]]));
+    return JSON.stringify({ hooks }, null, 2);
+}
+function buildClaudeHookSettings() {
+    const hook = {
+        type: "command",
+        command: ACE_HOOK_DISPATCH_COMMAND,
+    };
+    return JSON.stringify({
+        hooks: {
+            SessionStart: [{ matcher: "", hooks: [hook] }],
+            UserPromptSubmit: [{ matcher: "", hooks: [hook] }],
+            PreToolUse: [{ matcher: "", hooks: [hook] }],
+            PostToolUse: [{ matcher: "", hooks: [hook] }],
+            PreCompact: [{ matcher: "", hooks: [hook] }],
+            SubagentStart: [{ matcher: "", hooks: [hook] }],
+            SubagentStop: [{ matcher: "", hooks: [hook] }],
+            Stop: [{ matcher: "", hooks: [hook] }],
+        },
+    }, null, 2);
+}
+function buildCursorHookSettings() {
+    return buildCopilotHookSettings();
+}
+function buildVsCodeHookSettings() {
+    return buildCopilotHookSettings();
+}
+function buildGeminiHookSettings() {
+    return buildCopilotHookSettings();
+}
+function buildAntigravityHookSettings() {
+    return buildCopilotHookSettings();
+}
+function buildCodexHookSettings() {
+    return [
+        "# ACE lifecycle hook scaffold for Codex-compatible runtimes.",
+        "# Merge or source these entries in the host hook config that supports SessionStart/SubagentStart hooks.",
+        "",
+        ...ACE_HOOK_EVENTS.flatMap((event) => [
+            "[[hooks]]",
+            `event = "${event}"`,
+            `command = "${ACE_HOOK_DISPATCH_COMMAND}"`,
+            "",
+        ]),
+    ].join("\n");
+}
+function buildWorkspaceStateSeedFiles(projectName, generatedAt) {
+    const swarmHandoffTemplate = readFileSync(DEFAULT_TASK_FILES.handoff_template, "utf-8");
+    return [
+        {
+            path: wsPath("global-state", "GLOBAL_RISKS.md"),
+            content: [
+                "# GLOBAL_RISKS",
+                "",
+                `Generated: ${generatedAt}`,
+                "",
+                "## Systemic Risks",
+                "- None logged yet. Record cross-swarm blockers, runway constraints, and release risks here.",
+                "",
+                "## Update Rule",
+                "- Keep local implementation risks in the owning swarm folder or `agent-state/RISKS.md`.",
+            ].join("\n"),
+        },
+        {
+            path: wsPath("global-state", "DECISION_LOG.md"),
+            content: [
+                "# DECISION_LOG",
+                "",
+                `Generated: ${generatedAt}`,
+                "",
+                "Append-only record for orchestrator-level tradeoffs that affect multiple swarms.",
+                "",
+                "## Entry Template",
+                `- ${generatedAt} — Decision: <what changed>`,
+                "  - Reason: <why>",
+                "  - Impact: <which swarm/state folders are affected>",
+            ].join("\n"),
+        },
+        {
+            path: wsPath("global-state", "ENGINEERING_SNAPSHOT.md"),
+            content: [
+                "# ENGINEERING_SNAPSHOT.md",
+                "",
+                `Generated: ${generatedAt}`,
+                "",
+                "## Profile",
+                "- Status: pending initial orchestrator discovery scan",
+                "- Project: " + projectName,
+                `- Durable location: \`${ACE_ROOT_REL}/global-state/ENGINEERING_SNAPSHOT.md\``,
+                "",
+                "## Quality Signals",
+                "- Tests: pending scan",
+                "- Public surface: pending scan",
+                "- Delivery risk: pending scan",
+                "",
+                "## Routing Recommendation",
+                "- Run the orchestrator discovery pass before first coder handoff.",
+            ].join("\n"),
+        },
+        {
+            path: wsPath("global-state", "SWARM_HANDOFF.json"),
+            content: swarmHandoffTemplate,
+        },
+        {
+            path: wsPath("venture-state", "STATUS.md"),
+            content: [
+                "# VENTURE STATUS",
+                "",
+                "- Mode: bootstrap",
+                "- Focus: clarify thesis and MVP",
+                "- Current phase: discovery",
+                "- Next handoff: ACE-VOS -> ACE-Orchestrator",
+                `- Last update: ${generatedAt}`,
+            ].join("\n"),
+        },
+        {
+            path: wsPath("venture-state", "TEAL_CONFIG.md"),
+            content: [
+                "# TEAL_CONFIG",
+                "",
+                "## Venture Pipeline",
+                "- discovery -> thesis -> blueprint -> MVP spec -> handoff",
+                "",
+                "## Durable Outputs",
+                `- \`${ACE_ROOT_REL}/venture-state/THESIS.md\``,
+                `- \`${ACE_ROOT_REL}/venture-state/BLUEPRINT.md\``,
+                `- \`${ACE_ROOT_REL}/venture-state/GROWTH_LOOPS.md\``,
+                `- \`${ACE_ROOT_REL}/venture-state/RISKS.md\``,
+                `- \`${ACE_ROOT_REL}/venture-state/PROTOTYPE/MVP_SPEC.md\``,
+            ].join("\n"),
+        },
+        {
+            path: wsPath("venture-state", "THESIS.md"),
+            content: [
+                "# THESIS",
+                "",
+                "## Problem",
+                "- TBD",
+                "",
+                "## Users",
+                "- TBD",
+                "",
+                "## Why Now",
+                "- TBD",
+                "",
+                "## Wedge",
+                "- TBD",
+            ].join("\n"),
+        },
+        {
+            path: wsPath("venture-state", "INTERROGATION.log"),
+            content: [
+                "# INTERROGATION LOG",
+                "",
+                `- ${generatedAt} bootstrap: venture interrogation started.`,
+            ].join("\n"),
+        },
+        {
+            path: wsPath("venture-state", "BLUEPRINT.md"),
+            content: [
+                "# BLUEPRINT",
+                "",
+                "## System Outline",
+                "- TBD",
+                "",
+                "## Critical Flows",
+                "- TBD",
+            ].join("\n"),
+        },
+        {
+            path: wsPath("venture-state", "GROWTH_LOOPS.md"),
+            content: [
+                "# GROWTH_LOOPS",
+                "",
+                "## Acquisition",
+                "- TBD",
+                "",
+                "## Retention",
+                "- TBD",
+                "",
+                "## Monetization",
+                "- TBD",
+            ].join("\n"),
+        },
+        {
+            path: wsPath("venture-state", "RISKS.md"),
+            content: [
+                "# VENTURE RISKS",
+                "",
+                "## Active Risks",
+                "- None logged yet.",
+            ].join("\n"),
+        },
+        {
+            path: wsPath("venture-state", "PROTOTYPE", "MVP_SPEC.md"),
+            content: [
+                "# MVP_SPEC",
+                "",
+                "## Objective",
+                "- TBD",
+                "",
+                "## Must-Have Behaviors",
+                "- TBD",
+                "",
+                "## Proof Requirement",
+                "- Define the smallest working slice that demonstrates value.",
+            ].join("\n"),
+        },
+        {
+            path: wsPath("venture-state", "PROTOTYPE", "src", "README.md"),
+            content: [
+                "# Venture Prototype Source",
+                "",
+                `Use this directory when the venture swarm needs a lightweight proof-of-concept separate from \`${ACE_ROOT_REL}/engineering-state/src/\`.`,
+            ].join("\n"),
+        },
+        {
+            path: wsPath("brand-state", "BRAND_VOICE.md"),
+            content: [
+                "# BRAND_VOICE",
+                "",
+                "## Positioning",
+                "- TBD",
+                "",
+                "## Tone",
+                "- Clear",
+                "- Specific",
+                "- Trust-building",
+                "",
+                "## Messaging Guardrails",
+                "- Avoid generic claims.",
+                "- Tie every headline to a concrete user outcome.",
+            ].join("\n"),
+        },
+        {
+            path: wsPath("brand-state", "AUDIT_LOG.md"),
+            content: [
+                "# AUDIT_LOG",
+                "",
+                `- ${generatedAt} bootstrap: brand audit log initialized.`,
+            ].join("\n"),
+        },
+        {
+            path: wsPath("brand-state", "COPY_DECK.md"),
+            content: [
+                "# COPY_DECK",
+                "",
+                "## Primary Headline",
+                "- TBD",
+                "",
+                "## Supporting Copy",
+                "- TBD",
+                "",
+                "## CTA",
+                "- TBD",
+            ].join("\n"),
+        },
+        {
+            path: wsPath("brand-state", "ASSETS", "strings.json"),
+            content: JSON.stringify({
+                app_name: projectName,
+                headline: "",
+                subheadline: "",
+                primary_cta: "",
+            }, null, 2),
+        },
+        {
+            path: wsPath("engineering-state", "BUILD_STATUS.md"),
+            content: [
+                "# BUILD_STATUS",
+                "",
+                "- Status: not started",
+                "- Active owner: ACE-Coders",
+                "- Blockers: none recorded",
+                `- Last update: ${generatedAt}`,
+            ].join("\n"),
+        },
+        {
+            path: wsPath("engineering-state", "SPEC_CONTRACT.json"),
+            content: JSON.stringify({
+                version: "0.1.0",
+                project: projectName,
+                status: "draft",
+                requirements: [],
+                acceptance_tests: [],
+                deliverables: [],
+            }, null, 2),
+        },
+        {
+            path: wsPath("engineering-state", "ARCHITECTURE.md"),
+            content: [
+                "# ARCHITECTURE",
+                "",
+                "## Stack",
+                "- TBD",
+                "",
+                "## Interfaces",
+                "- TBD",
+                "",
+                "## Constraints",
+                "- TBD",
+            ].join("\n"),
+        },
+        {
+            path: wsPath("engineering-state", "TEST_LOG.md"),
+            content: [
+                "# TEST_LOG",
+                "",
+                `- ${generatedAt} bootstrap: no tests executed yet.`,
+            ].join("\n"),
+        },
+        {
+            path: wsPath("engineering-state", "src", "README.md"),
+            content: [
+                "# Engineering Source",
+                "",
+                `Place the main implementation here. Keep test evidence in \`${ACE_ROOT_REL}/engineering-state/TEST_LOG.md\`.`,
+            ].join("\n"),
+        },
+    ];
+}
+export function getMcpClientBundlePath(client) {
+    if (client === "codex")
+        return wsPath(".mcp-config", "codex.config.toml");
+    if (client === "vscode")
+        return wsPath(".mcp-config", "vscode.mcp.json");
+    if (client === "copilot")
+        return wsPath(".mcp.json");
+    if (client === "claude")
+        return wsPath(".mcp-config", "claude_desktop_config.json");
+    if (client === "cursor")
+        return wsPath(".mcp-config", "cursor.mcp.json");
+    return wsPath(".mcp-config", "antigravity.mcp.json");
+}
+export function getMcpClientInstallHint(client) {
+    if (client === "codex") {
+        const codexHome = resolve(process.env.CODEX_HOME ?? resolve(homedir(), ".codex"));
+        return `${resolve(codexHome, "config.toml")} (append output from \`ace mcp-config --client codex\`)`;
+    }
+    if (client === "vscode") {
+        return `${wsPath(".vscode", "mcp.json")} (workspace) or merge output from \`ace mcp-config --client vscode\``;
+    }
+    if (client === "copilot") {
+        return `${wsPath(".mcp.json")} (workspace root, compatible with GitHub Copilot CLI)`;
+    }
+    if (client === "claude") {
+        return [
+            `${resolve(homedir(), "Library", "Application Support", "Claude", "claude_desktop_config.json")} (macOS, merge output from \`ace mcp-config --client claude\`)`,
+            `${resolve(homedir(), ".config", "Claude", "claude_desktop_config.json")} (Linux, merge output from \`ace mcp-config --client claude\`)`,
+        ].join(" | ");
+    }
+    if (client === "cursor") {
+        return `${resolve(homedir(), ".cursor", "mcp.json")} (merge output from \`ace mcp-config --client cursor\`)`;
+    }
+    return "Use Antigravity MCP UI import with output from `ace mcp-config --client antigravity`";
+}
+export function getMcpServerConfigSnippet(client = "vscode") {
+    const stdio = getMcpCommandSpec(resolveWorkspaceRoot());
+    const mcpServers = {
+        "ace-swarm": {
+            ...stdio,
+        },
+    };
+    if (client === "codex") {
+        return [
+            `# ACE instructions are scaffolded into ${ACE_HOST_AGENTS_REL} during bootstrap.`,
+            `[mcp_servers.ace-swarm]`,
+            `command = "${stdio.command}"`,
+            `args = ["${stdio.args.join('", "')}"]`,
+            "",
+        ].join("\n");
+    }
+    if (client === "vscode") {
+        return JSON.stringify({
+            servers: {
+                "ace-swarm": {
+                    type: "stdio",
+                    ...stdio,
+                },
+            },
+        }, null, 2);
+    }
+    if (client === "copilot") {
+        return JSON.stringify({ mcpServers }, null, 2);
+    }
+    return JSON.stringify({ mcpServers }, null, 2);
+}
+export function getAllMcpServerConfigSnippets() {
+    return {
+        codex: getMcpServerConfigSnippet("codex"),
+        vscode: getMcpServerConfigSnippet("vscode"),
+        copilot: getMcpServerConfigSnippet("copilot"),
+        claude: getMcpServerConfigSnippet("claude"),
+        cursor: getMcpServerConfigSnippet("cursor"),
+        antigravity: getMcpServerConfigSnippet("antigravity"),
+    };
+}
+export function bootstrapAceWorkspace(options = {}) {
+    const force = options.force ?? false;
+    const projectName = options.projectName?.trim() || "ACE Project";
+    const includeMcpConfig = options.includeMcpConfig ?? true;
+    const includeClientConfigBundle = options.includeClientConfigBundle ?? true;
+    const normalizedProvider = normalizeProvider(options.llmProvider);
+    const llmProvider = normalizedProvider;
+    const llmModel = options.llmModel?.trim() ||
+        options.ollamaModel?.trim() ||
+        (llmProvider === "ollama" ? defaultModelForProvider(llmProvider) : undefined);
+    const llmBaseUrl = normalizeLocalBaseUrl(options.llmBaseUrl ?? options.ollamaBaseUrl);
+    if (llmProvider && !ALL_LLM_PROVIDERS.includes(llmProvider)) {
+        throw new Error(`Unsupported llmProvider: ${llmProvider}`);
+    }
+    const result = { created: [], updated: [], skipped: [] };
+    const generatedAt = new Date().toISOString();
+    const workspaceRoot = resolveWorkspaceRoot();
+    const dirSeeds = [
+        acePath(),
+        wsPath("global-state"),
+        wsPath("venture-state"),
+        wsPath("brand-state"),
+        wsPath("brand-state", "ASSETS"),
+        wsPath("engineering-state"),
+        wsPath("engineering-state", "src"),
+        wsPath("agent-state"),
+        wsPath("agent-state", "MODULES"),
+        wsPath("agent-state", "MODULES", "roles"),
+        wsPath("agent-state", "MODULES", "gates"),
+        acePath("tasks"),
+        acePath(".github"),
+        acePath(".github", "hooks"),
+        acePath(".claude"),
+        acePath(".cursor"),
+        acePath(".vscode"),
+        acePath(".mcp-config"),
+        acePath("scripts"),
+        acePath("scripts", "ace"),
+        acePath("skills"),
+    ];
+    if (llmProvider) {
+        dirSeeds.push(acePath(".ace"));
+    }
+    for (const dir of dirSeeds)
+        ensureDir(dir, result);
+    const skipStoreManaged = options.skipStoreManaged ?? false;
+    if (!skipStoreManaged) {
+        copyTree(DEFAULTS_TASKS_ROOT, acePath("tasks"), result, force);
+        copyTree(DEFAULTS_AGENT_STATE_ROOT, wsPath("agent-state"), result, force);
+        copyTree(resolve(DEFAULTS_ROOT, ".agents", "ACE"), acePath(), result, force);
+        copyTree(DEFAULTS_SKILLS_ROOT, acePath("skills"), result, force);
+    }
+    copyTree(DEFAULTS_GITHUB_ROOT, acePath(".github"), result, force);
+    copyTree(DEFAULTS_SCRIPTS_ROOT, acePath("scripts", "ace"), result, force);
+    const masterPlanPath = wsPath("global-state", "MASTER_PLAN.md");
+    writeIfMissingOrForced(masterPlanPath, [
+        `# ${projectName} — Master Plan`,
+        "",
+        `Created: ${generatedAt}`,
+        "",
+        "## Status",
+        "",
+        "- Phase: Bootstrap",
+        "- Next: Route first handoff",
+        "",
+        "## Roadmap",
+        "",
+        "1. [ ] Validate venture thesis (ACE-VOS)",
+        "2. [ ] Define UX copy/flow package (ACE-UI)",
+        "3. [ ] Ship tested implementation (ACE-Coders)",
+        "",
+        "## Active Swarm",
+        "",
+        "| Agent | Status | Last Update |",
+        "|---|---|---|",
+        "| ACE-Orchestrator | active | bootstrap |",
+        "| ACE-VOS | idle | — |",
+        "| ACE-UI | idle | — |",
+        "| ACE-Coders | idle | — |",
+    ].join("\n"), result, force);
+    for (const file of buildWorkspaceStateSeedFiles(projectName, generatedAt)) {
+        writeIfMissingOrForced(file.path, file.content, result, force);
+    }
+    const registryPath = wsPath("global-state", "SWARM_REGISTRY.json");
+    const swarmSubagents = [...COMPOSABLE_AGENTS];
+    const parentSwarms = [...SWARM_AGENTS].map((role) => `ace-${role}`);
+    writeIfMissingOrForced(registryPath, JSON.stringify({
+        swarms: {
+            "ace-orchestrator": {
+                group: "swarm",
+                state_dir: `./${ACE_ROOT_REL}/global-state/`,
+                status: "active",
+                instructions: ".agents/ACE/orchestrator/instructions.md",
+                subagents: swarmSubagents,
+            },
+            "ace-vos": {
+                group: "swarm",
+                state_dir: `./${ACE_ROOT_REL}/venture-state/`,
+                status: "idle",
+                instructions: ".agents/ACE/VOS/instructions.md",
+                subagents: swarmSubagents,
+            },
+            "ace-ui": {
+                group: "swarm",
+                state_dir: `./${ACE_ROOT_REL}/brand-state/`,
+                status: "idle",
+                instructions: ".agents/ACE/UI/instructions.md",
+                subagents: swarmSubagents,
+            },
+            "ace-coders": {
+                group: "swarm",
+                state_dir: `./${ACE_ROOT_REL}/engineering-state/`,
+                status: "idle",
+                instructions: ".agents/ACE/ACE_coders/INSTRUCTIONS.md",
+                subagents: swarmSubagents,
+            },
+            "agent-astgrep": {
+                group: "composable",
+                state_dir: `./${ACE_ROOT_REL}/agent-state/`,
+                status: "idle",
+                instructions: ".agents/ACE/agent-astgrep/instructions.md",
+                parent_swarms: parentSwarms,
+            },
+            "agent-skeptic": {
+                group: "composable",
+                state_dir: `./${ACE_ROOT_REL}/agent-state/`,
+                status: "idle",
+                instructions: ".agents/ACE/agent-skeptic/instructions.md",
+                parent_swarms: parentSwarms,
+            },
+            "agent-ops": {
+                group: "composable",
+                state_dir: `./${ACE_ROOT_REL}/agent-state/`,
+                status: "idle",
+                instructions: ".agents/ACE/agent-ops/instructions.md",
+                parent_swarms: parentSwarms,
+            },
+            "agent-research": {
+                group: "composable",
+                state_dir: `./${ACE_ROOT_REL}/agent-state/`,
+                status: "idle",
+                instructions: ".agents/ACE/agent-research/instructions.md",
+                parent_swarms: parentSwarms,
+            },
+            "agent-spec": {
+                group: "composable",
+                state_dir: `./${ACE_ROOT_REL}/agent-state/`,
+                status: "idle",
+                instructions: ".agents/ACE/agent-spec/instructions.md",
+                parent_swarms: parentSwarms,
+            },
+            "agent-builder": {
+                group: "composable",
+                state_dir: `./${ACE_ROOT_REL}/agent-state/`,
+                status: "idle",
+                instructions: ".agents/ACE/agent-builder/instructions.md",
+                parent_swarms: parentSwarms,
+            },
+            "agent-qa": {
+                group: "composable",
+                state_dir: `./${ACE_ROOT_REL}/agent-state/`,
+                status: "idle",
+                instructions: ".agents/ACE/agent-qa/instructions.md",
+                parent_swarms: parentSwarms,
+            },
+            "agent-docs": {
+                group: "composable",
+                state_dir: `./${ACE_ROOT_REL}/agent-state/`,
+                status: "idle",
+                instructions: ".agents/ACE/agent-docs/instructions.md",
+                parent_swarms: parentSwarms,
+            },
+            "agent-memory": {
+                group: "composable",
+                state_dir: `./${ACE_ROOT_REL}/agent-state/`,
+                status: "idle",
+                instructions: ".agents/ACE/agent-memory/instructions.md",
+                parent_swarms: parentSwarms,
+            },
+            "agent-security": {
+                group: "composable",
+                state_dir: `./${ACE_ROOT_REL}/agent-state/`,
+                status: "idle",
+                instructions: ".agents/ACE/agent-security/instructions.md",
+                parent_swarms: parentSwarms,
+            },
+            "agent-observability": {
+                group: "composable",
+                state_dir: `./${ACE_ROOT_REL}/agent-state/`,
+                status: "idle",
+                instructions: ".agents/ACE/agent-observability/instructions.md",
+                parent_swarms: parentSwarms,
+            },
+            "agent-eval": {
+                group: "composable",
+                state_dir: `./${ACE_ROOT_REL}/agent-state/`,
+                status: "idle",
+                instructions: ".agents/ACE/agent-eval/instructions.md",
+                parent_swarms: parentSwarms,
+            },
+            "agent-release": {
+                group: "composable",
+                state_dir: `./${ACE_ROOT_REL}/agent-state/`,
+                status: "idle",
+                instructions: ".agents/ACE/agent-release/instructions.md",
+                parent_swarms: parentSwarms,
+            },
+        },
+    }, null, 2), result, true);
+    writeIfMissingOrForced(wsPath("agent-state", "run-ledger.json"), JSON.stringify({ version: 1, updated_at: new Date().toISOString(), entries: [] }, null, 2), result, force);
+    writeIfMissingOrForced(wsPath("agent-state", "handoff-registry.json"), JSON.stringify({ version: 1, updated_at: new Date().toISOString(), handoffs: {} }, null, 2), result, force);
+    writeIfMissingOrForced(wsPath("agent-state", "index.json"), JSON.stringify({
+        version: 1,
+        root: ".",
+        generated_at: "",
+        discovery: {
+            mode: "ast_grep_commands",
+            command_pack: "agent-state/AST_GREP_COMMANDS.md",
+            subagent: "astgrep",
+            skill: "astgrep-index",
+            fingerprint_store: "agent-state/index-fingerprints.json",
+        },
+        options: {
+            depth: 6,
+            max_files: 10000,
+            include_hidden: false,
+            exclude: [
+                ".git",
+                "node_modules",
+                "dist",
+                "target",
+                ".venv",
+                "__pycache__",
+                ".DS_Store",
+            ],
+            file_entry_cap: 0,
+        },
+        file_count: 0,
+        stored_file_count: 0,
+        directories: {},
+        extensions: {},
+        files: {},
+    }, null, 2), result, force);
+    writeIfMissingOrForced(wsPath("agent-state", "index-fingerprints.json"), JSON.stringify({ version: 1, root: ".", generated_at: "", file_count: 0, fingerprints: {} }, null, 2), result, force);
+    writeIfMissingOrForced(wsPath("agent-state", "todo-state.json"), JSON.stringify({
+        version: 1,
+        updated_at: new Date().toISOString(),
+        source_todo_path: `${ACE_TASKS_ROOT_REL}/todo.md`,
+        order: [],
+        nodes: {},
+    }, null, 2), result, force);
+    writeIfMissingOrForced(wsPath("agent-state", "job-queue.json"), JSON.stringify({ version: 1, updated_at: new Date().toISOString(), jobs: [] }, null, 2), result, force);
+    writeIfMissingOrForced(wsPath("agent-state", "job-locks.json"), JSON.stringify({ version: 1, updated_at: new Date().toISOString(), locks: [] }, null, 2), result, force);
+    writeIfMissingOrForced(wsPath("agent-state", "scheduler-lease.json"), JSON.stringify({
+        version: 1,
+        lease_id: "LEASE-UNASSIGNED",
+        owner: "unassigned",
+        acquired_at: new Date().toISOString(),
+        heartbeat_at: new Date().toISOString(),
+        expires_at: new Date().toISOString(),
+    }, null, 2), result, force);
+    if (includeMcpConfig) {
+        writeIfMissingOrForced(acePath(".vscode", "mcp.json"), getMcpServerConfigSnippet("vscode"), result, force);
+    }
+    if (includeClientConfigBundle) {
+        const snippets = getAllMcpServerConfigSnippets();
+        for (const client of ALL_MCP_CLIENTS) {
+            writeIfMissingOrForced(getMcpClientBundlePath(client), snippets[client], result, force);
+        }
+        writeIfMissingOrForced(acePath("CLAUDE.md"), buildHostInstructionText("claude", workspaceRoot), result, force);
+        writeIfMissingOrForced(acePath(".github", "copilot-instructions.md"), buildHostInstructionText("copilot", workspaceRoot), result, force);
+        writeIfMissingOrForced(acePath(".cursorrules"), buildHostInstructionText("cursor", workspaceRoot), result, force);
+        writeIfMissingOrForced(acePath("AGENTS.md"), buildHostInstructionText("codex", workspaceRoot), result, force);
+        writeIfMissingOrForced(acePath(".claude", "settings.json"), buildClaudeHookSettings(), result, force);
+        writeIfMissingOrForced(acePath(".github", "hooks", "ace-copilot.json"), buildCopilotHookSettings(), result, force);
+        writeIfMissingOrForced(acePath(".vscode", "ace-hooks.json"), buildVsCodeHookSettings(), result, force);
+        writeIfMissingOrForced(acePath(".cursor", "hooks.json"), buildCursorHookSettings(), result, force);
+        writeIfMissingOrForced(wsPath(".mcp-config", "codex.hooks.toml"), buildCodexHookSettings(), result, force);
+        writeIfMissingOrForced(wsPath(".mcp-config", "gemini.hooks.json"), buildGeminiHookSettings(), result, force);
+        writeIfMissingOrForced(wsPath(".mcp-config", "antigravity.hooks.json"), buildAntigravityHookSettings(), result, force);
+        writeIfMissingOrForced(wsPath(".mcp-config", "README.md"), [
+            "# ACE MCP Client Config Bundle",
+            "",
+            "Generated by `ace init` so this workspace is turnkey across MCP clients.",
+            "",
+            "## Files",
+            "- `codex.config.toml`",
+            "- `vscode.mcp.json`",
+            "- `claude_desktop_config.json`",
+            "- `cursor.mcp.json`",
+            "- `antigravity.mcp.json`",
+            "",
+            "## Instruction + Hook Files",
+            `- \`${ACE_HOST_CLAUDE_REL}\``,
+            `- \`${ACE_GITHUB_ROOT_REL}/copilot-instructions.md\``,
+            `- \`${ACE_HOST_CURSOR_RULES_REL}\``,
+            `- \`${ACE_HOST_AGENTS_REL}\``,
+            `- \`${ACE_CLAUDE_ROOT_REL}/settings.json\``,
+            `- \`${ACE_VSCODE_ROOT_REL}/ace-hooks.json\``,
+            `- \`${ACE_CURSOR_ROOT_REL}/hooks.json\``,
+            `- \`${ACE_BUNDLE_ROOT_REL}/codex.hooks.toml\``,
+            `- \`${ACE_BUNDLE_ROOT_REL}/gemini.hooks.json\``,
+            `- \`${ACE_BUNDLE_ROOT_REL}/antigravity.hooks.json\``,
+            "",
+            "## Install Hints",
+            ...ALL_MCP_CLIENTS.map((client) => `- ${client}: ${getMcpClientInstallHint(client)}`),
+            ...(llmProvider
+                ? [
+                    "",
+                    "## LLM Runtime Profile",
+                    `- \`${ACE_LLM_ROOT_REL}/llm-profile.json\` (generated for ${llmProvider})`,
+                    `- \`${ACE_LLM_ROOT_REL}/doctor-checks.md\` (commands to verify provider runtime)`,
+                    llmBaseUrl
+                        ? `- Run \`ace doctor --llm ${llmProvider} --model ${llmModel} --base-url ${llmBaseUrl}\``
+                        : llmProvider === "ollama" || llmProvider === "llama.cpp"
+                            ? `- Run \`ace doctor --llm ${llmProvider} --model ${llmModel} --scan\` to discover a local endpoint`
+                            : `- Run \`ace doctor --llm ${llmProvider} --model ${llmModel}\` after exporting the provider credentials`,
+                ]
+                : []),
+        ].join("\n"), result, force);
+    }
+    if (llmProvider) {
+        const profilePayload = {
+            provider: llmProvider,
+            model: llmModel,
+            generated_at: new Date().toISOString(),
+        };
+        if (llmBaseUrl) {
+            profilePayload.base_url = llmBaseUrl;
+            if (llmProvider === "ollama") {
+                profilePayload.api_compat_base_url = buildOpenAiCompatibleBaseUrl(llmBaseUrl);
+                profilePayload.default_api_key = "ollama";
+            }
+        }
+        writeIfMissingOrForced(wsPath(".ace", "llm-profile.json"), JSON.stringify(profilePayload, null, 2), result, force);
+        const doctorCommands = buildProviderDoctorCommands(llmProvider, llmModel, llmBaseUrl);
+        writeIfMissingOrForced(wsPath(".ace", "doctor-checks.md"), [
+            `# ACE + ${llmProvider} Runtime Checks`,
+            "",
+            "Run these commands to verify ACE runtime readiness:",
+            "",
+            "```bash",
+            ...doctorCommands,
+            "```",
+            "",
+            `MCP is still configured separately via \`${ACE_VSCODE_ROOT_REL}/mcp.json\` or \`${ACE_BUNDLE_ROOT_REL}/*\`.`,
+        ].join("\n"), result, force);
+    }
+    return result;
+}
+//# sourceMappingURL=bootstrap.js.map