@voybio/ace-swarm 0.2.0 → 0.2.2

package/dist/todo-state.js

@@ -1,8 +1,10 @@
 import { existsSync } from "node:fs";
 import { ACE_TASKS_ROOT_REL, resolveWorkspaceRoot, safeRead, safeWrite, wsPath } from "./helpers.js";
 import { openStore } from "./store/ace-packed-store.js";
-import { VericifyProjector } from "./store/materializers/vericify-projector.js";
-import { getWorkspaceStorePath } from "./store/store-snapshot.js";
+import { ProjectionManager } from "./store/materializers/projection-manager.js";
+import { TodoRepository } from "./store/repositories/todo-repository.js";
+import { getWorkspaceStorePath, readStoreJsonSync, storeExistsSync } from "./store/store-snapshot.js";
+import { operationalArtifactVirtualPath } from "./store/store-artifacts.js";
 import { withStoreWriteQueue } from "./store/write-queue.js";
 import { isReadError, slugify } from "./shared.js";
 const TODO_MARKDOWN_REL = `${ACE_TASKS_ROOT_REL}/todo.md`;
@@ -182,9 +184,12 @@ function parseTodoState(raw) {
 }
 function readPersistedState() {
     const raw = safeRead(TODO_STATE_REL);
-    if (isReadError(raw))
-        return defaultState();
-    return parseTodoState(raw) ?? defaultState();
+    if (!isReadError(raw)) {
+        const parsed = parseTodoState(raw);
+        if (parsed)
+            return parsed;
+    }
+    return readStoreBackedState() ?? defaultState();
 }
 function mapStoreStatus(status) {
     switch (status) {
@@ -200,8 +205,61 @@ function mapStoreStatus(status) {
             return "pending";
     }
 }
-async function mirrorTodoStateToStore(state) {
+function mapLegacyStatus(status) {
+    switch (status) {
+        case "in_progress":
+            return "in_progress";
+        case "blocked":
+            return "blocked";
+        case "done":
+        case "cancelled":
+            return "done";
+        case "pending":
+        default:
+            return "backlog";
+    }
+}
+function readStoreBackedState() {
     const root = workspaceRoot();
+    if (!storeExistsSync(root))
+        return undefined;
+    const index = readStoreJsonSync(root, "state/todo/index") ?? [];
+    if (index.length === 0)
+        return undefined;
+    const nodes = {};
+    const order = [];
+    let updatedAt = Date.now();
+    for (const id of index) {
+        const record = readStoreJsonSync(root, `state/todo/${id}`);
+        if (!record?.id || !record.title || !record.status)
+            continue;
+        const noteSection = typeof record.notes === "string" && record.notes.startsWith("section: ")
+            ? record.notes.slice("section: ".length)
+            : "";
+        nodes[id] = {
+            id: record.id,
+            title: record.title,
+            section: noteSection,
+            source_line: 0,
+            depends_on: Array.isArray(record.depends_on)
+                ? record.depends_on.filter((value) => typeof value === "string")
+                : [],
+            status: mapLegacyStatus(record.status),
+        };
+        order.push(id);
+        if (typeof record.updated_at === "number" && Number.isFinite(record.updated_at)) {
+            updatedAt = Math.max(updatedAt, record.updated_at);
+        }
+    }
+    return {
+        version: 1,
+        updated_at: new Date(updatedAt).toISOString(),
+        source_todo_path: TODO_MARKDOWN_REL,
+        order,
+        nodes,
+    };
+}
+async function mirrorTodoStateToStore(root, state) {
     const storePath = getWorkspaceStorePath(root);
     if (!existsSync(storePath))
         return;
@@ -230,29 +288,59 @@ async function mirrorTodoStateToStore(state) {
             }
             await store.setJSON("state/todo/index", nextIds);
             await store.commit();
-            const projector = new VericifyProjector(store, root);
-            await projector.projectTodos();
+            const projections = new ProjectionManager(store, root);
+            await projections.projectAfterCommit(["todo_state"]);
+        }
+        finally {
+            await store.close();
+        }
+    });
+}
+async function writeStateStoreBacked(root, state) {
+    const storePath = getWorkspaceStorePath(root);
+    if (!existsSync(storePath)) {
+        return writeState(state);
+    }
+    return withStoreWriteQueue(storePath, async () => {
+        const store = await openStore(storePath);
+        try {
+            const repo = new TodoRepository(store);
+            await repo.replaceAll(state.order
+                .map((id) => state.nodes[id])
+                .filter((node) => Boolean(node))
+                .map((node) => ({
+                id: node.id,
+                title: node.title,
+                status: mapStoreStatus(node.status),
+                priority: "medium",
+                depends_on: node.depends_on,
+                notes: node.section ? `section: ${node.section}` : undefined,
+            })));
             await store.commit();
+            const projections = new ProjectionManager(store, root);
+            await projections.projectAfterCommit(["todo_state"]);
+            return operationalArtifactVirtualPath(root, TODO_STATE_REL);
         }
         finally {
             await store.close();
         }
     });
 }
