@voybio/ace-swarm 2.4.9 → 2.4.10

package/dist/todo-state.js

@@ -1,5 +1,7 @@
-import { existsSync } from "node:fs";
-import { ACE_TASKS_ROOT_REL, resolveWorkspaceRoot, resolveWritableTaskPath, safeRead, safeWrite, safeWriteAsync, withFileLock, wsPath, } from "./helpers.js";
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { dirname } from "node:path";
+import { TodoSyncer, parseTodoMd, renderTodoMd } from "./store/materializers/todo-syncer.js";
+import { ACE_TASKS_ROOT_REL, resolveWorkspaceRoot, safeRead, safeWrite, wsPath, } from "./helpers.js";
 import { openStore } from "./store/ace-packed-store.js";
 import { ProjectionManager } from "./store/materializers/projection-manager.js";
 import { TodoRepository } from "./store/repositories/todo-repository.js";
@@ -7,6 +9,7 @@ import { getWorkspaceStorePath, readStoreJsonSync, storeExistsSync } from "./sto
 import { operationalArtifactVirtualPath } from "./store/store-artifacts.js";
 import { withStoreWriteCoordinator } from "./store/write-coordinator.js";
 import { isReadError, slugify } from "./shared.js";
+import { deriveLinkedTodo } from './linked-work.js';
 const TODO_MARKDOWN_REL = `${ACE_TASKS_ROOT_REL}/todo.md`;
 const TODO_STATE_REL = "agent-state/todo-state.json";
 let todoMirrorChain = Promise.resolve();
