@code-yeongyu/senpi-agent-core 2026.9.30 → 2026.10.1-2

package/dist/harness/pico3/kinds/tool.js

@@ -0,0 +1,373 @@
+import { Errors } from "typebox/value";
+import { Bounded } from "../bounded.js";
+import { toStored, } from "../types.js";
+import { taskApi } from "./task-api.js";
+const synthetic = (text, code) => ({
+    content: [{ type: "text", text }],
+    isError: true,
+    diagnostics: [{ severity: "error", message: text, code }],
+});
+/** Validate arguments with the tool's real schema (TypeBox 1.x). */
+export function invalid(declaration, call) {
+    const errors = [...Errors(declaration.parameters, call.arguments)];
+    return errors.length === 0 ? undefined : errors.map((e) => `${e.instancePath || "/"}: ${e.message}`).join("; ");
+}
+const sameIdentity = (a, b) => a.id === b.id && a.name === b.name && a.namespace === b.namespace;
+export const tool = {
+    name: "pi.tool",
+    turn: true,
+    inflight: ["started"],
+    // Offered-set check, lookup, validate, beforeTool, validate again; then write `started`
+    // (the in-flight checkpoint) and invoke. A crash before `started` reruns all of this.
+    async initial(task, rt, ctx) {
+        const call = task.input.call;
+        if (!task.input.offered.includes(call.name))
+            return {
+                done: close(task, synthetic(`tool ${call.name} was not offered`, "not_offered"), undefined, rt.now()),
+            };
+        const declaration = rt.tools.get(call.name);
+        if (declaration === undefined)
+            return {
+                done: close(task, synthetic(`tool ${call.name} is not registered`, "missing_tool"), undefined, rt.now()),
+            };
+        const bad = invalid(declaration, call);
+        if (bad !== undefined)
+            return {
+                done: close(task, synthetic(`invalid arguments: ${bad}`, "invalid_arguments"), declaration, rt.now()),
+            };
+        const hooked = await beforeTool(task, rt, call, ctx);
+        if ("block" in hooked)
+            return { done: close(task, synthetic(`blocked: ${hooked.block}`, "blocked"), declaration, rt.now()) };
+        if (!sameIdentity(call, hooked.call))
+            return { done: close(task, synthetic("blocked: call identity changed", "blocked"), declaration, rt.now()) };
+        const badFinal = invalid(declaration, hooked.call);
+        if (badFinal !== undefined)
+            return {
+                done: close(task, synthetic(`invalid arguments after hook: ${badFinal}`, "invalid_arguments"), declaration, rt.now()),
+            };
+        const final = toStored(hooked.call);
+        await rt.commit((tx) => {
+            tx.checkpoint({ phase: "started", replay: declaration.replay ?? "unsafe", call: final });
+            const slot = tx.toolSlot(task);
+            slot.status = "running";
+            delete slot.waitingOn;
+            tx.emit({ type: "tool.started", taskId: task.id, callId: final.id, name: final.name });
+        }, ctx); // durable before the effect
+        return { done: await invoke(task, final, declaration, rt, ctx) };
+    },
+    phases: {
+        // Only entered by the scheduler after reopen. The stored final call is the evidence; beforeTool never reruns.
+        async started(task, rt, ctx) {
+            const cp = task.checkpoint;
+            const declaration = rt.tools.get(cp.call.name);
+            if (declaration === undefined)
+                return {
+                    done: close(task, synthetic(`tool ${cp.call.name} unavailable after restart`, "unavailable"), undefined, rt.now(), cp.call),
+                };
+            if (cp.replay !== "safe" || (declaration.replay ?? "unsafe") !== "safe")
+                return {
+                    done: close(task, synthetic(`tool ${cp.call.name} was interrupted`, "interrupted"), declaration, rt.now(), cp.call),
+                };
+            if (invalid(declaration, cp.call) !== undefined)
+                return {
+                    done: close(task, synthetic(`tool ${cp.call.name} was interrupted; arguments no longer validate`, "interrupted"), declaration, rt.now(), cp.call),
+                };
+            return { done: await invoke(task, cp.call, declaration, rt, ctx) };
+        },
+    },
+    async abort(task, rt, ctx) {
+        for (const conversationId of task.owns) {
+            const children = await rt.commit((tx) => tx.tasks({ conversationId, status: ["pending", "running"] }), ctx);
+            for (const child of children)
+                if (!child.background)
+                    await rt.abortTask(child.id, ctx);
+        }
+        return (tx, current) => {
+            const call = task.checkpoint?.call ?? task.input.call;
+            const entry = tx.appendEntry(current.conversationId, {
+                kind: "pi.tool_result",
+                model: [toMessage(call, synthetic("tool aborted", "aborted"), rt.now())],
+                data: { diagnostics: [{ severity: "error", message: "aborted", code: "aborted" }] },
+            });
+            const slot = tx.sticky(current.conversationId).turn.tools[task.input.index];
+            if (slot !== undefined) {
+                slot.status = "aborted";
+                slot.entry = entry;
+                delete slot.waitingOn;
+            }
+            tx.emit({ type: "tool.aborted", taskId: current.id, callId: call.id, entry });
+            return { entry };
+        };
+    },
+};
+/** The one point where a throwing handler blocks rather than being skipped. */
+async function beforeTool(task, rt, call, ctx) {
+    let current = call;
+    for (const binding of rt.hooks.handlers()) {
+        function memo(name, candidateOrContext, context) {
+            const targetContext = context ?? candidateOrContext;
+            return rt.commit((tx) => {
+                tx.plugins(binding.namespace);
+                const slot = tx.toolSlot(task);
+                if (!Object.hasOwn(slot, "memos"))
+                    slot.memos = {};
+                const memos = slot.memos;
+                const key = `hook:${binding.namespace.id}:${name}`;
+                if (Object.hasOwn(memos, key))
+                    return structuredClone(memos[key]);
+                if (context === undefined)
+                    return undefined;
+                const candidate = structuredClone(candidateOrContext);
+                memos[key] = candidate;
+                return candidate;
+            }, targetContext);
+        }
+        const api = {
+            ...binding.api,
+            callId: call.id,
+            waiting: (context) => rt.commit((tx, currentTask) => {
+                tx.plugins(binding.namespace);
+                const slot = tx.toolSlot(currentTask);
+                if (slot.waitingOn === binding.namespace.id)
+                    return;
+                slot.waitingOn = binding.namespace.id;
+                tx.emit({
+                    type: "tool.waiting",
+                    taskId: currentTask.id,
+                    callId: call.id,
+                    on: binding.namespace.id,
+                });
+            }, context),
+            memo,
+            emit: (name, data, context) => rt.commit((tx) => tx.emit(binding.namespace, name, data), context),
+        };
+        try {
+            const value = await binding.handlers.beforeTool?.(current, api, ctx);
+            if (!value)
+                continue;
+            if (value.block !== undefined)
+                return { block: value.block };
+            if (value.call !== undefined)
+                current = value.call;
+        }
+        catch (error) {
+            if (ctx.abortSignal?.aborted)
+                throw error;
+            return { block: `hook threw: ${String(error)}` };
+        }
+    }
+    return { call: current };
+}
+export const DEFAULT_BOUNDS = { maxBytes: 64 * 1024, maxLines: 200, retain: "head" };
+async function invoke(task, call, declaration, rt, ctx) {
+    // The kernel owns the stream: one bounded buffer, one throttle, one flush path. Flush failures are not swallowed.
+    const b = { ...DEFAULT_BOUNDS, ...declaration.output };
+    const buffer = new Bounded(b.maxBytes, b.maxLines, b.retain);
+    let streamed = false;
+    let lastFlush = 0;
+    let flushing = Promise.resolve();
+    let flushError;
+    const flush = () => {
+        lastFlush = rt.now();
+        const text = buffer.text();
+        flushing = flushing
+            .then(() => rt.commit((tx) => {
+            tx.toolSlot(task).output = text;
+        }, ctx))
+            .catch((e) => {
+            flushError ??= e;
+        });
+    };
+    const api = {
+        ...taskApi(task, rt),
+        // Only the free fields; identity (callId/name/args/output) is protected.
+        progress: (update, c) => rt.commit((tx) => {
+            const slot = tx.toolSlot(task);
+            const free = {
+                progress: slot.progress,
+                details: slot.details,
+                continuedBy: slot.continuedBy,
+            };
+            update(free);
+            if (free.progress !== undefined)
+                slot.progress = free.progress;
+            else
+                delete slot.progress;
+            if (free.details !== undefined)
+                slot.details = toStored(free.details);
+            else
+                delete slot.details;
+            if (free.continuedBy !== undefined)
+                slot.continuedBy = free.continuedBy;
+            else
+                delete slot.continuedBy;
+        }, c),
+        stream(chunk) {
+            streamed = true;
+            buffer.push(typeof chunk === "string" ? new TextEncoder().encode(chunk) : chunk);
+            if (rt.now() - lastFlush >= 100)
+                flush();
+        },
+    };
+    function memo(name, candidateOrContext, context) {
+        const targetContext = context ?? candidateOrContext;
+        return rt.commit((tx) => {
+            const slot = tx.toolSlot(task);
+            if (!Object.hasOwn(slot, "memos"))
+                slot.memos = {};
+            const memos = slot.memos;
+            const key = `tool:${name}`;
+            if (Object.hasOwn(memos, key))
+                return structuredClone(memos[key]);
+            if (context === undefined)
+                return undefined;
+            const candidate = structuredClone(candidateOrContext);
+            memos[key] = candidate;
+            return candidate;
+        }, targetContext);
+    }
+    const toolApi = { ...api, callId: call.id, memo };
+    let result;
+    try {
+        result = await declaration.execute(call.arguments, toolApi, ctx);
+    }
+    catch (error) {
+        if (ctx.abortSignal?.aborted)
+            throw error;
+        result = synthetic(`tool threw: ${String(error)}`, "threw");
+    }
+    if (streamed) {
+        flush();
+        await flushing;
+        if (flushError !== undefined)
+            throw flushError; // a persistence failure is never hidden
+        if (result.content === undefined)
+            result = {
+                ...result,
+                content: [{ type: "text", text: buffer.text() }],
+                ...(buffer.dropped
+                    ? {
+                        diagnostics: [
+                            ...(result.diagnostics ?? []),
+                            {
+                                severity: "warn",
+                                code: "truncated",
+                                message: `${buffer.droppedBytes} bytes / ${buffer.droppedLines} lines dropped (${b.retain} ${b.maxBytes} retained)`,
+                            },
+                        ],
+                    }
+                    : {}),
+            };
+    }
+    let final = result;
+    await rt.hooks.each(ctx, (h, api) => h.afterTool?.(call, final, { ...api, callId: call.id }, ctx), (value) => {
+        if (value !== undefined)
+            final = value;
+    });
+    return close(task, final, declaration, rt.now(), call, streamed ? { bytes: buffer.droppedBytes, lines: buffer.droppedLines } : undefined);
+}
+/** Closure: bound the output, store the exact model message under the stored final call, rest as strict-JSON data. */
+function close(task, raw, declaration, now, call = task.input.call, streamTruncated) {
+    return (tx, current) => {
+        const bounded = bound({ ...raw, content: raw.content ?? [] }, declaration?.output);
+        const result = bounded.result;
+        const bytes = (bounded.truncated?.bytes ?? 0) + (streamTruncated?.bytes ?? 0);
+        const lines = (bounded.truncated?.lines ?? 0) + (streamTruncated?.lines ?? 0);
+        const truncated = bytes > 0 || lines > 0 ? { bytes, lines } : undefined;
+        const data = {};
+        if (result.details !== undefined)
+            data.details = toStored(result.details);
+        if (result.diagnostics !== undefined)
+            data.diagnostics = toStored(result.diagnostics);
+        if (result.control !== undefined)
+            data.control = toStored(result.control);
+        if (truncated !== undefined)
+            data.truncated = truncated;
+        const entry = tx.appendEntry(current.conversationId, {
+            kind: "pi.tool_result",
+            model: [toMessage(call, result, now)],
+            data,
+        });
+        const slot = tx.toolSlot(task);
+        slot.status = result.isError === true ? "error" : "done";
+        slot.entry = entry;
+        delete slot.waitingOn;
+        tx.emit({
+            type: "tool.finished",
+            taskId: current.id,
+            callId: call.id,
+            entry,
+            isError: result.isError === true,
+            ...(result.control === undefined ? {} : { control: result.control }),
+        });
+        if (truncated !== undefined)
+            tx.emit({
+                type: "warning",
+                source: "tool",
+                message: `tool output truncated: ${truncated.bytes} bytes / ${truncated.lines} lines dropped`,
+            });
+        const completion = {
+            status: "completed",
+            result: { entry, ...(result.control === undefined ? {} : { control: toStored(result.control) }) },
+        };
+        return completion;
+    };
+}
+function toMessage(call, result, now) {
+    return toStored({
+        role: "toolResult",
+        toolCallId: call.id,
+        toolName: call.name,
+        content: result.content ?? [],
+        isError: result.isError ?? false,
+        timestamp: now,
+    });
+}
+function bound(result, declared) {
+    const bounds = { ...DEFAULT_BOUNDS, ...declared };
+    const blocks = result.content ?? [];
+    let text = blocks
+        .filter((block) => block.type === "text")
+        .map((block) => block.text)
+        .join("");
+    let droppedLines = 0;
+    let droppedBytes = 0;
+    const lines = text.split("\n");
+    if (lines.length > bounds.maxLines) {
+        droppedLines = lines.length - bounds.maxLines;
+        text = (bounds.retain === "head" ? lines.slice(0, bounds.maxLines) : lines.slice(-bounds.maxLines)).join("\n");
+    }
+    const bytes = new TextEncoder().encode(text);
+    if (bytes.length > bounds.maxBytes) {
+        droppedBytes = bytes.length - bounds.maxBytes;
+        text = new TextDecoder().decode(bounds.retain === "head" ? bytes.subarray(0, bounds.maxBytes) : bytes.subarray(-bounds.maxBytes));
+    }
+    if (droppedBytes === 0 && droppedLines === 0)
+        return { result };
+    let textIndex = -1;
+    for (let index = 0; index < blocks.length; index++) {
+        if (blocks[index].type !== "text")
+            continue;
+        if (bounds.retain === "head" && textIndex >= 0)
+            continue;
+        textIndex = index;
+    }
+    const content = [];
+    for (let index = 0; index < blocks.length; index++) {
+        const block = blocks[index];
+        if (block.type !== "text")
+            content.push(block);
+        else if (index === textIndex)
+            content.push({ ...block, text });
+    }
+    const note = {
+        severity: "warn",
+        code: "truncated",
+        message: `output truncated: ${droppedLines} lines, ${droppedBytes} bytes dropped`,
+    };
+    return {
+        result: { ...result, content, diagnostics: [...(result.diagnostics ?? []), note] },
+        truncated: { bytes: droppedBytes, lines: droppedLines },
+    };
+}
+//# sourceMappingURL=tool.js.map

