@voybio/ace-swarm 2.4.8 → 2.4.10

package/dist/store/bootstrap-store.js

@@ -99,7 +99,7 @@ async function materializeStoreSurfaces(store, workspaceRoot, opts) {
     await todoSyncer.initStarter();
     await store.commit();
     const projections = new ProjectionManager(store, workspaceRoot);
-    await projections.projectAfterCommit(["hook_context", "todo_state", "scheduler", "context_snapshots"]);
+    await projections.projectAfterCommit(["vericify_posts", "hook_context", "todo_state", "scheduler", "context_snapshots"]);
     materialized.push(join(workspaceRoot, ".agents", "ACE", "tasks", "todo.md"));
     return [...new Set(materialized)];
 }
@@ -113,6 +113,8 @@ const GATE_CONTRACT_OPERATIONAL_ARTIFACT_RELS = [
 async function seedOperationalArtifacts(store) {
     const bootstrapTs = new Date().toISOString();
     for (const relPath of OPERATIONAL_ARTIFACT_REL_PATHS) {
+        if (await store.getBlob(operationalArtifactKey(relPath)) !== undefined)
+            continue;
         const knowledgeKey = `knowledge/agent-state/${relPath.replace(/^agent-state\//, "")}`;
         let content = relPath.endsWith("-archive.ndjson")
             ? ""
@@ -156,6 +158,7 @@ export async function bootstrapStoreWorkspace(opts) {
             try {
                 await migrateExistingStoreGateContract(existingStore, workspaceRoot, assetsRoot, warnings);
                 if (!(opts.includeMcpConfig ?? false) && !(opts.includeClientConfigBundle ?? false) && !opts.llm) {
+                    await existingStore.commit();
                     const agents = (await existingStore.listAgents()).length;
                     warnings.push(`Reused existing store at ${storePath}. Refreshed package gate contract state.`);
                     return { storePath, agents, modules: { gates: 0, roles: 0, schemas: 0 }, materialized, warnings };
@@ -166,7 +169,7 @@ export async function bootstrapStoreWorkspace(opts) {
                 return { storePath, agents, modules: { gates: 0, roles: 0, schemas: 0 }, materialized, warnings };
             }
             finally {
-                await existingStore.close();
+                await existingStore.close({ commit: false });
             }
         }
         for (const dir of [
@@ -197,7 +200,9 @@ export async function bootstrapStoreWorkspace(opts) {
             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", []);
+            if (await store.getBlob("state/vericify/posts/index") === undefined) {
+                await store.setJSON("state/vericify/posts/index", []);
+            }
             await applyLlmRuntimeConfig(store, opts);
             await seedOperationalArtifacts(store);
             await buildCatalog(store);
@@ -214,7 +219,7 @@ export async function bootstrapStoreWorkspace(opts) {
             };
         }
         finally {
-            await store.close();
+            await store.close({ commit: false });
         }
     }, { operation_label: "bootstrapStoreWorkspace" });
 }
@@ -303,7 +308,7 @@ export async function repairWorkspace(workspaceRoot) {
         warnings.push(`repair error: ${e.message}`);
     }
     finally {
-        await store.close();
+        await store.close({ commit: false });
     }
     return warnings;
 }
@@ -318,13 +323,15 @@ export async function compactWorkspace(workspaceRoot, options = {}) {
     const { storePath } = resolved;
     const { statSync } = await import("fs");
     const before = statSync(storePath).size;
-    const store = await openStore(storePath);
-    try {
-        await store.compact();
-    }
-    finally {
-        await store.close();
-    }
+    await withStoreWriteCoordinator(storePath, async () => {
+        const store = await openStore(storePath);
+        try {
+            await store.compact();
+        }
+        finally {
+            await store.close({ commit: false });
+        }
+    }, { operation_label: "compactWorkspace" });
     const after = statSync(storePath).size;
     const sweep = options.sweep === false
         ? undefined

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

@@ -25,6 +25,14 @@ export interface CacheWorkspaceResult {
         key: string;
         bytes: number;
     }>;
+    verified_sources: Array<{
+        path: string;
+        sha256: string;
+        source_key: string;
+        target_key: string;
+        receipt_key: string;
+        removed: boolean;
+    }>;
 }
 export declare function cacheWorkspaceArtifacts(workspaceRoot: string, options?: CacheWorkspaceOptions): Promise<CacheWorkspaceResult>;
 //# sourceMappingURL=cache-workspace.d.ts.map

package/dist/store/cache-workspace.js

@@ -1,9 +1,11 @@
-import { existsSync, readdirSync, readFileSync, rmSync, statSync } from "node:fs";
+import { existsSync, readdirSync, rmSync, statSync } 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";
+import { getWorkspaceStorePath, readStoreBlobByPathSync, readStoreJsonByPathSync } from "./store-snapshot.js";
+import { openStore } from "./ace-packed-store.js";
+import { withStoreWriteCoordinator } from "./write-coordinator.js";
+import { captureWorkspaceSource, preservedSourceKey, sourceUnchanged, stagePreservedSource, verifyPreservedSource } from "./source-preservation.js";
 const SCAN_ROOTS_REL = [
     "agent-state",
     ".agents/ACE/agent-state",
@@ -146,8 +148,17 @@ export async function cacheWorkspaceArtifacts(workspaceRoot, options = {}) {
                 keptProjected += 1;
                 continue;
             }
-            const raw = readFileSync(absPath);
-            if (!isTextBuffer(raw)) {
+            let source;
+            try {
+                source = captureWorkspaceSource(workspaceRoot, absPath);
+            }
+            catch (error) {
+                skipped += 1;
+                warnings.push(`Kept unstable source ${relPath}: ${error.message}`);
+                continue;
+            }
+            const raw = Buffer.from(source.content_base64, "base64");
+            if (!isTextBuffer(raw) || !Buffer.from(raw.toString("utf8"), "utf8").equals(raw)) {
                 skipped += 1;
                 warnings.push(`Skipped non-text artifact: ${canonicalPath}`);
                 continue;
@@ -164,32 +175,87 @@ export async function cacheWorkspaceArtifacts(workspaceRoot, options = {}) {
                 key: fallbackKeys[0],
                 content: raw.toString("utf-8"),
                 bytes: raw.byteLength,
+                source,
             });
         }
     }
-    const dedupByKey = new Map();
+    const byKey = 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" });
+        const group = byKey.get(candidate.key) ?? [];
+        group.push(candidate);
+        byKey.set(candidate.key, group);
     }
     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);
-        }
+    const cached = [];
+    const verifiedSources = [];
+    if (!dryRun && candidates.length > 0) {
+        await withStoreWriteCoordinator(storePath, async () => {
+            const store = await openStore(storePath);
+            try {
+                for (const group of byKey.values()) {
+                    if (new Set(group.map((candidate) => candidate.source.sha256)).size > 1) {
+                        warnings.push(`Fallback-key collision at ${group[0].key}; kept all sources: ${group.map((c) => c.source.source_path).join(", ")}`);
+                        continue;
+                    }
+                    for (const candidate of group) {
+                        if (!sourceUnchanged(workspaceRoot, candidate.absPath, candidate.source)) {
+                            warnings.push(`Source changed since scan; kept ${candidate.source.source_path}`);
+                            continue;
+                        }
+                        await stagePreservedSource(store, candidate.source);
+                        const existing = await store.getBlob(candidate.key);
+                        if (existing !== undefined && existing !== candidate.content) {
+                            warnings.push(`Canonical content conflict at ${candidate.key}; kept ${candidate.source.source_path}`);
+                            continue;
+                        }
+                        if (existing === undefined)
+                            await store.setBlob(candidate.key, candidate.content);
+                        cached.push(candidate);
+                    }
+                }
+                await store.commit();
+                // Independent committed-file readback precedes the durable receipt.
+                for (const candidate of cached) {
+                    verifyPreservedSource(storePath, candidate.source);
+                    if (readStoreBlobByPathSync(storePath, candidate.key) !== candidate.content) {
+                        throw new Error(`Canonical readback failed: ${candidate.source.source_path}`);
+                    }
+                    const sourceKey = preservedSourceKey(candidate.source);
+                    const receiptKey = sourceKey.replace("/sources/", "/receipts/");
+                    await store.setJSON(receiptKey, {
+                        source_key: sourceKey, target_key: candidate.key,
+                        sha256: candidate.source.sha256, identity: candidate.source.identity,
+                        verified_at: new Date().toISOString(),
+                    });
+                    verifiedSources.push({ path: candidate.source.source_path, sha256: candidate.source.sha256, source_key: sourceKey, target_key: candidate.key, receipt_key: receiptKey, removed: false });
+                }
+                await store.commit();
+                // No awaits between the final source identity check and unlink.
+                for (let i = 0; i < cached.length; i++) {
+                    const candidate = cached[i];
+                    const receipt = verifiedSources[i];
+                    const committedReceipt = readStoreJsonByPathSync(storePath, receipt.receipt_key);
+                    verifyPreservedSource(storePath, candidate.source);
+                    if (committedReceipt?.sha256 !== receipt.sha256 || committedReceipt.target_key !== candidate.key || readStoreBlobByPathSync(storePath, candidate.key) !== candidate.content) {
+                        throw new Error(`Migration receipt readback failed: ${candidate.source.source_path}`);
+                    }
+                    if (!clean)
+                        continue;
+                    if (!sourceUnchanged(workspaceRoot, candidate.absPath, candidate.source)) {
+                        warnings.push(`Source changed before removal; kept ${candidate.source.source_path}`);
+                        continue;
+                    }
+                    rmSync(candidate.absPath);
+                    receipt.removed = true;
+                    removed += 1;
+                    const pruneRoot = scanRoots.find((root) => isInside(root, candidate.absPath)) ?? workspaceRoot;
+                    pruneEmptyParents(candidate.absPath, pruneRoot);
+                }
+            }
+            finally {
+                await store.close({ commit: false });
+            }
+        }, { operation_label: "cacheWorkspace" });
     }
     const removedSemanticCache = gcSemanticCache
         ? removeSemanticCache(workspaceRoot, minAgeMs, dryRun)
