@voybio/ace-swarm 0.2.4 → 2.4.0

package/dist/helpers.js

@@ -1,1750 +1,11 @@
-/**
- * Shared helpers – path resolution, file I/O, artifact discovery, bootstrap.
- */
-import { copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync, renameSync, writeFileSync, } from "node:fs";
-import { homedir } from "node:os";
-import { dirname, isAbsolute, join, relative, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-import { buildHostInstructionText } from "./ace-server-instructions.js";
-import { isInside, normalizeRelPath } from "./shared.js";
-import { getWorkspaceStorePath, listStoreKeysSync, parseVirtualStorePath, readStoreBlobSync, readVirtualStorePathSync, toVirtualStorePath, } from "./store/store-snapshot.js";
-import { isOperationalArtifactPath, operationalArtifactKey, writeStoreBlobSync, writeOperationalArtifactSync, } from "./store/store-artifacts.js";
-import { buildProviderDoctorCommands, buildOpenAiCompatibleBaseUrl, defaultModelForProvider, normalizeLocalBaseUrl, normalizeProvider, } from "./tui/provider-discovery.js";
+import { resolveWorkspaceRoot } from "./helpers/workspace-root.js";
 export { isInside, isReadError, normalizeRelPath, looksLikeSwarmHandoffPath } from "./shared.js";
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-export const SERVER_ROOT = resolve(__dirname, "..");
-export const PACKAGE_ROOT = SERVER_ROOT;
-function normalizeWorkspaceRootCandidate(candidate) {
-    const trimmed = candidate?.trim();
-    if (!trimmed)
-        return undefined;
-    return resolve(trimmed);
-}
-function isFilesystemRoot(path) {
-    return dirname(path) === path;
-}
-function normalizeWorkspaceRootLikePath(candidate) {
-    const resolvedCandidate = resolve(candidate);
-    if (resolvedCandidate.endsWith(join(".agents", "ACE", "ace-state.ace"))) {
-        return dirname(dirname(dirname(resolvedCandidate)));
-    }
-    if (resolvedCandidate.endsWith(join(".agents", "ACE"))) {
-        return dirname(dirname(resolvedCandidate));
-    }
-    if (resolvedCandidate.endsWith(join(".agents"))) {
-        return dirname(resolvedCandidate);
-    }
-    return resolvedCandidate;
-}
-function hasInitiatedAceWorkspace(root) {
-    return (existsSync(resolve(root, ".agents", "ACE", "ace-state.ace")) ||
-        existsSync(resolve(root, ".agents", "ACE")) ||
-        existsSync(resolve(root, "agent-state", "TASK.md")) ||
-        existsSync(resolve(root, "agent-state", "STATUS.md")));
-}
-function findNearestInitiatedWorkspaceRoot(candidate) {
-    let cursor = normalizeWorkspaceRootLikePath(candidate);
-    while (true) {
-        if (existsSync(cursor) && hasInitiatedAceWorkspace(cursor)) {
-            return cursor;
-        }
-        const parent = dirname(cursor);
-        if (parent === cursor)
-            break;
-        cursor = parent;
-    }
-    return undefined;
-}
-function pinWorkspaceRoot(root) {
-    const normalized = normalizeWorkspaceRootLikePath(root);
-    process.env.ACE_WORKSPACE_ROOT = normalized;
-    return normalized;
-}
-export function resolveWorkspaceRoot() {
-    const explicit = normalizeWorkspaceRootCandidate(process.env.ACE_WORKSPACE_ROOT);
-    if (explicit)
-        return pinWorkspaceRoot(findNearestInitiatedWorkspaceRoot(explicit) ?? explicit);
-    const ordered = [
-        process.env.ACE_TUI_WORKSPACE_ROOT,
-        process.env.INIT_CWD,
-        process.env.PWD,
-        process.cwd(),
-    ]
-        .map(normalizeWorkspaceRootCandidate)
-        .filter((candidate) => Boolean(candidate));
-    const candidates = [...new Set(ordered)];
-    for (const candidate of candidates) {
-        const initiated = findNearestInitiatedWorkspaceRoot(candidate);
-        if (initiated)
-            return pinWorkspaceRoot(initiated);
-    }
-    const firstExistingNonRoot = candidates.find((candidate) => existsSync(candidate) && !isFilesystemRoot(candidate));
-    if (firstExistingNonRoot)
-        return pinWorkspaceRoot(firstExistingNonRoot);
-    const firstExisting = candidates.find((candidate) => existsSync(candidate));
-    if (firstExisting)
-        return pinWorkspaceRoot(firstExisting);
-    return pinWorkspaceRoot(candidates[0] ?? resolve(process.cwd()));
-}
+export * from "./helpers/constants.js";
+export { resolveWorkspaceRoot };
 export const WORKSPACE_ROOT = resolveWorkspaceRoot();
-function currentWorkspaceRoot() {
-    return resolveWorkspaceRoot();
-}
-export const DEFAULTS_ROOT = resolve(PACKAGE_ROOT, "assets");
-const DEFAULTS_INSTRUCTIONS_ROOT = resolve(DEFAULTS_ROOT, "instructions");
-const DEFAULTS_TASKS_ROOT = resolve(DEFAULTS_ROOT, "tasks");
-const DEFAULTS_SKILLS_ROOT = resolve(DEFAULTS_ROOT, ".agents", "skills");
-const DEFAULTS_AGENT_STATE_ROOT = resolve(DEFAULTS_ROOT, "agent-state");
-const DEFAULTS_SCRIPTS_ROOT = resolve(DEFAULTS_ROOT, "scripts");
-const DEFAULTS_GITHUB_ROOT = resolve(DEFAULTS_ROOT, ".github");
-export const ACE_ROOT_REL = ".agents/ACE";
-export const ACE_SKILLS_ROOT_REL = `${ACE_ROOT_REL}/skills`;
-export const ACE_TASKS_ROOT_REL = `${ACE_ROOT_REL}/tasks`;
-export const ACE_SCRIPTS_ROOT_REL = `${ACE_ROOT_REL}/scripts/ace`;
-export const ACE_BUNDLE_ROOT_REL = ".mcp-config";
-export const ACE_LLM_ROOT_REL = `${ACE_ROOT_REL}/.ace`;
-export const ACE_VSCODE_ROOT_REL = ".vscode";
-export const ACE_CURSOR_ROOT_REL = ".cursor";
-export const ACE_CLAUDE_ROOT_REL = ".claude";
-export const ACE_GITHUB_ROOT_REL = ".github";
-export const ACE_HOST_AGENTS_REL = "AGENTS.md";
-export const ACE_HOST_CLAUDE_REL = "CLAUDE.md";
-export const ACE_HOST_CURSOR_RULES_REL = ".cursorrules";
-const ACE_MANAGED_PREFIXES = [
-    "agent-state",
-    "global-state",
-    "venture-state",
-    "brand-state",
-    "business-state",
-    "engineering-state",
-    ".ace",
-    ".mcp-config",
-];
-export const ALL_MCP_CLIENTS = [
-    "codex",
-    "vscode",
-    "claude",
-    "cursor",
-    "antigravity",
-];
-export const ALL_LLM_PROVIDERS = [
-    "ollama",
-    "llama.cpp",
-    "codex",
-    "claude",
-    "gemini",
-    "copilot",
-];
-export const ALL_AGENTS = [
-    "orchestrator",
-    "vos",
-    "ui",
-    "coders",
-    "astgrep",
-    "skeptic",
-    "ops",
-    "research",
-    "spec",
-    "builder",
-    "qa",
-    "docs",
-    "memory",
-    "security",
-    "observability",
-    "eval",
-    "release",
-];
-export const SWARM_AGENTS = ["orchestrator", "vos", "ui", "coders"];
-export const COMPOSABLE_AGENTS = [
-    "astgrep",
-    "skeptic",
-    "ops",
-    "research",
-    "spec",
-    "builder",
-    "qa",
-    "docs",
-    "memory",
-    "security",
-    "observability",
-    "eval",
-    "release",
-];
-export const SWARM_SUBAGENT_MAP = {
-    orchestrator: COMPOSABLE_AGENTS,
-    vos: COMPOSABLE_AGENTS,
-    ui: COMPOSABLE_AGENTS,
-    coders: COMPOSABLE_AGENTS,
-};
-// Workspace-first agent instruction candidates.
-export const AGENT_FILES = {
-    orchestrator: [
-        ".agents/ACE/orchestrator/instructions.md",
-        ".agents/ACE/orchestrator/AGENTS.md",
-        "ACE.instructions.md",
-        // Legacy fallback (pre split where ACE-Init carried orchestrator behavior)
-        ".agents/ACE/ACE-Init/instructions.md",
-        ".agents/ACE/ACE-Init/AGENTS.md",
-    ],
-    vos: [
-        ".agents/ACE/VOS/instructions.md",
-        ".agents/ACE/VOS/AGENTS.md",
-        "ACE_VOS.instructions.md",
-    ],
-    ui: [
-        ".agents/ACE/UI/instructions.md",
-        ".agents/ACE/UI/AGENTS.md",
-        "ACE_UI.instructions.md",
-    ],
-    coders: [
-        ".agents/ACE/ACE_coders/INSTRUCTIONS.md",
-        ".agents/ACE/ACE_coders/AGENTS.md",
-        "ACE_Coder.instructions.md",
-    ],
-    astgrep: [".agents/ACE/agent-astgrep/instructions.md", ".agents/ACE/agent-astgrep/AGENTS.md"],
-    skeptic: [".agents/ACE/agent-skeptic/instructions.md", ".agents/ACE/agent-skeptic/AGENTS.md"],
-    ops: [".agents/ACE/agent-ops/instructions.md", ".agents/ACE/agent-ops/AGENTS.md"],
-    research: [
-        ".agents/ACE/agent-research/instructions.md",
-        ".agents/ACE/agent-research/AGENTS.md",
-    ],
-    spec: [".agents/ACE/agent-spec/instructions.md", ".agents/ACE/agent-spec/AGENTS.md"],
-    builder: [
-        ".agents/ACE/agent-builder/instructions.md",
-        ".agents/ACE/agent-builder/AGENTS.md",
-    ],
-    qa: [".agents/ACE/agent-qa/instructions.md", ".agents/ACE/agent-qa/AGENTS.md"],
-    docs: [".agents/ACE/agent-docs/instructions.md", ".agents/ACE/agent-docs/AGENTS.md"],
-    memory: [
-        ".agents/ACE/agent-memory/instructions.md",
-        ".agents/ACE/agent-memory/AGENTS.md",
-    ],
-    security: [
-        ".agents/ACE/agent-security/instructions.md",
-        ".agents/ACE/agent-security/AGENTS.md",
-    ],
-    observability: [
-        ".agents/ACE/agent-observability/instructions.md",
-        ".agents/ACE/agent-observability/AGENTS.md",
-    ],
-    eval: [".agents/ACE/agent-eval/instructions.md", ".agents/ACE/agent-eval/AGENTS.md"],
-    release: [".agents/ACE/agent-release/instructions.md", ".agents/ACE/agent-release/AGENTS.md"],
-};
-// Workspace-first agent manifest candidates.
-export const AGENT_MANIFEST_FILES = {
-    orchestrator: [
-        ".agents/ACE/orchestrator/AGENTS.md",
-        // Legacy fallback (pre split where ACE-Init carried orchestrator behavior)
-        ".agents/ACE/ACE-Init/AGENTS.md",
-    ],
-    vos: [".agents/ACE/VOS/AGENTS.md"],
-    ui: [".agents/ACE/UI/AGENTS.md"],
-    coders: [".agents/ACE/ACE_coders/AGENTS.md"],
-    astgrep: [".agents/ACE/agent-astgrep/AGENTS.md"],
-    skeptic: [".agents/ACE/agent-skeptic/AGENTS.md"],
-    ops: [".agents/ACE/agent-ops/AGENTS.md"],
-    research: [".agents/ACE/agent-research/AGENTS.md"],
-    spec: [".agents/ACE/agent-spec/AGENTS.md"],
-    builder: [".agents/ACE/agent-builder/AGENTS.md"],
-    qa: [".agents/ACE/agent-qa/AGENTS.md"],
-    docs: [".agents/ACE/agent-docs/AGENTS.md"],
-    memory: [".agents/ACE/agent-memory/AGENTS.md"],
-    security: [".agents/ACE/agent-security/AGENTS.md"],
-    observability: [".agents/ACE/agent-observability/AGENTS.md"],
-    eval: [".agents/ACE/agent-eval/AGENTS.md"],
-    release: [".agents/ACE/agent-release/AGENTS.md"],
-};
-export const TASK_FILES = {
-    todo: [`${ACE_TASKS_ROOT_REL}/todo.md`],
-    role_tasks: [`${ACE_TASKS_ROOT_REL}/role_tasks.md`],
-    cli_work_split: [`${ACE_TASKS_ROOT_REL}/cli_work_split.md`],
-    lessons: [`${ACE_TASKS_ROOT_REL}/lessons.md`],
-    readme: [`${ACE_TASKS_ROOT_REL}/README.md`],
-    handoff_template: [`${ACE_TASKS_ROOT_REL}/SWARM_HANDOFF.template.json`],
-    handoff_example: [`${ACE_TASKS_ROOT_REL}/SWARM_HANDOFF.example.json`],
-    handoff_example_vos_ui: [`${ACE_TASKS_ROOT_REL}/SWARM_HANDOFF.example_vos_to_ui.json`],
-    handoff_example_ui_coders: [`${ACE_TASKS_ROOT_REL}/SWARM_HANDOFF.example_ui_to_coders.json`],
-};
-export const KERNEL_FILES = {
-    directive_kernel: [
-        ".agents/ACE/DIRECTIVE_KERNEL.md",
-        "agent-state/ACE_MACHINE_KERNEL_DIRECTIVES.md",
-    ],
-    agent_registry: [
-        ".agents/ACE/AGENT_REGISTRY.md",
-        ".agents/ACE/AGENT_REGISTRY_7.md",
-        "agent-state/ACE_7_AGENT_SYSTEM_SPEC.md",
-    ],
-};
-const DEFAULT_AGENT_INSTRUCTION_FILES = {
-    orchestrator: resolve(DEFAULTS_INSTRUCTIONS_ROOT, "ACE.instructions.md"),
-    vos: resolve(DEFAULTS_INSTRUCTIONS_ROOT, "ACE_VOS.instructions.md"),
-    ui: resolve(DEFAULTS_INSTRUCTIONS_ROOT, "ACE_UI.instructions.md"),
-    coders: resolve(DEFAULTS_INSTRUCTIONS_ROOT, "ACE_Coder.instructions.md"),
-    astgrep: resolve(DEFAULTS_ROOT, ".agents", "ACE", "agent-astgrep", "instructions.md"),
-    skeptic: resolve(DEFAULTS_ROOT, ".agents", "ACE", "agent-skeptic", "instructions.md"),
-    ops: resolve(DEFAULTS_ROOT, ".agents", "ACE", "agent-ops", "instructions.md"),
-    research: resolve(DEFAULTS_ROOT, ".agents", "ACE", "agent-research", "instructions.md"),
-    spec: resolve(DEFAULTS_ROOT, ".agents", "ACE", "agent-spec", "instructions.md"),
-    builder: resolve(DEFAULTS_ROOT, ".agents", "ACE", "agent-builder", "instructions.md"),
-    qa: resolve(DEFAULTS_ROOT, ".agents", "ACE", "agent-qa", "instructions.md"),
-    docs: resolve(DEFAULTS_ROOT, ".agents", "ACE", "agent-docs", "instructions.md"),
-    memory: resolve(DEFAULTS_ROOT, ".agents", "ACE", "agent-memory", "instructions.md"),
-    security: resolve(DEFAULTS_ROOT, ".agents", "ACE", "agent-security", "instructions.md"),
-    observability: resolve(DEFAULTS_ROOT, ".agents", "ACE", "agent-observability", "instructions.md"),
-    eval: resolve(DEFAULTS_ROOT, ".agents", "ACE", "agent-eval", "instructions.md"),
-    release: resolve(DEFAULTS_ROOT, ".agents", "ACE", "agent-release", "instructions.md"),
-};
-const DEFAULT_AGENT_MANIFEST_FILES = {
-    orchestrator: resolve(DEFAULTS_ROOT, ".agents", "ACE", "orchestrator", "AGENTS.md"),
-    vos: resolve(DEFAULTS_ROOT, ".agents", "ACE", "VOS", "AGENTS.md"),
-    ui: resolve(DEFAULTS_ROOT, ".agents", "ACE", "UI", "AGENTS.md"),
-    coders: resolve(DEFAULTS_ROOT, ".agents", "ACE", "ACE_coders", "AGENTS.md"),
-    astgrep: resolve(DEFAULTS_ROOT, ".agents", "ACE", "agent-astgrep", "AGENTS.md"),
-    skeptic: resolve(DEFAULTS_ROOT, ".agents", "ACE", "agent-skeptic", "AGENTS.md"),
-    ops: resolve(DEFAULTS_ROOT, ".agents", "ACE", "agent-ops", "AGENTS.md"),
-    research: resolve(DEFAULTS_ROOT, ".agents", "ACE", "agent-research", "AGENTS.md"),
-    spec: resolve(DEFAULTS_ROOT, ".agents", "ACE", "agent-spec", "AGENTS.md"),
-    builder: resolve(DEFAULTS_ROOT, ".agents", "ACE", "agent-builder", "AGENTS.md"),
-    qa: resolve(DEFAULTS_ROOT, ".agents", "ACE", "agent-qa", "AGENTS.md"),
-    docs: resolve(DEFAULTS_ROOT, ".agents", "ACE", "agent-docs", "AGENTS.md"),
-    memory: resolve(DEFAULTS_ROOT, ".agents", "ACE", "agent-memory", "AGENTS.md"),
-    security: resolve(DEFAULTS_ROOT, ".agents", "ACE", "agent-security", "AGENTS.md"),
-    observability: resolve(DEFAULTS_ROOT, ".agents", "ACE", "agent-observability", "AGENTS.md"),
-    eval: resolve(DEFAULTS_ROOT, ".agents", "ACE", "agent-eval", "AGENTS.md"),
-    release: resolve(DEFAULTS_ROOT, ".agents", "ACE", "agent-release", "AGENTS.md"),
-};
-const DEFAULT_TASK_FILES = {
-    todo: resolve(DEFAULTS_TASKS_ROOT, "todo.md"),
-    role_tasks: resolve(DEFAULTS_TASKS_ROOT, "role_tasks.md"),
-    cli_work_split: resolve(DEFAULTS_TASKS_ROOT, "cli_work_split.md"),
-    lessons: resolve(DEFAULTS_TASKS_ROOT, "lessons.md"),
-    readme: resolve(DEFAULTS_TASKS_ROOT, "README.md"),
-    handoff_template: resolve(DEFAULTS_TASKS_ROOT, "SWARM_HANDOFF.template.json"),
-    handoff_example: resolve(DEFAULTS_TASKS_ROOT, "SWARM_HANDOFF.example.json"),
-    handoff_example_vos_ui: resolve(DEFAULTS_TASKS_ROOT, "SWARM_HANDOFF.example_vos_to_ui.json"),
-    handoff_example_ui_coders: resolve(DEFAULTS_TASKS_ROOT, "SWARM_HANDOFF.example_ui_to_coders.json"),
-};
-const DEFAULT_KERNEL_FILES = {
-    directive_kernel: resolve(DEFAULTS_ROOT, ".agents", "ACE", "DIRECTIVE_KERNEL.md"),
-    agent_registry: resolve(DEFAULTS_ROOT, ".agents", "ACE", "AGENT_REGISTRY.md"),
-};
-const STORE_AGENT_FILES = {
-    orchestrator: {
-        agent: "ace-orchestrator",
-        instructions: ["instructions.md", "AGENTS.md"],
-        manifests: ["AGENTS.md"],
-    },
-    vos: { agent: "ace-vos", instructions: ["instructions.md", "AGENTS.md"], manifests: ["AGENTS.md"] },
-    ui: { agent: "ace-ui", instructions: ["instructions.md", "AGENTS.md"], manifests: ["AGENTS.md"] },
-    coders: { agent: "ace-coders", instructions: ["INSTRUCTIONS.md", "AGENTS.md"], manifests: ["AGENTS.md"] },
-    astgrep: { agent: "astgrep", instructions: ["instructions.md", "AGENTS.md"], manifests: ["AGENTS.md"] },
-    skeptic: { agent: "skeptic", instructions: ["instructions.md", "AGENTS.md"], manifests: ["AGENTS.md"] },
-    ops: { agent: "ops", instructions: ["instructions.md", "AGENTS.md"], manifests: ["AGENTS.md"] },
-    research: { agent: "research", instructions: ["instructions.md", "AGENTS.md"], manifests: ["AGENTS.md"] },
-    spec: { agent: "spec", instructions: ["instructions.md", "AGENTS.md"], manifests: ["AGENTS.md"] },
-    builder: { agent: "builder", instructions: ["instructions.md", "AGENTS.md"], manifests: ["AGENTS.md"] },
-    qa: { agent: "qa", instructions: ["instructions.md", "AGENTS.md"], manifests: ["AGENTS.md"] },
-    docs: { agent: "docs", instructions: ["instructions.md", "AGENTS.md"], manifests: ["AGENTS.md"] },
-    memory: { agent: "memory", instructions: ["instructions.md", "AGENTS.md"], manifests: ["AGENTS.md"] },
-    security: { agent: "security", instructions: ["instructions.md", "AGENTS.md"], manifests: ["AGENTS.md"] },
-    observability: {
-        agent: "observability",
-        instructions: ["instructions.md", "AGENTS.md"],
-        manifests: ["AGENTS.md"],
-    },
-    eval: { agent: "eval", instructions: ["instructions.md", "AGENTS.md"], manifests: ["AGENTS.md"] },
-    release: { agent: "release", instructions: ["instructions.md", "AGENTS.md"], manifests: ["AGENTS.md"] },
-};
-const STORE_TASK_FILES = {
-    todo: "knowledge/tasks/todo.md",
-    role_tasks: "knowledge/tasks/role_tasks.md",
-    cli_work_split: "knowledge/tasks/cli_work_split.md",
-    lessons: "knowledge/tasks/lessons.md",
-    readme: "knowledge/tasks/README.md",
-    handoff_template: "knowledge/tasks/SWARM_HANDOFF.template.json",
-    handoff_example: "knowledge/tasks/SWARM_HANDOFF.example.json",
-    handoff_example_vos_ui: "knowledge/tasks/SWARM_HANDOFF.example_vos_to_ui.json",
-    handoff_example_ui_coders: "knowledge/tasks/SWARM_HANDOFF.example_ui_to_coders.json",
-};
-const STORE_KERNEL_FILES = {
-    directive_kernel: ["knowledge/kernel/DIRECTIVE_KERNEL.md"],
-    agent_registry: ["knowledge/kernel/AGENT_REGISTRY.md", "knowledge/kernel/AGENT_REGISTRY_7.md"],
-};
-export function mapAceWorkspaceRelativePath(path) {
-    const normalized = normalizeRelPath(path);
-    if (!normalized || normalized === ".")
-        return normalized;
-    if (normalized === ACE_ROOT_REL || normalized.startsWith(`${ACE_ROOT_REL}/`)) {
-        return normalized;
-    }
-    for (const prefix of ACE_MANAGED_PREFIXES) {
-        if (normalized === prefix || normalized.startsWith(`${prefix}/`)) {
-            return `${ACE_ROOT_REL}/${normalized}`;
-        }
-    }
-    return normalized;
-}
-export function acePath(...segments) {
-    return resolve(currentWorkspaceRoot(), ACE_ROOT_REL, ...segments);
-}
-export function wsPath(...segments) {
-    const relativePath = normalizeRelPath(segments.join("/"));
-    return resolve(currentWorkspaceRoot(), mapAceWorkspaceRelativePath(relativePath));
-}
-/** Normalize a path for validation: workspace-relative, forward slashes. */
-export function normalizePathForValidation(path) {
-    const root = currentWorkspaceRoot();
-    const relPath = isAbsolute(path) ? relative(root, path) : path;
-    return normalizeRelPath(relPath);
-}
-/** Check if a role is a swarm agent (vs composable). */
-export function isSwarmRole(role) {
-    return SWARM_AGENTS.includes(role);
-}
-/** Atomically write a file via tmp + rename to prevent partial writes. */
-export function atomicWrite(filePath, content) {
-    const abs = isAbsolute(filePath) ? filePath : resolveWorkspaceWritePath(filePath);
-    mkdirSync(dirname(abs), { recursive: true });
-    const tmpPath = `${abs}.${process.pid}.tmp`;
-    writeFileSync(tmpPath, content, "utf-8");
-    renameSync(tmpPath, abs);
-    return abs;
-}
-/** Check if a file exists. Relative paths are workspace-relative. */
-export function fileExists(filePath) {
-    const abs = isAbsolute(filePath) ? filePath : resolveWorkspaceReadPath(filePath);
-    return existsSync(abs);
-}
-export function resolveWorkspaceWritePath(filePath) {
-    const root = currentWorkspaceRoot();
-    if (isFilesystemRoot(root)) {
-        throw new Error("Workspace root resolved to filesystem root. Set ACE_WORKSPACE_ROOT or run ACE from the target workspace.");
-    }
-    const abs = isAbsolute(filePath)
-        ? filePath
-        : resolve(root, mapAceWorkspaceRelativePath(filePath));
-    if (!isInside(root, abs)) {
-        throw new Error(`Path escapes workspace root: ${filePath}`);
-    }
-    return abs;
-}
-export function resolveWorkspaceReadPath(filePath) {
-    const root = currentWorkspaceRoot();
-    if (isAbsolute(filePath)) {
-        if (!isInside(root, filePath)) {
-            throw new Error(`Path escapes workspace root: ${filePath}`);
-        }
-        return filePath;
-    }
-    const normalized = normalizeRelPath(filePath);
-    const canonicalRel = mapAceWorkspaceRelativePath(normalized);
-    const canonicalAbs = resolve(root, canonicalRel);
-    if (canonicalRel !== normalized) {
-        const legacyAbs = resolve(root, normalized);
-        if (!existsSync(canonicalAbs) && existsSync(legacyAbs)) {
-            return legacyAbs;
-        }
-    }
-    if (!isInside(root, canonicalAbs)) {
-        throw new Error(`Path escapes workspace root: ${filePath}`);
-    }
-    return canonicalAbs;
-}
-export function resolveWorkspaceArtifactPath(filePath, mode = "write") {
-    return mode === "read" ? resolveWorkspaceReadPath(filePath) : resolveWorkspaceWritePath(filePath);
-}
-function toAbsoluteWorkspaceCandidates(candidates) {
-    return candidates.map((candidate) => isAbsolute(candidate) ? candidate : resolveWorkspaceReadPath(candidate));
-}
-function firstExistingPath(paths) {
-    return paths.find((candidate) => existsSync(candidate));
-}
-function readText(absPath) {
-    return readFileSync(absPath, "utf-8");
-}
-function resolveStoreFallbackKeys(filePath) {
-    const normalized = normalizeRelPath(filePath);
-    if (!normalized)
-        return [];
-    const canonical = mapAceWorkspaceRelativePath(normalized);
-    const keys = new Set();
-    if (canonical.startsWith(`${ACE_ROOT_REL}/agent-state/`)) {
-        const rel = canonical.slice(`${ACE_ROOT_REL}/`.length);
-        if (isOperationalArtifactPath(rel)) {
-            keys.add(operationalArtifactKey(rel));
-        }
-    }
-    if (normalized === "agent-state/ACE_WORKFLOW.md" || canonical === `${ACE_ROOT_REL}/agent-state/ACE_WORKFLOW.md`) {
-        keys.add("knowledge/runtime/ACE_WORKFLOW.md");
-    }
-    const gatePrefix = `${ACE_ROOT_REL}/agent-state/MODULES/gates/`;
-    if (canonical.startsWith(gatePrefix)) {
-        const file = canonical.slice(gatePrefix.length);
-        if (file)
-            keys.add(`knowledge/gates/${file}`);
-    }
-    const rolePrefix = `${ACE_ROOT_REL}/agent-state/MODULES/roles/`;
-    if (canonical.startsWith(rolePrefix)) {
-        const file = canonical.slice(rolePrefix.length);
-        if (file)
-            keys.add(`knowledge/roles/${file}`);
-    }
-    const schemaPrefix = `${ACE_ROOT_REL}/agent-state/MODULES/schemas/`;
-    if (canonical.startsWith(schemaPrefix)) {
-        const file = canonical.slice(schemaPrefix.length);
-        if (file)
-            keys.add(`knowledge/schemas/${file}`);
-    }
-    const staticAgentState = new Set([
-        "ACE_WORKFLOW.md",
-        "ARTIFACT_MANIFEST.json",
-        "AST_GREP_COMMANDS.md",
-        "AST_GREP_INDEX.json",
-        "AST_GREP_INDEX.md",
-        "DECISIONS.md",
-        "EVIDENCE_LOG.md",
-        "HANDOFF.json",
-        "INTERFACE_REGISTRY.md",
-        "PROVENANCE_LOG.md",
-        "QUALITY_GATES.md",
-        "RISKS.md",
-        "SCOPE.md",
-        "SKILL_CATALOG.md",
-        "STATUS.md",
-        "STATUS_EVENTS.ndjson",
-        "TASK.md",
-        "TEAL_CONFIG.md",
-        "MODULES/registry.json",
-        "handoff-registry.json",
-        "index-fingerprints.json",
-        "index.json",
-        "run-ledger.json",
-        "runtime-executor-sessions.json",
-        "runtime-tool-specs.json",
-        "runtime-workspaces.json",
-        "todo-state.json",
-        "tracker-snapshot.json",
-        "vericify/ace-bridge.json",
-        "vericify/process-posts.json",
-    ]);
-    const statePrefix = `${ACE_ROOT_REL}/agent-state/`;
-    if (canonical.startsWith(statePrefix)) {
-        const rel = canonical.slice(statePrefix.length);
-        const runtimeProjectionKey = {
-            "job-queue.json": "state/artifacts/agent-state/job-queue.json",
-            "job-locks.json": "state/artifacts/agent-state/job-locks.json",
-            "scheduler-lease.json": "state/artifacts/agent-state/scheduler-lease.json",
-        }[rel];
-        if (runtimeProjectionKey)
-            keys.add(runtimeProjectionKey);
-        if (staticAgentState.has(rel)) {
-            keys.add(`knowledge/agent-state/${rel}`);
-        }
-    }
-    const contextSnapshotPrefix = `${ACE_ROOT_REL}/agent-state/context-snapshots/`;
-    if (canonical.startsWith(contextSnapshotPrefix)) {
-        const rel = canonical.slice(contextSnapshotPrefix.length);
-        if (rel)
-            keys.add(`state/memory/context_snapshots/${rel}`);
-    }
-    const tasksPrefix = `${ACE_TASKS_ROOT_REL}/`;
-    if (canonical.startsWith(tasksPrefix)) {
-        keys.add(`knowledge/tasks/${canonical.slice(tasksPrefix.length)}`);
-    }
-    const scriptsPrefix = `${ACE_SCRIPTS_ROOT_REL}/`;
-    if (canonical.startsWith(scriptsPrefix)) {
-        keys.add(`knowledge/scripts/${canonical.slice(scriptsPrefix.length)}`);
-    }
-    for (const [key, candidates] of Object.entries(TASK_FILES)) {
-        if (candidates.includes(canonical)) {
-            keys.add(STORE_TASK_FILES[key]);
-        }
-    }
-    for (const [key, candidates] of Object.entries(KERNEL_FILES)) {
-        if (candidates.includes(canonical)) {
-            for (const storeKey of STORE_KERNEL_FILES[key])
-                keys.add(storeKey);
-        }
-    }
-    for (const [role, candidates] of Object.entries(AGENT_FILES)) {
-        if (candidates.includes(canonical)) {
-            for (const file of STORE_AGENT_FILES[role].instructions) {
-                keys.add(`knowledge/agents/${STORE_AGENT_FILES[role].agent}/${file}`);
-            }
-        }
-    }
-    for (const [role, candidates] of Object.entries(AGENT_MANIFEST_FILES)) {
-        if (candidates.includes(canonical)) {
-            for (const file of STORE_AGENT_FILES[role].manifests) {
-                keys.add(`knowledge/agents/${STORE_AGENT_FILES[role].agent}/${file}`);
-            }
-        }
-    }
-    return [...keys];
-}
-function readFirstAvailable(paths) {
-    const found = firstExistingPath(paths);
-    if (!found) {
-        return {
-            text: `[FILE NOT FOUND]\nTried:\n${paths.map((p) => `- ${p}`).join("\n")}`,
-            path: undefined,
-        };
-    }
-    return { text: readText(found), path: found };
-}
-export function classifyPathSource(path) {
-    if (!path)
-        return "missing";
-    const root = currentWorkspaceRoot();
-    if (path.includes(".ace#"))
-        return "store";
-    if (isInside(root, path))
-        return "workspace";
-    if (isInside(DEFAULTS_ROOT, path))
-        return "package-defaults";
-    return "missing";
-}
-/** Safely read a workspace file, returning either text or a not-found/access message. */
-export function safeRead(filePath) {
-    try {
-        if (parseVirtualStorePath(filePath)) {
-            const direct = readVirtualStorePathSync(filePath);
-            return typeof direct === "string" ? direct : `[FILE NOT FOUND] ${filePath}`;
-        }
-        const abs = resolveWorkspaceReadPath(filePath);
-        if (!existsSync(abs)) {
-            const store = readStoreText(resolveStoreFallbackKeys(filePath));
-            if (store)
-                return store.text;
-            return `[FILE NOT FOUND] ${abs}`;
-        }
-        return readText(abs);
-    }
-    catch (err) {
-        return `[ACCESS DENIED] ${String(err)}`;
-    }
-}
-/** Safely write a workspace file atomically (tmp + rename), creating directories if needed. */
-export function safeWrite(filePath, content) {
-    const normalized = normalizeRelPath(filePath);
-    const canonical = mapAceWorkspaceRelativePath(normalized);
-    const root = currentWorkspaceRoot();
-    if (canonical.startsWith(`${ACE_ROOT_REL}/agent-state/`)) {
-        const rel = canonical.slice(`${ACE_ROOT_REL}/`.length);
-        if (isOperationalArtifactPath(rel) && existsSync(getWorkspaceStorePath(root))) {
-            return writeOperationalArtifactSync(root, rel, content);
-        }
-    }
-    const storeKeys = resolveStoreFallbackKeys(filePath);
-    if (storeKeys.length > 0 && existsSync(getWorkspaceStorePath(root))) {
-        writeStoreBlobSync(root, storeKeys[0], content);
-    }
-    const abs = resolveWorkspaceWritePath(filePath);
-    mkdirSync(dirname(abs), { recursive: true });
-    const tmpPath = `${abs}.${process.pid}.${Date.now()}.tmp`;
-    writeFileSync(tmpPath, content, "utf-8");
-    renameSync(tmpPath, abs);
-    return abs;
-}
-// ────────────────────────────────────────────────────────────────────
-// File locks for read-modify-write concurrency safety
-// ────────────────────────────────────────────────────────────────────
-const _fileLocks = new Map();
-/**
- * Execute `fn` while holding a per-path serialization lock.
- * Prevents concurrent read-modify-write cycles on the same file
- * within a single process. Cross-process safety relies on atomic rename.
- */
-export async function withFileLock(path, fn) {
-    const key = resolveWorkspaceWritePath(path);
-    const prev = _fileLocks.get(key) ?? Promise.resolve();
-    let releaseLock;
-    const next = new Promise((r) => { releaseLock = r; });
-    _fileLocks.set(key, next);
-    await prev;
-    try {
-        return await fn();
-    }
-    finally {
-        releaseLock();
-        if (_fileLocks.get(key) === next)
-            _fileLocks.delete(key);
-    }
-}
-function formatStorePath(key) {
-    return toVirtualStorePath(getWorkspaceStorePath(currentWorkspaceRoot()), key);
-}
-function readStoreText(keys) {
-    const root = currentWorkspaceRoot();
-    for (const key of keys) {
-        const text = readStoreBlobSync(root, key);
-        if (typeof text === "string") {
-            return { key, path: formatStorePath(key), text };
-        }
-    }
-    return undefined;
-}
-function listStoreSkillReferences() {
-    const root = currentWorkspaceRoot();
-    const names = new Set();
-    for (const key of listStoreKeysSync(root, "knowledge/skills/")) {
-        const parts = key.split("/");
-        if (parts[2])
-            names.add(parts[2]);
-    }
-    return [...names]
-        .sort((a, b) => a.localeCompare(b))
-        .map((name) => ({
-        name,
-        path: formatStorePath(`knowledge/skills/${name}/SKILL.md`),
-        source: "store",
-    }));
-}
-function shouldPreferWorkspaceTaskFile(key) {
-    return key === "todo" || key === "lessons";
-}
-export function getAgentInstructionPath(role) {
-    const store = readStoreText(STORE_AGENT_FILES[role].instructions.map((file) => `knowledge/agents/${STORE_AGENT_FILES[role].agent}/${file}`));
-    if (store)
-        return store.path;
-    const workspaceCandidates = toAbsoluteWorkspaceCandidates(AGENT_FILES[role]);
-    return firstExistingPath([...workspaceCandidates, DEFAULT_AGENT_INSTRUCTION_FILES[role]]);
-}
-export function getAgentManifestPath(role) {
-    const store = readStoreText(STORE_AGENT_FILES[role].manifests.map((file) => `knowledge/agents/${STORE_AGENT_FILES[role].agent}/${file}`));
-    if (store)
-        return store.path;
-    const workspaceCandidates = toAbsoluteWorkspaceCandidates(AGENT_MANIFEST_FILES[role]);
-    return firstExistingPath([...workspaceCandidates, DEFAULT_AGENT_MANIFEST_FILES[role]]);
-}
-export function readAgentInstructions(role) {
-    const store = readStoreText(STORE_AGENT_FILES[role].instructions.map((file) => `knowledge/agents/${STORE_AGENT_FILES[role].agent}/${file}`));
-    if (store)
-        return store.text;
-    const workspaceCandidates = toAbsoluteWorkspaceCandidates(AGENT_FILES[role]);
-    return readFirstAvailable([...workspaceCandidates, DEFAULT_AGENT_INSTRUCTION_FILES[role]]).text;
-}
-export function readAgentManifest(role) {
-    const store = readStoreText(STORE_AGENT_FILES[role].manifests.map((file) => `knowledge/agents/${STORE_AGENT_FILES[role].agent}/${file}`));
-    if (store)
-        return store.text;
-    const workspaceCandidates = toAbsoluteWorkspaceCandidates(AGENT_MANIFEST_FILES[role]);
-    return readFirstAvailable([...workspaceCandidates, DEFAULT_AGENT_MANIFEST_FILES[role]]).text;
-}
-export function getTaskArtifactPath(key) {
-    const workspaceCandidates = toAbsoluteWorkspaceCandidates(TASK_FILES[key]);
-    const workspaceFirst = shouldPreferWorkspaceTaskFile(key);
-    if (workspaceFirst) {
-        const workspace = firstExistingPath(workspaceCandidates);
-        if (workspace)
-            return workspace;
-    }
-    const store = readStoreText([STORE_TASK_FILES[key]]);
-    if (store)
-        return store.path;
-    return firstExistingPath([
-        ...workspaceCandidates,
-        DEFAULT_TASK_FILES[key],
-    ]);
-}
-export function readTaskArtifact(key) {
-    if (shouldPreferWorkspaceTaskFile(key)) {
-        const workspaceCandidates = toAbsoluteWorkspaceCandidates(TASK_FILES[key]);
-        const workspacePath = firstExistingPath(workspaceCandidates);
-        if (workspacePath)
-            return readText(workspacePath);
-    }
-    const store = readStoreText([STORE_TASK_FILES[key]]);
-    if (store)
-        return store.text;
-    const workspaceCandidates = toAbsoluteWorkspaceCandidates(TASK_FILES[key]);
-    return readFirstAvailable([...workspaceCandidates, DEFAULT_TASK_FILES[key]]).text;
-}
-export function getKernelArtifactPath(key) {
-    const store = readStoreText(STORE_KERNEL_FILES[key]);
-    if (store)
-        return store.path;
-    const workspaceCandidates = toAbsoluteWorkspaceCandidates(KERNEL_FILES[key]);
-    return firstExistingPath([...workspaceCandidates, DEFAULT_KERNEL_FILES[key]]);
-}
-export function readKernelArtifact(key) {
-    const store = readStoreText(STORE_KERNEL_FILES[key]);
-    if (store)
-        return store.text;
-    const workspaceCandidates = toAbsoluteWorkspaceCandidates(KERNEL_FILES[key]);
-    return readFirstAvailable([...workspaceCandidates, DEFAULT_KERNEL_FILES[key]]).text;
-}
-export function resolveWritableTaskPath(key) {
-    const workspaceCandidates = toAbsoluteWorkspaceCandidates(TASK_FILES[key]);
-    const existingWorkspacePath = workspaceCandidates.find((candidate) => existsSync(candidate));
-    if (existingWorkspacePath)
-        return existingWorkspacePath;
-    // Write to canonical workspace target when not yet present.
-    return resolveWorkspaceWritePath(TASK_FILES[key][0]);
-}
-function listSkillDirs() {
-    const root = currentWorkspaceRoot();
-    return [
-        { root: acePath("skills"), source: "workspace" },
-        { root: resolve(root, ".agents", "skills"), source: "workspace" },
-        { root: DEFAULTS_SKILLS_ROOT, source: "package-defaults" },
-    ];
-}
-export function listAvailableSkills() {
-    const dedup = new Map();
-    for (const skill of listStoreSkillReferences()) {
-        dedup.set(skill.name, skill);
-    }
-    for (const { root, source } of listSkillDirs()) {
-        if (!existsSync(root))
-            continue;
-        const entries = readdirSync(root, { withFileTypes: true });
-        for (const entry of entries) {
-            if (!entry.isDirectory())
-                continue;
-            const skillName = entry.name;
-            const skillPath = resolve(root, skillName, "SKILL.md");
-            if (!existsSync(skillPath))
-                continue;
-            if (source === "package-defaults" && dedup.has(skillName)) {
-                continue;
-            }
-            dedup.set(skillName, {
-                name: skillName,
-                path: skillPath,
-                source,
-            });
-        }
-    }
-    return [...dedup.values()].sort((a, b) => a.name.localeCompare(b.name));
-}
-export function getSkillPath(name) {
-    const target = name.trim().toLowerCase();
-    const skills = listAvailableSkills();
-    const exact = skills.find((skill) => skill.name.toLowerCase() === target);
-    return exact?.path;
-}
-export function readSkillInstructions(name) {
-    const target = name.trim().toLowerCase();
-    const match = listAvailableSkills().find((skill) => skill.name.toLowerCase() === target);
-    if (!match) {
-        return `Skill not found: ${name}\nAvailable: ${listAvailableSkills()
-            .map((s) => s.name)
-            .join(", ")}`;
-    }
-    if (match.source === "store") {
-        return readStoreBlobSync(currentWorkspaceRoot(), `knowledge/skills/${match.name}/SKILL.md`) ?? "";
-    }
-    return readText(match.path);
-}
-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 buildPosixMcpLaunchCommand(workspaceRoot) {
-    const quotedWorkspaceRoot = quotePosixShell(workspaceRoot);
-    return `cd ${quotedWorkspaceRoot} && ACE_WORKSPACE_ROOT=${quotedWorkspaceRoot} npx -y ace-swarm mcp`;
-}
-function buildWindowsMcpLaunchCommand(workspaceRoot) {
-    return [
-        `cd /d ${quoteCmdExe(workspaceRoot)}`,
-        `set "ACE_WORKSPACE_ROOT=${workspaceRoot.replace(/"/g, '""')}"`,
-        "npx -y ace-swarm mcp",
-    ].join(" && ");
-}
-function getMcpCommandSpec(workspaceRoot = WORKSPACE_ROOT) {
-    // On macOS/Linux, VS Code may not inherit the user's shell PATH (nvm, fnm,
-    // volta, etc.), so `npx` resolves to ENOENT.  Wrap via a login-shell so the
-    // user's profile is sourced and node tooling is on PATH.
-    if (process.platform !== "win32") {
-        const shell = process.env.SHELL || "/bin/zsh";
-        return {
-            command: shell,
-            args: ["-lc", buildPosixMcpLaunchCommand(workspaceRoot)],
-        };
-    }
-    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 = readText(DEFAULT_TASK_FILES.handoff_template);
-    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 === "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 === "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();
-    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");
-    }
-    const mcpServers = {
-        "ace-swarm": {
-            ...stdio,
-        },
-    };
-    if (client === "vscode") {
-        return JSON.stringify({
-            servers: {
-                "ace-swarm": {
-                    type: "stdio",
-                    ...stdio,
-                },
-            },
-        }, null, 2);
-    }
-    return JSON.stringify({ mcpServers }, null, 2);
-}
-export function getAllMcpServerConfigSnippets() {
-    return {
-        codex: getMcpServerConfigSnippet("codex"),
-        vscode: getMcpServerConfigSnippet("vscode"),
-        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() ||
-        defaultModelForProvider(llmProvider);
-    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 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);
-    // Copy packaged defaults. When the store bootstrap has already run,
-    // skip the trees it now owns so we don't overwrite its materialized output.
-    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);
-    // Global ACE orchestrator state files.
-    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);
-    }
-    // SWARM_REGISTRY is a derived artifact from code topology — always refresh.
-    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 // Always force SWARM_REGISTRY refresh — derived from code topology
-    );
-    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", WORKSPACE_ROOT), result, force);
-        writeIfMissingOrForced(acePath(".github", "copilot-instructions.md"), buildHostInstructionText("copilot", WORKSPACE_ROOT), result, force);
-        writeIfMissingOrForced(acePath(".cursorrules"), buildHostInstructionText("cursor", WORKSPACE_ROOT), result, force);
-        writeIfMissingOrForced(acePath("AGENTS.md"), buildHostInstructionText("codex", WORKSPACE_ROOT), 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;
-}
-/**
- * Compare packaged assets against runtime workspace copies.
- * Detects silent divergence between authoritative defaults and live state.
- */
-export function detectAssetDrift() {
-    const entries = [];
-    const assetDirs = [
-        { assetRoot: DEFAULTS_AGENT_STATE_ROOT, workspaceRoot: wsPath("agent-state") },
-        { assetRoot: DEFAULTS_TASKS_ROOT, workspaceRoot: acePath("tasks") },
-    ];
-    function walkAndCompare(assetDir, runtimeDir) {
-        if (!existsSync(assetDir))
-            return;
-        const items = readdirSync(assetDir, { withFileTypes: true });
-        for (const item of items) {
-            const assetPath = resolve(assetDir, item.name);
-            const runtimePath = resolve(runtimeDir, item.name);
-            if (item.isDirectory()) {
-                walkAndCompare(assetPath, runtimePath);
-                continue;
-            }
-            if (!existsSync(runtimePath)) {
-                entries.push({ asset_path: assetPath, runtime_path: runtimePath, status: "missing-runtime" });
-                continue;
-            }
-            const assetContent = readText(assetPath);
-            const runtimeContent = readText(runtimePath);
-            entries.push({
-                asset_path: assetPath,
-                runtime_path: runtimePath,
-                status: assetContent === runtimeContent ? "match" : "drift",
-            });
-        }
-    }
-    for (const { assetRoot, workspaceRoot } of assetDirs) {
-        walkAndCompare(assetRoot, workspaceRoot);
-    }
-    return {
-        checked: entries.length,
-        drifted: entries.filter((e) => e.status === "drift").length,
-        missing_runtime: entries.filter((e) => e.status === "missing-runtime").length,
-        entries,
-    };
-}
+export * from "./helpers/path-utils.js";
+export * from "./helpers/store-resolution.js";
+export * from "./helpers/artifacts.js";
+export * from "./helpers/bootstrap.js";
+export * from "./helpers/drift.js";
 //# sourceMappingURL=helpers.js.map