package/dist/harness/pico3/legacy-tracker.d.ts

@@ -0,0 +1,11 @@
+import { type Op } from "@earendil-works/chord/delta";
+/** Temporary compatibility surface for Pico3's flush-based document handling. */
+export interface Tracker<T extends object> {
+    readonly state: T;
+    readonly target: T;
+    readonly dirty: boolean;
+    flush(): Op[];
+    rebase(): void;
+}
+export declare function track<T extends object>(initial: T): Tracker<T>;
+//# sourceMappingURL=legacy-tracker.d.ts.map

package/dist/harness/pico3/legacy-tracker.js

@@ -0,0 +1,39 @@
+import { track as trackChord, } from "@earendil-works/chord/delta";
+class LegacyTracker {
+    constructor(initial) {
+        this.forceBase = true;
+        this.tracker = trackChord(initial);
+    }
+    get state() {
+        this.change ??= this.tracker.beginChange();
+        return this.change.state;
+    }
+    get target() {
+        return this.tracker.value;
+    }
+    get dirty() {
+        return this.forceBase || this.change !== undefined;
+    }
+    flush() {
+        let prepared;
+        if (this.change !== undefined) {
+            const change = this.change;
+            this.change = undefined;
+            prepared = change.prepare();
+            // Pico3 adopts before storage. A storage failure faults the owning Session.
+            this.tracker.adopt(prepared);
+        }
+        if (this.forceBase) {
+            this.forceBase = false;
+            return [["r", this.tracker.value]];
+        }
+        return (prepared?.ops ?? []);
+    }
+    rebase() {
+        this.forceBase = true;
+    }
+}
+export function track(initial) {
+    return new LegacyTracker(initial);
+}
+//# sourceMappingURL=legacy-tracker.js.map

