@voybio/ace-swarm 0.2.3 → 0.2.5

package/dist/helpers.js

@@ -8,8 +8,8 @@ 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 { buildOpenAiCompatibleBaseUrl, DEFAULT_LLAMA_CPP_MODEL, DEFAULT_OLLAMA_MODEL, normalizeLocalBaseUrl, } from "./tui/provider-discovery.js";
+import { isOperationalArtifactPath, operationalArtifactKey, writeStoreBlobSync, } from "./store/store-artifacts.js";
+import { buildProviderDoctorCommands, buildOpenAiCompatibleBaseUrl, defaultModelForProvider, normalizeLocalBaseUrl, normalizeProvider, } from "./tui/provider-discovery.js";
 export { isInside, isReadError, normalizeRelPath, looksLikeSwarmHandoffPath } from "./shared.js";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -111,6 +111,14 @@ 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_PROJECTED_WORKSPACE_FILES = new Set([
+    `${ACE_TASKS_ROOT_REL}/todo.md`,
+    `${ACE_ROOT_REL}/ace-hook-context.json`,
+    `${ACE_ROOT_REL}/agent-state/job-queue.json`,
+    `${ACE_ROOT_REL}/agent-state/job-locks.json`,
+    `${ACE_ROOT_REL}/agent-state/scheduler-lease.json`,
+    `${ACE_ROOT_REL}/agent-state/context-snapshots/index.json`,
+]);
 const ACE_MANAGED_PREFIXES = [
     "agent-state",
     "global-state",
@@ -128,7 +136,14 @@ export const ALL_MCP_CLIENTS = [
     "cursor",
     "antigravity",
 ];
-export const ALL_LLM_PROVIDERS = ["ollama", "llama.cpp"];
+export const ALL_LLM_PROVIDERS = [
+    "ollama",
+    "llama.cpp",
+    "codex",
+    "claude",
+    "gemini",
+    "copilot",
+];
 export const ALL_AGENTS = [
     "orchestrator",
     "vos",
@@ -379,6 +394,10 @@ export function mapAceWorkspaceRelativePath(path) {
     }
     return normalized;
 }
+export function isProjectedAceWorkspacePath(filePath) {
+    const canonical = mapAceWorkspaceRelativePath(normalizeRelPath(filePath));
+    return ACE_PROJECTED_WORKSPACE_FILES.has(canonical);
+}
 export function acePath(...segments) {
     return resolve(currentWorkspaceRoot(), ACE_ROOT_REL, ...segments);
 }
@@ -525,6 +544,9 @@ function resolveStoreFallbackKeys(filePath) {
     const statePrefix = `${ACE_ROOT_REL}/agent-state/`;
     if (canonical.startsWith(statePrefix)) {
         const rel = canonical.slice(statePrefix.length);
+        if (!rel.startsWith("context-snapshots/")) {
+            keys.add(`state/artifacts/agent-state/${rel}`);
+        }
         const runtimeProjectionKey = {
             "job-queue.json": "state/artifacts/agent-state/job-queue.json",
             "job-locks.json": "state/artifacts/agent-state/job-locks.json",
@@ -542,6 +564,10 @@ function resolveStoreFallbackKeys(filePath) {
         if (rel)
             keys.add(`state/memory/context_snapshots/${rel}`);
     }
+    const skillsPrefix = `${ACE_SKILLS_ROOT_REL}/`;
+    if (canonical.startsWith(skillsPrefix)) {
+        keys.add(`knowledge/skills/${canonical.slice(skillsPrefix.length)}`);
+    }
     const tasksPrefix = `${ACE_TASKS_ROOT_REL}/`;
     if (canonical.startsWith(tasksPrefix)) {
         keys.add(`knowledge/tasks/${canonical.slice(tasksPrefix.length)}`);
@@ -577,6 +603,9 @@ function resolveStoreFallbackKeys(filePath) {
     }
     return [...keys];
 }
+export function resolveStoreFallbackKeysForPath(filePath) {
+    return resolveStoreFallbackKeys(filePath);
+}
 function readFirstAvailable(paths) {
     const found = firstExistingPath(paths);
     if (!found) {
@@ -624,15 +653,14 @@ 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);
-        }
-    }
+    let storeVirtualPath;
     const storeKeys = resolveStoreFallbackKeys(filePath);
     if (storeKeys.length > 0 && existsSync(getWorkspaceStorePath(root))) {
-        writeStoreBlobSync(root, storeKeys[0], content);
+        storeVirtualPath = writeStoreBlobSync(root, storeKeys[0], content);
+        const isAcePath = canonical === ACE_ROOT_REL || canonical.startsWith(`${ACE_ROOT_REL}/`);
+        if (isAcePath && !isProjectedAceWorkspacePath(canonical)) {
+            return storeVirtualPath;
+        }
     }
     const abs = resolveWorkspaceWritePath(filePath);
     mkdirSync(dirname(abs), { recursive: true });
@@ -1325,10 +1353,11 @@ export function bootstrapAceWorkspace(options = {}) {
     const projectName = options.projectName?.trim() || "ACE Project";
     const includeMcpConfig = options.includeMcpConfig ?? true;
     const includeClientConfigBundle = options.includeClientConfigBundle ?? true;
-    const llmProvider = options.llmProvider;
+    const normalizedProvider = normalizeProvider(options.llmProvider);
+    const llmProvider = normalizedProvider;
     const llmModel = options.llmModel?.trim() ||
         options.ollamaModel?.trim() ||
-        (llmProvider === "llama.cpp" ? DEFAULT_LLAMA_CPP_MODEL : DEFAULT_OLLAMA_MODEL);
+        defaultModelForProvider(llmProvider);
     const llmBaseUrl = normalizeLocalBaseUrl(options.llmBaseUrl ?? options.ollamaBaseUrl);
     if (llmProvider && !ALL_LLM_PROVIDERS.includes(llmProvider)) {
         throw new Error(`Unsupported llmProvider: ${llmProvider}`);
@@ -1654,12 +1683,14 @@ export function bootstrapAceWorkspace(options = {}) {
             ...(llmProvider
                 ? [
                     "",
-                    "## Local Model Profile",
+                    "## LLM Runtime Profile",
                     `- \`${ACE_LLM_ROOT_REL}/llm-profile.json\` (generated for ${llmProvider})`,
-                    `- \`${ACE_LLM_ROOT_REL}/doctor-checks.md\` (commands to verify local runtime)`,
+                    `- \`${ACE_LLM_ROOT_REL}/doctor-checks.md\` (commands to verify provider runtime)`,
                     llmBaseUrl
                         ? `- Run \`ace doctor --llm ${llmProvider} --model ${llmModel} --base-url ${llmBaseUrl}\``
-                        : `- Run \`ace doctor --llm ${llmProvider} --model ${llmModel} --scan\` to discover a local endpoint`,
+                        : 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);
@@ -1678,27 +1709,14 @@ export function bootstrapAceWorkspace(options = {}) {
             }
         }
         writeIfMissingOrForced(wsPath(".ace", "llm-profile.json"), JSON.stringify(profilePayload, null, 2), result, force);
-        const doctorCommands = llmProvider === "ollama"
-            ? [
-                "ollama serve",
-                `ollama pull ${llmModel}`,
-                ...(llmBaseUrl ? [`curl -s ${llmBaseUrl}/api/tags`] : []),
-            ]
-            : [
-                "# Start llama-server separately, for example:",
-                "# llama-server -m /path/to/model.gguf --port 8080",
-                ...(llmBaseUrl ? [`curl -s ${buildOpenAiCompatibleBaseUrl(llmBaseUrl)}/models`] : []),
-            ];
+        const doctorCommands = buildProviderDoctorCommands(llmProvider, llmModel, llmBaseUrl);
         writeIfMissingOrForced(wsPath(".ace", "doctor-checks.md"), [
-            `# ACE + ${llmProvider} Doctor Checks`,
+            `# ACE + ${llmProvider} Runtime Checks`,
             "",
-            "Run these commands to verify local-model readiness:",
+            "Run these commands to verify ACE runtime readiness:",
             "",
             "```bash",
             ...doctorCommands,
-            llmBaseUrl
-                ? `ace doctor --llm ${llmProvider} --model ${llmModel} --base-url ${llmBaseUrl}`
-                : `ace doctor --llm ${llmProvider} --model ${llmModel} --scan`,
             "```",
             "",
             `MCP is still configured separately via \`${ACE_VSCODE_ROOT_REL}/mcp.json\` or \`${ACE_BUNDLE_ROOT_REL}/*\`.`,

package/dist/local-model-runtime.js

@@ -1,6 +1,5 @@
-import { existsSync, readFileSync } from "node:fs";
 import { resolve } from "node:path";
-import { ROLE_ENUM, scoreDomains } from "./shared.js";
+import { ROLE_ENUM } from "./shared.js";
 import { resolveWorkspaceRoot } from "./helpers.js";
 import { executeAceInternalTool } from "./ace-internal-tools.js";
 import { ModelBridge } from "./model-bridge.js";
@@ -28,61 +27,17 @@ function normalizeRoleCandidate(input) {
         ? candidate
         : undefined;
 }
-function parseRoleFromRoutingSummary(summary) {
-    const match = summary.match(/\*\*Primary Swarm Agent\(s\):\*\*\s*([^\n]+)/i);
-    if (!match?.[1])
-        return undefined;
-    const firstAgent = match[1]
-        .split(",")
-        .map((entry) => entry.trim())
-        .find(Boolean);
-    return normalizeRoleCandidate(firstAgent);
-}
-function hasAlignedTaskContract(workspaceRoot) {
-    const required = [
-        "agent-state/TASK.md",
-        "agent-state/SCOPE.md",
-        "agent-state/QUALITY_GATES.md",
-        "agent-state/HANDOFF.json",
-    ];
-    return required.every((relativePath) => {
-        const absolute = resolve(workspaceRoot, relativePath);
-        if (!existsSync(absolute))
-            return false;
-        return readFileSync(absolute, "utf-8").trim().length > 0;
-    });
+function fallbackRoleForTask() {
+    return "orchestrator";
 }
-function fallbackRoleForTask(task, workspaceRoot) {
-    if (!hasAlignedTaskContract(workspaceRoot)) {
-        return "orchestrator";
-    }
-    const { domain } = scoreDomains(task);
-    switch (domain) {
-        case "engineering":
-            return "coders";
-        case "venture":
-            return "vos";
-        case "ux":
-            return "ui";
-        default:
-            return "orchestrator";
-    }
-}
-async function resolveRole(task, workspaceRoot, sessionId, requestedRole) {
+async function resolveRole(task, sessionId, requestedRole) {
     const explicitRole = normalizeRoleCandidate(requestedRole);
     if (explicitRole) {
         return { role: explicitRole, routingSummary: undefined };
     }
     const routing = await executeAceInternalTool("route_task", { description: task, domain: "unknown" }, sessionId);
     const routingSummary = extractTextContent(routing);
-    const routedRole = parseRoleFromRoutingSummary(routingSummary);
-    const fallbackRole = fallbackRoleForTask(task, workspaceRoot);
-    return {
-        role: routedRole && !(routedRole === "orchestrator" && fallbackRole !== "orchestrator")
-            ? routedRole
-            : fallbackRole,
-        routingSummary,
-    };
+    return { role: fallbackRoleForTask(), routingSummary };
 }
 function resolveTier(requested, provider, model, role) {
     if (requested && requested !== "auto")
@@ -152,7 +107,7 @@ export async function runLocalModelTask(options) {
         ollamaUrl: options.ollamaUrl,
     });
     const bridge = new ModelBridge(options.clients ?? createDefaultModelBridgeClients(runtime));
-    const { role, routingSummary } = await resolveRole(options.task, runtime.workspaceRoot, undefined, options.role);
+    const { role, routingSummary } = await resolveRole(options.task, undefined, options.role);
     const tier = resolveTier(options.tier, runtime.provider, runtime.model, role);
     const result = await bridge.run({
         task: options.task,

package/dist/store/bootstrap-store.d.ts

@@ -24,6 +24,7 @@ export interface BootstrapOptions {
     mcpServerPath?: string;
     llm?: string;
     model?: string;
+    baseUrl?: string;
     ollamaUrl?: string;
 }
 export interface BootstrapResult {

package/dist/store/bootstrap-store.js

@@ -27,7 +27,7 @@ import { ProjectionManager } from "./materializers/projection-manager.js";
 import { TodoSyncer } from "./materializers/todo-syncer.js";
 import { OPERATIONAL_ARTIFACT_REL_PATHS, operationalArtifactKey, } from "./store-artifacts.js";
 import { STORE_VERSION } from "./types.js";
-import { DEFAULT_LLAMA_CPP_MODEL, DEFAULT_OLLAMA_MODEL, } from "../tui/provider-discovery.js";
+import { buildProviderDoctorCommands, defaultModelForProvider, normalizeLocalBaseUrl, normalizeProvider, } from "../tui/provider-discovery.js";
 const __dirname = dirname(fileURLToPath(import.meta.url));
 function getAssetsRoot() {
     // Resolve relative to this file's location in the installed package
@@ -40,45 +40,32 @@ function getAssetsRoot() {
 async function applyLlmRuntimeConfig(store, opts) {
     if (!opts.llm)
         return;
-    const configuredModel = opts.model ?? (opts.llm === "llama.cpp" ? DEFAULT_LLAMA_CPP_MODEL : DEFAULT_OLLAMA_MODEL);
+    const provider = normalizeProvider(opts.llm) ?? opts.llm;
+    const configuredModel = opts.model ?? defaultModelForProvider(provider);
+    const configuredBaseUrl = normalizeLocalBaseUrl(opts.baseUrl ?? opts.ollamaUrl);
     const profilePayload = {
-        provider: opts.llm,
+        provider,
         model: configuredModel,
         generated_at: new Date().toISOString(),
     };
-    if (opts.ollamaUrl) {
-        profilePayload.base_url = opts.ollamaUrl;
-        if (opts.llm === "ollama") {
-            profilePayload.api_compat_base_url = opts.ollamaUrl.endsWith("/v1")
-                ? opts.ollamaUrl
-                : `${opts.ollamaUrl}/v1`;
+    if (configuredBaseUrl) {
+        profilePayload.base_url = configuredBaseUrl;
+        if (provider === "ollama") {
+            profilePayload.api_compat_base_url = configuredBaseUrl.endsWith("/v1")
+                ? configuredBaseUrl
+                : `${configuredBaseUrl}/v1`;
             profilePayload.default_api_key = "ollama";
         }
     }
     await store.setJSON("state/runtime/llm_profile", profilePayload);
-    const doctorCommands = opts.llm === "ollama"
-        ? [
-            "ollama serve",
-            `ollama pull ${configuredModel}`,
-            ...(opts.ollamaUrl ? [`curl -s ${opts.ollamaUrl}/api/tags`] : []),
-        ]
-        : [
-            "# Start llama-server separately, for example:",
-            "# llama-server -m /path/to/model.gguf --port 8080",
-            ...(opts.ollamaUrl
-                ? [`curl -s ${opts.ollamaUrl.endsWith("/v1") ? opts.ollamaUrl : `${opts.ollamaUrl}/v1`}/models`]
-                : []),
-        ];
+    const doctorCommands = buildProviderDoctorCommands(provider, configuredModel, configuredBaseUrl);
     await store.setBlob("state/runtime/doctor_checks.md", [
-        `# ACE + ${opts.llm} Doctor Checks`,
+        `# ACE + ${provider} Runtime Checks`,
         "",
-        "Run these commands to verify local-model readiness:",
+        "Run these commands to verify ACE runtime readiness:",
         "",
         "```bash",
         ...doctorCommands,
-        opts.ollamaUrl
-            ? `ace doctor --llm ${opts.llm} --model ${configuredModel} --base-url ${opts.ollamaUrl}`
-            : `ace doctor --llm ${opts.llm} --model ${configuredModel} --scan`,
         "```",
         "",
     ].join("\n"));

package/dist/store/cache-workspace.d.ts

@@ -0,0 +1,22 @@
+export interface CacheWorkspaceOptions {
+    dryRun?: boolean;
+    clean?: boolean;
+}
+export interface CacheWorkspaceResult {
+    storePath: string;
+    dry_run: boolean;
+    clean: boolean;
+    scanned_files: number;
+    cached_files: number;
+    removed_files: number;
+    kept_projected_files: number;
+    skipped_files: number;
+    warnings: string[];
+    cached: Array<{
+        path: string;
+        key: string;
+        bytes: number;
+    }>;
+}
+export declare function cacheWorkspaceArtifacts(workspaceRoot: string, options?: CacheWorkspaceOptions): Promise<CacheWorkspaceResult>;
+//# sourceMappingURL=cache-workspace.d.ts.map

package/dist/store/cache-workspace.js

@@ -0,0 +1,143 @@
+import { existsSync, readdirSync, readFileSync, rmSync } from "node:fs";
+import { dirname, isAbsolute, join, relative } from "node:path";
+import { ACE_ROOT_REL, isProjectedAceWorkspacePath, mapAceWorkspaceRelativePath, resolveStoreFallbackKeysForPath, } from "../helpers.js";
+import { normalizeRelPath } from "../shared.js";
+import { writeStoreBlobsSync } from "./store-artifacts.js";
+const SCAN_ROOTS_REL = [
+    "agent-state",
+    ".agents/ACE/agent-state",
+    ".agents/ACE/tasks",
+    ".agents/ACE/skills",
+];
+function isInside(base, target) {
+    const rel = relative(base, target);
+    return rel === "" || (!rel.startsWith("..") && !isAbsolute(rel));
+}
+function collectFiles(root) {
+    const out = [];
+    if (!existsSync(root))
+        return out;
+    const walk = (dir) => {
+        for (const entry of readdirSync(dir, { withFileTypes: true })) {
+            const abs = join(dir, entry.name);
+            if (entry.isDirectory()) {
+                walk(abs);
+                continue;
+            }
+            if (entry.isFile()) {
+                out.push(abs);
+            }
+        }
+    };
+    walk(root);
+    return out;
+}
+function pruneEmptyParents(path, stopAt) {
+    let cursor = dirname(path);
+    while (isInside(stopAt, cursor) && cursor !== stopAt && existsSync(cursor)) {
+        const entries = readdirSync(cursor);
+        if (entries.length > 0)
+            break;
+        rmSync(cursor, { recursive: true, force: true });
+        cursor = dirname(cursor);
+    }
+}
+function isTextBuffer(input) {
+    return !input.includes(0);
+}
+function selectScanRoots(workspaceRoot) {
+    return SCAN_ROOTS_REL.map((relPath) => join(workspaceRoot, relPath)).filter((abs) => existsSync(abs));
+}
+export async function cacheWorkspaceArtifacts(workspaceRoot, options = {}) {
+    const dryRun = options.dryRun ?? false;
+    const clean = options.clean ?? true;
+    const storePath = join(workspaceRoot, ".agents", "ACE", "ace-state.ace");
+    if (!existsSync(storePath)) {
+        throw new Error(`No store found at ${storePath}. Run 'ace init' first.`);
+    }
+    const warnings = [];
+    const scanRoots = selectScanRoots(workspaceRoot);
+    const candidates = [];
+    let scanned = 0;
+    let keptProjected = 0;
+    let skipped = 0;
+    for (const scanRoot of scanRoots) {
+        for (const absPath of collectFiles(scanRoot)) {
+            scanned += 1;
+            const relPath = normalizeRelPath(relative(workspaceRoot, absPath));
+            const canonicalPath = mapAceWorkspaceRelativePath(relPath);
+            if (!canonicalPath.startsWith(`${ACE_ROOT_REL}/`)) {
+                skipped += 1;
+                continue;
+            }
+            if (canonicalPath === `${ACE_ROOT_REL}/ace-state.ace`) {
+                skipped += 1;
+                continue;
+            }
+            if (isProjectedAceWorkspacePath(canonicalPath)) {
+                keptProjected += 1;
+                continue;
+            }
+            const raw = readFileSync(absPath);
+            if (!isTextBuffer(raw)) {
+                skipped += 1;
+                warnings.push(`Skipped non-text artifact: ${canonicalPath}`);
+                continue;
+            }
+            const fallbackKeys = resolveStoreFallbackKeysForPath(canonicalPath);
+            if (fallbackKeys.length === 0) {
+                skipped += 1;
+                warnings.push(`No store fallback key for ${canonicalPath}`);
+                continue;
+            }
+            candidates.push({
+                absPath,
+                canonicalPath,
+                key: fallbackKeys[0],
+                content: raw.toString("utf-8"),
+                bytes: raw.byteLength,
+            });
+        }
+    }
+    const dedupByKey = new Map();
+    for (const candidate of candidates) {
+        dedupByKey.set(candidate.key, candidate);
+    }
+    const uniqueForWrite = [...dedupByKey.values()];
+    if (!dryRun && uniqueForWrite.length > 0) {
+        writeStoreBlobsSync(workspaceRoot, uniqueForWrite.map((candidate) => ({
+            key: candidate.key,
+            content: candidate.content,
+        })));
+    }
+    let removed = 0;
+    if (!dryRun && clean && candidates.length > 0) {
+        const removedPaths = new Set();
+        for (const candidate of candidates) {
+            if (removedPaths.has(candidate.absPath))
+                continue;
+            rmSync(candidate.absPath, { force: true });
+            removedPaths.add(candidate.absPath);
+            removed += 1;
+            const pruneRoot = scanRoots.find((root) => isInside(root, candidate.absPath)) ?? workspaceRoot;
+            pruneEmptyParents(candidate.absPath, pruneRoot);
+        }
+    }
+    return {
+        storePath,
+        dry_run: dryRun,
+        clean,
+        scanned_files: scanned,
+        cached_files: candidates.length,
+        removed_files: removed,
+        kept_projected_files: keptProjected,
+        skipped_files: skipped,
+        warnings,
+        cached: candidates.map((candidate) => ({
+            path: candidate.canonicalPath,
+            key: candidate.key,
+            bytes: candidate.bytes,
+        })),
+    };
+}
+//# sourceMappingURL=cache-workspace.js.map

package/dist/store/materializers/context-snapshot-materializer.js

@@ -26,11 +26,6 @@ export class ContextSnapshotMaterializer {
         if (!existsSync(dir))
             mkdirSync(dir, { recursive: true });
         const snapshots = await this.repo.listSnapshots();
-        const retained = new Set(["index.json"]);
-        for (const snapshot of snapshots) {
-            retained.add(snapshot.file);
-            writeText(join(dir, snapshot.file), `${JSON.stringify(snapshot.record, null, 2)}\n`);
-        }
         writeText(join(dir, "index.json"), `${JSON.stringify({
             snapshots: snapshots.map(({ name, file, timestamp, summary }) => ({
                 name,
@@ -42,7 +37,7 @@ export class ContextSnapshotMaterializer {
         for (const file of readdirSync(dir)) {
             if (!file.endsWith(".json"))
                 continue;
-            if (retained.has(file))
+            if (file === "index.json")
                 continue;
             rmSync(join(dir, file), { force: true });
         }