@voybio/ace-swarm 0.2.0 → 0.2.1

package/dist/helpers.js

@@ -3,12 +3,12 @@
  */
 import { copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync, renameSync, writeFileSync, } from "node:fs";
 import { homedir } from "node:os";
-import { dirname, isAbsolute, relative, resolve } from "node:path";
+import { dirname, isAbsolute, join, relative, resolve } from "node:path";
 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, writeOperationalArtifactSync, } from "./store/store-artifacts.js";
+import { isOperationalArtifactPath, operationalArtifactKey, writeStoreBlobSync, writeOperationalArtifactSync, } from "./store/store-artifacts.js";
 import { buildOpenAiCompatibleBaseUrl, DEFAULT_LLAMA_CPP_MODEL, DEFAULT_OLLAMA_MODEL, normalizeLocalBaseUrl, } from "./tui/provider-discovery.js";
 export { isInside, isReadError, normalizeRelPath, looksLikeSwarmHandoffPath } from "./shared.js";
 const __filename = fileURLToPath(import.meta.url);
@@ -24,9 +24,49 @@ function normalizeWorkspaceRootCandidate(candidate) {
 function isFilesystemRoot(path) {
     return dirname(path) === path;
 }
+function normalizeWorkspaceRootLikePath(candidate) {
+    const resolvedCandidate = resolve(candidate);
+    if (resolvedCandidate.endsWith(join(".agents", "ACE", "ace-state.ace"))) {
+        return dirname(dirname(dirname(resolvedCandidate)));
+    }
+    if (resolvedCandidate.endsWith(join(".agents", "ACE"))) {
+        return dirname(dirname(resolvedCandidate));
+    }
+    if (resolvedCandidate.endsWith(join(".agents"))) {
+        return dirname(resolvedCandidate);
+    }
+    return resolvedCandidate;
+}
+function hasInitiatedAceWorkspace(root) {
+    return (existsSync(resolve(root, ".agents", "ACE", "ace-state.ace")) ||
+        existsSync(resolve(root, ".agents", "ACE")) ||
+        existsSync(resolve(root, "agent-state", "TASK.md")) ||
+        existsSync(resolve(root, "agent-state", "STATUS.md")));
+}
+function findNearestInitiatedWorkspaceRoot(candidate) {
+    let cursor = normalizeWorkspaceRootLikePath(candidate);
+    while (true) {
+        if (existsSync(cursor) && hasInitiatedAceWorkspace(cursor)) {
+            return cursor;
+        }
+        const parent = dirname(cursor);
+        if (parent === cursor)
+            break;
+        cursor = parent;
+    }
+    return undefined;
+}
+function pinWorkspaceRoot(root) {
+    const normalized = normalizeWorkspaceRootLikePath(root);
+    process.env.ACE_WORKSPACE_ROOT = normalized;
+    return normalized;
+}
 export function resolveWorkspaceRoot() {
+    const explicit = normalizeWorkspaceRootCandidate(process.env.ACE_WORKSPACE_ROOT);
+    if (explicit)
+        return pinWorkspaceRoot(findNearestInitiatedWorkspaceRoot(explicit) ?? explicit);
     const ordered = [
-        process.env.ACE_WORKSPACE_ROOT,
+        process.env.ACE_TUI_WORKSPACE_ROOT,
         process.env.INIT_CWD,
         process.env.PWD,
         process.cwd(),
@@ -34,13 +74,18 @@ export function resolveWorkspaceRoot() {
         .map(normalizeWorkspaceRootCandidate)
         .filter((candidate) => Boolean(candidate));
     const candidates = [...new Set(ordered)];
+    for (const candidate of candidates) {
+        const initiated = findNearestInitiatedWorkspaceRoot(candidate);
+        if (initiated)
+            return pinWorkspaceRoot(initiated);
+    }
     const firstExistingNonRoot = candidates.find((candidate) => existsSync(candidate) && !isFilesystemRoot(candidate));
     if (firstExistingNonRoot)
-        return firstExistingNonRoot;
+        return pinWorkspaceRoot(firstExistingNonRoot);
     const firstExisting = candidates.find((candidate) => existsSync(candidate));
     if (firstExisting)
-        return firstExisting;
-    return candidates[0] ?? resolve(process.cwd());
+        return pinWorkspaceRoot(firstExisting);
+    return pinWorkspaceRoot(candidates[0] ?? resolve(process.cwd()));
 }
 export const WORKSPACE_ROOT = resolveWorkspaceRoot();
 function currentWorkspaceRoot() {
@@ -367,6 +412,9 @@ export function fileExists(filePath) {
 }
 export function resolveWorkspaceWritePath(filePath) {
     const root = currentWorkspaceRoot();
+    if (isFilesystemRoot(root)) {
+        throw new Error("Workspace root resolved to filesystem root. Set ACE_WORKSPACE_ROOT or run ACE from the target workspace.");
+    }
     const abs = isAbsolute(filePath)
         ? filePath
         : resolve(root, mapAceWorkspaceRelativePath(filePath));
@@ -477,10 +525,23 @@ function resolveStoreFallbackKeys(filePath) {
     const statePrefix = `${ACE_ROOT_REL}/agent-state/`;
     if (canonical.startsWith(statePrefix)) {
         const rel = canonical.slice(statePrefix.length);
+        const runtimeProjectionKey = {
+            "job-queue.json": "state/artifacts/agent-state/job-queue.json",
+            "job-locks.json": "state/artifacts/agent-state/job-locks.json",
+            "scheduler-lease.json": "state/artifacts/agent-state/scheduler-lease.json",
+        }[rel];
+        if (runtimeProjectionKey)
+            keys.add(runtimeProjectionKey);
         if (staticAgentState.has(rel)) {
             keys.add(`knowledge/agent-state/${rel}`);
         }
     }
+    const contextSnapshotPrefix = `${ACE_ROOT_REL}/agent-state/context-snapshots/`;
+    if (canonical.startsWith(contextSnapshotPrefix)) {
+        const rel = canonical.slice(contextSnapshotPrefix.length);
+        if (rel)
+            keys.add(`state/memory/context_snapshots/${rel}`);
+    }
     const tasksPrefix = `${ACE_TASKS_ROOT_REL}/`;
     if (canonical.startsWith(tasksPrefix)) {
         keys.add(`knowledge/tasks/${canonical.slice(tasksPrefix.length)}`);
@@ -562,12 +623,17 @@ export function safeRead(filePath) {
 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(currentWorkspaceRoot()))) {
-            return writeOperationalArtifactSync(currentWorkspaceRoot(), rel, content);
+        if (isOperationalArtifactPath(rel) && existsSync(getWorkspaceStorePath(root))) {
+            return writeOperationalArtifactSync(root, rel, content);
         }
     }
+    const storeKeys = resolveStoreFallbackKeys(filePath);
+    if (storeKeys.length > 0 && existsSync(getWorkspaceStorePath(root))) {
+        writeStoreBlobSync(root, storeKeys[0], content);
+    }
     const abs = resolveWorkspaceWritePath(filePath);
     mkdirSync(dirname(abs), { recursive: true });
     const tmpPath = `${abs}.${process.pid}.${Date.now()}.tmp`;

package/dist/job-scheduler.js

@@ -1,10 +1,15 @@
 import { randomUUID } from "node:crypto";
 import { readHandoffRegistry } from "./handoff-registry.js";
-import { safeRead, safeWrite, withFileLock, wsPath } from "./helpers.js";
+import { resolveWorkspaceRoot, safeRead, safeWrite, withFileLock, wsPath } from "./helpers.js";
 import { isReadError } from "./shared.js";
 import { appendStatusEventSafe, readStatusEvents } from "./status-events.js";
 import { appendRunLedgerEntrySafe } from "./run-ledger.js";
 import { readTodoState } from "./todo-state.js";
+import { openStore } from "./store/ace-packed-store.js";
+import { ProjectionManager } from "./store/materializers/projection-manager.js";
+import { SchedulerRepository } from "./store/repositories/scheduler-repository.js";
+import { getWorkspaceStorePath, readStoreJsonSync, storeExistsSync, } from "./store/store-snapshot.js";
+import { withStoreWriteQueue } from "./store/write-queue.js";
 // ── Buffered transition-event infrastructure ────────────────────────
 // Events are collected during the scheduler lock and flushed after
 // the lock is released.  Emission is failure-tolerant: a broken
@@ -270,33 +275,63 @@ export function getSchedulerLeasePath() {
     return wsPath(SCHEDULER_LEASE_REL);
 }
 export function readJobQueue() {
+    const root = resolveWorkspaceRoot();
+    if (storeExistsSync(root)) {
+        const stored = readStoreJsonSync(root, "state/scheduler/queue");
+        if (stored)
+            return stored;
+    }
     const raw = safeRead(JOB_QUEUE_REL);
     if (isReadError(raw))
         return defaultQueueFile();
     return parseQueueFile(raw) ?? defaultQueueFile();
 }
 export function readJobLockTable() {
+    const root = resolveWorkspaceRoot();
+    if (storeExistsSync(root)) {
+        const stored = readStoreJsonSync(root, "state/scheduler/locks");
+        if (stored)
+            return stored;
+    }
     const raw = safeRead(JOB_LOCK_TABLE_REL);
     if (isReadError(raw))
         return defaultJobLockFile();
     return parseJobLockFile(raw) ?? defaultJobLockFile();
 }
 export function readSchedulerLease() {
+    const root = resolveWorkspaceRoot();
+    if (storeExistsSync(root)) {
+        const stored = readStoreJsonSync(root, "state/scheduler/lease");
+        if (stored)
+            return stored ?? undefined;
+    }
     const raw = safeRead(SCHEDULER_LEASE_REL);
     if (isReadError(raw))
         return undefined;
     return parseLease(raw);
 }
-function writeQueue(queue) {
-    queue.updated_at = nowIso();
-    return safeWrite(JOB_QUEUE_REL, JSON.stringify(queue, null, 2));
-}
-function writeJobLocks(table) {
-    table.updated_at = nowIso();
-    return safeWrite(JOB_LOCK_TABLE_REL, JSON.stringify(table, null, 2));
-}
-function writeLease(lease) {
-    return safeWrite(SCHEDULER_LEASE_REL, JSON.stringify(lease, null, 2));
+async function persistSchedulerState(input) {
+    const root = resolveWorkspaceRoot();
+    if (!storeExistsSync(root)) {
+        safeWrite(JOB_QUEUE_REL, JSON.stringify({ ...input.queue, updated_at: nowIso() }, null, 2));
+        safeWrite(JOB_LOCK_TABLE_REL, JSON.stringify({ ...input.locks, updated_at: nowIso() }, null, 2));
+        safeWrite(SCHEDULER_LEASE_REL, JSON.stringify(input.lease ?? null, null, 2));
+        return;
+    }
+    const storePath = getWorkspaceStorePath(root);
+    await withStoreWriteQueue(storePath, async () => {
+        const store = await openStore(storePath);
+        try {
+            const repo = new SchedulerRepository(store);
+            await repo.replaceState(input);
+            await store.commit();
+            const projections = new ProjectionManager(store, root);
+            await projections.projectAfterCommit(["scheduler"]);
+        }
+        finally {
+            await store.close();
+        }
+    });
 }
 function compareJobs(a, b) {
     const priorityCmp = PRIORITY_WEIGHT[a.priority] - PRIORITY_WEIGHT[b.priority];
@@ -480,8 +515,7 @@ function defaultLeaseTtlSeconds() {
 function hasActiveLockForJob(locks, jobId) {
     return locks.some((lock) => lock.job_id === jobId && isJobLockActive(lock));
 }
-function acquireLease(owner, ttlSeconds, now) {
-    const existing = readSchedulerLease();
+function acquireLease(existing, owner, ttlSeconds, now) {
     const expiry = new Date(now.getTime() + ttlSeconds * 1000);
     if (!existing) {
         const lease = {
@@ -492,7 +526,6 @@ function acquireLease(owner, ttlSeconds, now) {
             heartbeat_at: nowIso(now),
             expires_at: nowIso(expiry),
         };
-        writeLease(lease);
         return { acquired: true, lease, recovery_mode: false };
     }
     const existingExpiry = parseDate(existing.expires_at);
@@ -506,7 +539,6 @@ function acquireLease(owner, ttlSeconds, now) {
             heartbeat_at: nowIso(now),
             expires_at: nowIso(expiry),
         };
-        writeLease(lease);
         return { acquired: true, lease, recovery_mode: expired };
     }
     return { acquired: false, lease: existing, recovery_mode: false };
@@ -522,7 +554,7 @@ function hasActiveLeaseForOwner(lease, owner, now) {
     return expires.getTime() > now.getTime();
 }
 function ensureLeaseForOwner(owner, now, ttlSeconds = defaultLeaseTtlSeconds()) {
-    const leaseResult = acquireLease(owner, ttlSeconds, now);
+    const leaseResult = acquireLease(readSchedulerLease(), owner, ttlSeconds, now);
     if (!leaseResult.acquired) {
         return leaseResult;
     }
@@ -532,7 +564,6 @@ function ensureLeaseForOwner(owner, now, ttlSeconds = defaultLeaseTtlSeconds())
         heartbeat_at: nowIso(now),
         expires_at: nowIso(new Date(now.getTime() + ttlSeconds * 1000)),
     };
-    writeLease(refreshedLease);
     return {
         ...leaseResult,
         lease: refreshedLease,
@@ -657,7 +688,7 @@ function reconcileRecoveryState(queue, table, now, recoveryMode, buf) {
 }
 export async function enqueueJob(input) {
     const buf = newEventBuffer();
-    const result = await withFileLock(SCHEDULER_LOCK_REL, () => {
+    const result = await withFileLock(SCHEDULER_LOCK_REL, async () => {
         if (!input.kind || input.kind.trim().length === 0) {
             const queue = readJobQueue();
             return {
@@ -715,7 +746,11 @@ export async function enqueueJob(input) {
             accepted_at: created,
         };
         queue.jobs.push(job);
-        const path = writeQueue(queue);
+        await persistSchedulerState({
+            queue,
+            locks: readJobLockTable(),
+            lease: readSchedulerLease(),
+        });
         buf.status.push({
             event_type: "SCHEDULER_JOB_ENQUEUED",
             status: "started",
@@ -741,7 +776,7 @@ export async function enqueueJob(input) {
         });
         return {
             ok: true,
-            path,
+            path: getJobQueuePath(),
             queue,
             ack: {
                 job_id: job.job_id,
@@ -754,7 +789,7 @@ export async function enqueueJob(input) {
 }
 export async function acknowledgeJob(input) {
     const buf = newEventBuffer();
-    const result = await withFileLock(SCHEDULER_LOCK_REL, () => {
+    const result = await withFileLock(SCHEDULER_LOCK_REL, async () => {
         const queue = readJobQueue();
         const job = queue.jobs.find((row) => row.job_id === input.job_id);
         if (!job) {
@@ -794,7 +829,11 @@ export async function acknowledgeJob(input) {
                 }
             }
         }
-        const path = writeQueue(queue);
+        await persistSchedulerState({
+            queue,
+            locks: readJobLockTable(),
+            lease: readSchedulerLease(),
+        });
         buf.status.push({
             event_type: "SCHEDULER_JOB_ACK",
             status: job.status === "canceled" ? "done" : "pass",
@@ -821,7 +860,7 @@ export async function acknowledgeJob(input) {
         });
         return {
             ok: true,
-            path,
+            path: getJobQueuePath(),
             queue,
             from,
             to: job.status,
@@ -832,14 +871,14 @@ export async function acknowledgeJob(input) {
 }
 export async function dispatchJobs(input = {}) {
     const buf = newEventBuffer();
-    const result = await withFileLock(SCHEDULER_LOCK_REL, () => {
+    const result = await withFileLock(SCHEDULER_LOCK_REL, async () => {
         const owner = deriveOwner(input.owner);
         const now = parseDate(input.now_iso) ?? new Date();
         const table = readJobLockTable();
         const leaseTtl = typeof input.lease_ttl_seconds === "number" && input.lease_ttl_seconds > 0
             ? Math.floor(input.lease_ttl_seconds)
             : defaultLeaseTtlSeconds();
-        const leaseResult = acquireLease(owner, leaseTtl, now);
+        const leaseResult = acquireLease(readSchedulerLease(), owner, leaseTtl, now);
         if (!leaseResult.acquired) {
             const queue = readJobQueue();
             return {
@@ -913,9 +952,11 @@ export async function dispatchJobs(input = {}) {
             heartbeat_at: nowIso(now),
             expires_at: nowIso(new Date(now.getTime() + leaseTtl * 1000)),
         };
-        writeLease(refreshedLease);
-        const finalQueuePath = writeQueue(queue);
-        const finalLockPath = writeJobLocks(table);
+        await persistSchedulerState({
+            queue,
+            locks: table,
+            lease: refreshedLease,
+        });
         const summary = {
             total_jobs: queue.jobs.length,
             blocked_jobs: queue.jobs.filter((job) => job.status === "blocked").length,
@@ -954,8 +995,8 @@ export async function dispatchJobs(input = {}) {
             owner,
             lease_acquired: true,
             lease: refreshedLease,
-            queue_path: finalQueuePath,
-            lock_path: finalLockPath,
+            queue_path: getJobQueuePath(),
+            lock_path: getJobLockTablePath(),
             queue,
             locks: table,
             summary,
@@ -966,7 +1007,7 @@ export async function dispatchJobs(input = {}) {
 }
 export async function dispatchJobNow(input) {
     const buf = newEventBuffer();
-    const result = await withFileLock(SCHEDULER_LOCK_REL, () => {
+    const result = await withFileLock(SCHEDULER_LOCK_REL, async () => {
         const owner = deriveOwner(input.owner);
         const now = parseDate(input.now_iso) ?? new Date();
         const leaseResult = ensureLeaseForOwner(owner, now);
@@ -1022,12 +1063,15 @@ export async function dispatchJobNow(input) {
                 job.started_at ??
                 nowIso(now);
             heartbeatRunningLocks(table, leaseResult.lease.lease_id, now);
-            const queuePath = writeQueue(queue);
-            const lockPath = writeJobLocks(table);
+            await persistSchedulerState({
+                queue,
+                locks: table,
+                lease: leaseResult.lease,
+            });
             return {
                 ok: true,
-                queue_path: queuePath,
-                lock_path: lockPath,
+                queue_path: getJobQueuePath(),
+                lock_path: getJobLockTablePath(),
                 queue,
                 locks: table,
                 started_lock: {
@@ -1069,12 +1113,15 @@ export async function dispatchJobNow(input) {
             occupancy.add(resource);
         }
         const startedLock = startJobNow(job, table, leaseResult.lease, now, buf, "dispatch_job_now");
-        const queuePath = writeQueue(queue);
-        const lockPath = writeJobLocks(table);
+        await persistSchedulerState({
+            queue,
+            locks: table,
+            lease: leaseResult.lease,
+        });
         return {
             ok: true,
-            queue_path: queuePath,
-            lock_path: lockPath,
+            queue_path: getJobQueuePath(),
+            lock_path: getJobLockTablePath(),
             queue,
             locks: table,
             started_lock: startedLock,
@@ -1085,7 +1132,7 @@ export async function dispatchJobNow(input) {
 }
 export async function completeJob(input) {
     const buf = newEventBuffer();
-    const result = await withFileLock(SCHEDULER_LOCK_REL, () => {
+    const result = await withFileLock(SCHEDULER_LOCK_REL, async () => {
         const owner = deriveOwner(input.owner);
         const now = parseDate(input.now_iso) ?? new Date();
         const leaseResult = ensureLeaseForOwner(owner, now);
@@ -1170,8 +1217,11 @@ export async function completeJob(input) {
                 job.started_at = undefined;
             }
         }
-        const queuePath = writeQueue(queue);
-        const lockPath = writeJobLocks(table);
+        await persistSchedulerState({
+            queue,
+            locks: table,
+            lease: leaseResult.lease,
+        });
         const finalStatus = job.status;
         const isSuccess = finalStatus === "done";
         buf.status.push({
@@ -1203,8 +1253,8 @@ export async function completeJob(input) {
         });
         return {
             ok: true,
-            queue_path: queuePath,
-            lock_path: lockPath,
+            queue_path: getJobQueuePath(),
+            lock_path: getJobLockTablePath(),
             queue,
             locks: table,
             status: job.status,

package/dist/run-ledger.js

@@ -2,7 +2,7 @@ import { existsSync } from "node:fs";
 import { resolveWorkspaceRoot, safeRead, safeWrite, wsPath, withFileLock, } from "./helpers.js";
 import { isReadError } from "./shared.js";
 import { openStore } from "./store/ace-packed-store.js";
-import { VericifyProjector } from "./store/materializers/vericify-projector.js";
+import { ProjectionManager } from "./store/materializers/projection-manager.js";
 import { LedgerRepository } from "./store/repositories/ledger-repository.js";
 import { withStoreWriteQueue } from "./store/write-queue.js";
 import { getWorkspaceStorePath, listStoreKeysSync, readStoreJsonSync, storeExistsSync, } from "./store/store-snapshot.js";
@@ -234,9 +234,8 @@ export async function appendRunLedgerEntrySafe(input) {
                     },
                 });
                 await store.commit();
-                const projector = new VericifyProjector(store, root);
-                await projector.projectLedger();
-                await store.commit();
+                const projections = new ProjectionManager(store, root);
+                await projections.projectAfterCommit(["ledger"]);
                 return {
                     entry: toLegacyRunLedgerEntryDirect(record),
                     path: operationalArtifactVirtualPath(root, RUN_LEDGER_REL),

package/dist/server.d.ts

@@ -1,6 +1,6 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 export declare const ACE_MCP_SERVER_NAME = "ace-swarm";
-export declare const ACE_MCP_SERVER_VERSION = "1.1.0";
+export declare const ACE_MCP_SERVER_VERSION = "0.2.1";
 export interface CreateAceServerOptions {
     toolGovernance?: boolean;
     instructions?: string;

package/dist/server.js

@@ -7,7 +7,7 @@ import { registerResources } from "./resources.js";
 import { registerTools } from "./tools.js";
 import { backfillHandoffsIntoScheduler } from "./tools-handoff.js";
 export const ACE_MCP_SERVER_NAME = "ace-swarm";
-export const ACE_MCP_SERVER_VERSION = "1.1.0";
+export const ACE_MCP_SERVER_VERSION = "0.2.1";
 export function createAceServer(options = {}) {
     const workspaceRoot = resolveWorkspaceRoot();
     const server = new McpServer({

package/dist/shared.d.ts

@@ -45,9 +45,9 @@ export declare const ROLE_ENUM: z.ZodEnum<{
     release: "release";
 }>;
 export declare const HANDOFF_VALIDATION_MODE: z.ZodOptional<z.ZodEnum<{
+    "agent-state": "agent-state";
     auto: "auto";
     swarm: "swarm";
-    "agent-state": "agent-state";
 }>>;
 export declare const KERNEL_KEY_ENUM: z.ZodEnum<{
     directive_kernel: "directive_kernel";

package/dist/status-events.js

@@ -4,7 +4,7 @@ import { resolveWorkspaceRoot, resolveWorkspaceArtifactPath as resolveWorkspaceA
 import { isReadError } from "./shared.js";
 import { validateStatusEventPayload, PROVENANCE_CRITICAL_EVENT_TYPES } from "./schemas.js";
 import { openStore } from "./store/ace-packed-store.js";
-import { VericifyProjector } from "./store/materializers/vericify-projector.js";
+import { ProjectionManager } from "./store/materializers/projection-manager.js";
 import { TrackerRepository } from "./store/repositories/tracker-repository.js";
 import { getWorkspaceStorePath, listStoreKeysSync, readStoreJsonSync, storeExistsSync, } from "./store/store-snapshot.js";
 import { operationalArtifactVirtualPath } from "./store/store-artifacts.js";
@@ -90,8 +90,7 @@ function rotateIfNeeded(content) {
     safeWriteWorkspaceFile(STATUS_EVENTS_ARCHIVE_REL, archiveFull);
     return lines.join("\n") + "\n";
 }
-async function mirrorStatusEventToStore(event) {
-    const root = workspaceRoot();
+async function mirrorStatusEventToStore(root, event) {
     const storePath = getWorkspaceStorePath(root);
     if (!existsSync(storePath))
         return;
@@ -115,9 +114,8 @@ async function mirrorStatusEventToStore(event) {
                 },
             });
             await store.commit();
-            const projector = new VericifyProjector(store, root);
-            await projector.projectStatusEvents();
-            await store.commit();
+            const projections = new ProjectionManager(store, root);
+            await projections.projectAfterCommit(["status_events"]);
         }
         finally {
             await store.close();
@@ -125,17 +123,17 @@ async function mirrorStatusEventToStore(event) {
     });
 }
 function scheduleStatusEventMirror(event) {
+    const root = workspaceRoot();
     const snapshot = JSON.parse(JSON.stringify(event));
     trackerMirrorChain = trackerMirrorChain
         .catch(() => { })
-        .then(() => mirrorStatusEventToStore(snapshot))
+        .then(() => mirrorStatusEventToStore(root, snapshot))
         .catch(() => { });
 }
 export async function waitForPendingStatusEventMirrors() {
     await trackerMirrorChain.catch(() => { });
 }
-async function appendStatusEventStoreBacked(event) {
-    const root = workspaceRoot();
+async function appendStatusEventStoreBacked(root, event) {
     const storePath = getWorkspaceStorePath(root);
     return withStoreWriteQueue(storePath, async () => {
         const store = await openStore(storePath);
@@ -157,9 +155,8 @@ async function appendStatusEventStoreBacked(event) {
                 },
             });
             await store.commit();
-            const projector = new VericifyProjector(store, root);
-            await projector.projectStatusEvents();
-            await store.commit();
+            const projections = new ProjectionManager(store, root);
+            await projections.projectAfterCommit(["status_events"]);
             return {
                 path: operationalArtifactVirtualPath(root, STATUS_EVENTS_REL_PATH),
                 event,
@@ -187,11 +184,12 @@ export function appendStatusEvent(input) {
  * Use this from async tool handlers where parallel subagents may fire.
  */
 export async function appendStatusEventSafe(input) {
+    const root = workspaceRoot();
     return withDynamicFileLock(STATUS_EVENTS_REL_PATH, async () => {
         const event = buildStatusEvent(input);
         validateStatusEvent(event);
-        if (storeExistsSync(workspaceRoot())) {
-            return appendStatusEventStoreBacked(event);
+        if (storeExistsSync(root)) {
+            return appendStatusEventStoreBacked(root, event);
         }
         return appendStatusEvent(input);
     });

package/dist/store/bootstrap-store.js

@@ -22,8 +22,8 @@ import { openStore } from "./ace-packed-store.js";
 import { bakeAllCoreKnowledge } from "./knowledge-bake.js";
 import { bakeTopology } from "./topology-bake.js";
 import { buildCatalog } from "./catalog-builder.js";
-import { HookContextMaterializer } from "./materializers/hook-context-materializer.js";
 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 { STORE_VERSION } from "./types.js";
@@ -99,21 +99,31 @@ async function materializeStoreSurfaces(store, workspaceRoot, opts) {
             includeClientConfigBundle: opts.includeClientConfigBundle ?? false,
         })));
     }
-    const hookCtx = new HookContextMaterializer(store, workspaceRoot);
-    await hookCtx.materialize();
-    materialized.push(join(workspaceRoot, ".agents", "ACE", "ace-hook-context.json"));
     const todoSyncer = new TodoSyncer(store, workspaceRoot);
     await todoSyncer.initStarter();
-    materialized.push(join(workspaceRoot, ".agents", "ACE", "tasks", "todo.md"));
     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.
+const TIMESTAMPED_ARTIFACT_RELS = new Set(["agent-state/STATUS.md", "agent-state/EVIDENCE_LOG.md"]);
 async function seedOperationalArtifacts(store) {
+    const bootstrapTs = new Date().toISOString();
     for (const relPath of OPERATIONAL_ARTIFACT_REL_PATHS) {
         const knowledgeKey = `knowledge/agent-state/${relPath.replace(/^agent-state\//, "")}`;
-        const content = relPath.endsWith("-archive.ndjson")
+        let content = relPath.endsWith("-archive.ndjson")
             ? ""
             : (await store.getBlob(knowledgeKey)) ?? "";
+        if (TIMESTAMPED_ARTIFACT_RELS.has(relPath) && content.includes("{{BOOTSTRAP_TIMESTAMP}}")) {
+            content = content.replaceAll("{{BOOTSTRAP_TIMESTAMP}}", bootstrapTs);
+        }
         await store.setBlob(operationalArtifactKey(relPath), content);
     }
 }
@@ -168,6 +178,8 @@ export async function bootstrapStoreWorkspace(opts) {
         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", []);
@@ -208,10 +220,9 @@ export async function repairWorkspace(workspaceRoot) {
             includeMcpConfig: hostPolicy.include_mcp_config ?? false,
             includeClientConfigBundle: hostPolicy.include_client_config_bundle ?? false,
         });
-        // Re-materialize hook context
-        const hookCtx = new HookContextMaterializer(store, workspaceRoot);
-        await hookCtx.materialize();
         await store.commit();
+        const projections = new ProjectionManager(store, workspaceRoot);
+        await projections.projectAfterCommit(["hook_context", "todo_state", "scheduler", "context_snapshots"]);
     }
     catch (e) {
         warnings.push(`repair error: ${e.message}`);

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

@@ -0,0 +1,10 @@
+import { AcePackedStore } from "../ace-packed-store.js";
+export declare class ContextSnapshotMaterializer {
+    private store;
+    private workspaceRoot;
+    private repo;
+    constructor(store: AcePackedStore, workspaceRoot: string);
+    private directoryPath;
+    materializeAll(): Promise<void>;
+}
+//# sourceMappingURL=context-snapshot-materializer.d.ts.map