@voybio/ace-swarm 0.2.4 → 0.2.5

package/assets/.agents/skills/eval-harness/SKILL.md

@@ -173,6 +173,20 @@ Confidence: <score>% (<label>)
 
 ---
 
+## Validation Surface
+
+- Run this skill against at least one known-pass baseline and one known-fail fixture before trusting a promotion decision.
+- Validation command example: execute the configured eval harness runner and confirm deterministic suite counts in `agent-state/EVAL_REPORT.md`.
+
+---
+
+## Portability Notes
+
+- Keep this skill vendor-neutral: it should work across Codex, Claude, Cursor, and Antigravity runtimes.
+- Avoid provider-specific assumptions in suite execution or report parsing; rely on ACE artifacts as the source of truth.
+
+---
+
 ## Anti-Patterns
 
 | Anti-Pattern | Correct Behavior |

package/assets/.agents/skills/handoff-lint/SKILL.md

@@ -132,6 +132,20 @@ Also use when:
 
 ---
 
+## Validation Surface
+
+- Run this check with one valid and one intentionally broken handoff payload to verify deterministic PASS/FAIL behavior.
+- Validation command example: execute the handoff lint path used by the runtime and confirm schema, route, and evidence checks all emit rule-level outcomes.
+
+---
+
+## Portability Notes
+
+- Keep lint output schema and rule IDs stable so different clients can consume results uniformly.
+- Do not depend on provider-specific behavior; handoff validation must rely only on ACE artifacts and schemas.
+
+---
+
 ## Anti-Patterns
 
 | Anti-Pattern | Correct Behavior |

package/assets/.agents/skills/incident-commander/SKILL.md

@@ -156,6 +156,20 @@ No incident closure without ALL of:
 
 ---
 
+## Validation Surface
+
+- Run an incident simulation with synthetic `GATE_FAILED` events and verify severity classification, owner assignment, and timeline reconstruction are deterministic.
+- Validation command example: replay a known event stream and confirm `global-state/INCIDENTS.md` and `agent-state/INCIDENT_TIMELINE.md` contain matching evidence-linked rows.
+
+---
+
+## Portability Notes
+
+- Incident lifecycle states and emitted event names must remain stable across clients.
+- Keep the protocol provider-agnostic: all decisions should be derivable from ACE state artifacts and event logs.
+
+---
+
 ## Anti-Patterns
 
 | Anti-Pattern | Correct Behavior |

package/assets/.agents/skills/memory-curator/SKILL.md

@@ -161,6 +161,20 @@ Generated: <ISO8601>
 
 ---
 
+## Validation Surface
+
+- Run this skill on a fixture with known duplicates and contradictions, then verify the reconciliation report counts match expected values.
+- Validation command example: execute memory curation and confirm no source logs are modified while `MEMORY_INDEX.md` updates with provenance links.
+
+---
+
+## Portability Notes
+
+- Preserve schema and section labels so downstream consumers can parse curated memory artifacts consistently.
+- Keep curation logic independent of model/provider specifics; evidence linkage is the portable contract.
+
+---
+
 ## Anti-Patterns
 
 | Anti-Pattern | Correct Behavior |

package/assets/.agents/skills/release-sentry/SKILL.md

@@ -160,6 +160,20 @@ Reason: <one sentence>
 
 ---
 
+## Validation Surface
+
+- Validate this skill with one known-pass and one known-fail release packet to confirm gate outcomes are deterministic.
+- Validation command example: run release sentry checks and verify `RELEASE_DECISION.md` always includes explicit gate evidence rows.
+
+---
+
+## Portability Notes
+
+- Keep decision enums and gate names stable so any client can consume release outputs consistently.
+- Avoid provider-specific assumptions; release readiness must be computed from ACE artifacts only.
+
+---
+
 ## Anti-Patterns
 
 | Anti-Pattern | Correct Behavior |

package/assets/.agents/skills/risk-quant/SKILL.md

@@ -158,6 +158,20 @@ Every risk in `RISKS.md` must contain these fields:
 
 ---
 