package/dist/harness/pico3/membrane.d.ts

@@ -0,0 +1,23 @@
+/**
+ * A transaction-scoped revocable membrane over a Chord-tracked document.
+ *
+ * Every object reached through a document proxy is wrapped lazily; all wrappers of one
+ * transaction share one liveness flag; identity is preserved by a WeakMap. Mutations forward
+ * to the underlying Chord proxy so its tracker records ops. At transaction finish — success,
+ * callback failure, validation failure, storage failure — `revoke()` flips the flag and every
+ * retained wrapper, root or nested, throws on any operation.
+ *
+ * Assigning one wrapper into another (`a.list = b.list`) is rejected: Chord stores the value it
+ * is given, and a stored proxy is the classic footgun. Assign plain values; splice in place.
+ */
+export declare class Membrane {
+    private alive;
+    private readonly wrappers;
+    private readonly isWrapper;
+    private readonly what;
+    constructor(what: string);
+    revoke(): void;
+    wrap<T extends object>(target: T): T;
+    private assertPlainInput;
+}
+//# sourceMappingURL=membrane.d.ts.map

package/dist/harness/pico3/membrane.js

@@ -0,0 +1,140 @@
+/**
+ * A transaction-scoped revocable membrane over a Chord-tracked document.
+ *
+ * Every object reached through a document proxy is wrapped lazily; all wrappers of one
+ * transaction share one liveness flag; identity is preserved by a WeakMap. Mutations forward
+ * to the underlying Chord proxy so its tracker records ops. At transaction finish — success,
+ * callback failure, validation failure, storage failure — `revoke()` flips the flag and every
+ * retained wrapper, root or nested, throws on any operation.
+ *
+ * Assigning one wrapper into another (`a.list = b.list`) is rejected: Chord stores the value it
+ * is given, and a stored proxy is the classic footgun. Assign plain values; splice in place.
+ */
+export class Membrane {
+    constructor(what) {
+        this.alive = true;
+        this.wrappers = new WeakMap();
+        this.isWrapper = new WeakSet();
+        this.what = what;
+    }
+    revoke() {
+        this.alive = false;
+    }
+    wrap(target) {
+        const hit = this.wrappers.get(target);
+        if (hit !== undefined)
+            return hit;
+        const m = this;
+        const dead = () => new TypeError(`document proxy (${m.what}) used outside its transaction`);
+        const out = (v) => (typeof v === "object" && v !== null ? m.wrap(v) : v);
+        const inp = (value) => {
+            if (typeof value !== "object" || value === null)
+                return value;
+            m.assertPlainInput(value, new WeakSet());
+            return JSON.parse(JSON.stringify(value));
+        };
+        const proxy = new Proxy(target, {
+            get(t, key, receiver) {
+                if (!m.alive)
+                    throw dead();
+                const v = Reflect.get(t, key, receiver === proxy ? t : receiver);
+                if (typeof v === "function") {
+                    // Methods run against the tracked target. Callback arguments (array elements and
+                    // the array itself) must cross back through the membrane before user code sees them.
+                    return (...args) => {
+                        if (!m.alive)
+                            throw dead();
+                        const safeArgs = args.map((arg) => {
+                            if (typeof arg !== "function")
+                                return inp(arg);
+                            return function (...callbackArgs) {
+                                if (!m.alive)
+                                    throw dead();
+                                return Reflect.apply(arg, this, callbackArgs.map(out));
+                            };
+                        });
+                        return out(Reflect.apply(v, t, safeArgs));
+                    };
+                }
+                return out(v);
+            },
+            set(t, key, value) {
+                if (!m.alive)
+                    throw dead();
+                if (key === "__proto__")
+                    throw new TypeError(`document proxy (${m.what}) cannot change prototypes`);
+                return Reflect.set(t, key, inp(value));
+            },
+            deleteProperty(t, key) {
+                if (!m.alive)
+                    throw dead();
+                return Reflect.deleteProperty(t, key);
+            },
+            has(t, key) {
+                if (!m.alive)
+                    throw dead();
+                return Reflect.has(t, key);
+            },
+            ownKeys(t) {
+                if (!m.alive)
+                    throw dead();
+                return Reflect.ownKeys(t);
+            },
+            getOwnPropertyDescriptor(t, key) {
+                if (!m.alive)
+                    throw dead();
+                const d = Reflect.getOwnPropertyDescriptor(t, key);
+                if (d === undefined)
+                    return undefined;
+                // Descriptors must not leak a raw nested object.
+                if ("value" in d)
+                    d.value = out(d.value);
+                return d;
+            },
+            defineProperty(t, key, descriptor) {
+                if (!m.alive)
+                    throw dead();
+                if ("get" in descriptor || "set" in descriptor)
+                    throw new TypeError(`document proxy (${m.what}) cannot define accessors`);
+                const safe = "value" in descriptor ? { ...descriptor, value: inp(descriptor.value) } : descriptor;
+                return Reflect.defineProperty(t, key, safe);
+            },
+            getPrototypeOf(t) {
+                if (!m.alive)
+                    throw dead();
+                return Reflect.getPrototypeOf(t);
+            },
+            setPrototypeOf() {
+                if (!m.alive)
+                    throw dead();
+                throw new TypeError(`document proxy (${m.what}) cannot change prototypes`);
+            },
+            isExtensible(t) {
+                if (!m.alive)
+                    throw dead();
+                return Reflect.isExtensible(t);
+            },
+            preventExtensions() {
+                if (!m.alive)
+                    throw dead();
+                throw new TypeError(`document proxy (${m.what}) cannot change extensibility`);
+            },
+        });
+        this.wrappers.set(target, proxy);
+        this.isWrapper.add(proxy);
+        return proxy;
+    }
+    assertPlainInput(value, seen) {
+        if (this.isWrapper.has(value))
+            throw new TypeError(`assigning a document proxy into a document (${this.what}); assign a plain value`);
+        if (seen.has(value))
+            throw new TypeError(`assigning a cyclic value into a document (${this.what})`);
+        seen.add(value);
+        for (const nested of Object.values(value)) {
+            if (typeof nested === "object" && nested !== null)
+                this.assertPlainInput(nested, seen);
+        }
+        seen.delete(value);
+    }
+}
+//# sourceMappingURL=membrane.js.map