-function scheduleTodoMirror(state) {
+function scheduleTodoMirror(root, state) {
     const snapshot = JSON.parse(JSON.stringify(state));
     todoMirrorChain = todoMirrorChain
         .catch(() => { })
-        .then(() => mirrorTodoStateToStore(snapshot))
+        .then(() => mirrorTodoStateToStore(root, snapshot))
         .catch(() => { });
 }
 export async function waitForTodoStoreMirror() {
     await todoMirrorChain.catch(() => { });
 }
 function writeState(state) {
+    const root = workspaceRoot();
     state.updated_at = new Date().toISOString();
     const path = safeWrite(TODO_STATE_REL, JSON.stringify(state, null, 2));
-    scheduleTodoMirror(state);
+    scheduleTodoMirror(root, state);
     return path;
 }
 function syncStateWithTodo(todoRaw, previous) {
@@ -314,11 +402,26 @@ export function syncTodoState(todoContent) {
     return { state, path };
 }
 export async function syncTodoStateSafe(todoContent) {
+    const root = workspaceRoot();
+    if (storeExistsSync(root)) {
+        const todoRaw = typeof todoContent === "string" ? todoContent : safeRead(TODO_MARKDOWN_REL);
+        if (isReadError(todoRaw)) {
+            const state = defaultState();
+            const path = await writeStateStoreBacked(root, state);
+            return { state, path };
+        }
+        const state = syncStateWithTodo(todoRaw, readPersistedState());
+        const path = await writeStateStoreBacked(root, state);
+        return { state, path };
+    }
     const result = syncTodoState(todoContent);
     await waitForTodoStoreMirror();
     return result;
 }
 export function readTodoState() {
+    if (storeExistsSync(workspaceRoot())) {
+        return readPersistedState();
+    }
     const todoRaw = safeRead(TODO_MARKDOWN_REL);
     if (isReadError(todoRaw))
         return readPersistedState();
@@ -392,6 +495,71 @@ export function transitionTodoNode(nodeId, targetStatus) {
     };
 }
 export async function transitionTodoNodeSafe(nodeId, targetStatus) {
+    const root = workspaceRoot();
+    if (storeExistsSync(root)) {
+        const todoRaw = safeRead(TODO_MARKDOWN_REL);
+        if (isReadError(todoRaw)) {
+            return {
+                ok: false,
+                path: getTodoStatePath(),
+                todo_path: getTodoPath(),
+                error: `${TODO_MARKDOWN_REL} not found; cannot apply transition.`,
+            };
+        }
+        const synced = syncStateWithTodo(todoRaw, readPersistedState());
+        const node = synced.nodes[nodeId];
+        if (!node) {
+            return {
+                ok: false,
+                path: getTodoStatePath(),
+                todo_path: getTodoPath(),
+                error: `Unknown node_id: ${nodeId}`,
+            };
+        }
+        const from = node.status;
+        if (from !== targetStatus) {
+            const allowed = TRANSITIONS[from];
+            if (!allowed.includes(targetStatus)) {
+                return {
+                    ok: false,
+                    path: getTodoStatePath(),
+                    todo_path: getTodoPath(),
+                    node_id: nodeId,
+                    from,
+                    to: targetStatus,
+                    allowed,
+                    error: `Invalid transition ${from} -> ${targetStatus}`,
+                };
+            }
+        }
+        if (targetStatus === "in_progress" ||
+            targetStatus === "gated" ||
+            targetStatus === "done") {
+            const unresolved = node.depends_on.filter((depId) => synced.nodes[depId]?.status !== "done");
+            if (unresolved.length > 0) {
+                return {
+                    ok: false,
+                    path: getTodoStatePath(),
+                    todo_path: getTodoPath(),
+                    node_id: nodeId,
+                    from,
+                    to: targetStatus,
+                    unresolved_dependencies: unresolved,
+                    error: `Dependencies not satisfied for ${nodeId}`,
+                };
+            }
+        }
+        node.status = targetStatus;
+        const statePath = await writeStateStoreBacked(root, synced);
+        return {
+            ok: true,
+            path: statePath,
+            todo_path: getTodoPath(),
+            node_id: nodeId,
+            from,
+            to: targetStatus,
+        };
+    }
     const result = transitionTodoNode(nodeId, targetStatus);
     await waitForTodoStoreMirror();
     return result;

package/dist/tools-files.js

@@ -470,12 +470,13 @@ export function registerFileTools(server) {
                 validationNotes.push(`lint warnings: ${lint.warnings.join("; ")}`);
             }
         }
-        const abs = safeWrite(path, content);
         let todoStateSuffix = "";
         if (normalizedPath === `${ACE_TASKS_ROOT_REL}/todo.md`) {
             const synced = await syncTodoStateSafe(content);
             todoStateSuffix = `\nTODO state synced: ${synced.path}`;
         }
+        // Keep the file as a materialized projection after the canonical store update.
+        const abs = safeWrite(path, content);
         let kanbanSuffix = "";
         const shouldRefreshKanban = shouldAutoRefreshKanbanForPath(normalizedPath);
         if (shouldRefreshKanban) {

package/dist/tools-framework.js

@@ -17,6 +17,7 @@ import { isGitRepo, gitStatus } from "./git-ops.js";
 import { existsSync, readdirSync, readFileSync } from "node:fs";
 import { resolve } from "node:path";
 import { auditPublicSurface } from "./public-surface.js";
+import { auditStoreAuthority, writeStoreAuthorityAuditReport, } from "./store/store-authority-audit.js";
 import { PROVENANCE_CRITICAL_EVENT_TYPES, validateArtifactManifestPayload, validateProvenanceLogContent, validateTealConfigContent, } from "./schemas.js";
 import { readAceTaskContractAssessment } from "./ace-autonomy.js";
 function getArtifactManifestEntries(payload) {
@@ -1003,6 +1004,28 @@ export function registerFrameworkTools(server) {
                 });
             }
         }
+        const storeAuthority = auditStoreAuthority();
+        checks.push({
+            name: "store-authority:bypasses",
+            ok: storeAuthority.bypassing_sites.length === 0,
+            detail: storeAuthority.bypassing_sites.length === 0
+                ? "no runtime writers bypass ACEPACK"
+                : `${storeAuthority.bypassing_sites.length} runtime writers still bypass ACEPACK`,
+        });
+        checks.push({
+            name: "store-authority:runtime-fallbacks",
+            ok: storeAuthority.runtime_files_without_store_fallback_keys.length === 0,
+            detail: storeAuthority.runtime_files_without_store_fallback_keys.length === 0
+                ? "all runtime writers have store fallback keys"
+                : `${storeAuthority.runtime_files_without_store_fallback_keys.length} runtime writers lack store fallback keys`,
+        });
+        checks.push({
+            name: "store-authority:regenerable-projections",
+            ok: storeAuthority.non_regenerable_projections.length === 0,
+            detail: storeAuthority.non_regenerable_projections.length === 0
+                ? "all projections are regenerable from store state"
+                : `${storeAuthority.non_regenerable_projections.length} projections are not regenerable from store state`,
+        });
         // Check: TEAL config has exactly one active YAML block
         const tealRaw = safeRead("agent-state/TEAL_CONFIG.md");
         if (!tealRaw.startsWith("[FILE NOT FOUND]")) {
@@ -1259,6 +1282,43 @@ export function registerFrameworkTools(server) {
             ],
         };
     });