+## Validation Surface
+
+- Run this skill against a fixture risk set with expected probability-impact scores and verify computed tiers match exactly.
+- Validation command example: execute risk quantification and confirm HIGH/CRITICAL entries always include owner, mitigation, and verification condition.
+
+---
+
+## Portability Notes
+
+- Keep scoring scales and tier thresholds explicit and stable across clients.
+- Quantification must remain vendor-neutral and based on ACE state artifacts, not model-specific behavior.
+
+---
+
 ## Anti-Patterns
 
 | Anti-Pattern | Correct Behavior |

package/assets/.agents/skills/schema-forge/SKILL.md

@@ -151,6 +151,20 @@ Use when:
 
 ---
 
+## Validation Surface
+
+- Validate schema updates against both old and new sample payload fixtures before promoting contract changes.
+- Validation command example: run JSON-schema validation for backward and forward compatibility samples and record results in `EVIDENCE_LOG.md`.
+
+---
+
+## Portability Notes
+
+- Preserve stable schema IDs, version fields, and migration metadata so any ACE client can consume updates.
+- Keep evolution rules provider-agnostic; compatibility decisions must be artifact-driven, not model-driven.
+
+---
+
 ## Anti-Patterns
 
 | Anti-Pattern | Correct Behavior |

package/assets/.agents/skills/state-auditor/SKILL.md

@@ -161,6 +161,20 @@ Overall: <PASS | WARN | CRITICAL>
 
 ---
 
+## Validation Surface
+
+- Run audits against fixtures with known contradictions to verify deterministic CRITICAL/WARN classification.
+- Validation command example: execute the state audit flow and confirm every checklist row maps to a concrete pass/fail artifact reference.
+
+---
+
+## Portability Notes
+
+- Keep report structure and checklist IDs stable so multiple clients can parse outputs consistently.
+- State drift checks must remain independent of model/provider implementation details.
+
+---
+
 ## Anti-Patterns
 
 | Anti-Pattern | Correct Behavior |

package/assets/agent-state/MODULES/gates/gate-correctness.json

@@ -2,6 +2,6 @@
   "id": "gate-correctness",
   "type": "executable",
   "invariant": "All required tests pass",
-  "command": "cd ace-mcp-server && npm test --silent",
+  "command": "if [ -f ace-mcp-server/package.json ]; then cd ace-mcp-server && npm test --silent; elif [ -f package.json ]; then npm test --silent; else echo 'package.json not found for gate-correctness' && exit 1; fi",
   "evidence_requirement": "Command output snippet with exit code 0"
 }

package/dist/cli.js

@@ -25,6 +25,7 @@ Usage:
   ace init [options]           Bootstrap the ACE store into current workspace
   ace turnkey [options]        Project minimal workspace bootstrap stubs from the ACE store
   ace doctor [options]         Validate ACE runtime + MCP readiness
+  ace cache [options]          Cache ACE artifacts into ace-state.ace and optionally clean projections
   ace mcp-config [options]     Print global/client MCP config snippet(s) from store
   ace preconfig                Write .mcp-config/ bundle for all supported clients to workspace root
   ace paths                    Show resolved package/workspace paths
@@ -53,6 +54,10 @@ Options for doctor:
   --ollama-url <url>           Legacy alias for --base-url
   --scan                       Probe common local Ollama + llama.cpp endpoints when URL is unset
 
+Options for cache:
+  --dry-run                    Preview what would be cached and cleaned (no writes/deletes)
+  --no-clean                   Keep workspace ACE artifacts after caching them into ace-state.ace
+
 Options for mcp-config:
   --client <name>              codex|vscode|claude|cursor|antigravity
   --all                        Print all client snippets for optional global install
@@ -680,6 +685,26 @@ async function main() {
         console.log(`Store compacted: ${result.before} → ${result.after} bytes (saved ${savedKb}KB)`);
         return;
     }
