@voybio/ace-swarm 2.4.8 → 2.4.10

package/dist/store/source-preservation.js

@@ -0,0 +1,79 @@
+import { createHash } from "node:crypto";
+import { closeSync, constants, fstatSync, lstatSync, openSync, readFileSync, realpathSync } from "node:fs";
+import { dirname, isAbsolute, relative } from "node:path";
+import { readStoreJsonByPathSync } from "./store-snapshot.js";
+export function sourceFromBytes(sourcePath, bytes) {
+    return {
+        source_path: sourcePath.replaceAll("\\", "/"),
+        sha256: createHash("sha256").update(bytes).digest("hex"),
+        byte_length: bytes.length,
+        content_base64: bytes.toString("base64"),
+    };
+}
+function identity(stat) {
+    const { dev, ino, size, mtimeMs, ctimeMs } = stat;
+    return { dev, ino, size, mtimeMs, ctimeMs };
+}
+function sameIdentity(a, b) {
+    return Object.entries(a).every(([key, value]) => b[key] === value);
+}
+/** Capture exact bytes without following a replaced final symlink or accepting an unstable read. */
+export function captureWorkspaceSource(root, path) {
+    const parent = relative(realpathSync(root), realpathSync(dirname(path)));
+    if (parent.startsWith("..") || isAbsolute(parent))
+        throw new Error(`Source outside workspace: ${path}`);
+    const fd = openSync(path, constants.O_RDONLY | constants.O_NOFOLLOW);
+    try {
+        const before = fstatSync(fd);
+        if (!before.isFile())
+            throw new Error(`Source is not a regular file: ${path}`);
+        const bytes = readFileSync(fd);
+        const after = fstatSync(fd);
+        const current = lstatSync(path);
+        if (current.isSymbolicLink() || !sameIdentity(identity(before), identity(after)) || !sameIdentity(identity(after), identity(current))) {
+            throw new Error(`Source changed during read: ${path}`);
+        }
+        return { ...sourceFromBytes(relative(root, path), bytes), identity: identity(after) };
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+export function sourceUnchanged(root, path, source) {
+    try {
+        const current = captureWorkspaceSource(root, path);
+        return current.sha256 === source.sha256 && !!source.identity && !!current.identity && sameIdentity(source.identity, current.identity);
+    }
+    catch {
+        return false;
+    }
+}
+export function preservedSourceKey(source) {
+    const pathHash = createHash("sha256").update(source.source_path).digest("hex");
+    return `state/migrations/sources/${pathHash}/${source.sha256}`;
+}
+export async function stagePreservedSource(store, source) {
+    const key = preservedSourceKey(source);
+    const existing = await store.getJSON(key);
+    if (existing) {
+        if (existing.source_path !== source.source_path || existing.content_base64 !== source.content_base64 || existing.sha256 !== source.sha256) {
+            throw new Error(`Preserved-source collision: ${source.source_path}`);
+        }
+    }
+    else {
+        await store.setJSON(key, source);
+    }
+    return key;
+}
+/** Uses the committed-file reader, never the writer's pending values. */
+export function verifyPreservedSource(storePath, source) {
+    const retained = readStoreJsonByPathSync(storePath, preservedSourceKey(source));
+    if (!retained || retained.source_path !== source.source_path || retained.byte_length !== source.byte_length || retained.sha256 !== source.sha256 || retained.content_base64 !== source.content_base64) {
+        throw new Error(`Exact-source readback failed: ${source.source_path}`);
+    }
+    const bytes = Buffer.from(retained.content_base64, "base64");
+    if (bytes.length !== source.byte_length || sourceFromBytes(source.source_path, bytes).sha256 !== source.sha256) {
+        throw new Error(`Exact-source digest mismatch: ${source.source_path}`);
+    }
+}
+//# sourceMappingURL=source-preservation.js.map

package/dist/store/store-artifacts.js

@@ -5,6 +5,7 @@ import { getWorkspaceStorePath, invalidateStoreSnapshotCache, readStoreBlobSync,
 import { withStoreWriteCoordinator } from "./write-coordinator.js";
 import { HEADER_SIZE, HEADER_SIZE_V1, STORE_VERSION, MAGIC } from "./types.js";
 import { crc32 } from "./crc32.js";
+import { assertTestWriteAllowed } from "./test-write-boundary.js";
 // ── v2 header constants (mirrors ace-packed-store.ts) ─────────────────────────
 const H_KV_IDX_OFF = 16;
 const H_KV_IDX_LEN = 24;
@@ -146,6 +147,7 @@ function validateStoreHeaderInvariants(hdr, index, fileLength) {
 }
 function quarantineCorruptStore(storePath, rawFile) {
     const quarantinePath = `${storePath}.corrupt-${Date.now()}`;
+    assertTestWriteAllowed(quarantinePath);
     writeFileSync(quarantinePath, rawFile);
     return quarantinePath;
 }
@@ -194,6 +196,7 @@ export function operationalArtifactVirtualPath(workspaceRoot, relPath) {
 }
 export function writeStoreBlobsSync(workspaceRoot, blobs) {
     const storePath = getWorkspaceStorePath(workspaceRoot);
+    assertTestWriteAllowed(storePath);
     const { file, kvChunkEnd, evtBytes, evtCount, evtBaseId, index } = readStoreBuffer(storePath);
     const encoded = blobs.map(({ key, content }) => ({
         key,
@@ -255,8 +258,12 @@ export async function writeStoreBlobsQueued(workspaceRoot, blobs, options = {})
             await store.commit();
             return blobs.map(({ key }) => toVirtualStorePath(storePath, key));
         }
+        catch (error) {
+            store.discardPending();
+            throw error;
+        }
         finally {
-            await store.close();
+            await store.close({ commit: false });
         }
     }, { ...options, operation_label: options.operation_label ?? "writeStoreBlobsQueued" });
 }

package/dist/store/test-write-boundary.d.ts

@@ -0,0 +1,16 @@
+export interface TestWriteAnchor {
+    path: string;
+    dev: string;
+    ino: string;
+}
+export declare class TestWriteBoundaryError extends Error {
+    readonly code = "ACE_TEST_WRITE_BOUNDARY";
+    constructor(message: string);
+}
+export declare function assertTestWriteAllowed(path: string): void;
+/** Pin a store handle to the directory that actually existed when it opened. */
+export declare function captureTestWriteBoundary(path: string): () => void;
+/** Retain fixture ownership across promises and timers created by a mutation. */
+export declare function withTestWriteBoundary<T>(path: string, fn: () => T): T;
+export declare function currentTestWriteAnchors(): readonly TestWriteAnchor[];
+//# sourceMappingURL=test-write-boundary.d.ts.map

package/dist/store/test-write-boundary.js

@@ -0,0 +1,175 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import { lstatSync, readFileSync, realpathSync, statSync } from "node:fs";
+import { basename, dirname, isAbsolute, join, relative } from "node:path";
+export class TestWriteBoundaryError extends Error {
+    code = "ACE_TEST_WRITE_BOUNDARY";
+    constructor(message) {
+        super(`Test write refused: ${message}`);
+        this.name = "TestWriteBoundaryError";
+    }
+}
+const contexts = new AsyncLocalStorage();
+const boundarySymbol = Symbol.for("ace.test.write-boundary");
+// Node's JS realpath implementation lexically normalizes `..` before symlinks.
+// The native resolver follows the same traversal as an eventual filesystem write.
+const canonicalRealpath = realpathSync.native;
+function testContextPresent() {
+    return process.env.ACE_TEST_ISOLATION !== undefined ||
+        process.env.ACE_TEST_ALLOWED_ROOTS !== undefined ||
+        process.env.ACE_TEST_WORKER_ROOT !== undefined ||
+        process.env.NODE_TEST_CONTEXT !== undefined;
+}
+function anchor(path) {
+    const canonical = canonicalRealpath(path);
+    const info = statSync(canonical, { bigint: true });
+    if (!info.isDirectory())
+        throw new Error("allocated root must be a directory");
+    return { path: canonical, dev: String(info.dev), ino: String(info.ino) };
+}
+function parseAnchors(raw) {
+    if (!raw)
+        return [];
+    const value = JSON.parse(raw);
+    if (!Array.isArray(value) || value.some((item) => !item || typeof item !== "object" ||
+        typeof item.path !== "string" || !isAbsolute(item.path) || typeof item.dev !== "string" || typeof item.ino !== "string")) {
+        throw new Error("invalid inherited fixture identities");
+    }
+    return value;
+}
+function captureConfiguration() {
+    if (!testContextPresent())
+        return { active: false, roots: [], inherited: [] };
+    try {
+        if (process.env.ACE_TEST_ISOLATION !== "1")
+            throw new Error("isolated runner marker is missing");
+        const paths = JSON.parse(process.env.ACE_TEST_ALLOWED_ROOTS ?? "null");
+        if (!Array.isArray(paths) || paths.length === 0 || paths.some((path) => typeof path !== "string" || !isAbsolute(path))) {
+            throw new Error("allocated fixture roots are missing or invalid");
+        }
+        if (!process.env.ACE_TEST_LEASE_FILE || !isAbsolute(process.env.ACE_TEST_LEASE_FILE) || !process.env.ACE_TEST_RUN_ID) {
+            throw new Error("fixture lease identity is missing");
+        }
+        return { active: true, roots: paths.map(anchor), inherited: parseAnchors(process.env.ACE_TEST_WRITE_ANCHORS), lease: process.env.ACE_TEST_LEASE_FILE, run: process.env.ACE_TEST_RUN_ID };
+    }
+    catch (error) {
+        return { active: true, roots: [], inherited: [], error: error instanceof Error ? error.message : String(error) };
+    }
+}
+// Capture once before application loading: later environment changes cannot
+// disable the test boundary or turn an outside workspace into an allowed root.
+let configuration = captureConfiguration();
+function validateAnchor(value) {
+    try {
+        const current = anchor(value.path);
+        if (current.path === value.path && current.dev === value.dev && current.ino === value.ino)
+            return;
+    }
+    catch { /* Removed fixtures and symlink substitutions are both refused. */ }
+    throw new TestWriteBoundaryError(`allocated fixture was removed or replaced: ${value.path}`);
+}
+/**
+ * Resolve existing symlinks before appending a not-yet-created suffix.
+ * `parent` is the directory holding the target's entry. An existing target
+ * directory (such as a contended lock) is never its own ownership anchor:
+ * another owner may legitimately remove it.
+ */
+function destination(path) {
+    let cursor = isAbsolute(path) ? path : `${process.cwd()}/${path}`;
+    const suffix = [];
+    while (true) {
+        try {
+            const info = lstatSync(cursor);
+            const canonical = canonicalRealpath(cursor);
+            const parent = suffix.length > 0 && info.isDirectory() ? canonical : dirname(canonical);
+            return { canonical: join(canonical, ...suffix), parent };
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+            // A dangling symlink is an existing object, not a safe missing directory.
+            try {
+                if (lstatSync(cursor).isSymbolicLink())
+                    throw new TestWriteBoundaryError(`unresolved symlink: ${cursor}`);
+            }
+            catch (probe) {
+                if (probe instanceof TestWriteBoundaryError)
+                    throw probe;
+            }
+            const parent = dirname(cursor);
+            if (parent === cursor)
+                throw error;
+            suffix.unshift(basename(cursor));
+            cursor = parent;
+        }
+    }
+}
+function inside(root, path) {
+    const subpath = relative(root, path);
+    return subpath === "" || (!isAbsolute(subpath) && subpath !== ".." && !subpath.startsWith(`..${process.platform === "win32" ? "\\" : "/"}`));
+}
+export function assertTestWriteAllowed(path) {
+    // Also fail closed if a module was imported before a test context was set.
+    if (!configuration.active && testContextPresent())
+        configuration = captureConfiguration();
+    if (!configuration.active)
+        return;
+    if (configuration.error)
+        throw new TestWriteBoundaryError(configuration.error);
+    if (!globalThis[Symbol.for("ace.test.preload")]) {
+        throw new TestWriteBoundaryError("the isolated runner preloader has not established the fixture boundary");
+    }
+    try {
+        const lease = JSON.parse(readFileSync(configuration.lease, "utf8"));
+        if (lease.status !== "active" || lease.run_id !== configuration.run)
+            throw new Error("inactive lease");
+    }
+    catch {
+        throw new TestWriteBoundaryError("fixture lease is missing, closed, or belongs to another run");
+    }
+    for (const value of [...configuration.roots, ...configuration.inherited, ...(contexts.getStore() ?? [])])
+        validateAnchor(value);
+    let target;
+    try {
+        target = destination(path).canonical;
+    }
+    catch (error) {
+        throw error instanceof TestWriteBoundaryError ? error : new TestWriteBoundaryError(`cannot resolve destination: ${path}`);
+    }
+    if (!configuration.roots.some((root) => inside(root.path, target))) {
+        throw new TestWriteBoundaryError(`destination is outside allocated fixtures: ${path}`);
+    }
+}
+/** Pin a store handle to the directory that actually existed when it opened. */
+export function captureTestWriteBoundary(path) {
+    assertTestWriteAllowed(path);
+    if (!configuration.active)
+        return () => { };
+    const captured = [...(contexts.getStore() ?? []), anchor(destination(path).parent)];
+    return () => {
+        assertTestWriteAllowed(path);
+        for (const value of captured)
+            validateAnchor(value);
+    };
+}
+/** Retain fixture ownership across promises and timers created by a mutation. */
+export function withTestWriteBoundary(path, fn) {
+    assertTestWriteAllowed(path);
+    if (!configuration.active)
+        return fn();
+    const captured = [...(contexts.getStore() ?? []), anchor(destination(path).parent)];
+    return contexts.run(captured, fn);
+}
+export function currentTestWriteAnchors() {
+    return [...configuration.inherited, ...(contexts.getStore() ?? [])];
+}
+// The isolated runner propagates these identities into owned subprocesses. This
+// contains paths/inodes only, never store contents or application state.
+if (!globalThis[boundarySymbol]) {
+    Object.defineProperty(globalThis, boundarySymbol, { value: Object.freeze({
+            serialize: () => JSON.stringify(currentTestWriteAnchors()),
+        }), configurable: false, writable: false });
+}
+if (!globalThis[Symbol.for("ace.test.write.anchors")]) {
+    Object.defineProperty(globalThis, Symbol.for("ace.test.write.anchors"), { get: currentTestWriteAnchors, configurable: false });
+}
+//# sourceMappingURL=test-write-boundary.js.map

package/dist/store/types.d.ts

@@ -62,7 +62,10 @@ export interface IAcePackedStore extends AsyncReadable, AsyncWritable {
     open(path: string): Promise<void>;
     commit(): Promise<void>;
     compact(): Promise<void>;
-    close(): Promise<void>;
+    discardPending(): void;
+    close(options?: {
+        commit?: boolean;
+    }): Promise<void>;
     list(): AsyncGenerator<string>;
     getJSON<T>(key: string): Promise<T | undefined>;
     setJSON(key: string, value: unknown): Promise<void>;
@@ -130,6 +133,7 @@ export interface MaterializationChecksum {
 }
 export interface HookContextSnapshot {
     schema_version: 1;
+    current_work?: string;
     generated_at: string;
     task: {
         content: string;

package/dist/store/write-coordinator.js

@@ -4,6 +4,7 @@ import { hostname } from "node:os";
 import { dirname, join } from "node:path";
 import { getWorkspaceStorePath } from "./store-snapshot.js";
 import { withStoreWriteQueue } from "./write-queue.js";
+import { assertTestWriteAllowed, withTestWriteBoundary } from "./test-write-boundary.js";
 const DEFAULT_WAIT_MS = 15_000;
 const DEFAULT_POLL_INTERVAL_MS = 100;
 const DEFAULT_LEASE_TTL_MS = 30_000;
@@ -203,20 +204,27 @@ function createLeaseRecord(storePath, lockPath, options, waitedMs) {
     };
 }
 function tryAcquireLeaseSync(storePath, lockPath, options, waitedMs) {
+    assertTestWriteAllowed(storePath);
+    assertTestWriteAllowed(lockPath);
     mkdirSync(dirname(lockPath), { recursive: true });
     mkdirSync(lockPath, { recursive: false });
     const lease = createLeaseRecord(storePath, lockPath, options, waitedMs);
+    assertTestWriteAllowed(lease.metadataPath);
     writeFileSync(lease.metadataPath, JSON.stringify({ kind: "store_write_lease", ...lease }, null, 2), "utf-8");
     return lease;
 }
 async function tryAcquireLeaseAsync(storePath, lockPath, options, waitedMs) {
+    assertTestWriteAllowed(storePath);
+    assertTestWriteAllowed(lockPath);
     mkdirSync(dirname(lockPath), { recursive: true });
     mkdirSync(lockPath, { recursive: false });
     const lease = createLeaseRecord(storePath, lockPath, options, waitedMs);
+    assertTestWriteAllowed(lease.metadataPath);
     writeFileSync(lease.metadataPath, JSON.stringify({ kind: "store_write_lease", ...lease }, null, 2), "utf-8");
     return lease;
 }
 function releaseLease(lease) {
+    assertTestWriteAllowed(lease.lockPath);
     const current = readLeaseRecord(lease.lockPath);
     if (!current) {
         rmSync(lease.lockPath, { recursive: true, force: true });
@@ -245,6 +253,7 @@ async function acquireLeaseAsync(storePath, options) {
                 throw error;
             const current = readLeaseRecord(lockPath);
             if (current && canRecoverStaleLease(current, staleGraceMs)) {
+                assertTestWriteAllowed(lockPath);
                 rmSync(lockPath, { recursive: true, force: true });
                 continue;
             }
@@ -285,6 +294,7 @@ function acquireLeaseSync(storePath, options) {
                 throw error;
             const current = readLeaseRecord(lockPath);
             if (current && canRecoverStaleLease(current, staleGraceMs)) {
+                assertTestWriteAllowed(lockPath);
                 rmSync(lockPath, { recursive: true, force: true });
                 continue;
             }
@@ -308,6 +318,9 @@ function acquireLeaseSync(storePath, options) {
     });
 }
 export async function withStoreWriteCoordinator(storePath, fn, options = {}) {
+    return withTestWriteBoundary(storePath, () => withStoreWriteCoordinatorInternal(storePath, fn, options));
+}
+async function withStoreWriteCoordinatorInternal(storePath, fn, options) {
     const operationLabel = getOperationLabel(options);
     registerAsyncStoreOwnership(storePath, operationLabel);
     emitLifecycleEvent(options, {
@@ -367,6 +380,9 @@ export async function withStoreWriteCoordinator(storePath, fn, options = {}) {
     }
 }
 export function withStoreWriteCoordinatorSync(storePath, fn, options = {}) {
+    return withTestWriteBoundary(storePath, () => withStoreWriteCoordinatorSyncInternal(storePath, fn, options));
+}
+function withStoreWriteCoordinatorSyncInternal(storePath, fn, options) {
     const operationLabel = getOperationLabel(options);
     const asyncOwnership = getAsyncStoreOwnership(storePath);
     if (asyncOwnership && asyncOwnership.count > 0) {

package/dist/task-plan-context.d.ts

@@ -0,0 +1,11 @@
+import type { TaskPlan, TaskStep } from "./orchestrator-supervisor.js";
+/** Preserve complete Unicode code points while respecting the delivered byte budget. */
+export declare function utf8Prefix(text: string, maxBytes: number): string;
+export declare function getReadyTaskSteps(plan: TaskPlan): TaskStep[];
+export declare function formatStepTaskForBridge(step: Pick<TaskStep, "task" | "upstream_outputs">): string;
+export declare function collectUpstreamOutputs(plan: TaskPlan, step: TaskStep): {
+    step_id: string;
+    result_summary: string;
+    evidence_refs: string[];
+}[];
+//# sourceMappingURL=task-plan-context.d.ts.map

package/dist/task-plan-context.js

@@ -0,0 +1,59 @@
+/** Preserve complete Unicode code points while respecting the delivered byte budget. */
+export function utf8Prefix(text, maxBytes) {
+    let bytes = 0, result = '';
+    for (const char of text) {
+        const size = Buffer.byteLength(char);
+        if (bytes + size > maxBytes)
+            break;
+        result += char;
+        bytes += size;
+    }
+    return result;
+}
+// Shared pure plan readers: importing host context must not initialize an executor.
+export function getReadyTaskSteps(plan) {
+    const completed = new Set(plan.steps
+        .filter((step) => step.status === "done" || step.status === "skipped")
+        .map((step) => step.step_id));
+    return plan.steps.filter((step) => {
+        if (step.status !== "planned")
+            return false;
+        const dependencies = step.depends_on ?? [];
+        return dependencies.every((dependency) => completed.has(dependency));
+    });
+}
+export function formatStepTaskForBridge(step) {
+    const upstreamOutputs = step.upstream_outputs ?? [];
+    if (upstreamOutputs.length === 0) {
+        return step.task;
+    }
+    const renderedOutputs = upstreamOutputs
+        .map((output) => `- ${output.step_id}: ${output.result_summary || "[no summary]"}${output.evidence_refs.length > 0 ? ` (evidence: ${output.evidence_refs.join(", ")})` : ""}`)
+        .join("\n");
+    return [
+        step.task,
+        "",
+        "Upstream outputs:",
+        renderedOutputs,
+    ].join("\n");
+}
+export function collectUpstreamOutputs(plan, step) {
+    const dependencyOutputs = (step.depends_on ?? [])
+        .map((depId) => plan.steps.find((s) => s.step_id === depId))
+        .filter((dep) => dep?.status === "done")
+        .map((dep) => ({
+        step_id: dep.step_id,
+        result_summary: dep.result_summary ?? "",
+        evidence_refs: dep.evidence_refs ?? [],
+    }));
+    const carriedOutputs = (step.upstream_outputs ?? []).filter((output) => Boolean(output) &&
+        typeof output.step_id === "string" &&
+        typeof output.result_summary === "string" &&
+        Array.isArray(output.evidence_refs));
+    const merged = new Map();
+    for (const output of [...carriedOutputs, ...dependencyOutputs]) {
+        merged.set(output.step_id, output);
+    }
+    return [...merged.values()];
+}
+//# sourceMappingURL=task-plan-context.js.map

package/dist/todo-state.d.ts

@@ -1,4 +1,6 @@
-export type TodoNodeStatus = "backlog" | "in_progress" | "blocked" | "gated" | "done";
+import type { TodoNode as StoredTodo } from "./store/repositories/todo-repository.js";
+import type { TaskStep } from './orchestrator-supervisor.js';
+export type TodoNodeStatus = "backlog" | "in_progress" | "blocked" | "gated" | "done" | "cancelled";
 export interface TodoNode {
     id: string;
     title: string;
@@ -21,6 +23,8 @@ export interface TodoAppendResult {
     node_id?: string;
     section?: string;
     error?: string;
+    import_warnings?: string[];
+    projection_pending?: boolean;
 }
 export interface TodoTransitionResult {
     ok: boolean;
@@ -32,6 +36,8 @@ export interface TodoTransitionResult {
     unresolved_dependencies?: string[];
     allowed?: TodoNodeStatus[];
     error?: string;
+    import_warnings?: string[];
+    projection_pending?: boolean;
 }
 export declare function waitForTodoStoreMirror(): Promise<void>;
 export declare function getTodoStatePath(): string;
@@ -39,24 +45,28 @@ export declare function syncTodoState(todoContent?: string): {
     state: TodoStateFile;
     path: string;
 };
+/** Repair a linked projection after its authoritative plan has been saved. */
+export declare function syncLinkedTodoStepSafe(id: string, ref: NonNullable<StoredTodo['step_ref']>, step: TaskStep): Promise<{
+    ok: true;
+} & {
+    import_warnings: string[];
+    projection_pending: boolean;
+}>;
 export declare function syncTodoStateSafe(todoContent?: string): Promise<{
     state: TodoStateFile;
+    markdown: string;
     path: string;
+    import_warnings: string[];
+    projection_pending?: boolean;
 }>;
 export declare function readTodoState(): TodoStateFile;
 export declare function transitionTodoNode(nodeId: string, targetStatus: TodoNodeStatus): TodoTransitionResult;
 export declare function transitionTodoNodeSafe(nodeId: string, targetStatus: TodoNodeStatus): Promise<TodoTransitionResult>;
-/**
- * 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 declare function appendTodoItemSafe(title: string, options?: {
     section?: string;
     depends_on?: string[];
     id?: string;
 }): Promise<TodoAppendResult>;
+export declare function deleteTodoItemSafe(nodeId: string): Promise<TodoAppendResult>;
 //# sourceMappingURL=todo-state.d.ts.map