@voybio/ace-swarm 0.2.4 → 2.4.0

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));
@@ -91,12 +93,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 +113,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 +231,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.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,149 @@
+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 { getWorkspaceStorePath } from "./store-snapshot.js";
+import { writeStoreBlobsQueued } 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));
+}
+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 = getWorkspaceStorePath(workspaceRoot);
+    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 (!isCacheableAcePath(canonicalPath)) {
+                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) {
+        await writeStoreBlobsQueued(workspaceRoot, uniqueForWrite.map((candidate) => ({
+            key: candidate.key,
+            content: candidate.content,
+        })), { operation_label: "cacheWorkspace" });
+    }
+    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

@@ -19,18 +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 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`);
-        }
+        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,
@@ -39,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 (retained.has(file))
+            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 {