+    if (command === "cache") {
+        const { cacheWorkspaceArtifacts } = await import("./store/cache-workspace.js");
+        const dryRun = args.includes("--dry-run");
+        const clean = !args.includes("--no-clean");
+        const result = await cacheWorkspaceArtifacts(WORKSPACE_ROOT, { dryRun, clean });
+        console.log("ACE cache complete");
+        console.log(`Workspace: ${WORKSPACE_ROOT}`);
+        console.log(`Store: ${result.storePath}`);
+        console.log(`Scanned files: ${result.scanned_files}`);
+        console.log(`Cached files: ${result.cached_files}`);
+        console.log(`Kept projected files: ${result.kept_projected_files}`);
+        console.log(`Skipped files: ${result.skipped_files}`);
+        console.log(`Removed files: ${result.removed_files}`);
+        if (result.warnings.length > 0) {
+            console.warn(`Warnings (${result.warnings.length}):`);
+            for (const warning of result.warnings)
+                console.warn(`  ! ${warning}`);
+        }
+        return;
+    }
     if (command === "help" || command === "--help" || command === "-h") {
         printHelp();
         return;

package/dist/helpers.d.ts

@@ -66,6 +66,7 @@ export interface BootstrapResult {
     skipped: string[];
 }
 export declare function mapAceWorkspaceRelativePath(path: string): string;
+export declare function isProjectedAceWorkspacePath(filePath: string): boolean;
 export declare function acePath(...segments: string[]): string;
 export declare function wsPath(...segments: string[]): string;
 /** Normalize a path for validation: workspace-relative, forward slashes. */
@@ -79,6 +80,7 @@ export declare function fileExists(filePath: string): boolean;
 export declare function resolveWorkspaceWritePath(filePath: string): string;
 export declare function resolveWorkspaceReadPath(filePath: string): string;
 export declare function resolveWorkspaceArtifactPath(filePath: string, mode?: "read" | "write"): string;
+export declare function resolveStoreFallbackKeysForPath(filePath: string): string[];
 export declare function classifyPathSource(path?: string): ArtifactSource;
 /** Safely read a workspace file, returning either text or a not-found/access message. */
 export declare function safeRead(filePath: string): string;

package/dist/helpers.js

@@ -8,7 +8,7 @@ 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 { 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);
@@ -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",
@@ -386,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);
 }
