@voybio/ace-swarm 0.2.5 → 2.4.0

package/dist/astgrep-index.d.ts

@@ -1,3 +1,11 @@
+export interface AstgrepMatch {
+    file: string;
+    line: number;
+    column: number;
+    text: string;
+    context_lines?: string[];
+}
+export declare function runAstgrepQuery(pattern: string, lang: string, roots: string[], _contextLines?: number): AstgrepMatch[];
 export interface RefreshAstgrepIndexInput {
     scope?: string;
     append_evidence?: boolean;
@@ -20,5 +28,5 @@ export interface RefreshAstgrepIndexResult {
         todo_signals: number;
     };
 }
-export declare function refreshAstgrepIndex(input?: RefreshAstgrepIndexInput): RefreshAstgrepIndexResult;
+export declare function refreshAstgrepIndex(input?: RefreshAstgrepIndexInput): Promise<RefreshAstgrepIndexResult>;
 //# sourceMappingURL=astgrep-index.d.ts.map

package/dist/astgrep-index.js

@@ -1,8 +1,19 @@
 import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
 import { isAbsolute, relative, resolve } from "node:path";
 import { spawnSync } from "node:child_process";
-import { appendStatusEvent } from "./status-events.js";
+import { appendStatusEventSafe } from "./status-events.js";
 import { safeRead, safeWrite, WORKSPACE_ROOT, wsPath } from "./helpers.js";