@@ -14,11 +17,12 @@ function workspaceRoot() {
     return resolveWorkspaceRoot();
 }
 const TRANSITIONS = {
-    backlog: ["in_progress", "blocked"],
-    in_progress: ["blocked", "gated", "done"],
-    blocked: ["backlog", "in_progress"],
-    gated: ["in_progress", "blocked", "done"],
+    backlog: ["in_progress", "blocked", "cancelled"],
+    in_progress: ["blocked", "gated", "done", "cancelled"],
+    blocked: ["backlog", "in_progress", "cancelled"],
+    gated: ["in_progress", "blocked", "done", "cancelled"],
     done: ["in_progress", "blocked"],
+    cancelled: ["backlog", "in_progress"],
 };
 function defaultState() {
     return {
@@ -34,48 +38,7 @@ function isTodoNodeStatus(value) {
         value === "in_progress" ||
         value === "blocked" ||
         value === "gated" ||
-        value === "done");
-}
-function parseMeta(rawTitle) {
-    const metaMatch = rawTitle.match(/<!--\s*ace:(.*?)\s*-->/i);
-    const config = {};
-    const applyMetaChunks = (rawMeta) => {
-        for (const chunk of rawMeta.split(";")) {
-            const match = chunk.match(/^\s*([A-Za-z0-9_\- ]+)\s*[:=]\s*(.+?)\s*$/);
-            if (!match)
-                continue;
-            const rawKey = match[1]?.trim() ?? "";
-            const rawValue = match[2]?.trim() ?? "";
-            if (!rawKey || !rawValue)
-                continue;
-            config[rawKey.toLowerCase().replace(/\s+/g, "_")] = rawValue;
-        }
-    };
-    let cleanTitle = rawTitle.trim();
-    if (metaMatch?.[1]) {
-        applyMetaChunks(metaMatch[1]);
-        cleanTitle = cleanTitle.replace(metaMatch[0], "").trim();
-    }
-    while (true) {
-        const inlineMatch = cleanTitle.match(/\s+\(([^()]*[:=][^()]*)\)\s*$/);
-        if (!inlineMatch?.[1])
-            break;
-        const before = cleanTitle.slice(0, cleanTitle.length - inlineMatch[0].length).trimEnd();
-        const priorConfigSize = Object.keys(config).length;
-        applyMetaChunks(inlineMatch[1]);
-        if (Object.keys(config).length === priorConfigSize)
-            break;
-        cleanTitle = before;
-    }
-    const dependsOn = (config.depends_on ?? config.depends ?? "")
-        .split(",")
-        .map((entry) => entry.trim())
-        .filter((entry) => entry.length > 0);
-    return {
-        cleanTitle: cleanTitle.trim(),
-        id: config.id,
-        depends_on: dependsOn,
-    };
+        value === "done" || value === "cancelled");
 }
 function defaultStatusFor(section, checked) {
     if (checked)
@@ -87,48 +50,19 @@ function defaultStatusFor(section, checked) {
         return "in_progress";
     return "backlog";
 }
-function parseTodoMarkdown(todoRaw) {
-    const entries = [];
-    const activeIds = [];
-    const verificationIndexes = [];
-    let section = "General";
-    for (const [idx, line] of todoRaw.split(/\r?\n/).entries()) {
-        const header = line.match(/^##\s+(.+)$/);
-        if (header?.[1]) {
-            section = header[1].trim();
-            continue;
-        }
-        const item = line.match(/^- \[( |x|X)\]\s+(.+)$/);
-        if (!item?.[2])
-            continue;
-        const checked = item[1]?.toLowerCase() === "x";
-        const rawTitle = item[2].trim();
-        const meta = parseMeta(rawTitle);
-        const lineNumber = idx + 1;
-        const id = (meta.id && meta.id.trim()) || `todo-${lineNumber}-${slugify(meta.cleanTitle)}`;
-        const row = {
-            id,
-            title: meta.cleanTitle || "Untitled task",
-            section,
-            line: lineNumber,
-            checked,
-            default_status: defaultStatusFor(section, checked),
-            depends_on: meta.depends_on,
-        };
-        if (section.toLowerCase().includes("active work")) {
-            activeIds.push(id);
-        }
-        if (section.toLowerCase().includes("verification") && row.depends_on.length === 0) {
-            verificationIndexes.push(entries.length);
-        }
-        entries.push(row);
-    }
-    for (const idx of verificationIndexes) {
-        const node = entries[idx];
-        if (!node)
-            continue;
-        node.depends_on = [...activeIds];
-    }
+function parseLegacyTodoEntries(todoRaw) {
+    const { items } = parseTodoMd(todoRaw);
+    const entries = items.map((item) => ({
+        id: item.id ?? `todo-${item.source_line}-${slugify(item.title)}`,
+        title: item.title, section: item.section ?? "General", line: item.source_line,
+        checked: item.status === "done",
+        default_status: item.status === "pending" ? defaultStatusFor(item.section ?? "", false) : mapLegacyStatus(item.status),
+        depends_on: item.depends_on ?? [],
+    }));
+    const active = entries.filter((item) => item.section.toLowerCase().includes("active work")).map((item) => item.id);
+    for (const item of entries)
+        if (item.section.toLowerCase().includes("verification") && !item.depends_on.length)
+            item.depends_on = [...active];
     return entries;
 }
 function parseTodoState(raw) {
@@ -160,6 +94,7 @@ function parseTodoState(raw) {
                 continue;
             }
             nodes[key] = {
+                ...row,
                 id: row.id,
                 title: row.title,
                 section: row.section,
@@ -183,6 +118,9 @@ function parseTodoState(raw) {
     }
 }
 function readPersistedState() {
+    const canonical = readStoreBackedState();
+    if (canonical)
+        return canonical;
     const raw = safeRead(TODO_STATE_REL);
     if (!isReadError(raw)) {
         const parsed = parseTodoState(raw);
@@ -200,6 +138,9 @@ function mapStoreStatus(status) {
         case "done":
             return "done";
         case "gated":
+            return "gated";
+        case "cancelled":
+            return "cancelled";
         case "backlog":
         default:
             return "pending";
@@ -212,8 +153,11 @@ function mapLegacyStatus(status) {
         case "blocked":
             return "blocked";
         case "done":
-        case "cancelled":
             return "done";
+        case "gated":
+            return "gated";
+        case "cancelled":
+            return "cancelled";
         case "pending":
         default:
             return "backlog";
@@ -223,41 +167,26 @@ function readStoreBackedState() {
     const root = workspaceRoot();
     if (!storeExistsSync(root))
         return undefined;
-    const index = readStoreJsonSync(root, "state/todo/index") ?? [];
-    if (index.length === 0)
+    const index = readStoreJsonSync(root, "state/todo/index");
+    if (!index)
         return undefined;
+    const records = index.map((id) => readStoreJsonSync(root, `state/todo/${id}`)).filter((record) => !!record).map(record => deriveLinkedTodo(record, root));
+    return todoStateFromRecords(records);
+}
+function todoStateFromRecords(records) {
     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")
-                : [],
+    let updatedAt = 0;
+    for (const record of records) {
+        nodes[record.id] = {
+            ...record,
+            section: record.section ?? (record.notes?.startsWith("section: ") ? record.notes.slice(9) : ""),
+            source_line: record.source_line ?? 0,
+            depends_on: record.depends_on ?? [],
             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);
-        }
+        updatedAt = Math.max(updatedAt, record.updated_at ?? 0);
     }
-    return {
-        version: 1,
-        updated_at: new Date(updatedAt).toISOString(),
-        source_todo_path: TODO_MARKDOWN_REL,
-        order,
-        nodes,
-    };
+    return { version: 1, updated_at: updatedAt ? new Date(updatedAt).toISOString() : "", source_todo_path: TODO_MARKDOWN_REL, order: records.map((record) => record.id), nodes };
 }
 async function mirrorTodoStateToStore(root, state) {
     const storePath = getWorkspaceStorePath(root);
@@ -268,61 +197,29 @@ async function mirrorTodoStateToStore(root, state) {
         try {
             const nextIds = state.order.filter((id) => Boolean(state.nodes[id]));
             const previousIds = (await store.getJSON("state/todo/index")) ?? [];
-            for (const staleId of previousIds.filter((id) => !nextIds.includes(id))) {
-                await store.delete(`state/todo/${staleId}`);
-            }
             for (const id of nextIds) {
                 const node = state.nodes[id];
                 if (!node)
                     continue;
                 const existing = await store.getJSON(`state/todo/${id}`);
                 await store.setJSON(`state/todo/${id}`, {
+                    ...existing,
                     id: node.id,
                     title: node.title,
                     status: mapStoreStatus(node.status),
                     depends_on: node.depends_on,
                     created_at: existing?.created_at ?? Date.now(),
                     updated_at: Date.now(),
-                    notes: node.section ? `section: ${node.section}` : undefined,
+                    section: node.section,
                 });
             }
-            await store.setJSON("state/todo/index", nextIds);
-            await store.commit();
-            const projections = new ProjectionManager(store, root);
-            await projections.projectAfterCommit(["todo_state"]);
-        }
-        finally {
-            await store.close();
-        }
-    }, { operation_label: "syncTodoStateSafe" });
-}
-async function writeStateStoreBacked(root, state) {
-    const storePath = getWorkspaceStorePath(root);
-    if (!existsSync(storePath)) {
-        return writeState(state);
-    }
-    return withStoreWriteCoordinator(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.setJSON("state/todo/index", [...new Set([...previousIds, ...nextIds])]);
             await store.commit();
             const projections = new ProjectionManager(store, root);
             await projections.projectAfterCommit(["todo_state"]);
-            return operationalArtifactVirtualPath(root, TODO_STATE_REL);
         }
         finally {
-            await store.close();
+            await store.close({ commit: false });
         }
     }, { operation_label: "syncTodoStateSafe" });
 }
@@ -344,9 +241,9 @@ function writeState(state) {
     return path;
 }
 function syncStateWithTodo(todoRaw, previous) {
-    const parsed = parseTodoMarkdown(todoRaw);
-    const nodes = {};
-    const order = [];
+    const parsed = parseLegacyTodoEntries(todoRaw);
+    const nodes = { ...previous.nodes };
+    const order = [...previous.order];
     for (const row of parsed) {
         const prev = previous.nodes[row.id];
         let status;
@@ -360,6 +257,7 @@ function syncStateWithTodo(todoRaw, previous) {
             status = row.default_status;
         }
         nodes[row.id] = {
+            ...prev,
             id: row.id,
             title: row.title,
             section: row.section,
@@ -367,7 +265,8 @@ function syncStateWithTodo(todoRaw, previous) {
             depends_on: row.depends_on.filter((dep) => dep !== row.id),
             status,
         };
-        order.push(row.id);
+        if (!order.includes(row.id))
+            order.push(row.id);
     }
     return {
         version: 1,
@@ -385,38 +284,6 @@ function setTodoCheckbox(todoRaw, line, checked) {
     lines[line - 1] = target.replace(/^- \[( |x|X)\]/, `- [${checked ? "x" : " "}]`);
     return lines.join("\n");
 }
-function insertTodoItem(todoRaw, section, title, id, dependsOn) {
-    const metaParts = [`id=${id}`];
-    if (dependsOn.length > 0)
-        metaParts.push(`depends_on=${dependsOn.join(",")}`);
-    const newLine = `- [ ] ${title} <!-- ace:${metaParts.join("; ")} -->`;
-    const lines = todoRaw.length > 0 ? todoRaw.split(/\r?\n/) : [];
-    let sectionStart = -1;
-    let sectionEnd = lines.length;
-    for (let i = 0; i < lines.length; i++) {
-        const header = lines[i]?.match(/^##\s+(.+)$/);
-        if (!header?.[1])
-            continue;
-        if (header[1].trim().toLowerCase() === section.toLowerCase()) {
-            sectionStart = i;
-            let j = i + 1;
-            while (j < lines.length && !/^##\s+/.test(lines[j] ?? ""))
-                j++;
-            sectionEnd = j;
-            break;
-        }
-    }
-    if (sectionStart === -1) {
-        const trimmed = todoRaw.replace(/\s+$/, "");
-        const prefix = trimmed.length > 0 ? `${trimmed}\n\n` : "";
-        return `${prefix}## ${section}\n${newLine}\n`;
-    }
-    let insertAt = sectionEnd;
-    while (insertAt > sectionStart + 1 && (lines[insertAt - 1] ?? "").trim() === "")
-        insertAt--;
-    lines.splice(insertAt, 0, newLine);
-    return lines.join("\n");
-}
 function uniqueTodoId(base, existingIds) {
     if (!existingIds.has(base))
         return base;
@@ -435,6 +302,8 @@ export function getTodoStatePath() {
     return wsPath(TODO_STATE_REL);
 }
 export function syncTodoState(todoContent) {
+    if (todoContent === undefined && storeExistsSync(workspaceRoot()))
+        return { state: readTodoState(), path: operationalArtifactVirtualPath(workspaceRoot(), TODO_STATE_REL) };
     const todoRaw = typeof todoContent === "string" ? todoContent : safeRead(TODO_MARKDOWN_REL);
     if (isReadError(todoRaw)) {
         const path = writeState(defaultState());
@@ -444,28 +313,99 @@ export function syncTodoState(todoContent) {
     const path = writeState(state);
     return { state, path };
 }
-// Lock-free core: callers that already hold the TODO_MARKDOWN_REL lock (e.g.
-// appendTodoItemSafe) must call this directly instead of syncTodoStateSafe,
-// since withFileLock is not reentrant and re-acquiring the same key deadlocks.
-async function syncTodoStateLocked(todoContent) {
+/** A single fresh repository transaction, followed by repairable projections. */
+async function mutateTodos(label, action, content) {
     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 storePath = getWorkspaceStorePath(root);
+    return withStoreWriteCoordinator(storePath, async () => {
+        const store = await openStore(storePath);
+        try {
+            if ((await store.getJSON("state/todo/index")) === undefined) {
+                const legacy = readPersistedState();
+                const repo = new TodoRepository(store);
+                for (const id of legacy.order) {
+                    const node = legacy.nodes[id];
+                    if (node)
+                        await repo.create({ ...node, status: mapStoreStatus(node.status) });
+                }
+            }
+            const syncer = new TodoSyncer(store, root);
+            const md = getTodoPath();
+            const original = existsSync(md) ? readFileSync(md, "utf8") : undefined;
+            let imported = await syncer.syncFromFile();
+            if (typeof content === "string") {
+                const submitted = await syncer.syncFromFile(content, false, false);
+                imported = { changed: imported.changed || submitted.changed, import_warnings: submitted.import_warnings };
+            }
+            const repository = new TodoRepository(store);
+            for (const todo of await repository.getAll()) {
+                const derived = deriveLinkedTodo(todo, root);
+                if (derived.status !== todo.status || derived.assigned_to !== todo.assigned_to || JSON.stringify(derived.step_ref) !== JSON.stringify(todo.step_ref))
+                    await repository.update(todo.id, { status: derived.status, assigned_to: derived.assigned_to, step_ref: derived.step_ref });
+            }
+            const result = await action(new TodoRepository(store));
+            await store.commit();
+            const warnings = [...imported.import_warnings];
+            let projectionPending = false;
+            // Explicit imports/deletes own their supplied text. Never overwrite a newer native edit.
+            const replacement = result.ok ? (typeof content === "function" ? content(original ?? "") : content) : undefined;
+            try {
+                if (replacement !== undefined) {
+                    if ((existsSync(md) ? readFileSync(md, "utf8") : undefined) !== original) {
+                        warnings.push("Todo markdown changed during the operation; newer native edit retained.");
+                        projectionPending = true;
+                    }
+                    else {
+                        mkdirSync(dirname(md), { recursive: true });
+                        writeFileSync(md, replacement, "utf8");
+                        if (typeof content === "string")
+                            await syncer.acknowledgeSubmittedFile(replacement);
+                        else {
+                            const checked = await syncer.syncFromFile(undefined, true);
+                            warnings.splice(0, warnings.length, ...checked.import_warnings);
+                        }
+                        await store.commit();
+                    }
+                }
+                if ((result.ok && label !== "read_todos") || imported.changed || !existsSync(md) || (!warnings.length && !(await syncer.projectionIsCurrent()))) {
+                    const projected = await new ProjectionManager(store, root).projectAfterCommit(["todo_state"]);
+                    warnings.push(...(projected.todo?.import_warnings ?? []));
+                    projectionPending ||= projected.todo?.written === false;
+                }
+            }
+            catch (error) {
+                warnings.push(`Todo state committed; projection refresh pending: ${error instanceof Error ? error.message : String(error)}`);
+                projectionPending = true;
+            }
+            return { ...result, import_warnings: [...new Set(warnings)], projection_pending: projectionPending || warnings.length > 0 };
         }
-        const state = syncStateWithTodo(todoRaw, readPersistedState());
-        const path = await writeStateStoreBacked(root, state);
-        return { state, path };
-    }
-    const result = syncTodoState(todoContent);
-    await waitForTodoStoreMirror();
-    return result;
+        finally {
+            await store.close({ commit: false });
+        }
+    }, { operation_label: label });
+}
+/** Repair a linked projection after its authoritative plan has been saved. */
+export async function syncLinkedTodoStepSafe(id, ref, step) {
+    return mutateTodos('linked_todo_view', async (repo) => {
+        const todo = await repo.get(id);
+        if (!todo)
+            throw new Error(`Linked todo missing: ${id}`);
+        if (todo.step_ref && (todo.step_ref.goal_id !== ref.goal_id || todo.step_ref.step_id !== ref.step_id))
+            throw new Error(`Todo already linked elsewhere: ${id}`);
+        const derived = deriveLinkedTodo({ ...todo, step_ref: ref }, workspaceRoot());
+        const notes = step.blocked_reason && !todo.notes?.includes(step.blocked_reason) ? [todo.notes, step.blocked_reason].filter(Boolean).join('\n') : todo.notes;
+        const patch = { step_ref: ref, status: derived.status, assigned_to: derived.assigned_to, notes };
+        if (Object.entries(patch).some(([key, value]) => JSON.stringify(todo[key]) !== JSON.stringify(value)))
+            await repo.update(id, patch);
+        return { ok: true };
+    });
 }
 export async function syncTodoStateSafe(todoContent) {
-    return withFileLock(TODO_MARKDOWN_REL, () => syncTodoStateLocked(todoContent));
+    const result = await mutateTodos(todoContent === undefined ? "read_todos" : "import_todos", async (repo) => {
+        const records = await repo.getAll();
+        return { ok: true, markdown: renderTodoMd(records), state: todoStateFromRecords(records) };
+    }, todoContent);
+    return { state: result.state, markdown: result.markdown, path: operationalArtifactVirtualPath(workspaceRoot(), TODO_STATE_REL), import_warnings: result.import_warnings, projection_pending: result.projection_pending };
 }
 export function readTodoState() {
     if (storeExistsSync(workspaceRoot())) {
@@ -544,121 +484,64 @@ export function transitionTodoNode(nodeId, targetStatus) {
     };
 }
 export async function transitionTodoNodeSafe(nodeId, targetStatus) {
-    return withFileLock(TODO_MARKDOWN_REL, async () => {
-        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 current = readStoreJsonSync(workspaceRoot(), `state/todo/${nodeId}`);
+    if (current && deriveLinkedTodo(current, workspaceRoot()).step_ref)
+        return { ok: false, path: getTodoStatePath(), todo_path: getTodoPath(), error: 'Linked todo status belongs to its goal step; use complete_step.' };
+    return mutateTodos("transition_todo", async (repo) => {
+        const base = { path: getTodoStatePath(), todo_path: getTodoPath(), node_id: nodeId };
+        const node = await repo.get(nodeId);
+        if (!node)
+            return { ...base, ok: false, error: `Unknown node_id: ${nodeId}` };
+        const from = mapLegacyStatus(node.status);
+        if (from !== targetStatus && !TRANSITIONS[from]?.includes(targetStatus))
+            return { ...base, ok: false, from, to: targetStatus, allowed: TRANSITIONS[from], error: `Invalid transition ${from} -> ${targetStatus}` };
+        if (["in_progress", "gated", "done"].includes(targetStatus)) {
+            const unresolved = [];
+            for (const dep of node.depends_on ?? [])
+                if ((await repo.get(dep))?.status !== "done")
+                    unresolved.push(dep);
+            if (unresolved.length)
+                return { ...base, ok: false, from, to: targetStatus, unresolved_dependencies: unresolved, error: `Dependencies not satisfied for ${nodeId}` };
         }
-        const result = transitionTodoNode(nodeId, targetStatus);
-        await waitForTodoStoreMirror();
-        return result;
+        if (from !== targetStatus)
+            await repo.update(nodeId, { status: mapStoreStatus(targetStatus) });
+        return { ...base, ok: true, from, to: targetStatus };
     });
 }
-/**
- * Atomically append a new TODO item under a section, without requiring the
- * caller to read the whole board and resubmit it via update_todo(new_content).
- * That read-modify-write dance is what let concurrent agents silently clobber
- * each other's appended items: the read and write are separate MCP calls, so
- * a lock around the write alone cannot close the race. Here the read, insert,
- * and write all happen inside one TODO_MARKDOWN_REL lock acquisition.
- */
+/** Insert once under the cross-process coordinator; never reconstruct existing records. */
 export async function appendTodoItemSafe(title, options) {
-    const trimmedTitle = title.trim();
-    if (!trimmedTitle) {
-        return {
-            ok: false,
-            path: getTodoStatePath(),
-            todo_path: getTodoPath(),
-            error: "Todo item title must not be empty.",
-        };
-    }
-    return withFileLock(TODO_MARKDOWN_REL, async () => {
-        const existingRaw = safeRead(TODO_MARKDOWN_REL);
-        const baseRaw = isReadError(existingRaw) ? "# Tasks\n" : existingRaw;
+    const trimmed = title.trim();
+    const base = { path: getTodoStatePath(), todo_path: getTodoPath() };
+    if (!trimmed)
+        return { ...base, ok: false, error: "Todo item title must not be empty." };
+    return mutateTodos("append_todo", async (repo) => {
+        const ids = new Set((await repo.getAll()).map((todo) => todo.id));
+        const id = options?.id?.trim() || uniqueTodoId(`todo-${slugify(trimmed)}`, ids);
+        if (ids.has(id))
+            return { ...base, ok: false, error: `Todo id already exists: ${id}` };
         const section = options?.section?.trim() || "Active Work";
-        const dependsOn = (options?.depends_on ?? []).map((dep) => dep.trim()).filter(Boolean);
-        const existingIds = new Set(parseTodoMarkdown(baseRaw).map((entry) => entry.id));
-        const requestedId = options?.id?.trim();
-        if (requestedId && existingIds.has(requestedId)) {
-            return {
-                ok: false,
-                path: getTodoStatePath(),
-                todo_path: getTodoPath(),
-                error: `Todo id already exists: ${requestedId}`,
-            };
-        }
-        const id = requestedId || uniqueTodoId(`todo-${slugify(trimmedTitle)}`, existingIds);
-        const updatedRaw = insertTodoItem(baseRaw, section, trimmedTitle, id, dependsOn);
-        const synced = await syncTodoStateLocked(updatedRaw);
-        const mdPath = await safeWriteAsync(resolveWritableTaskPath("todo"), updatedRaw);
-        return {
-            ok: true,
-            path: synced.path,
-            todo_path: mdPath,
-            node_id: id,
-            section,
-        };
+        await repo.create({ id, title: trimmed, status: "pending", section, depends_on: options?.depends_on?.map((dep) => dep.trim()).filter(Boolean) ?? [] });
+        return { ...base, ok: true, node_id: id, section };
+    });
+}
+export async function deleteTodoItemSafe(nodeId) {
+    return mutateTodos("delete_todo", async (repo) => {
+        const removed = await repo.remove(nodeId);
+        return { ok: removed, node_id: nodeId, path: getTodoStatePath(), todo_path: getTodoPath(), ...(removed ? {} : { error: `Unknown node_id: ${nodeId}` }) };
+    }, (raw) => {
+        const lines = raw.split(/\r?\n/);
+        let removing = false;
+        return lines.filter((line) => {
+            if (removing && /^\s*>/.test(line))
+                return false;
+            removing = false;
+            const id = line.match(/\(id:\s*([^;)]+)/)?.[1]?.trim() ?? line.match(/<!--\s*ace:.*?id\s*[:=]\s*([^;>]+)/)?.[1]?.trim();
+            if (id === nodeId) {
+                removing = true;
+                return false;
+            }
+            return true;
+        }).join("\n");
     });
 }
 //# sourceMappingURL=todo-state.js.map