@@ -532,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",
@@ -549,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)}`);
@@ -584,6 +603,9 @@ function resolveStoreFallbackKeys(filePath) {
     }
     return [...keys];
 }
+export function resolveStoreFallbackKeysForPath(filePath) {
+    return resolveStoreFallbackKeys(filePath);
+}
 function readFirstAvailable(paths) {
     const found = firstExistingPath(paths);
     if (!found) {
@@ -631,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 });

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 });
         }

package/dist/tools-agent.js

@@ -2,7 +2,7 @@
  * Agent, skill, kernel, and task-pack tool registrations.
  */
 import { z } from "zod";
-import { ALL_AGENTS, COMPOSABLE_AGENTS, SWARM_AGENTS, SWARM_SUBAGENT_MAP, classifyPathSource, getAgentInstructionPath, getAgentManifestPath, getKernelArtifactPath, isSwarmRole, listAvailableSkills, readAgentInstructions, readAgentManifest, readKernelArtifact, readSkillInstructions, readTaskArtifact, resolveWritableTaskPath, safeWrite, } from "./helpers.js";
+import { ALL_AGENTS, COMPOSABLE_AGENTS, SWARM_AGENTS, SWARM_SUBAGENT_MAP, classifyPathSource, getAgentInstructionPath, getAgentManifestPath, getKernelArtifactPath, isSwarmRole, listAvailableSkills, readAgentInstructions, readAgentManifest, readKernelArtifact, readSkillInstructions, readTaskArtifact, resolveWorkspaceRoot, resolveWritableTaskPath, safeWrite, } from "./helpers.js";
 import { loadRuntimeProfile, readRuntimePromptTemplate, readRuntimeProfileState, validateRuntimeProfileContent, } from "./runtime-profile.js";
 import { getUnattendedSession, listUnattendedSessions, startUnattendedSession, stopUnattendedSession, validateRuntimeExecutorSessionRegistryContent, waitForUnattendedSession, } from "./runtime-executor.js";
 import { executeRuntimeTool, listRuntimeToolSpecs, loadRuntimeToolRegistry, validateRuntimeToolRegistryContent, } from "./runtime-tool-specs.js";
@@ -80,6 +80,17 @@ function appendUniqueNote(target, note) {
         target.push(note);
     }
 }
+function createToolOnlyBridgeResult(step, reason) {
+    return {
+        bridge_id: `tool-only-${step.step_id}-${Date.now()}`,
+        role: step.role,
+        status: "completed",
+        summary: `Tool-only orchestrator completion for ${step.step_id} (${step.role}): ${step.task}. ${reason}`,
+        turns: 0,
+        tool_calls: [],
+        child_results: [],
+    };
+}
 function buildDefaultOrchestratorAmendment(input) {
     if (input.result.status !== "completed" || input.step.role !== "coders") {
         return undefined;
@@ -687,13 +698,23 @@ export function registerAgentTools(server) {
             .optional()
             .describe("Optional workspace root override; defaults to the active workspace"),
     }, async ({ task, steps, execution_mode, max_turns_per_step, provider, model, base_url, ollama_url, workspace_root }, extra) => {
-        const runtime = resolveLocalModelRuntime({
-            workspaceRoot: workspace_root,
-            provider,
-            model,
-            baseUrl: base_url,
-            ollamaUrl: ollama_url,
-        });
+        let runtime;
+        const runtimeWarnings = [];
+        try {
+            runtime = resolveLocalModelRuntime({
+                workspaceRoot: workspace_root,
+                provider,
+                model,
+                baseUrl: base_url,
+                ollamaUrl: ollama_url,
+            });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            appendUniqueNote(runtimeWarnings, `Model bridge runtime unavailable; continuing in tool-only mode. ${message}`);
+        }
+        const effectiveWorkspaceRoot = runtime?.workspaceRoot ??
+            (workspace_root ? resolveRuntimeWorkspaceRoot(workspace_root) : resolveWorkspaceRoot());
         const sessionId = typeof extra?.sessionId === "string" ? extra.sessionId : undefined;
         const planSource = Array.isArray(steps) && steps.length > 0 ? "explicit_steps" : "orchestrator_default_step";
         const planSteps = Array.isArray(steps) && steps.length > 0
@@ -704,20 +725,27 @@ export function registerAgentTools(server) {
             steps: planSteps,
             execution_mode: execution_mode ?? "sequential",
         });
-        const bridge = new ModelBridge(createDefaultModelBridgeClients(runtime));
+        const bridge = runtime
+            ? new ModelBridge(createDefaultModelBridgeClients(runtime))
+            : undefined;
         const fallbackHandoffPrefix = `LOCAL-${plan.plan_id}-`;
         const vericifyWarnings = [];
         const supervised = await superviseTaskPlan(plan, {
             async spawnStep(step) {
-                return bridge.spawn({
-                    task: step.task,
-                    role: step.role,
-                    workspace: runtime.workspaceRoot,
-                    maxTurns: max_turns_per_step ?? 6,
-                    provider: runtime.provider,
-                    model: runtime.model,
-                    toolScope: step.tool_scope,
-                });
+                if (bridge && runtime) {
+                    return bridge.spawn({
+                        task: step.task,
+                        role: step.role,
+                        workspace: runtime.workspaceRoot,
+                        maxTurns: max_turns_per_step ?? 6,
+                        provider: runtime.provider,
+                        model: runtime.model,
+                        toolScope: step.tool_scope,
+                    });
+                }
+                const reason = runtimeWarnings[0] ??
+                    "No local model provider/runtime was resolved for model bridge execution.";
+                return createToolOnlyBridgeResult(step, reason);
             },
             async createHandoff({ step, plan: activePlan }) {
                 const created = await executeAceInternalTool("create_handoff", {
@@ -756,13 +784,13 @@ export function registerAgentTools(server) {
             },
             async getVericifyContext() {
                 return tryVericifyPacket(() => getVericifyContextPacket({
-                    workspaceRoot: runtime.workspaceRoot,
+                    workspaceRoot: effectiveWorkspaceRoot,
                 }), (message) => appendUniqueNote(vericifyWarnings, `Vericify context unavailable for ${plan.plan_id}: ${message}`));
             },
             async getVericifyDelta(since) {
                 return tryVericifyPacket(() => getVericifyDelta({
                     since,
-                    workspaceRoot: runtime.workspaceRoot,
+                    workspaceRoot: effectiveWorkspaceRoot,
                 }), (message) => appendUniqueNote(vericifyWarnings, `Vericify delta unavailable for ${plan.plan_id}: ${message}`));
             },
             async openCircuitBreaker(reason) {
@@ -818,7 +846,10 @@ export function registerAgentTools(server) {
                 {
                     type: "text",
                     text: JSON.stringify({
-                        runtime,
+                        runtime: runtime ?? null,
+                        execution_backend: runtime ? "model_bridge" : "tool_only",
+                        runtime_warnings: runtimeWarnings,
+                        workspace_root: effectiveWorkspaceRoot,
                         plan_source: planSource,
                         planning_note: planSource === "orchestrator_default_step"
                             ? "Auto-planning currently starts with ACE-Orchestrator. Pass explicit steps for multi-step orchestration."

package/dist/tools-framework.js

@@ -4,7 +4,7 @@
  */
 import { z } from "zod";
 import { bootstrapStoreWorkspace } from "./store/bootstrap-store.js";
-import { ACE_ROOT_REL, ACE_TASKS_ROOT_REL, ALL_MCP_CLIENTS, ALL_LLM_PROVIDERS, ALL_AGENTS, COMPOSABLE_AGENTS, SWARM_AGENTS, SWARM_SUBAGENT_MAP, WORKSPACE_ROOT, classifyPathSource, detectAssetDrift, getAllMcpServerConfigSnippets, getAgentInstructionPath, getAgentManifestPath, getKernelArtifactPath, getMcpClientInstallHint, getMcpServerConfigSnippet, getTaskArtifactPath, isSwarmRole, listAvailableSkills, normalizePathForValidation, safeRead, safeWrite, withFileLock, wsPath, } from "./helpers.js";
+import { ACE_ROOT_REL, ACE_TASKS_ROOT_REL, ALL_MCP_CLIENTS, ALL_LLM_PROVIDERS, ALL_AGENTS, COMPOSABLE_AGENTS, SWARM_AGENTS, SWARM_SUBAGENT_MAP, WORKSPACE_ROOT, classifyPathSource, detectAssetDrift, getAllMcpServerConfigSnippets, getAgentInstructionPath, getAgentManifestPath, getKernelArtifactPath, getMcpClientInstallHint, getMcpServerConfigSnippet, getTaskArtifactPath, isSwarmRole, listAvailableSkills, normalizePathForValidation, resolveWorkspaceRoot, safeRead, safeWrite, withFileLock, wsPath, } from "./helpers.js";
 import { getRoleTitle, MCP_CLIENT_ENUM, scoreDomains, } from "./shared.js";
 import { defaultModelForProvider, } from "./tui/provider-discovery.js";
 import { refreshAstgrepIndex } from "./astgrep-index.js";
@@ -20,6 +20,7 @@ import { auditPublicSurface } from "./public-surface.js";
 import { auditStoreAuthority, writeStoreAuthorityAuditReport, } from "./store/store-authority-audit.js";
 import { PROVENANCE_CRITICAL_EVENT_TYPES, validateArtifactManifestPayload, validateProvenanceLogContent, validateTealConfigContent, } from "./schemas.js";
 import { readAceTaskContractAssessment } from "./ace-autonomy.js";
+import { listStoreKeysSync, readStoreBlobSync } from "./store/store-snapshot.js";
 function getArtifactManifestEntries(payload) {
     if (!payload || typeof payload !== "object" || Array.isArray(payload))
         return [];
@@ -38,15 +39,37 @@ function getArtifactManifestEntries(payload) {
     }
     return [];
 }
+function parseGateManifest(raw, sourceRef) {
+    try {
+        const gate = JSON.parse(raw);
+        const id = typeof gate.id === "string" ? gate.id.trim() : "";
+        if (!id)
+            return undefined;
+        const type = gate.type === "executable" || gate.type === "artifact_scan" || gate.type === "manual_review"
+            ? gate.type
+            : "manual_review";
+        return {
+            id,
+            type,
+            invariant: typeof gate.invariant === "string" ? gate.invariant : "",
+            command: typeof gate.command === "string" ? gate.command : "",
+            evidence_requirement: typeof gate.evidence_requirement === "string" ? gate.evidence_requirement : "",
+            source_ref: sourceRef,
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
 function readGateManifests(gatesDir) {
     const files = readdirSync(gatesDir).filter((f) => f.endsWith(".json"));
     const allGates = [];
     for (const file of files) {
         try {
             const raw = readFileSync(resolve(gatesDir, file), "utf-8");
-            const gate = JSON.parse(raw);
-            if (gate.id)
-                allGates.push(gate);
+            const parsed = parseGateManifest(raw, `agent-state/MODULES/gates/${file}`);
+            if (parsed)
+                allGates.push(parsed);
         }
         catch {
             /* skip corrupt manifests */
@@ -54,6 +77,44 @@ function readGateManifests(gatesDir) {
     }
     return allGates;
 }
+function readStoreGateManifests(workspaceRoot) {
+    const gateKeys = listStoreKeysSync(workspaceRoot, "knowledge/gates/").filter((key) => key.endsWith(".json"));
+    const allGates = [];
+    for (const key of gateKeys) {
+        const raw = readStoreBlobSync(workspaceRoot, key);
+        if (typeof raw !== "string")
+            continue;
+        const parsed = parseGateManifest(raw, key);
+        if (parsed)
+            allGates.push(parsed);
+    }
+    return allGates;
+}
+function resolveGateManifests(gatesDir) {
+    if (existsSync(gatesDir)) {
+        const workspaceGates = readGateManifests(gatesDir);
+        if (workspaceGates.length > 0) {
+            return { gates: workspaceGates, source: "workspace" };
+        }
+    }
+    const storeGates = readStoreGateManifests(resolveWorkspaceRoot());
+    if (storeGates.length > 0) {
+        return { gates: storeGates, source: "store" };
+    }
+    return { gates: [], source: "none" };
+}
+function hasArtifactEvidence(reference) {
+    const normalized = reference.trim();
+    if (!normalized)
+        return false;
+    const candidates = [wsPath("agent-state", normalized), wsPath(normalized)];
+    if (candidates.some((candidate) => existsSync(candidate)))
+        return true;
+    return candidates.some((candidate) => {
+        const content = safeRead(candidate);
+        return !content.startsWith("[FILE NOT FOUND]") && !content.startsWith("[ACCESS DENIED]");
+    });
+}
 function evaluateGateTargets(targets) {
     const results = [];
     for (const gate of targets) {
@@ -97,7 +158,7 @@ function evaluateGateTargets(targets) {
                 }
                 else {
                     for (const artifact of relevantArtifacts) {
-                        if (!existsSync(wsPath("agent-state", artifact))) {
+                        if (!hasArtifactEvidence(artifact)) {
                             missing.push(artifact);
                         }
                     }
@@ -109,11 +170,9 @@ function evaluateGateTargets(targets) {
                     .map((s) => s.trim())
                     .filter(Boolean);
                 for (const ref of evidenceFiles) {
-                    const candidates = [wsPath("agent-state", ref), wsPath(ref)];
-                    const found = candidates.some((candidate) => existsSync(candidate));
-                    if (!found) {
+                    if (!hasArtifactEvidence(ref)) {
                         const asFile = ref.replace(/\s+/g, "_").replace(/[^a-zA-Z0-9_./-]/g, "");
-                        const fileFound = existsSync(wsPath("agent-state", asFile));
+                        const fileFound = hasArtifactEvidence(asFile);
                         if (!fileFound)
                             missing.push(ref);
                     }
@@ -1349,31 +1408,27 @@ export function registerFrameworkTools(server) {
             .describe("Optional short focus string persisted with skeptic adversarial review evidence."),
     }, async ({ gate_ids, review_mode, review_focus }) => {
         const gatesDir = wsPath("agent-state", "MODULES", "gates");
-        if (!existsSync(gatesDir)) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: "❌ Gates directory not found: agent-state/MODULES/gates/",
-                    },
-                ],
-            };
-        }
-        const allGates = readGateManifests(gatesDir);
+        const resolved = resolveGateManifests(gatesDir);
+        const allGates = resolved.gates;
+        const gateEvidenceRef = resolved.source === "store" ? "knowledge/gates/*" : "agent-state/MODULES/gates/";
         // Filter to requested gates (or run all)
         const targets = gate_ids
             ? allGates.filter((g) => gate_ids.includes(g.id))
             : allGates;
         if (targets.length === 0) {
+            const noGateMessage = allGates.length === 0
+                ? "❌ No gate manifests found in agent-state/MODULES/gates/ or ace-state.ace knowledge/gates/*."
+                : `❌ No matching gates found. Available: ${allGates.map((g) => g.id).join(", ")}`;
             return {
                 content: [
                     {
                         type: "text",
-                        text: `❌ No matching gates found. Available: ${allGates.map((g) => g.id).join(", ")}`,
+                        text: noGateMessage,
                     },
                 ],
             };
         }
+        const gateArtifactRefs = targets.map((gate) => gate.source_ref ?? gateEvidenceRef);
         const results = evaluateGateTargets(targets);
         const passed = results.filter((r) => r.ok).length;
         const failed = results.filter((r) => !r.ok).length;
@@ -1401,7 +1456,8 @@ export function registerFrameworkTools(server) {
                 })),
                 passed,
                 failed,
-                evidence_ref: evidence?.evidenceRef ?? "agent-state/MODULES/gates/",
+                evidence_ref: evidence?.evidenceRef ?? gateEvidenceRef,
+                gate_manifest_source: resolved.source,
                 ...(review
                     ? {
                         review: {
@@ -1428,13 +1484,14 @@ export function registerFrameworkTools(server) {
                 ? `Gate execution with skeptic review: ${review.summary.confirmed_count} confirmed findings`
                 : `Gate execution: ${passed}/${results.length} passed`,
             artifacts: [
-                ...results.map((r) => `agent-state/MODULES/gates/${r.id}.json`),
+                ...gateArtifactRefs,
                 ...(evidence ? ["agent-state/EVIDENCE_LOG.md"] : []),
             ],
             metadata: {
                 passed,
                 failed,
                 gate_ids: results.map((r) => r.id),
+                gate_manifest_source: resolved.source,
                 ...(review
                     ? {
                         review_mode: review.mode,
@@ -1460,6 +1517,9 @@ export function registerFrameworkTools(server) {
                             : allOk
                                 ? `✅ All gates passed: ${passed}/${results.length}`
                                 : `❌ Gate failures: ${failed}/${results.length} failed`,
+                        `Gate manifest source: ${resolved.source === "store"
+                            ? "ace-state.ace (knowledge/gates/*)"
+                            : "agent-state/MODULES/gates/"}`,
                         `Run ledger: ${ledger.path} (${ledger.entry.id})`,
                         ...(evidence ? [`Evidence: ${evidence.path} (${evidence.evidenceRef})`] : []),
                         "",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@voybio/ace-swarm",
-  "version": "0.2.4",
+  "version": "0.2.5",
   "description": "ACE Framework MCP server and CLI — single-file ACEPACK state, local-model serving, agent orchestration, and host compliance enforcement.",
   "type": "module",
   "main": "dist/index.js",