@voybio/ace-swarm 2.4.8 → 2.4.10

package/dist/store/materializers/todo-syncer.js

@@ -1,140 +1,238 @@
-/**
- * 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 { writeFileSync, readFileSync, existsSync, mkdirSync } from "fs";
-import { join, dirname } from "path";
-import { createHash } from "crypto";
+/** Human-editable todo projection and its single inverse parser. */
+import { writeFileSync, readFileSync, existsSync, mkdirSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { createHash } from "node:crypto";
+import { EntityKind } from "../types.js";
 import { TodoRepository } from "../repositories/todo-repository.js";
-const STATUS_ICONS = {
-    pending: " ",
-    in_progress: "~",
-    done: "x",
-    blocked: "!",
-    cancelled: "-",
+export const STATUS_ICONS = {
+    pending: " ", in_progress: "~", done: "x", blocked: "!", gated: "?", cancelled: "-",
 };
-const ICON_STATUS = {
-    " ": "pending",
-    "~": "in_progress",
-    x: "done",
-    "!": "blocked",
-    "-": "cancelled",
+export const ICON_STATUS = {
+    " ": "pending", "~": "in_progress", x: "done", X: "done", "!": "blocked", "?": "gated", "-": "cancelled",
 };
-function sha256(content) {
-    return createHash("sha256").update(content, "utf8").digest("hex");
-}
-function renderTodoMd(todos) {
-    const lines = ["# Tasks\n"];
-    const byStatus = {};
-    for (const t of todos) {
-        (byStatus[t.status] ??= []).push(t);
-    }
-    const order = ["in_progress", "pending", "blocked", "done", "cancelled"];
-    for (const status of order) {
-        const group = byStatus[status];
-        if (!group?.length)
+const CHECKSUMS_KEY = "host/materializations/checksums";
+const TODO_REL = ".agents/ACE/tasks/todo.md";
+const sha256 = (text) => createHash("sha256").update(text, "utf8").digest("hex");
+export function parseTodoMd(content) {
+    const items = [];
+    const counts = new Map();
+    const import_warnings = [];
+    let section;
+    let notesTarget;
+    for (const [offset, line] of content.split(/\r?\n/).entries()) {
+        if (/^\s*>/.test(line)) {
+            if (notesTarget)
+                notesTarget.notes = [notesTarget.notes, line.replace(/^\s*>\s?/, "")].filter((v) => v !== undefined).join("\n");
+            else
+                import_warnings.push(`Line ${offset + 1}: unattached note retained in markdown.`);
+            continue;
+        }
+        notesTarget = undefined;
+        const header = line.match(/^##\s+(.+)$/);
+        if (header) {
+            section = header[1].trim();
+            continue;
+        }
+        const match = line.match(/^\s*-\s+\[([^\]]*)\]\s*(.*)$/);
+        if (!match) {
+            if (line.trim() && !/^#/.test(line))
+                import_warnings.push(`Line ${offset + 1}: unparseable todo row; retained canonical records.`);
+            continue;
+        }
+        const status = ICON_STATUS[match[1]];
+        const meta = {};
+        const metadata = (value) => {
+            for (const part of value.split(";")) {
+                const field = part.match(/^\s*(id|depends_on|depends)\s*[:=]\s*(.*?)\s*$/);
+                if (field)
+                    meta[field[1]] = field[2];
+            }
+            return "";
+        };
+        let title = match[2].replace(/<!--\s*ace:([\s\S]*?)-->/g, (_, value) => metadata(value))
+            .replace(/\s*\((id\s*[:=][^)]*)\)\s*$/, (_, value) => metadata(value)).trim();
+        if (meta.id)
+            counts.set(meta.id, (counts.get(meta.id) ?? 0) + 1);
+        const assignee = title.match(/\s+@(\S+)$/);
+        if (assignee)
+            title = title.slice(0, assignee.index).trimEnd();
+        const priority = title.match(/\s+\[(high|medium|low)\]$/);
+        if (priority)
+            title = title.slice(0, priority.index).trimEnd();
+        if (!status || !title || ("id" in meta && !meta.id)) {
+            import_warnings.push(`Line ${offset + 1}: invalid checkbox, title or id; canonical row unchanged.`);
             continue;
-        const icon = STATUS_ICONS[status];
-        for (const t of group) {
-            const priority = t.priority ? ` [${t.priority}]` : "";
-            const assignee = t.assigned_to ? ` @${t.assigned_to}` : "";
-            lines.push(`- [${icon}] ${t.title}${priority}${assignee} (id: ${t.id})`);
-            if (t.notes)
-                lines.push(`  > ${t.notes}`);
         }
+        const dependencies = meta.depends_on ?? meta.depends;
+        const item = { raw_line: line, id: meta.id, title, status, section, source_line: offset + 1,
+            ...(dependencies === undefined ? {} : { depends_on: dependencies.split(",").map((s) => s.trim()).filter(Boolean) }),
+            ...(priority ? { priority: priority[1] } : {}),
+            ...(assignee ? { assigned_to: assignee[1] } : {}), };
+        items.push(item);
+        notesTarget = item;
     }
-    return lines.join("\n") + "\n";
+    for (const [id, count] of counts)
+        if (count > 1)
+            import_warnings.push(`Duplicate id ${id}; canonical row unchanged.`);
+    return { items: items.filter((item) => !item.id || counts.get(item.id) === 1), import_warnings };
 }
-function parseTodoMd(content) {
-    const results = [];
-    for (const line of content.split("\n")) {
-        const match = line.match(/^- \[(.)\] (.+)/);
-        if (!match)
-            continue;
-        const [, iconChar, rest] = match;
-        const status = ICON_STATUS[iconChar] ?? "pending";
-        // Extract id if present
-        const idMatch = rest.match(/\(id: ([^)]+)\)/);
-        const id = idMatch?.[1];
-        const title = rest.replace(/\s*\(id: [^)]+\)/, "").replace(/\s*\[[^\]]+\]/, "").replace(/\s*@\S+/, "").trim();
-        results.push({ id, title, status });
+export function renderTodoMd(todos) {
+    const lines = ["# Tasks", ""];
+    for (const todo of todos) {
+        const priority = todo.priority ? ` [${todo.priority}]` : "";
+        const assignee = todo.assigned_to ? ` @${todo.assigned_to}` : "";
+        const deps = todo.depends_on?.length ? `; depends_on: ${todo.depends_on.join(",")}` : "";
+        lines.push(`- [${STATUS_ICONS[todo.status]}] ${todo.title}${priority}${assignee} (id: ${todo.id}${deps})`);
+        if (todo.notes)
+            lines.push(...todo.notes.split("\n").map((line) => `  > ${line}`));
     }
-    return results;
+    return lines.join("\n") + "\n";
 }
 export class TodoSyncer {
     store;
     workspaceRoot;
     repo;
-    lastHash = "";
+    submittedStamp;
     todoMdPath;
     constructor(store, workspaceRoot) {
         this.store = store;
         this.workspaceRoot = workspaceRoot;
         this.repo = new TodoRepository(store);
-        // Canonical ACE path: .agents/ACE/tasks/todo.md (mirrors ACE_TASKS_ROOT_REL in helpers.ts)
-        this.todoMdPath = join(workspaceRoot, ".agents", "ACE", "tasks", "todo.md");
+        this.todoMdPath = join(workspaceRoot, TODO_REL);
     }
-    /** Write store todo state → tasks/todo.md */
-    async writeToFile() {
-        const todos = await this.repo.getAll();
-        const content = renderTodoMd(todos);
-        const dir = dirname(this.todoMdPath);
-        if (!existsSync(dir))
-            mkdirSync(dir, { recursive: true });
-        writeFileSync(this.todoMdPath, content, "utf8");
-        this.lastHash = sha256(content);
+    async stamp() {
+        return (await this.store.getJSON(CHECKSUMS_KEY))?.[TODO_REL];
+    }
+    async setStamp(stamp) {
+        const all = await this.store.getJSON(CHECKSUMS_KEY) ?? {};
+        all[TODO_REL] = stamp;
+        await this.store.setJSON(CHECKSUMS_KEY, all);
+    }
+    /** Stage a non-destructive native import. The caller owns commit/discard and the coordinator. */
+    async syncFromFile(content, force = false, observeNative = true) {
+        if (content === undefined && !existsSync(this.todoMdPath))
+            return { changed: false, import_warnings: [] };
+        const raw = content ?? readFileSync(this.todoMdPath, "utf8");
+        const hash = sha256(raw);
+        const stamp = await this.stamp();
+        if (!force && hash === (stamp?.observed_hash ?? stamp?.hash)) {
+            if (!observeNative)
+                this.submittedStamp = stamp;
+            return { changed: false, import_warnings: stamp?.import_warnings ?? [] };
+        }
+        const { items, import_warnings } = parseTodoMd(raw);
+        const existing = await this.repo.getAll();
+        const byId = new Map(existing.map((todo) => [todo.id, todo]));
+        const seen = new Set();
+        const observed_rows = {};
+        // Reuse deletion history: a stale, unrendered file must not resurrect an explicit delete.
+        const deleted = new Set();
+        for (const entry of await this.store.getEntries({ kind: EntityKind.Todo })) {
+            const value = entry.payload;
+            if (!value?.id)
+                continue;
+            if (value.op === "remove")
+                deleted.add(value.id);
+            else
+                deleted.delete(value.id);
+        }
+        for (const item of items) {
+            let id = item.id;
+            if (!id) {
+                const matching = existing.filter((todo) => todo.title === item.title && !seen.has(todo.id));
+                if (matching.length === 1)
+                    id = matching[0].id;
+                else {
+                    const base = `todo-${item.title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "") || "item"}`;
+                    id = base;
+                    for (let n = 2; byId.has(id) || seen.has(id); n++)
+                        id = `${base}-${n}`;
+                }
+            }
+            seen.add(id);
+            if (deleted.has(id) && !byId.has(id)) {
+                import_warnings.push(`Deleted todo ${id} remains in markdown; not recreated.`);
+                continue;
+            }
+            const prior = byId.get(id);
+            const rowHash = sha256(JSON.stringify([item.raw_line, item.notes ?? ""]));
+            observed_rows[id] = rowHash;
+            // Only changed native rows are edits. An unchanged stale row must not undo
+            // accepted work while another malformed row is being repaired.
+            if (prior && stamp?.observed_rows?.[id] === rowHash)
+                continue;
+            const { id: _id, raw_line: _raw, ...fields } = item;
+            if (!prior) {
+                const section = item.section?.toLowerCase() ?? "";
+                const status = item.status === "pending" && section.includes("verification") ? "gated" : item.status === "pending" && section.includes("active") ? "in_progress" : item.status;
+                const created = await this.repo.create({ ...fields, id, status });
+                byId.set(id, created);
+            }
+            else {
+                if (renderTodoMd([prior]).split("\n").some((line) => line === item.raw_line)) {
+                    fields.title = prior.title;
+                    fields.priority = prior.priority;
+                    fields.assigned_to = prior.assigned_to;
+                    fields.depends_on = prior.depends_on;
+                }
+                const patch = Object.fromEntries(Object.entries(fields).filter(([key, value]) => value !== undefined && JSON.stringify(prior[key]) !== JSON.stringify(value)));
+                if (prior.step_ref && patch.status !== undefined) {
+                    delete patch.status;
+                    import_warnings.push(`Todo ${id} is a step view; use complete_step for its status.`);
+                }
+                // Line numbers are view metadata; a reordered file alone need not rewrite the task.
+                delete patch.source_line;
+                if (Object.keys(patch).length)
+                    await this.repo.update(id, patch);
+            }
+        }
+        for (const todo of existing)
+            if (!seen.has(todo.id))
+                import_warnings.push(`Todo ${todo.id} missing from markdown; canonical record retained. Use explicit delete to remove it.`);
+        const nextStamp = { path: TODO_REL, hash: stamp?.hash ?? "", written_at: stamp?.written_at ?? 0, observed_hash: hash, observed_rows, import_warnings };
+        if (observeNative)
+            await this.setStamp(nextStamp);
+        else
+            this.submittedStamp = nextStamp;
+        return { changed: true, import_warnings };
     }
-    /** Check if tasks/todo.md was modified externally, and if so ingest changes */
-    async syncFromFile() {
+    /** Supplied content is an observation only after its file publication succeeds. */
+    async acknowledgeSubmittedFile(content) {
+        if (this.submittedStamp?.observed_hash === sha256(content))
+            await this.setStamp(this.submittedStamp);
+    }
+    async projectionIsCurrent() {
         if (!existsSync(this.todoMdPath))
             return false;
-        const content = readFileSync(this.todoMdPath, "utf8");
-        const currentHash = sha256(content);
-        if (currentHash === this.lastHash)
-            return false; // not modified
-        const parsed = parseTodoMd(content);
-        let changed = false;
-        for (const item of parsed) {
-            if (!item.id)
-                continue; // can't sync without id
-            const existing = await this.repo.get(item.id);
-            if (!existing)
-                continue;
-            if (existing.status !== item.status || existing.title !== item.title) {
-                await this.repo.update(item.id, { title: item.title, status: item.status });
-                changed = true;
+        const expected = sha256(renderTodoMd(await this.repo.getAll()));
+        return (await this.stamp())?.hash === expected && sha256(readFileSync(this.todoMdPath, "utf8")) === expected;
+    }
+    /** Do not overwrite unimported edits or malformed source text. */
+    async writeToFile() {
+        const stamp = await this.stamp();
+        const warnings = stamp?.import_warnings ?? [];
+        if (existsSync(this.todoMdPath)) {
+            const current = sha256(readFileSync(this.todoMdPath, "utf8"));
+            if (warnings.length || current !== (stamp?.observed_hash ?? stamp?.hash)) {
+                return { written: false, import_warnings: warnings.length ? warnings : ["Todo markdown changed before projection; native edit retained, refresh pending."] };
             }
         }
-        this.lastHash = currentHash;
-        return changed;
+        const content = renderTodoMd(await this.repo.getAll());
+        mkdirSync(dirname(this.todoMdPath), { recursive: true });
+        writeFileSync(this.todoMdPath, content, "utf8");
+        const hash = sha256(content);
+        const observed_rows = Object.fromEntries(parseTodoMd(content).items.filter((item) => item.id).map((item) => [item.id, sha256(JSON.stringify([item.raw_line, item.notes ?? ""]))]));
+        await this.setStamp({ path: TODO_REL, hash, observed_hash: hash, observed_rows, written_at: Date.now(), import_warnings: [] });
+        return { written: true, import_warnings: [] };
     }
-    /** Initialize todo.md with starter content if it doesn't exist */
     async initStarter() {
-        if (existsSync(this.todoMdPath))
+        if (existsSync(this.todoMdPath)) {
+            await this.syncFromFile();
             return;
-        const dir = dirname(this.todoMdPath);
-        if (!existsSync(dir))
-            mkdirSync(dir, { recursive: true });
-        const starter = `# Tasks\n\n- [ ] Initiate ACE (id: todo-001)\n`;
-        writeFileSync(this.todoMdPath, starter, "utf8");
-        this.lastHash = sha256(starter);
-        // Seed into store
-        await this.repo.create({
-            id: "todo-001",
-            title: "Initiate ACE",
-            status: "pending",
-            priority: "high",
-        });
+        }
+        if (!(await this.repo.getAll()).length)
+            await this.repo.create({ id: "todo-001", title: "Initiate ACE", status: "pending", priority: "high" });
+        await this.writeToFile();
     }
 }
 //# sourceMappingURL=todo-syncer.js.map

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

@@ -19,7 +19,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 { VericifyRepository, projectVericifyPost } from "../repositories/vericify-repository.js";
+import { preserveLegacyVericifyPosts } from "../legacy-vericify-posts.js";
 import { operationalArtifactKey } from "../store-artifacts.js";
 // Runtime-facing state now lives in top-level agent-state/.
 const ACE_STATE_ROOT = "agent-state";
@@ -74,6 +75,7 @@ export class VericifyProjector {
                 task_type: typeof metadata.task_type === "string" ? metadata.task_type : r.task,
                 priority: typeof metadata.priority === "string" ? metadata.priority : undefined,
                 source_file: typeof metadata.source_file === "string" ? metadata.source_file : undefined,
+                step_ref: metadata.step_ref,
                 status: legacyStatus,
                 history: Array.isArray(metadata.history) ? metadata.history : [],
             };
@@ -90,10 +92,11 @@ export class VericifyProjector {
         for (const t of todos) {
             order.push(t.id);
             nodes[t.id] = {
+                ...t,
                 id: t.id,
                 title: t.title,
-                section: "",
-                source_line: 0,
+                section: t.section ?? (t.notes?.startsWith("section: ") ? t.notes.slice(9) : ""),
+                source_line: t.source_line ?? 0,
                 depends_on: t.depends_on ?? [],
                 status: mapStatus(t.status),
             };
@@ -147,32 +150,16 @@ export class VericifyProjector {
         await this._write("STATUS_EVENTS.ndjson", ndjson);
     }
     async projectVericifyPosts() {
+        const legacy = await preserveLegacyVericifyPosts(this.store, this.workspaceRoot);
+        for (const warning of legacy.warnings)
+            console.warn(warning);
+        if (!legacy.canProject)
+            return;
         const posts = await this.vericify.list();
         const content = JSON.stringify({
             version: 1,
             updated_at: new Date().toISOString(),
-            posts: posts.map((post) => ({
-                process_post_id: post.id,
-                run_id: post.run_id,
-                agent_id: post.agent_id,
-                kind: post.kind,
-                summary: post.summary,
-                timestamp: new Date(post.ts).toISOString(),
-                branch_id: typeof post.metadata?.branch_id === "string" ? post.metadata.branch_id : undefined,
-                lane_id: typeof post.metadata?.lane_id === "string" ? post.metadata.lane_id : undefined,
-                blocker_category: typeof post.metadata?.blocker_category === "string"
-                    ? post.metadata.blocker_category
-                    : undefined,
-                checkpoint_ref: typeof post.metadata?.checkpoint_ref === "string"
-                    ? post.metadata.checkpoint_ref
-                    : undefined,
-                tool_refs: Array.isArray(post.metadata?.tool_refs)
-                    ? post.metadata.tool_refs.filter((value) => typeof value === "string")
-                    : [],
-                evidence_refs: Array.isArray(post.metadata?.evidence_refs)
-                    ? post.metadata.evidence_refs.filter((value) => typeof value === "string")
-                    : [],
-            })),
+            posts: posts.map(projectVericifyPost),
         }, null, 2);
         await this._write("vericify/process-posts.json", content);
     }
@@ -203,8 +190,10 @@ function mapStatus(storeStatus) {
             return "blocked";
         case "done":
             return "done";
+        case "gated":
+            return "gated";
         case "cancelled":
-            return "done"; // closest legacy equivalent
+            return "cancelled";
         default:
             return "backlog";
     }

package/dist/store/repositories/goal-repository.d.ts

@@ -18,11 +18,21 @@ import type { TaskPlan } from "../../orchestrator-supervisor.js";
 export type GoalStatus = "draft" | "planning" | "executing" | "verifying" | "blocked" | "done" | "failed" | "stopped";
 export type GoalEscalationKind = "approval_required" | "run_complete" | "run_error" | "gate_failed" | "budget_blocked" | "blocker";
 export interface GoalBudgets {
+    /** Zero means unlimited; only an explicitly marked allowance is enforced. */
     max_wall_clock_ms: number;
+    /** Only an explicit host budget_hours request enables this duration. */
+    host_deadline_explicit?: boolean;
+    deadline_explicit?: boolean;
     max_ticks: number;
+    tick_budget_explicit?: boolean;
     max_replans: number;
+    replan_budget_explicit?: boolean;
     max_step_retries: number;
 }
+/** Wire representation understood by pre-marker 2.4.x engines, which compare
+ * numeric limits directly. In-memory callers continue to use zero for unlimited.
+ * This is a finite compatibility sentinel, not a mathematical infinity. */
+export declare const UNBOUNDED_GOAL_BUDGET_WIRE_VALUE: number;
 export interface SuccessContract {
     /** Union of step-level and goal-level required artifacts. */
     expected_artifacts: Array<{
@@ -30,7 +40,7 @@ export interface SuccessContract {
         required?: boolean;
     }>;
     required_evidence_refs: string[];
-    verification_commands: string[];
+    verification_commands: import('../../goal-engine.js').VerificationCommand[];
     /**
      * TODO(WS-F): wire gate_ids to execute_gates. Always `[]` today and never
      * read, so it is deliberately excluded from `enforceableObligationCount`.
@@ -61,12 +71,51 @@ export interface GoalRecord {
     started_at?: string;
     tick_count: number;
     replan_count: number;
+    /** Consecutive unchanged failure sets, not a ceiling on productive corrections. */
+    failure_repetition?: {
+        signature: string;
+        count: number;
+    };
     last_heartbeat_at?: string;
     stop_requested: boolean;
     escalations: GoalEscalation[];
     result_summary?: string;
     reason_code?: string;
     current_step_id?: string;
+    executor?: "engine" | "host";
+    verified?: boolean;
+    verification_results?: Array<{
+        command: string;
+        ok: boolean;
+        output: string;
+    }>;
+    verification_attempt?: number;
+    verification_run?: {
+        job_id: string;
+        attempt: number;
+        enqueued_at: string;
+        status: 'queued' | 'running' | 'interrupted' | 'uncertain' | 'done' | 'failed' | 'stopped';
+        worker?: import('../../process-identity.js').ProcessIdentity;
+        command?: import('../../progress-command.js').CommandProgress & {
+            index: number;
+            command: string;
+            process?: import('../../process-identity.js').ProcessIdentity;
+            log_path?: string;
+        };
+        error?: string;
+    };
+    final_contract_check?: {
+        ok: boolean;
+        missing_artifacts: string[];
+        missing_evidence_refs: string[];
+        failed_commands: string[];
+    };
+    pending_follow_ups?: Array<{
+        step_id: string;
+        task: string;
+        role: string;
+        depends_on?: string[];
+    }>;
 }
 export interface GoalIndexEntry {
     goal_id: string;
@@ -86,7 +135,7 @@ export declare class GoalRepository {
     constructor(workspaceRoot: string);
     private ensureDir;
     private goalPath;
-    private planPath;
+    planPath(goalId: string): string;
     private indexPath;
     private writeAtomic;
     private readJson;