package/dist/harness/pico3/memory.d.ts

@@ -0,0 +1,53 @@
+import type { Context } from "@earendil-works/chord";
+import { type Op } from "@earendil-works/chord/delta";
+import type { Conversation, DocRef, Entry, EntryScan, Id, Input, JsonObject, Seq, Storage, Task, TaskScan, Write } from "./types.ts";
+/**
+ * In-memory Storage. The reference backend, and the read path of JsonlStorage.
+ *
+ * A batch is validated and staged in full before any table changes: one failed
+ * batch changes no table, no document, no ID high-water, no sequence. Committed
+ * IDs are never reused; IDs minted but never committed may be reused after reopen.
+ */
+export declare class MemoryStorage implements Storage {
+    protected readonly conversationsById: Map<number, Conversation>;
+    protected readonly entriesById: Map<number, Entry>;
+    protected readonly entriesByConversation: Map<number, Entry[]>;
+    protected readonly tasksById: Map<number, Task<import("@earendil-works/chord").JsonValue, import("./types.ts").Checkpoint>>;
+    protected readonly inputsById: Map<number, Input>;
+    protected readonly inputsByRequest: Map<string, Input>;
+    /** Rewindable docs keep their full op history with the seq of each batch, for `docAsOf`. */
+    protected readonly rewindableLog: Map<number, {
+        seq: Seq;
+        ops: Op[];
+    }[]>;
+    protected readonly stickyLog: Map<number, Op[][]>;
+    protected sessionDoc: JsonObject | undefined;
+    protected readonly entrySeq: Map<number, number>;
+    protected nextIdValue: number;
+    protected seq: Seq;
+    private closed;
+    mintId(): Id;
+    protected setNextId(n: Id): void;
+    commit(writes: readonly Write[], _ctx: Context): Promise<Seq>;
+    /** Validate the whole batch against the current tables; return a function that applies it. */
+    protected stage(writes: readonly Write[], seq: Seq): () => void;
+    conversation(id: Id, _ctx?: Context): Promise<Conversation | undefined>;
+    conversations(_ctx?: Context): Promise<Conversation[]>;
+    entries(ids: readonly Id[], _ctx?: Context): Promise<Map<number, Entry>>;
+    /** Newest-first, fork-aware: after this conversation's own entries, the parent's up to the fork point, and so on. */
+    scanEntries(scan: EntryScan, _ctx?: Context): Promise<Entry[]>;
+    task(id: Id, _ctx?: Context): Promise<Task<import("@earendil-works/chord").JsonValue, import("./types.ts").Checkpoint> | undefined>;
+    scanTasks(scan: TaskScan, _ctx?: Context): Promise<Task<import("@earendil-works/chord").JsonValue, import("./types.ts").Checkpoint>[]>;
+    input(id: Id, _ctx?: Context): Promise<Input | undefined>;
+    inputByRequest(conversationId: Id, requestId: string, _ctx?: Context): Promise<Input | undefined>;
+    doc(ref: DocRef, _ctx?: Context): Promise<JsonObject | undefined>;
+    /**
+     * Commit-granular history: the rewindable state after the atomic commit that contains
+     * entry `at`, walking the fork chain for entries owned by ancestors.
+     */
+    docAsOf(conversationId: Id, at: Id, _ctx?: Context): Promise<JsonObject | undefined>;
+    protected fold(log: Op[][]): JsonObject;
+    truncate(ref: DocRef, _ctx?: Context): Promise<void>;
+    close(_ctx?: Context): Promise<void>;
+}
+//# sourceMappingURL=memory.d.ts.map