+export function runAstgrepQuery(pattern, lang, roots, _contextLines) {
+    const cmd = detectAstgrepCommand();
+    const raw = runAstgrep(cmd, pattern, lang, roots);
+    return raw.slice(0, 200).map((m) => ({
+        file: m.file ?? "",
+        line: m.range?.start?.line ?? 0,
+        column: m.range?.start?.column ?? 0,
+        text: m.text ?? "",
+        context_lines: [],
+    }));
+}
 const CODE_EXTENSIONS = new Set(["ts", "tsx", "js", "mjs", "cjs", "py", "rs", "go"]);
 const EXCLUDE_DIRS = new Set([
     ".git",
@@ -180,7 +191,7 @@ function appendEvidenceLine(timestamp, astgrepCmd, stats) {
     ].join("\n");
     safeWrite("agent-state/EVIDENCE_LOG.md", `${seed}${entry}\n`);
 }
-export function refreshAstgrepIndex(input = {}) {
+export async function refreshAstgrepIndex(input = {}) {
     const generatedAt = new Date().toISOString();
     const scope = resolveScope(input.scope);
     const appendEvidence = input.append_evidence ?? true;
@@ -440,7 +451,7 @@ export function refreshAstgrepIndex(input = {}) {
     if (emitEvent) {
         const status = astgrepCmd ? "pass" : "blocked";
         const eventType = astgrepCmd ? "DISCOVERY_INDEX_READY" : "DISCOVERY_SCOPE_BLOCKED";
-        const event = appendStatusEvent({
+        const event = await appendStatusEventSafe({
             source_module: "capability-astgrep",
             event_type: eventType,
             status,

package/dist/cli.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { ACE_ROOT_REL, ACE_TASKS_ROOT_REL, ALL_MCP_CLIENTS, ALL_LLM_PROVIDERS, DEFAULTS_ROOT, PACKAGE_ROOT, WORKSPACE_ROOT, fileExists, getAllMcpServerConfigSnippets, getMcpClientInstallHint, getMcpServerConfigSnippet, wsPath, } from "./helpers.js";
+import { ACE_TASKS_ROOT_REL, ALL_MCP_CLIENTS, ALL_LLM_PROVIDERS, DEFAULTS_ROOT, PACKAGE_ROOT, WORKSPACE_ROOT, fileExists, getAllMcpServerConfigSnippets, getMcpClientInstallHint, getMcpServerConfigSnippet, wsPath, } from "./helpers.js";
 import { refreshAstgrepIndex } from "./astgrep-index.js";
 import { scanWorkspaceDelta } from "./index-store.js";
 import { startStdioServer } from "./server.js";
@@ -8,9 +8,10 @@ import { waitForPendingStatusEventMirrors } from "./status-events.js";
 import { bootstrapStoreWorkspace } from "./store/bootstrap-store.js";
 import { HostFileMaterializer } from "./store/materializers/host-file-materializer.js";
 import { openStore } from "./store/ace-packed-store.js";
-import { withStoreWriteQueue } from "./store/write-queue.js";
 import { DiscoveryRepository } from "./store/repositories/discovery-repository.js";
+import { withStoreWriteCoordinator } from "./store/write-coordinator.js";
 import { getWorkspaceStorePath, readStoreBlobSync, readStoreJsonSync, } from "./store/store-snapshot.js";
+import { ensureCanonicalWorkspaceStore } from "./store/workspace-store-paths.js";
 import { readFileSync } from "node:fs";
 import { runTui } from "./tui/index.js";
 import { buildOpenAiCompatibleBaseUrl, buildProviderDoctorCommands, defaultModelForProvider, discoverProviderContext, isLocalLlmProvider, normalizeLocalBaseUrl, normalizeProvider, scanLocalModelRuntimes, } from "./tui/provider-discovery.js";
@@ -38,7 +39,7 @@ Options for tui:
   --ollama-url <url>           Legacy alias for --base-url
 
 Options for init:
-  --project <name>             Project name stored in ${ACE_ROOT_REL}/ace-state.ace metadata
+  --project <name>             Project name stored in agent-state/ace-state.ace metadata
   --force                      Overwrite scaffolded files if they already exist
   --mcp-config                 Also write .vscode/mcp.json workspace bridge
   --client-config-bundle       Also write minimal workspace host stubs (AGENTS.md, CLAUDE.md, .cursorrules, .github/copilot-instructions.md)
@@ -48,7 +49,7 @@ Options for init:
   --ollama-url <url>           Legacy alias for --base-url
 
 Options for doctor:
-  --llm <provider>             ollama|llama.cpp|codex|claude|gemini|copilot|... (default: auto from ${ACE_ROOT_REL}/ace-state.ace)
+  --llm <provider>             ollama|llama.cpp|codex|claude|gemini|copilot|... (default: auto from agent-state/ace-state.ace)
   --model <name>               Model name override
   --base-url <url>             Runtime base URL override
   --ollama-url <url>           Legacy alias for --base-url
@@ -59,11 +60,12 @@ Options for cache:
   --no-clean                   Keep workspace ACE artifacts after caching them into ace-state.ace
 
 Options for mcp-config:
-  --client <name>              codex|vscode|claude|cursor|antigravity
+  --client <name>              codex|vscode|copilot|claude|cursor|antigravity
   --all                        Print all client snippets for optional global install
 
 preconfig writes .mcp-config/ at the workspace root with ready-to-use config files for every
-supported MCP client. Run once after ace init. Each file includes the install hint for its client.
+supported MCP client plus a root .mcp.json for GitHub Copilot CLI. Run once after ace init.
+Each file includes the install hint for its client.
 `);
 }
 function readFlagValue(args, flag) {
@@ -116,7 +118,7 @@ function parseLlmOptions(args) {
 }
 async function writeLlmProfile(profile) {
     const storePath = getWorkspaceStorePath(WORKSPACE_ROOT);
-    await withStoreWriteQueue(storePath, async () => {
+    await withStoreWriteCoordinator(storePath, async () => {
         const payload = {
             provider: profile.provider,
             model: profile.model,
@@ -148,12 +150,12 @@ async function writeLlmProfile(profile) {
         finally {
             await store.close();
         }
-    });
+    }, { operation_label: "writeLlmProfile" });
     return `${storePath}#state/runtime/llm_profile`;
 }
 async function recordDiscoveryProfile(input) {
     const storePath = getWorkspaceStorePath(WORKSPACE_ROOT);
-    await withStoreWriteQueue(storePath, async () => {
+    await withStoreWriteCoordinator(storePath, async () => {
         const store = await openStore(storePath);
         try {
             const discovery = new DiscoveryRepository(store);
@@ -176,7 +178,7 @@ async function recordDiscoveryProfile(input) {
         finally {
             await store.close();
         }
-    });
+    }, { operation_label: "recordDiscoveryProfile" });
 }
 async function runInit(args, mode = "init") {
     const projectName = readFlagValue(args, "--project");
@@ -197,7 +199,7 @@ async function runInit(args, mode = "init") {
         model: llm.llmModel ?? undefined,
         baseUrl: llm.llmBaseUrl ?? undefined,
     });
-    const astIndex = refreshAstgrepIndex({
+    const astIndex = await refreshAstgrepIndex({
         scope: ".",
         append_evidence: true,
         emit_event: true,
@@ -253,7 +255,7 @@ async function runInit(args, mode = "init") {
             message: `ace ${mode} completed: ${storeResult.materialized.length} bootstrap files materialized`,
             artifacts: [
                 `${ACE_TASKS_ROOT_REL}/`,
-                `${ACE_ROOT_REL}/ace-state.ace`,
+                storeResult.storePath,
                 delta.index_path,
                 astIndex.output_json_path,
             ],
@@ -340,7 +342,7 @@ async function runDoctor(args) {
         ok: hasProfile,
         detail: hasProfile
             ? profilePath
-            : `Missing ${ACE_ROOT_REL}/ace-state.ace#state/runtime/llm_profile. Run \`ace init --llm <provider>\` or \`ace doctor --scan\` for a local runtime.`,
+            : `Missing agent-state/ace-state.ace#state/runtime/llm_profile. Run \`ace init --llm <provider>\` or \`ace doctor --scan\` for a local runtime.`,
     });
     let provider = llm.llmProvider;
     let model = llm.llmModel;
@@ -383,7 +385,7 @@ async function runDoctor(args) {
         }
     }
     if (!provider) {
-        throw new Error(`No runtime provider configured. Use --llm <provider>, bootstrap one into ${ACE_ROOT_REL}/ace-state.ace#state/runtime/llm_profile, or run \`ace doctor --scan\` for a local runtime.`);
+        throw new Error(`No runtime provider configured. Use --llm <provider>, bootstrap one into agent-state/ace-state.ace#state/runtime/llm_profile, or run \`ace doctor --scan\` for a local runtime.`);
     }
     if (!model) {
         model = defaultModelForProvider(provider);
@@ -520,16 +522,21 @@ function parseClientFlag(args) {
     return match;
 }
 async function runPreconfig() {
-    const storePath = wsPath(".agents", "ACE", "ace-state.ace");
-    if (!fileExists(storePath)) {
-        console.error(`No ACE store found at ${storePath}. Run 'ace init' first.`);
+    const resolved = await ensureCanonicalWorkspaceStore(WORKSPACE_ROOT, {
+        operationLabel: "runPreconfig",
+    });
+    if (resolved.mode === "missing") {
+        console.error(`No ACE store found. Expected canonical ${resolved.canonicalPath}; legacy fallback ${resolved.legacyPath} was also not found. Run 'ace init' first.`);
         process.exit(1);
     }
-    const store = await openStore(storePath);
+    for (const w of resolved.warnings) {
+        console.warn(`[preconfig] ${w}`);
+    }
+    const store = await openStore(resolved.storePath);
     try {
         const mat = new HostFileMaterializer(store, WORKSPACE_ROOT);
         const written = await mat.materializeMcpBundle();
-        console.log(`ACE preconfig complete — wrote ${written.length} files to .mcp-config/\n`);
+        console.log(`ACE preconfig complete — wrote ${written.length} files to .mcp-config/ and root .mcp.json\n`);
         for (const p of written) {
             console.log(`  ${p}`);
         }
@@ -649,7 +656,7 @@ async function main() {
     }
     if (command === "migrate") {
         const { importFromFileWorkspace } = await import("./store/importer.js");
-        const storePath = args[1] ?? `${WORKSPACE_ROOT}/.agents/ACE/ace-state.ace`;
+        const storePath = args[1] ?? getWorkspaceStorePath(WORKSPACE_ROOT);
         console.log(`Migrating file workspace at ${WORKSPACE_ROOT} to store at ${storePath}...`);
         const result = await importFromFileWorkspace(WORKSPACE_ROOT, storePath);
         console.log(`Migration complete:`);

package/dist/handoff-registry.js

@@ -4,7 +4,7 @@ import { openStore } from "./store/ace-packed-store.js";
 import { ProjectionManager } from "./store/materializers/projection-manager.js";
 import { HandoffRepository } from "./store/repositories/handoff-repository.js";
 import { getWorkspaceStorePath, listStoreKeysSync, readStoreJsonSync, storeExistsSync, } from "./store/store-snapshot.js";
-import { withStoreWriteQueue } from "./store/write-queue.js";
+import { withStoreWriteCoordinator } from "./store/write-coordinator.js";
 import { waitForPendingStatusEventMirrors } from "./status-events.js";
 import { waitForTodoStoreMirror } from "./todo-state.js";
 const HANDOFF_REGISTRY_REL = "agent-state/handoff-registry.json";
@@ -299,7 +299,7 @@ export async function registerHandoffSafe(input) {
         return withFileLock(HANDOFF_REGISTRY_REL, () => registerHandoff(input));
     }
     return withFileLock(HANDOFF_REGISTRY_REL, async () => {
-        return withStoreWriteQueue(storePath, async () => {
+        return withStoreWriteCoordinator(storePath, async () => {
             const store = await openStore(storePath);
             try {
                 const repo = new HandoffRepository(store);
@@ -346,7 +346,7 @@ export async function registerHandoffSafe(input) {
             finally {
                 await store.close();
             }
-        });
+        }, { operation_label: "registerHandoffSafe" });
     });
 }
 /**
@@ -361,7 +361,7 @@ export async function acknowledgeHandoffSafe(input) {
         return withFileLock(HANDOFF_REGISTRY_REL, () => acknowledgeHandoff(input));
     }
     return withFileLock(HANDOFF_REGISTRY_REL, async () => {
-        return withStoreWriteQueue(storePath, async () => {
+        return withStoreWriteCoordinator(storePath, async () => {
             const store = await openStore(storePath);
             try {
                 const repo = new HandoffRepository(store);
@@ -420,7 +420,7 @@ export async function acknowledgeHandoffSafe(input) {
             finally {
                 await store.close();
             }
-        });
+        }, { operation_label: "acknowledgeHandoffSafe" });
     });
 }
 //# sourceMappingURL=handoff-registry.js.map

package/dist/helpers/artifacts.d.ts

@@ -0,0 +1,19 @@
+import { type AgentRole, type KernelKey, type TaskKey } from "./constants.js";
+export interface SkillReference {
+    name: string;
+    path: string;
+    source: "workspace" | "package-defaults" | "store";
+}
+export declare function getAgentInstructionPath(role: AgentRole): string | undefined;
+export declare function getAgentManifestPath(role: AgentRole): string | undefined;
+export declare function readAgentInstructions(role: AgentRole): string;
+export declare function readAgentManifest(role: AgentRole): string;
+export declare function getTaskArtifactPath(key: TaskKey): string | undefined;
+export declare function readTaskArtifact(key: TaskKey): string;
+export declare function getKernelArtifactPath(key: KernelKey): string | undefined;
+export declare function readKernelArtifact(key: KernelKey): string;
+export declare function resolveWritableTaskPath(key: TaskKey): string;
+export declare function listAvailableSkills(): SkillReference[];
+export declare function getSkillPath(name: string): string | undefined;
+export declare function readSkillInstructions(name: string): string;
+//# sourceMappingURL=artifacts.d.ts.map

package/dist/helpers/artifacts.js

@@ -0,0 +1,152 @@
+import { existsSync, readdirSync } from "node:fs";
+import { resolve } from "node:path";
+import { AGENT_FILES, AGENT_MANIFEST_FILES, DEFAULT_AGENT_INSTRUCTION_FILES, DEFAULT_AGENT_MANIFEST_FILES, DEFAULT_KERNEL_FILES, DEFAULTS_SKILLS_ROOT, DEFAULT_TASK_FILES, KERNEL_FILES, STORE_AGENT_FILES, STORE_KERNEL_FILES, STORE_TASK_FILES, TASK_FILES, } from "./constants.js";
+import { acePath, currentWorkspaceRoot, firstExistingPath, readText, resolveWorkspaceWritePath, toAbsoluteWorkspaceCandidates, } from "./path-utils.js";
+import { listStoreSkillReferences, readStoreText } from "./store-resolution.js";
+function shouldPreferWorkspaceTaskFile(key) {
+    return key === "todo" || key === "lessons";
+}
+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 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;
+    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 readStoreText([`knowledge/skills/${match.name}/SKILL.md`])?.text ?? "";
+    }
+    return readText(match.path);
+}
+//# sourceMappingURL=artifacts.js.map

package/dist/helpers/bootstrap.d.ts

@@ -0,0 +1,24 @@
+import { type LlmProvider, type McpClient } from "./constants.js";
+export interface BootstrapOptions {
+    projectName?: string;
+    force?: boolean;
+    includeMcpConfig?: boolean;
+    includeClientConfigBundle?: boolean;
+    llmProvider?: LlmProvider;
+    llmModel?: string;
+    llmBaseUrl?: string;
+    ollamaModel?: string;
+    ollamaBaseUrl?: string;
+    skipStoreManaged?: boolean;
+}
+export interface BootstrapResult {
+    created: string[];
+    updated: string[];
+    skipped: string[];
+}
+export declare function getMcpClientBundlePath(client: McpClient): string;
+export declare function getMcpClientInstallHint(client: McpClient): string;
+export declare function getMcpServerConfigSnippet(client?: McpClient): string;
+export declare function getAllMcpServerConfigSnippets(): Record<McpClient, string>;
+export declare function bootstrapAceWorkspace(options?: BootstrapOptions): BootstrapResult;
+//# sourceMappingURL=bootstrap.d.ts.map