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

package/dist/harness/pico3/memory.js

@@ -0,0 +1,265 @@
+import { applyImmutable, isBase } from "@earendil-works/chord/delta";
+/**
+ * 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 class MemoryStorage {
+    constructor() {
+        this.conversationsById = new Map();
+        this.entriesById = new Map();
+        this.entriesByConversation = new Map(); // ascending
+        this.tasksById = new Map();
+        this.inputsById = new Map();
+        this.inputsByRequest = new Map();
+        /** Rewindable docs keep their full op history with the seq of each batch, for `docAsOf`. */
+        this.rewindableLog = new Map();
+        this.stickyLog = new Map();
+        this.entrySeq = new Map(); // entry id → seq of its batch
+        this.nextIdValue = 1;
+        this.seq = 0;
+        this.closed = false;
+    }
+    mintId() {
+        return this.nextIdValue++;
+    }
+    setNextId(n) {
+        this.nextIdValue = Math.max(this.nextIdValue, n);
+    }
+    async commit(writes, _ctx) {
+        if (this.closed)
+            throw new Error("storage closed");
+        const seq = this.seq + 1;
+        const staged = this.stage(writes, seq); // throws before any mutation
+        staged();
+        this.seq = seq;
+        return seq;
+    }
+    /** Validate the whole batch against the current tables; return a function that applies it. */
+    stage(writes, seq) {
+        const ops = [];
+        const created = new Set();
+        let maxId = 0;
+        const claim = (id, what) => {
+            if (!Number.isSafeInteger(id) || id <= 0)
+                throw new Error(`${what}: invalid id ${id}`);
+            if (created.has(id))
+                throw new Error(`${what}: id ${id} created twice in one batch`);
+            created.add(id);
+            maxId = Math.max(maxId, id);
+        };
+        for (const w of writes) {
+            switch (w.type) {
+                case "conversation": {
+                    if (this.conversationsById.has(w.conversation.id))
+                        throw new Error(`conversation ${w.conversation.id} exists`);
+                    claim(w.conversation.id, "conversation");
+                    const c = clone(w.conversation);
+                    ops.push(() => {
+                        this.conversationsById.set(c.id, c);
+                        this.entriesByConversation.set(c.id, []);
+                    });
+                    break;
+                }
+                case "entry": {
+                    if (this.entriesById.has(w.entry.id))
+                        throw new Error(`entry ${w.entry.id} exists`);
+                    claim(w.entry.id, "entry");
+                    const e = clone(w.entry);
+                    ops.push(() => {
+                        this.entriesById.set(e.id, e);
+                        (this.entriesByConversation.get(e.conversationId) ??
+                            this.entriesByConversation.set(e.conversationId, []).get(e.conversationId)).push(e);
+                        this.entrySeq.set(e.id, seq);
+                    });
+                    break;
+                }
+                case "task": {
+                    if (this.tasksById.has(w.task.id))
+                        throw new Error(`task ${w.task.id} exists`);
+                    claim(w.task.id, "task");
+                    const t = clone(w.task);
+                    ops.push(() => this.tasksById.set(t.id, t));
+                    break;
+                }
+                case "task.patch": {
+                    const prev = this.tasksById.get(w.patch.id) ??
+                        [...writes]
+                            .filter((x) => x.type === "task")
+                            .find((x) => x.task.id === w.patch.id)?.task;
+                    if (prev === undefined)
+                        throw new Error(`patch for unknown task ${w.patch.id}`);
+                    const p = clone(w.patch);
+                    ops.push(() => {
+                        const cur = this.tasksById.get(p.id);
+                        const { id: _i, ...fields } = p;
+                        const next = { ...cur, ...fields };
+                        if (p.checkpoint === null)
+                            delete next.checkpoint;
+                        this.tasksById.set(p.id, next);
+                    });
+                    break;
+                }
+                case "input": {
+                    const i = clone(w.input);
+                    if (!this.inputsById.has(i.id))
+                        claim(i.id, "input");
+                    ops.push(() => {
+                        this.inputsById.set(i.id, i);
+                        if (i.requestId !== undefined)
+                            this.inputsByRequest.set(`${i.conversationId}:${i.requestId}`, i);
+                    });
+                    break;
+                }
+                case "doc": {
+                    const ref = clone(w.ref);
+                    const o = clone(w.ops);
+                    if (ref.doc === "session")
+                        ops.push(() => {
+                            this.sessionDoc = applyImmutable((this.sessionDoc ?? { plugins: {} }), o);
+                        });
+                    else if (ref.doc === "rewindable")
+                        ops.push(() => (this.rewindableLog.get(ref.conversationId) ??
+                            this.rewindableLog.set(ref.conversationId, []).get(ref.conversationId)).push({ seq, ops: o }));
+                    else
+                        ops.push(() => (this.stickyLog.get(ref.conversationId) ??
+                            this.stickyLog.set(ref.conversationId, []).get(ref.conversationId)).push(o));
+                    break;
+                }
+            }
+        }
+        return () => {
+            for (const op of ops)
+                op();
+            this.setNextId(maxId + 1);
+        };
+    }
+    async conversation(id, _ctx) {
+        return optionalClone(this.conversationsById.get(id));
+    }
+    async conversations(_ctx) {
+        return [...this.conversationsById.values()].map(clone);
+    }
+    async entries(ids, _ctx) {
+        const out = new Map();
+        for (const id of ids) {
+            const e = this.entriesById.get(id);
+            if (e)
+                out.set(id, clone(e));
+        }
+        return out;
+    }
+    /** Newest-first, fork-aware: after this conversation's own entries, the parent's up to the fork point, and so on. */
+    async scanEntries(scan, _ctx) {
+        const out = [];
+        let conversationId = scan.conversationId;
+        let cap = scan.before;
+        while (conversationId !== undefined && out.length < scan.limit) {
+            const own = this.entriesByConversation.get(conversationId) ?? [];
+            for (let i = own.length - 1; i >= 0 && out.length < scan.limit; i--) {
+                const e = own[i];
+                if (cap !== undefined && e.id >= cap)
+                    continue;
+                if (scan.kind !== undefined && e.kind !== scan.kind)
+                    continue;
+                if (scan.withHead && e.head === undefined)
+                    continue;
+                out.push(clone(e));
+            }
+            const c = this.conversationsById.get(conversationId);
+            conversationId = c?.parent?.conversationId;
+            cap = c?.parent === undefined ? undefined : Math.min(cap ?? Infinity, c.parent.at + 1);
+        }
+        return out;
+    }
+    async task(id, _ctx) {
+        return optionalClone(this.tasksById.get(id));
+    }
+    async scanTasks(scan, _ctx) {
+        const out = [];
+        for (const t of this.tasksById.values()) {
+            if (scan.conversationId !== undefined && t.conversationId !== scan.conversationId)
+                continue;
+            if (scan.status !== undefined && !scan.status.includes(t.status))
+                continue;
+            if (scan.kind !== undefined && t.kind !== scan.kind)
+                continue;
+            out.push(clone(t));
+        }
+        return out;
+    }
+    async input(id, _ctx) {
+        return optionalClone(this.inputsById.get(id));
+    }
+    async inputByRequest(conversationId, requestId, _ctx) {
+        return optionalClone(this.inputsByRequest.get(`${conversationId}:${requestId}`));
+    }
+    async doc(ref, _ctx) {
+        if (ref.doc === "session")
+            return this.sessionDoc === undefined ? { plugins: {} } : structuredClone(this.sessionDoc);
+        const log = ref.doc === "rewindable"
+            ? this.rewindableLog.get(ref.conversationId)?.map((r) => r.ops)
+            : this.stickyLog.get(ref.conversationId);
+        if (log === undefined)
+            return undefined;
+        return clone(this.fold(log));
+    }
+    /**
+     * Commit-granular history: the rewindable state after the atomic commit that contains
+     * entry `at`, walking the fork chain for entries owned by ancestors.
+     */
+    async docAsOf(conversationId, at, _ctx) {
+        const owner = this.entriesById.get(at)?.conversationId;
+        if (owner === undefined)
+            return undefined;
+        const chain = [];
+        let c = this.conversationsById.get(conversationId);
+        while (c !== undefined && c.id !== owner) {
+            chain.push(c.id);
+            c = c.parent ? this.conversationsById.get(c.parent.conversationId) : undefined;
+        }
+        if (c === undefined)
+            return undefined;
+        const seqAt = this.entrySeq.get(at) ?? 0;
+        const log = (this.rewindableLog.get(owner) ?? []).filter((r) => r.seq <= seqAt).map((r) => r.ops);
+        return log.length === 0 ? undefined : clone(this.fold(log));
+    }
+    fold(log) {
+        let start = 0;
+        for (let i = log.length - 1; i >= 0; i--)
+            if (isBase(log[i])) {
+                start = i;
+                break;
+            }
+        let state = {};
+        for (let i = start; i < log.length; i++)
+            state = applyImmutable(state, log[i]);
+        return state;
+    }
+    async truncate(ref, _ctx) {
+        if (ref.doc !== "sticky")
+            return;
+        const log = this.stickyLog.get(ref.conversationId);
+        if (log === undefined)
+            return;
+        let start = 0;
+        for (let i = log.length - 1; i >= 0; i--)
+            if (isBase(log[i])) {
+                start = i;
+                break;
+            }
+        log.splice(0, start);
+    }
+    async close(_ctx) {
+        this.closed = true;
+    }
+}
+function clone(value) {
+    return JSON.parse(JSON.stringify(value));
+}
+function optionalClone(value) {
+    return value === undefined ? undefined : clone(value);
+}
+//# sourceMappingURL=memory.js.map

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