+    server.tool("audit_store_authority", "Report ACEPACK writer bypasses, missing fallback keys, and non-regenerable projections", {
+        write_artifact: z
+            .boolean()
+            .optional()
+            .describe("Write agent-state/STORE_AUTHORITY_AUDIT.md (default: true)"),
+        artifact_path: z
+            .string()
+            .optional()
+            .describe("Optional workspace-relative path for the audit report"),
+    }, async ({ write_artifact, artifact_path }) => {
+        const result = auditStoreAuthority();
+        const reportPath = artifact_path ?? result.report_path;
+        if (write_artifact !== false) {
+            writeStoreAuthorityAuditReport({
+                ...result,
+                report_path: reportPath,
+            }, reportPath);
+        }
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: [
+                        `✅ Store authority audit completed (${result.total_safe_write_sites} safeWrite users)`,
+                        `Report: ${reportPath}`,
+                        `Bypassing ACEPACK: ${result.bypassing_sites.length}`,
+                        `Runtime files without fallback keys: ${result.runtime_files_without_store_fallback_keys.length}`,
+                        `Non-regenerable projections: ${result.non_regenerable_projections.length}`,
+                        "",
+                        `- canonical knowledge artifacts: ${result.classifications["canonical knowledge artifact"].length}`,
+                        `- canonical runtime state writers: ${result.classifications["canonical runtime state"].length}`,
+                        `- projection-only writers: ${result.classifications["projection only"].length}`,
+                    ].join("\n"),
+                },
+            ],
+        };
+    });
     // ── Execute Gates (manifest-driven gate runner) ───────────────────
     server.tool("execute_gates", "Run quality gates from agent-state/MODULES/gates/*.json manifests (single source of truth)", {
         gate_ids: z

package/dist/tools-memory.js

@@ -1,13 +1,19 @@
 /**
  * Memory tool registrations – context snapshots and recall.
  */
+import { existsSync } from "node:fs";
 import { z } from "zod";
-import { safeRead, safeWrite, wsPath } from "./helpers.js";
+import { resolveWorkspaceRoot, safeRead, safeWrite, wsPath } from "./helpers.js";
 import { isReadError } from "./shared.js";
 import { appendRunLedgerEntrySafe } from "./run-ledger.js";
-import { appendStatusEvent } from "./status-events.js";
+import { appendStatusEventSafe } from "./status-events.js";
 import { readRuntimeProfile } from "./runtime-profile.js";
 import { buildAceContinuityPacket, formatAceContinuityPacketMarkdown, normalizeContinuityPolicy, } from "./ace-autonomy.js";
+import { openStore } from "./store/ace-packed-store.js";
+import { ProjectionManager } from "./store/materializers/projection-manager.js";
+import { ContextSnapshotRepository } from "./store/repositories/context-snapshot-repository.js";
+import { getWorkspaceStorePath, storeExistsSync, toVirtualStorePath, } from "./store/store-snapshot.js";
+import { withStoreWriteQueue } from "./store/write-queue.js";
 const CONTEXT_STORE_REL = "agent-state/context-snapshots";
 export function registerMemoryTools(server) {
     server.tool("context_snapshot", "Capture a named context snapshot for later retrieval (decisions, progress, state)", {
@@ -31,39 +37,68 @@ export function registerMemoryTools(server) {
             .describe("Additional metadata"),
     }, async ({ name, summary, decisions, open_questions, artifacts, metadata }) => {
         const timestamp = new Date().toISOString();
-        const snapshot = {
-            name,
-            timestamp,
-            summary,
-            decisions: decisions ?? [],
-            open_questions: open_questions ?? [],
-            artifacts: artifacts ?? [],
-            metadata: metadata ?? {},
-        };
-        const slug = name
-            .trim()
-            .toLowerCase()
-            .replace(/[^a-z0-9]+/g, "-")
-            .slice(0, 48);
-        const filename = `${slug}.json`;
-        const path = wsPath(CONTEXT_STORE_REL, filename);
-        safeWrite(path, JSON.stringify(snapshot, null, 2));
-        // Update index
-        const indexPath = wsPath(CONTEXT_STORE_REL, "index.json");
-        const indexRaw = safeRead(indexPath);
-        let index = { snapshots: [] };
-        if (!isReadError(indexRaw)) {
-            try {
-                index = JSON.parse(indexRaw);
-            }
-            catch {
-                /* keep default */
+        const root = resolveWorkspaceRoot();
+        let path = wsPath(CONTEXT_STORE_REL, `${name}.json`);
+        if (storeExistsSync(root) && existsSync(getWorkspaceStorePath(root))) {
+            const storePath = getWorkspaceStorePath(root);
+            const saved = await withStoreWriteQueue(storePath, async () => {
+                const store = await openStore(storePath);
+                try {
+                    const repo = new ContextSnapshotRepository(store);
+                    const result = await repo.saveSnapshot({
+                        name,
+                        summary,
+                        decisions,
+                        open_questions,
+                        artifacts,
+                        metadata,
+                        timestamp,
+                    });
+                    await store.commit();
+                    const projections = new ProjectionManager(store, root);
+                    await projections.projectAfterCommit(["context_snapshots"]);
+                    return result;
+                }
+                finally {
+                    await store.close();
+                }
+            });
+            path = toVirtualStorePath(storePath, `state/memory/context_snapshots/${saved.file}`);
+        }
+        else {
+            const snapshot = {
+                name,
+                timestamp,
+                summary,
+                decisions: decisions ?? [],
+                open_questions: open_questions ?? [],
+                artifacts: artifacts ?? [],
+                metadata: metadata ?? {},
+            };
+            const slug = name
+                .trim()
+                .toLowerCase()
+                .replace(/[^a-z0-9]+/g, "-")
+                .slice(0, 48);
+            const filename = `${slug}.json`;
+            path = wsPath(CONTEXT_STORE_REL, filename);
+            safeWrite(path, JSON.stringify(snapshot, null, 2));
+            const indexPath = wsPath(CONTEXT_STORE_REL, "index.json");
+            const indexRaw = safeRead(indexPath);
+            let index = { snapshots: [] };
+            if (!isReadError(indexRaw)) {
+                try {
+                    index = JSON.parse(indexRaw);
+                }
+                catch {
+                    /* keep default */
+                }
             }
+            index.snapshots = index.snapshots.filter((s) => s.name !== name);
+            index.snapshots.push({ name, file: filename, timestamp, summary });
+            index.snapshots.sort((a, b) => b.timestamp.localeCompare(a.timestamp));
+            safeWrite(indexPath, JSON.stringify(index, null, 2));
         }
-        index.snapshots = index.snapshots.filter((s) => s.name !== name);
-        index.snapshots.push({ name, file: filename, timestamp, summary });
-        index.snapshots.sort((a, b) => b.timestamp.localeCompare(a.timestamp));
-        safeWrite(indexPath, JSON.stringify(index, null, 2));
         const ledger = await appendRunLedgerEntrySafe({
             tool: "context_snapshot",
             category: "info",
@@ -74,7 +109,7 @@ export function registerMemoryTools(server) {
                 decisions_count: (decisions ?? []).length,
             },
         });
-        appendStatusEvent({
+        await appendStatusEventSafe({
             source_module: "capability-memory",
             event_type: "CONTEXT_SNAPSHOT",
             status: "done",

package/dist/tools-todo.js

@@ -32,8 +32,8 @@ export function registerTodoTools(server) {
         note: z.string().optional().describe("Optional transition context note"),
     }, async ({ new_content, node_id, status, note }) => {
         if (typeof new_content === "string") {
-            const path = safeWrite(resolveWritableTaskPath("todo"), new_content);
             const synced = await syncTodoStateSafe(new_content);
+            const path = safeWrite(resolveWritableTaskPath("todo"), new_content);
             const runLedger = await appendRunLedgerEntrySafe({
                 tool: "update_todo",
                 category: "major_update",

package/dist/tui/agent-worker.d.ts

@@ -6,5 +6,5 @@
  * present, while retaining deterministic adapter fallback for unreachable or
  * unconfigured runtimes.
  */
-export {};
+export declare function canUseAceBridgeWorkspace(workspaceRoot: string): boolean;
 //# sourceMappingURL=agent-worker.d.ts.map

package/dist/tui/agent-worker.js

@@ -7,11 +7,10 @@
  * unconfigured runtimes.
  */
 import { parseManualHandoffCommand, parseManualToolCommand, planRoleExecution, } from "../agent-runtime/role-adapters.js";
-import { existsSync } from "node:fs";
-import { resolve } from "node:path";
 import { ModelBridge } from "../model-bridge.js";
 import { OllamaClient } from "./ollama.js";
 import { OpenAICompatibleClient, diagnoseChatRuntimeConfig, } from "./openai-compatible.js";
+import { resolveAceStateLayout } from "../ace-state-resolver.js";
 const config = new Map();
 let role = process.env.ACE_TUI_AGENT_ROLE ?? "unknown";
 let initialized = false;
@@ -22,6 +21,9 @@ const bridge = new ModelBridge({
     ollama: ollamaClient,
     openai: openaiClient,
 });
+export function canUseAceBridgeWorkspace(workspaceRoot) {
+    return resolveAceStateLayout(workspaceRoot).isAcePresent;
+}
 function send(message) {
     if (typeof process.send === "function") {
         process.send(message);
@@ -101,7 +103,7 @@ async function tryModelBridge(text) {
     const workspace = config.get("workspace_root")?.trim();
     if (!provider || !model || !workspace)
         return false;
-    if (!existsSync(resolve(workspace, ".agents", "ACE", "agent-state", "TASK.md"))) {
+    if (!canUseAceBridgeWorkspace(workspace)) {
         return false;
     }
     if (provider.toLowerCase() === "ollama" && !baseUrl) {

package/dist/tui/chat.d.ts

@@ -11,6 +11,7 @@ import { EventEmitter } from "node:events";
 import type { ChatMessage } from "./layout.js";
 import { ModelBridge } from "../model-bridge.js";
 import type { AceContextTier } from "../ace-context.js";
+import { type AceRuntimeStatusPacket } from "../store/repositories/local-model-runtime-repository.js";
 export interface ChatSessionOptions {
     provider: string;
     model: string;
@@ -53,9 +54,21 @@ export declare class ChatSession extends EventEmitter {
     private aceBridge;
     private activeAceBridge;
     private providerBaseUrls;
+    private sessionId;
+    private createdAt;
+    private lastActiveAt;
+    private currentRuntimeStatus;
+    private activationLedger;
     constructor(clients: ChatSessionClients, telemetry: TelemetryTracker, options: ChatSessionOptions);
     /** Get display messages for rendering */
     getDisplayMessages(): ChatMessage[];
+    getSessionId(): string;
+    getCreatedAt(): number;
+    getLastActiveAt(): number;
+    getCurrentRuntimeStatus(): AceRuntimeStatusPacket | undefined;
+    hasMeaningfulTranscript(): boolean;
+    getTranscriptExcerpt(maxMessages?: number): string | undefined;
+    getTranscriptSummary(): string | undefined;
     /** Is currently streaming a response? */
     isStreaming(): boolean;
     /** Get current model */
@@ -78,6 +91,12 @@ export declare class ChatSession extends EventEmitter {
     private shouldUseAceBridge;
     private buildBridgeTask;
     private pushSystemMessage;
+    private noteActivity;
+    private buildRuntimeStatusPacket;
+    private setRuntimeStatus;
+    setApprovalState(state: NonNullable<AceRuntimeStatusPacket["approval_state"]>): boolean;
+    private persistRuntimeStatus;
+    private persistRuntimeSessionArtifacts;
     private runAceBridge;
 }
 export {};