@@ -199,13 +265,14 @@ export async function cacheWorkspaceArtifacts(workspaceRoot, options = {}) {
         dry_run: dryRun,
         clean,
         scanned_files: scanned,
-        cached_files: candidates.length,
+        cached_files: dryRun ? candidates.length : cached.length,
         removed_files: removed,
         removed_semantic_cache_files: removedSemanticCache,
         kept_projected_files: keptProjected,
         skipped_files: skipped,
         warnings,
-        cached: candidates.map((candidate) => ({
+        verified_sources: verifiedSources,
+        cached: (dryRun ? candidates : cached).map((candidate) => ({
             path: candidate.canonicalPath,
             key: candidate.key,
             bytes: candidate.bytes,

package/dist/store/importer.js

@@ -14,7 +14,8 @@ import { HandoffRepository } from "./repositories/handoff-repository.js";
 import { TodoRepository } from "./repositories/todo-repository.js";
 import { LedgerRepository } from "./repositories/ledger-repository.js";
 import { TrackerRepository } from "./repositories/tracker-repository.js";
-import { VericifyRepository } from "./repositories/vericify-repository.js";
+import { preserveLegacyVericifyPosts } from "./legacy-vericify-posts.js";
+import { withStoreWriteCoordinator } from "./write-coordinator.js";
 function readJSON(path) {
     if (!existsSync(path))
         return undefined;
@@ -36,6 +37,11 @@ function readText(path) {
     }
 }
 export async function importFromFileWorkspace(workspaceRoot, storePath) {
+    return withStoreWriteCoordinator(storePath, () => importFileWorkspaceLocked(workspaceRoot, storePath), {
+        operation_label: "importFromFileWorkspace",
+    });
+}
+async function importFileWorkspaceLocked(workspaceRoot, storePath) {
     const result = {
         handoffs: 0,
         todos: 0,
@@ -50,7 +56,6 @@ export async function importFromFileWorkspace(workspaceRoot, storePath) {
         const todoRepo = new TodoRepository(store);
         const ledgerRepo = new LedgerRepository(store);
         const trackerRepo = new TrackerRepository(store);
-        const vericifyRepo = new VericifyRepository(store);
         await ledgerRepo.init();
         // ── Handoffs ──────────────────────────────────────────────────────────
         const handoffReg = readJSON(join(workspaceRoot, "agent-state", "handoff-registry.json"));
@@ -129,28 +134,14 @@ export async function importFromFileWorkspace(workspaceRoot, storePath) {
             }
         }
         // ── Vericify Posts ────────────────────────────────────────────────────
-        const postsFile = readJSON(join(workspaceRoot, "agent-state", "vericify", "process-posts.json"));
-        if (postsFile?.posts) {
-            for (const post of postsFile.posts) {
-                try {
-                    await vericifyRepo.appendPost({
-                        run_id: String(post.run_id ?? "migrated"),
-                        agent_id: String(post.agent_id ?? "unknown"),
-                        kind: post.kind ?? "completion",
-                        summary: String(post.summary ?? ""),
-                    });
-                    result.vericify_posts++;
-                }
-                catch (e) {
-                    result.warnings.push(`vericify post: ${e.message}`);
-                }
-            }
-        }
+        const legacy = await preserveLegacyVericifyPosts(store, workspaceRoot, storePath);
+        result.vericify_posts = legacy.imported;
+        result.warnings.push(...legacy.warnings);
         await store.commit();
         await store.compact();
     }
     finally {
-        await store.close();
+        await store.close({ commit: false });
     }
     return result;
 }

package/dist/store/knowledge-bake.d.ts

@@ -31,7 +31,9 @@ export declare function bakeTaskArtifacts(store: AcePackedStore, assetsRoot: str
     tasks: number;
     runtime: number;
 }>;
-export declare function bakeSkillPack(store: AcePackedStore, assetsRoot: string, skillName: string): Promise<number>;
+export declare function bakeSkillPack(store: AcePackedStore, assetsRoot: string, skillName: string, options?: {
+    onSkip?: (key: string) => void;
+}): Promise<number>;
 export declare function listAvailableSkills(assetsRoot: string): Promise<string[]>;
 export declare function bakeAllCoreKnowledge(store: AcePackedStore, assetsRoot: string): Promise<{
     agents: {

package/dist/store/knowledge-bake.js

@@ -292,17 +292,26 @@ export async function bakeTaskArtifacts(store, assetsRoot) {
     return { state, tasks, runtime };
 }
 // ── Skills ───────────────────────────────────────────────────────────────────
-export async function bakeSkillPack(store, assetsRoot, skillName) {
+export async function bakeSkillPack(store, assetsRoot, skillName, options = {}) {
     const skillDir = join(assetsRoot, ".agents", "skills", skillName);
     if (!existsSync(skillDir)) {
         throw new Error(`[knowledge-bake] skill pack not found: ${skillName} at ${skillDir}`);
     }
     let fileCount = 0;
+    const prefix = `knowledge/skills/${skillName}/`;
+    const owners = new Map((await store.getEntries({ keyPrefix: prefix })).map((entry) => [entry.key, entry.content_source]));
     for (const filePath of walkDir(skillDir)) {
         const ext = extname(filePath);
         if (!MARKDOWN_EXTS.has(ext))
             continue;
         const relPath = relative(skillDir, filePath);
+        const key = `${prefix}${relPath.replaceAll("\\", "/")}`;
+        const existing = await store.getBlob(key);
+        if (key.startsWith("knowledge/skills/learned/") || (existing !== undefined && owners.get(key) !== ContentSource.Package)) {
+            options.onSkip?.(key);
+            console.log(`[knowledge-bake] skipped user-owned file: ${key}`);
+            continue;
+        }
         const content = readText(filePath);
         await store.setSkillContent(skillName, relPath, content, ContentSource.Package);
         fileCount++;

package/dist/store/legacy-vericify-posts.d.ts

@@ -0,0 +1,8 @@
+import type { AcePackedStore } from "./ace-packed-store.js";
+/** Caller owns the store coordinator. No projection or unlink is performed here. */
+export declare function preserveLegacyVericifyPosts(store: AcePackedStore, root: string, storePath?: string): Promise<{
+    imported: number;
+    canProject: boolean;
+    warnings: string[];
+}>;
+//# sourceMappingURL=legacy-vericify-posts.d.ts.map

package/dist/store/legacy-vericify-posts.js

@@ -0,0 +1,76 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { operationalArtifactKey } from "./store-artifacts.js";
+import { VericifyRepository, projectVericifyPost } from "./repositories/vericify-repository.js";
+import { captureWorkspaceSource, sourceFromBytes, stagePreservedSource, verifyPreservedSource } from "./source-preservation.js";
+import { getWorkspaceStorePath, readStoreJsonByPathSync } from "./store-snapshot.js";
+import { isDeepStrictEqual } from "node:util";
+const REL = "agent-state/vericify/process-posts.json";
+/** Caller owns the store coordinator. No projection or unlink is performed here. */
+export async function preserveLegacyVericifyPosts(store, root, storePath = getWorkspaceStorePath(root)) {
+    const warnings = [];
+    const sources = [];
+    const loose = join(root, REL);
+    let canProject = true;
+    if (existsSync(loose)) {
+        try {
+            sources.push(captureWorkspaceSource(root, loose));
+        }
+        catch (error) {
+            warnings.push(`Kept legacy posts: ${error.message}`);
+            canProject = false;
+        }
+    }
+    const packed = await store.getBlob(operationalArtifactKey(REL));
+    const checksums = await store.getJSON("host/materializations/checksums");
+    const repo = new VericifyRepository(store);
+    if (packed?.trim()) {
+        const source = sourceFromBytes(`${REL}#prior-store-value`, Buffer.from(packed));
+        let represented = false;
+        if (checksums?.["vericify/process-posts.json"]?.hash === source.sha256) {
+            try {
+                const prior = JSON.parse(packed);
+                const records = new Map((await repo.list()).map((p) => [p.id, JSON.parse(JSON.stringify(projectVericifyPost(p)))]));
+                represented = Array.isArray(prior.posts) && prior.posts.every((p) => isDeepStrictEqual(records.get(String(p.process_post_id ?? p.id)), p));
+            }
+            catch { /* Unverified content is preserved below, never projected over. */ }
+        }
+        if (!represented && !sources.some((s) => s.sha256 === source.sha256))
+            sources.push(source);
+    }
+    const expected = new Map();
+    let imported = 0;
+    for (const source of sources) {
+        await stagePreservedSource(store, source);
+        try {
+            const parsed = JSON.parse(Buffer.from(source.content_base64, "base64").toString("utf8"));
+            if (!parsed || !Array.isArray(parsed.posts))
+                throw new Error("Expected a posts array");
+            for (const post of parsed.posts) {
+                if (!post || typeof post !== "object" || Array.isArray(post))
+                    throw new Error("Invalid historical post");
+                const record = await repo.importPost(post);
+                expected.set(record.id, post);
+                imported += 1;
+            }
+        }
+        catch (error) {
+            canProject = false;
+            warnings.push(`Legacy post projection retained: ${error.message}`);
+        }
+    }
+    if (sources.length > 0) {
+        await store.commit();
+        for (const source of sources)
+            verifyPreservedSource(storePath, source);
+        const index = readStoreJsonByPathSync(storePath, "state/vericify/posts/index") ?? [];
+        for (const [id, original] of expected) {
+            const actual = readStoreJsonByPathSync(storePath, `state/vericify/posts/${id}`);
+            const retained = actual && (actual.legacy_record ?? JSON.parse(JSON.stringify(projectVericifyPost(actual))));
+            if (!index.includes(id) || !isDeepStrictEqual(retained, original))
+                throw new Error(`Historical post readback failed: ${id}`);
+        }
+    }
+    return { imported, canProject, warnings };
+}
+//# sourceMappingURL=legacy-vericify-posts.js.map

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

@@ -7,9 +7,10 @@
 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);
+    constructor(store: AcePackedStore, workspaceRoot: string);
     private buildSnapshot;
     stageStoreProjection(): Promise<void>;
     private _readContent;

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

@@ -4,6 +4,7 @@
  * Stages the compact hook snapshot into ace-state.ace so hook clients can
  * read a single runtime payload without extra workspace projections.
  */
+import { resolveCurrentWork, formatCurrentWork } from "../../ace-autonomy.js";
 import { RuntimeKVRepository } from "../repositories/runtime-kv-repository.js";
 function fnv1a(s) {
     let h = 2166136261;
@@ -15,10 +16,12 @@ function fnv1a(s) {
 }
 export class HookContextMaterializer {
     store;
+    workspaceRoot;
     static STORE_KEY = "state/runtime/hook_context";
     kv;
-    constructor(store) {
+    constructor(store, workspaceRoot) {
         this.store = store;
+        this.workspaceRoot = workspaceRoot;
         this.kv = new RuntimeKVRepository(store);
     }
     async buildSnapshot() {
@@ -32,6 +35,7 @@ export class HookContextMaterializer {
         return {
             schema_version: 1,
             generated_at: new Date().toISOString(),
+            current_work: formatCurrentWork(resolveCurrentWork({ workspaceRoot: this.workspaceRoot }), "block"),
             task: { content: task, hash: fnv1a(task) },
             status: { content: status, hash: fnv1a(status) },
             scope: { content: scope, hash: fnv1a(scope) },
@@ -59,7 +63,7 @@ export class HookContextMaterializer {
             evidence_log: "knowledge/agent-state/EVIDENCE_LOG.md",
         };
         const fallbackKey = fallback[kind];
-        return fallbackKey ? (await this.store.getBlob(fallbackKey)) ?? "" : "";
+        return fallbackKey ? (await this.store.getBlob(fallbackKey.replace("knowledge/", "state/artifacts/"))) ?? (await this.store.getBlob(fallbackKey)) ?? "" : "";
     }
     async _readKernelWorkflow() {
         return ((await this.store.getBlob("knowledge/runtime/ACE_WORKFLOW.md")) ??

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

@@ -8,7 +8,7 @@
  */
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
+import { fileURLToPath, pathToFileURL } from "node:url";
 import { buildHostInstructionText } from "../../ace-server-instructions.js";
 import { ALL_MCP_CLIENTS, getAllMcpServerConfigSnippets, getMcpClientInstallHint, getMcpServerConfigSnippet, } from "../../helpers.js";
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -186,7 +186,7 @@ export class HostFileMaterializer {
             return {
                 absPath: this.ace("scripts", "ace", scriptName),
                 keyParts: [".agents", "ACE", "scripts", "ace", scriptName],
-                fallbackContent: readFileSync(src, "utf8"),
+                fallbackContent: readFileSync(src, "utf8").replace("__ACE_AUTONOMY_MODULE_URL__", pathToFileURL(resolve(__dirname, "..", "..", "ace-autonomy.js")).href),
             };
         });
     }

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

@@ -1,4 +1,5 @@
 import { AcePackedStore } from "../ace-packed-store.js";
+import { type TodoProjectionResult } from "./todo-syncer.js";
 export type RuntimeProjectionTarget = "context_snapshots" | "handoffs" | "ledger" | "scheduler" | "status_events" | "todo_state" | "vericify_posts" | "hook_context";
 /**
  * Awaitable handle for the detached lifecycle sweep. CLI entry points and
@@ -15,6 +16,8 @@ export declare class ProjectionManager {
     private scheduler;
     private static lifecycleSweepActive;
     constructor(store: AcePackedStore, workspaceRoot: string);
-    projectAfterCommit(targets: readonly RuntimeProjectionTarget[]): Promise<void>;
+    projectAfterCommit(targets: readonly RuntimeProjectionTarget[]): Promise<{
+        todo?: TodoProjectionResult;
+    }>;
 }
 //# sourceMappingURL=projection-manager.d.ts.map

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

@@ -27,10 +27,11 @@ export class ProjectionManager {
         this.workspaceRoot = workspaceRoot;
         this.vericify = new VericifyProjector(store, workspaceRoot);
         this.todoSyncer = new TodoSyncer(store, workspaceRoot);
-        this.hookContext = new HookContextMaterializer(store);
+        this.hookContext = new HookContextMaterializer(store, workspaceRoot);
         this.scheduler = new SchedulerProjectionMaterializer(store, workspaceRoot);
     }
     async projectAfterCommit(targets) {
+        const result = {};
         const uniqueTargets = [...new Set(targets)];
         let stagedStoreWrites = false;
         let renderedScheduler;
@@ -81,7 +82,11 @@ export class ProjectionManager {
             // REPORT_STORE_WIRING_MITIGATIONS_2026-07-09.md F1). The detached promise
             // is exposed via waitForPendingLifecycleSweep() for CLI/test flows.
             pendingLifecycleSweep = cacheWorkspaceArtifacts(workspaceRoot, {
-                clean: true,
+                // Automatic discovery must not ingest over live state or remove an
+                // unverified loose source. Explicit cache/compact uses verified migration.
+                dryRun: true,
+                clean: false,
+                gcSemanticCache: false,
                 minAgeMs: 5 * 60 * 1000,
             })
                 .then(() => undefined)
@@ -94,9 +99,11 @@ export class ProjectionManager {
         }
         for (const target of uniqueTargets) {
             if (target === "todo_state") {
-                await this.todoSyncer.writeToFile();
+                result.todo = await this.todoSyncer.writeToFile();
+                await this.store.commit();
             }
         }
+        return result;
     }
 }
 //# sourceMappingURL=projection-manager.js.map

package/dist/store/materializers/todo-syncer.d.ts

@@ -1,30 +1,49 @@
-/**
- * TodoSyncer
- *
- * Bidirectional sync between tasks/todo.md (human-editable) and the store.
- *
- * - On write: store → tasks/todo.md (ACE writes todo state from store)
- * - On read: tasks/todo.md → store (if externally modified by mtime + hash)
- *
- * tasks/todo.md format:
- *   - [ ] Todo item title (id: todo-001)
- *   - [x] Completed item (id: todo-002)
- *   - [~] In progress (id: todo-003)
- *   - [!] Blocked (id: todo-004)
- */
 import { AcePackedStore } from "../ace-packed-store.js";
+import { type TodoNode } from "../repositories/todo-repository.js";
+export declare const STATUS_ICONS: Record<TodoNode["status"], string>;
+export declare const ICON_STATUS: Record<string, TodoNode["status"]>;
+export interface TodoImportResult {
+    changed: boolean;
+    import_warnings: string[];
+}
+export interface TodoProjectionResult {
+    written: boolean;
+    import_warnings: string[];
+}
+interface ParsedTodo {
+    raw_line: string;
+    id?: string;
+    title: string;
+    status: TodoNode["status"];
+    section?: string;
+    source_line: number;
+    depends_on?: string[];
+    priority?: TodoNode["priority"];
+    assigned_to?: string;
+    notes?: string;
+}
+export declare function parseTodoMd(content: string): {
+    items: ParsedTodo[];
+    import_warnings: string[];
+};
+export declare function renderTodoMd(todos: TodoNode[]): string;
 export declare class TodoSyncer {
     private store;
     private workspaceRoot;
     private repo;
-    private lastHash;
+    private submittedStamp?;
     private todoMdPath;
     constructor(store: AcePackedStore, workspaceRoot: string);
-    /** Write store todo state → tasks/todo.md */
-    writeToFile(): Promise<void>;
-    /** Check if tasks/todo.md was modified externally, and if so ingest changes */
-    syncFromFile(): Promise<boolean>;
-    /** Initialize todo.md with starter content if it doesn't exist */
+    private stamp;
+    private setStamp;
+    /** Stage a non-destructive native import. The caller owns commit/discard and the coordinator. */
+    syncFromFile(content?: string, force?: boolean, observeNative?: boolean): Promise<TodoImportResult>;
+    /** Supplied content is an observation only after its file publication succeeds. */
+    acknowledgeSubmittedFile(content: string): Promise<void>;
+    projectionIsCurrent(): Promise<boolean>;
+    /** Do not overwrite unimported edits or malformed source text. */
+    writeToFile(): Promise<TodoProjectionResult>;
     initStarter(): Promise<void>;
 }
+export {};
 //# sourceMappingURL=todo-syncer.d.ts.map