@@ -0,0 +1,49 @@
+import type { Context } from "@earendil-works/chord";
+import type { Session } from "./session.ts";
+import { type AnyKind, type Id, type Input, type Invoker, type Runtime, type Task } from "./types.ts";
+export interface SchedulerDeps {
+    session: Session;
+    kinds: ReadonlyMap<string, AnyKind>;
+    runtime(task: Task, invoker: Extract<Invoker, {
+        type: "task";
+    }>, ctx: Context): Runtime;
+    onReport(error: unknown): void;
+    ctx: Context;
+}
+export declare class Scheduler {
+    private readonly deps;
+    private enabled;
+    private holds;
+    private dirty;
+    private draining;
+    private readonly invocations;
+    private readonly taskWaiters;
+    private readonly inputWaiters;
+    private readonly idleWaiters;
+    constructor(deps: SchedulerDeps);
+    resume(): void;
+    stop(): void;
+    hold(): () => void;
+    kick(): void;
+    private drain;
+    /** On the line: reserve every eligible task. */
+    private reserveEligible;
+    private dispatch;
+    private lease;
+    /** The phase loop. Each handler gets a capability lease revoked when that handler's promise returns. */
+    private runPhases;
+    /** Mark, revoke, signal, join. The scheduler then reserves the fresh abort on its next drain. */
+    abortTask(id: Id, ctx: Context): Promise<"marked" | "terminal">;
+    waitForTask(id: Id, ctx: Context): Promise<Task>;
+    waitForInput(id: Id, ctx: Context): Promise<Input>;
+    /** Read state and install the waiter in one line operation; the wait itself happens off-line. */
+    private waiter;
+    waitForIdle(conversationId: Id | undefined, ctx: Context): Promise<void>;
+    private isIdle;
+    private checkIdle;
+    /** Signal every invocation and wait for them; nothing is written. */
+    joinAll(): Promise<void>;
+    quiescent(): boolean;
+    get liveInvocations(): number;
+}
+//# sourceMappingURL=scheduler.d.ts.map