@voybio/ace-swarm 0.2.5 → 2.4.1

package/dist/store/bootstrap-store.js

@@ -5,7 +5,7 @@
  *
  * Replaces the old copyTree()-based bootstrap with:
  *   1. Create minimal directories
- *   2. Initialize AcePackedStore at .agents/ACE/ace-state.ace
+ *   2. Initialize AcePackedStore at agent-state/ace-state.ace
  *   3. Bake core knowledge (agents, modules, kernel)
  *   4. Write topology records
  *   5. Write initial runtime state seeds
@@ -26,6 +26,8 @@ import { HostFileMaterializer } from "./materializers/host-file-materializer.js"
 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 { ensureCanonicalWorkspaceStore } from "./workspace-store-paths.js";
+import { withStoreWriteCoordinator } from "./write-coordinator.js";
 import { STORE_VERSION } from "./types.js";
 import { buildProviderDoctorCommands, defaultModelForProvider, normalizeLocalBaseUrl, normalizeProvider, } from "../tui/provider-discovery.js";
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -41,13 +43,19 @@ async function applyLlmRuntimeConfig(store, opts) {
     if (!opts.llm)
         return;
     const provider = normalizeProvider(opts.llm) ?? opts.llm;
-    const configuredModel = opts.model ?? defaultModelForProvider(provider);
+    const configuredModel = opts.model?.trim() ||
+        (provider === "ollama" ? defaultModelForProvider(provider) : undefined);
     const configuredBaseUrl = normalizeLocalBaseUrl(opts.baseUrl ?? opts.ollamaUrl);
     const profilePayload = {
         provider,
-        model: configuredModel,
         generated_at: new Date().toISOString(),
     };
+    if (configuredModel) {
+        profilePayload.model = configuredModel;
+    }
+    if (opts.launcherCommand) {
+        profilePayload.launch_command = opts.launcherCommand;
+    }
     if (configuredBaseUrl) {
         profilePayload.base_url = configuredBaseUrl;
         if (provider === "ollama") {
@@ -91,12 +99,7 @@ async function materializeStoreSurfaces(store, workspaceRoot, opts) {
     await store.commit();
     const projections = new ProjectionManager(store, workspaceRoot);
     await projections.projectAfterCommit(["hook_context", "todo_state", "scheduler", "context_snapshots"]);
-    materialized.push(join(workspaceRoot, ".agents", "ACE", "ace-hook-context.json"));
     materialized.push(join(workspaceRoot, ".agents", "ACE", "tasks", "todo.md"));
-    materialized.push(join(workspaceRoot, ".agents", "ACE", "agent-state", "job-queue.json"));
-    materialized.push(join(workspaceRoot, ".agents", "ACE", "agent-state", "job-locks.json"));
-    materialized.push(join(workspaceRoot, ".agents", "ACE", "agent-state", "scheduler-lease.json"));
-    materialized.push(join(workspaceRoot, ".agents", "ACE", "agent-state", "context-snapshots", "index.json"));
     return [...new Set(materialized)];
 }
 // Artifacts that receive live timestamp substitution on first seed.
@@ -116,88 +119,101 @@ async function seedOperationalArtifacts(store) {
 }
 export async function bootstrapStoreWorkspace(opts) {
     const { workspaceRoot, force = false } = opts;
-    const warnings = [];
-    const materialized = [];
-    const storePath = join(workspaceRoot, ".agents", "ACE", "ace-state.ace");
-    if (existsSync(storePath) && !force) {
-        if (!(opts.includeMcpConfig ?? false) && !(opts.includeClientConfigBundle ?? false) && !opts.llm) {
-            warnings.push(`Store already exists at ${storePath}. Use --force to reinitialize, or run 'ace migrate' to import existing state.`);
+    const resolved = await ensureCanonicalWorkspaceStore(workspaceRoot, {
+        operationLabel: "bootstrapStoreWorkspace",
+    });
+    const storePath = resolved.storePath;
+    return withStoreWriteCoordinator(storePath, async () => {
+        const warnings = [...resolved.warnings];
+        const materialized = [];
+        if (resolved.mode === "dual_store_conflict" && !force) {
+            warnings.push("Both canonical and legacy stores exist and differ. Resolve with 'ace repair' before reinitializing.");
             return { storePath, agents: 0, modules: { gates: 0, roles: 0, schemas: 0 }, materialized, warnings };
         }
-        const existingStore = await openStore(storePath);
+        if (existsSync(storePath) && !force) {
+            if (!(opts.includeMcpConfig ?? false) && !(opts.includeClientConfigBundle ?? false) && !opts.llm) {
+                warnings.push(`Store already exists at ${storePath}. Use --force to reinitialize, or run 'ace migrate' to import existing state.`);
+                return { storePath, agents: 0, modules: { gates: 0, roles: 0, schemas: 0 }, materialized, warnings };
+            }
+            const existingStore = await openStore(storePath);
+            try {
+                await seedOperationalArtifacts(existingStore);
+                materialized.push(...(await materializeStoreSurfaces(existingStore, workspaceRoot, opts)));
+                const agents = (await existingStore.listAgents()).length;
+                warnings.push(`Reused existing store at ${storePath} and refreshed host materializations.`);
+                return { storePath, agents, modules: { gates: 0, roles: 0, schemas: 0 }, materialized, warnings };
+            }
+            finally {
+                await existingStore.close();
+            }
+        }
+        for (const dir of [
+            join(workspaceRoot, "agent-state"),
+            join(workspaceRoot, ".agents", "ACE"),
+            join(workspaceRoot, ".agents", "ACE", "tasks"),
+        ]) {
+            mkdirSync(dir, { recursive: true });
+        }
+        const store = await openStore(storePath);
         try {
-            await seedOperationalArtifacts(existingStore);
-            materialized.push(...(await materializeStoreSurfaces(existingStore, workspaceRoot, opts)));
-            const agents = (await existingStore.listAgents()).length;
-            warnings.push(`Reused existing store at ${storePath} and refreshed host materializations.`);
-            return { storePath, agents, modules: { gates: 0, roles: 0, schemas: 0 }, materialized, warnings };
+            await store.setJSON("meta/schema_version", STORE_VERSION);
+            await store.setJSON("meta/created_at", Date.now());
+            await store.setJSON("meta/project_name", opts.projectName ?? "ACE Workspace");
+            await store.setJSON("meta/host_materialization", {
+                include_mcp_config: opts.includeMcpConfig ?? false,
+                include_client_config_bundle: opts.includeClientConfigBundle ?? false,
+            });
+            const assetsRoot = getAssetsRoot();
+            const knowledge = await bakeAllCoreKnowledge(store, assetsRoot);
+            await bakeTopology(store, assetsRoot);
+            await store.setJSON("state/handoffs/__index", []);
+            await store.setJSON("state/todo/index", []);
+            await store.setJSON("state/ledger/seq", 0);
+            await store.setJSON("state/scheduler/queue", []);
+            await store.setJSON("state/scheduler/locks", []);
+            await store.setJSON("state/scheduler/lease", null);
+            await store.setJSON("state/memory/context_snapshots/index.json", { snapshots: [] });
+            await store.setJSON("state/runtime/sessions/index", []);
+            await store.setJSON("state/discovery/index", []);
+            await store.setJSON("state/vericify/posts/index", []);
+            await applyLlmRuntimeConfig(store, opts);
+            await seedOperationalArtifacts(store);
+            await buildCatalog(store);
+            await store.commit();
+            await store.compact();
+            materialized.push(...(await materializeStoreSurfaces(store, workspaceRoot, opts)));
+            const agents = (await store.listAgents()).length;
+            return {
+                storePath,
+                agents,
+                modules: knowledge.modules,
+                materialized,
+                warnings,
+            };
         }
         finally {
-            await existingStore.close();
+            await store.close();
         }
-    }
-    // 1. Create minimal directories under .agents/ACE/ (canonical ACE namespace)
-    for (const dir of [
-        join(workspaceRoot, ".agents", "ACE"),
-        join(workspaceRoot, ".agents", "ACE", "tasks"),
-    ]) {
-        mkdirSync(dir, { recursive: true });
-    }
-    // 2. Initialize store
-    const store = await openStore(storePath);
-    try {
-        // 3. Write meta
-        await store.setJSON("meta/schema_version", STORE_VERSION);
-        await store.setJSON("meta/created_at", Date.now());
-        await store.setJSON("meta/project_name", opts.projectName ?? "ACE Workspace");
-        await store.setJSON("meta/host_materialization", {
-            include_mcp_config: opts.includeMcpConfig ?? false,
-            include_client_config_bundle: opts.includeClientConfigBundle ?? false,
-        });
-        // 4. Bake core knowledge
-        const assetsRoot = getAssetsRoot();
-        const knowledge = await bakeAllCoreKnowledge(store, assetsRoot);
-        // 5. Write topology
-        await bakeTopology(store, assetsRoot);
-        // 6. Write initial empty runtime seeds
-        await store.setJSON("state/handoffs/__index", []);
-        await store.setJSON("state/todo/index", []);
-        await store.setJSON("state/ledger/seq", 0);
-        await store.setJSON("state/scheduler/queue", []);
-        await store.setJSON("state/scheduler/locks", []);
-        await store.setJSON("state/scheduler/lease", null);
-        await store.setJSON("state/memory/context_snapshots/index.json", { snapshots: [] });
-        await store.setJSON("state/runtime/sessions/index", []);
-        await store.setJSON("state/discovery/index", []);
-        await store.setJSON("state/vericify/posts/index", []);
-        await applyLlmRuntimeConfig(store, opts);
-        await seedOperationalArtifacts(store);
-        // 7. Build catalog
-        await buildCatalog(store);
-        // 8. Commit + compact
-        await store.commit();
-        await store.compact();
-        materialized.push(...(await materializeStoreSurfaces(store, workspaceRoot, opts)));
-        const agents = (await store.listAgents()).length;
-        return {
-            storePath,
-            agents,
-            modules: knowledge.modules,
-            materialized,
-            warnings,
-        };
-    }
-    finally {
-        await store.close();
-    }
+    }, { operation_label: "bootstrapStoreWorkspace" });
 }
 // ── ace repair ────────────────────────────────────────────────────────────────
 export async function repairWorkspace(workspaceRoot) {
-    const storePath = join(workspaceRoot, ".agents", "ACE", "ace-state.ace");
-    if (!existsSync(storePath)) {
-        return [`No store found at ${storePath}. Run 'ace init' first.`];
+    const resolved = await ensureCanonicalWorkspaceStore(workspaceRoot, {
+        operationLabel: "repairWorkspace",
+    });
+    if (resolved.mode === "missing") {
+        return [
+            `No store found at ${resolved.canonicalPath} or ${resolved.legacyPath}. Run 'ace init' first.`,
+        ];
     }
-    const warnings = [];
+    if (resolved.mode === "dual_store_conflict") {
+        return [
+            ...resolved.warnings,
+            "Resolve dual ACE stores before repair can safely materialize host files.",
+        ];
+    }
+    const { storePath } = resolved;
+    const warnings = [...resolved.warnings];
     const store = await openStore(storePath);
     try {
         const hostPolicy = (await store.getJSON("meta/host_materialization")) ?? {};
@@ -221,10 +237,13 @@ export async function repairWorkspace(workspaceRoot) {
 }
 // ── ace compact ───────────────────────────────────────────────────────────────
 export async function compactWorkspace(workspaceRoot) {
-    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 resolved = await ensureCanonicalWorkspaceStore(workspaceRoot, {
+        operationLabel: "compactWorkspace",
+    });
+    if (resolved.mode === "missing") {
+        throw new Error(`No store found at ${resolved.canonicalPath} or ${resolved.legacyPath}. Run 'ace init' first.`);
     }
+    const { storePath } = resolved;
     const { statSync } = await import("fs");
     const before = statSync(storePath).size;
     const store = await openStore(storePath);

package/dist/store/cache-workspace.js

@@ -2,7 +2,8 @@ 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";
+import { getWorkspaceStorePath } from "./store-snapshot.js";
+import { writeStoreBlobsQueued } from "./store-artifacts.js";
 const SCAN_ROOTS_REL = [
     "agent-state",
     ".agents/ACE/agent-state",
@@ -48,10 +49,15 @@ function isTextBuffer(input) {
 function selectScanRoots(workspaceRoot) {
     return SCAN_ROOTS_REL.map((relPath) => join(workspaceRoot, relPath)).filter((abs) => existsSync(abs));
 }
+function isCacheableAcePath(path) {
+    return path === "agent-state"
+        || path.startsWith("agent-state/")
+        || path.startsWith(`${ACE_ROOT_REL}/`);
+}
 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");
+    const storePath = getWorkspaceStorePath(workspaceRoot);
     if (!existsSync(storePath)) {
         throw new Error(`No store found at ${storePath}. Run 'ace init' first.`);
     }
@@ -66,7 +72,7 @@ export async function cacheWorkspaceArtifacts(workspaceRoot, options = {}) {
             scanned += 1;
             const relPath = normalizeRelPath(relative(workspaceRoot, absPath));
             const canonicalPath = mapAceWorkspaceRelativePath(relPath);
-            if (!canonicalPath.startsWith(`${ACE_ROOT_REL}/`)) {
+            if (!isCacheableAcePath(canonicalPath)) {
                 skipped += 1;
                 continue;
             }
@@ -105,10 +111,10 @@ export async function cacheWorkspaceArtifacts(workspaceRoot, options = {}) {
     }
     const uniqueForWrite = [...dedupByKey.values()];
     if (!dryRun && uniqueForWrite.length > 0) {
-        writeStoreBlobsSync(workspaceRoot, uniqueForWrite.map((candidate) => ({
+        await writeStoreBlobsQueued(workspaceRoot, uniqueForWrite.map((candidate) => ({
             key: candidate.key,
             content: candidate.content,
-        })));
+        })), { operation_label: "cacheWorkspace" });
     }
     let removed = 0;
     if (!dryRun && clean && candidates.length > 0) {

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

@@ -19,13 +19,14 @@ export class ContextSnapshotMaterializer {
         this.repo = new ContextSnapshotRepository(store);
     }
     directoryPath() {
-        return join(this.workspaceRoot, ".agents", "ACE", "agent-state", "context-snapshots");
+        return join(this.workspaceRoot, "agent-state", "context-snapshots");
     }
     async materializeAll() {
         const dir = this.directoryPath();
         if (!existsSync(dir))
             mkdirSync(dir, { recursive: true });
         const snapshots = await this.repo.listSnapshots();
+        const expectedFiles = new Set(["index.json", ...snapshots.map(({ file }) => file)]);
         writeText(join(dir, "index.json"), `${JSON.stringify({
             snapshots: snapshots.map(({ name, file, timestamp, summary }) => ({
                 name,
@@ -34,10 +35,13 @@ export class ContextSnapshotMaterializer {
                 summary,
             })),
         }, null, 2)}\n`);
+        for (const { file, record } of snapshots) {
+            writeText(join(dir, file), `${JSON.stringify(record, null, 2)}\n`);
+        }
         for (const file of readdirSync(dir)) {
             if (!file.endsWith(".json"))
                 continue;
-            if (file === "index.json")
+            if (expectedFiles.has(file))
                 continue;
             rmSync(join(dir, file), { force: true });
         }

package/dist/store/materializers/hook-context-materializer.d.ts

@@ -1,20 +1,17 @@
 /**
  * HookContextMaterializer
  *
- * Writes .agents/ACE/ace-hook-context.json from store state.
- * Called at every session start, prompt submit, and tool gating change.
- *
- * The hook dispatcher (ace-hook-dispatch.mjs) reads ONLY this file.
- * It never touches the .ace store directly.
+ * Stages the compact hook snapshot into ace-state.ace so hook clients can
+ * read a single runtime payload without extra workspace projections.
  */
 import { AcePackedStore } from "../ace-packed-store.js";
 export declare class HookContextMaterializer {
     private store;
-    private workspaceRoot;
+    static readonly STORE_KEY = "state/runtime/hook_context";
     private kv;
-    constructor(store: AcePackedStore, workspaceRoot: string);
-    private contextPath;
-    materialize(): Promise<void>;
+    constructor(store: AcePackedStore);
+    private buildSnapshot;
+    stageStoreProjection(): Promise<void>;
     private _readContent;
     private _readKernelWorkflow;
     private _getEnabledAgents;

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

@@ -1,14 +1,9 @@
 /**
  * HookContextMaterializer
  *
- * Writes .agents/ACE/ace-hook-context.json from store state.
- * Called at every session start, prompt submit, and tool gating change.
- *
- * The hook dispatcher (ace-hook-dispatch.mjs) reads ONLY this file.
- * It never touches the .ace store directly.
+ * Stages the compact hook snapshot into ace-state.ace so hook clients can
+ * read a single runtime payload without extra workspace projections.
  */
-import { writeFileSync, mkdirSync, existsSync } from "fs";
-import { join, dirname } from "path";
 import { RuntimeKVRepository } from "../repositories/runtime-kv-repository.js";
 function fnv1a(s) {
     let h = 2166136261;
@@ -20,17 +15,13 @@ function fnv1a(s) {
 }
 export class HookContextMaterializer {
     store;
-    workspaceRoot;
+    static STORE_KEY = "state/runtime/hook_context";
     kv;
-    constructor(store, workspaceRoot) {
+    constructor(store) {
         this.store = store;
-        this.workspaceRoot = workspaceRoot;
         this.kv = new RuntimeKVRepository(store);
     }
-    contextPath() {
-        return join(this.workspaceRoot, ".agents", "ACE", "ace-hook-context.json");
-    }
-    async materialize() {
+    async buildSnapshot() {
         const task = await this._readContent("task");
         const status = await this._readContent("status");
         const scope = await this._readContent("scope");
@@ -38,7 +29,7 @@ export class HookContextMaterializer {
         const workflow = await this._readKernelWorkflow();
         const enabledAgents = await this._getEnabledAgents();
         const gatedTools = await this._buildGateMap();
-        const snapshot = {
+        return {
             schema_version: 1,
             generated_at: new Date().toISOString(),
             task: { content: task, hash: fnv1a(task) },
@@ -49,11 +40,9 @@ export class HookContextMaterializer {
             active_agents: enabledAgents,
             gated_tools: gatedTools,
         };
-        const contextPath = this.contextPath();
-        const dir = dirname(contextPath);
-        if (!existsSync(dir))
-            mkdirSync(dir, { recursive: true });
-        writeFileSync(contextPath, JSON.stringify(snapshot, null, 2), "utf8");
+    }
+    async stageStoreProjection() {
+        await this.store.setJSON(HookContextMaterializer.STORE_KEY, await this.buildSnapshot());
     }
     async _readContent(kind) {
         // Try KV first (runtime overrides), then store blobs, then empty
@@ -94,7 +83,8 @@ export class HookContextMaterializer {
     /** Update a runtime content field (task, status, scope, etc.) */
     async setContent(kind, content) {
         await this.kv.setString(`context/${kind}`, content);
-        await this.materialize();
+        await this.stageStoreProjection();
+        await this.store.commit();
     }
 }
 //# sourceMappingURL=hook-context-materializer.js.map

package/dist/store/materializers/host-file-materializer.js

@@ -198,6 +198,7 @@ export class HostFileMaterializer {
         const fileNames = {
             codex: "codex.config.toml",
             vscode: "vscode.mcp.json",
+            copilot: ".mcp.json",
             claude: "claude_desktop_config.json",
             cursor: "cursor.mcp.json",
             antigravity: "antigravity.mcp.json",
@@ -272,6 +273,11 @@ export class HostFileMaterializer {
         }
         if (includeMcpConfig) {
             paths.push(await this.materializeEntry(this.buildVsCodeMcpEntry()));
+            paths.push(await this.materializeEntry({
+                absPath: this.root(".mcp.json"),
+                keyParts: [".mcp.json"],
+                fallbackContent: getMcpServerConfigSnippet("copilot"),
+            }));
         }
         if (includeClientConfigBundle) {
             for (const entry of this.buildInstructionShimEntries()) {

package/dist/store/materializers/projection-manager.d.ts

@@ -6,7 +6,6 @@ export declare class ProjectionManager {
     private vericify;
     private todoSyncer;
     private hookContext;
-    private contextSnapshots;
     private scheduler;
     constructor(store: AcePackedStore, workspaceRoot: string);
     projectAfterCommit(targets: readonly RuntimeProjectionTarget[]): Promise<void>;

package/dist/store/materializers/projection-manager.js

@@ -1,4 +1,3 @@
-import { ContextSnapshotMaterializer } from "./context-snapshot-materializer.js";
 import { HookContextMaterializer } from "./hook-context-materializer.js";
 import { SchedulerProjectionMaterializer } from "./scheduler-projection-materializer.js";
 import { TodoSyncer } from "./todo-syncer.js";
@@ -9,15 +8,13 @@ export class ProjectionManager {
     vericify;
     todoSyncer;
     hookContext;
-    contextSnapshots;
     scheduler;
     constructor(store, workspaceRoot) {
         this.store = store;
         this.workspaceRoot = workspaceRoot;
         this.vericify = new VericifyProjector(store, workspaceRoot);
         this.todoSyncer = new TodoSyncer(store, workspaceRoot);
-        this.hookContext = new HookContextMaterializer(store, workspaceRoot);
-        this.contextSnapshots = new ContextSnapshotMaterializer(store, workspaceRoot);
+        this.hookContext = new HookContextMaterializer(store);
         this.scheduler = new SchedulerProjectionMaterializer(store, workspaceRoot);
     }
     async projectAfterCommit(targets) {
@@ -45,6 +42,10 @@ export class ProjectionManager {
                 await this.vericify.projectVericifyPosts();
                 stagedStoreWrites = true;
             }
+            else if (target === "hook_context") {
+                await this.hookContext.stageStoreProjection();
+                stagedStoreWrites = true;
+            }
             else if (target === "scheduler") {
                 renderedScheduler = await this.scheduler.render();
                 await this.scheduler.stageStoreProjections(renderedScheduler);
@@ -58,15 +59,6 @@ export class ProjectionManager {
             if (target === "todo_state") {
                 await this.todoSyncer.writeToFile();
             }
-            else if (target === "hook_context") {
-                await this.hookContext.materialize();
-            }
-            else if (target === "context_snapshots") {
-                await this.contextSnapshots.materializeAll();
-            }
-            else if (target === "scheduler") {
-                await this.scheduler.materializeFiles(renderedScheduler);
-            }
         }
     }
 }

package/dist/store/materializers/scheduler-projection-materializer.js

@@ -20,7 +20,7 @@ export class SchedulerProjectionMaterializer {
         this.repo = new SchedulerRepository(store);
     }
     filePath(file) {
-        return join(this.workspaceRoot, ".agents", "ACE", "agent-state", file);
+        return join(this.workspaceRoot, "agent-state", file);
     }
     async render() {
         const queue = await this.repo.readQueue();

package/dist/store/materializers/vericify-projector.d.ts

@@ -4,15 +4,15 @@
  * Writes 5 Vericify-facing files from store state on every relevant mutation.
  * These are MIRRORS only — the store is source of truth.
  *
- * All files live under .agents/ACE/ (the canonical ACE namespace as defined
- * by ACE_ROOT_REL in helpers.ts and remapped via ACE_MANAGED_PREFIXES).
+ * Runtime-facing state projections now live under top-level agent-state/.
+ * Host/task scaffolding remains under .agents/ACE/ where required.
  *
  * Files projected:
- *   .agents/ACE/agent-state/handoff-registry.json
- *   .agents/ACE/agent-state/todo-state.json       ← schema: { version, updated_at, order[], nodes{} }
- *   .agents/ACE/agent-state/run-ledger.json        ← schema: { version, updated_at, entries[] }
- *   .agents/ACE/agent-state/STATUS_EVENTS.ndjson   ← schema: StatusEventRecord per line
- *   .agents/ACE/agent-state/vericify/process-posts.json
+ *   agent-state/handoff-registry.json
+ *   agent-state/todo-state.json       ← schema: { version, updated_at, order[], nodes{} }
+ *   agent-state/run-ledger.json       ← schema: { version, updated_at, entries[] }
+ *   agent-state/STATUS_EVENTS.ndjson  ← schema: StatusEventRecord per line
+ *   agent-state/vericify/process-posts.json
  */
 import { AcePackedStore } from "../ace-packed-store.js";
 export declare class VericifyProjector {

package/dist/store/materializers/vericify-projector.js

@@ -4,15 +4,15 @@
  * Writes 5 Vericify-facing files from store state on every relevant mutation.
  * These are MIRRORS only — the store is source of truth.
  *
- * All files live under .agents/ACE/ (the canonical ACE namespace as defined
- * by ACE_ROOT_REL in helpers.ts and remapped via ACE_MANAGED_PREFIXES).
+ * Runtime-facing state projections now live under top-level agent-state/.
+ * Host/task scaffolding remains under .agents/ACE/ where required.
  *
  * Files projected:
- *   .agents/ACE/agent-state/handoff-registry.json
- *   .agents/ACE/agent-state/todo-state.json       ← schema: { version, updated_at, order[], nodes{} }
- *   .agents/ACE/agent-state/run-ledger.json        ← schema: { version, updated_at, entries[] }
- *   .agents/ACE/agent-state/STATUS_EVENTS.ndjson   ← schema: StatusEventRecord per line
- *   .agents/ACE/agent-state/vericify/process-posts.json
+ *   agent-state/handoff-registry.json
+ *   agent-state/todo-state.json       ← schema: { version, updated_at, order[], nodes{} }
+ *   agent-state/run-ledger.json       ← schema: { version, updated_at, entries[] }
+ *   agent-state/STATUS_EVENTS.ndjson  ← schema: StatusEventRecord per line
+ *   agent-state/vericify/process-posts.json
  */
 import { createHash, randomUUID } from "crypto";
 import { HandoffRepository } from "../repositories/handoff-repository.js";
@@ -21,9 +21,9 @@ import { LedgerRepository } from "../repositories/ledger-repository.js";
 import { TrackerRepository } from "../repositories/tracker-repository.js";
 import { VericifyRepository } from "../repositories/vericify-repository.js";
 import { operationalArtifactKey } from "../store-artifacts.js";
-// Canonical ACE state root — mirrors helpers.ts ACE_ROOT_REL + ACE_MANAGED_PREFIXES remapping
-const ACE_ROOT = ".agents/ACE";
-const ACE_STATE_ROOT = `${ACE_ROOT}/agent-state`;
+// Runtime-facing state now lives in top-level agent-state/.
+const ACE_STATE_ROOT = "agent-state";
+const ACE_TASKS_ROOT = ".agents/ACE/tasks";
 const CHECKSUMS_KEY = "host/materializations/checksums";
 function sha256(content) {
     return createHash("sha256").update(content, "utf8").digest("hex");
@@ -101,7 +101,7 @@ export class VericifyProjector {
         const content = JSON.stringify({
             version: 1,
             updated_at: new Date().toISOString(),
-            source_todo_path: `${ACE_ROOT}/tasks/todo.md`,
+            source_todo_path: `${ACE_TASKS_ROOT}/todo.md`,
             order,
             nodes,
         }, null, 2);