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

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

@@ -0,0 +1,19 @@
+/**
+ * Experimental Pico3 kernel API.
+ *
+ * This subpath is intentionally separate from the package root while the kernel
+ * and its Chord integration are being validated.
+ */
+export { bashTool } from "./bash.ts";
+export { Bounded } from "./bounded.ts";
+export type { ChordViewBridge, ChordViewBridgeOptions, PublishedConversationView, } from "./chord.ts";
+export { attachChordView, createPicoConversationService, PicoConversationService, PicoHarnessService, } from "./chord.ts";
+export type { BuiltinKinds, ConfigFor, ConversationHandle, HarnessOptions, InputHandle, Watch, } from "./harness.ts";
+export { applyEnvelope, captureActiveTranscript, entries, Harness, isCoreKind, kinds, WATCH_CAPACITY, withAbortSignal, } from "./harness.ts";
+export { JsonlStorage } from "./jsonl.ts";
+export { MemoryStorage } from "./memory.ts";
+export type { SystemSection } from "./system.ts";
+export { defineSystemSection, systemSections } from "./system.ts";
+export type { AbortClosure, AnyKind, AnyToolDeclaration, AssistantMessage, BeforeToolApi, Checkpoint, CheckpointAt, Closure, Completion, ConfigFacade, ConfigOf, ConfigOfKinds, ConfigShape, ContextEdit, ContextView, Conversation, ConversationSpec, ConversationView, DeferredHandle, DisjointConfig, DocRef, Entry, EntryInput, EntryKind, EntryRef, EntryScan, Envelope, GenerationStatus, HookApi, HookBinding, HookInfo, HookResult, HookRunner, HooksOf, HostTx, Id, Input, InputOf, JsonObject, JsonPrimitive, JsonValue, Kind, KindConfig, KindTypes, Message, Model, ModelRef, Models, Namespace, NamespaceDefaults, NewEntry, Outcome, OwnedConversation, OwnedConversationSpec, PhaseHandler, PluginHandler, ProcessHost, ProcessSpec, ProcessStatus, QueuedInput, RequestMessage, RequestOptions, RetryPolicy, RewindableState, Runtime, SendInput, Seq, SessionState, SlotOf, Step, StickyState, Storage, Stored, StoredMessage, SystemMessage, Task, TaskOf, TaskRef, TaskScan, TaskTx, ThinkingLevel, ToolApi, ToolCall, ToolControl, ToolDeclaration, ToolDiagnostic, ToolResult, ToolResultMessage, ToolSlot, TurnState, TurnView, UserInput, UserMessage, ViewEvent, Write, } from "./types.ts";
+export { Closed, CollapseInProgress, ConversationBusy, defineEntry, defineTask, Faulted, Forbidden, GenerationInProgress, memoOnce, ReadAfterWrite, TaskContractFault, toStored, } from "./types.ts";
+//# sourceMappingURL=index.d.ts.map

package/dist/harness/pico3/index.js

@@ -0,0 +1,15 @@
+/**
+ * Experimental Pico3 kernel API.
+ *
+ * This subpath is intentionally separate from the package root while the kernel
+ * and its Chord integration are being validated.
+ */
+export { bashTool } from "./bash.js";
+export { Bounded } from "./bounded.js";
+export { attachChordView, createPicoConversationService, PicoConversationService, PicoHarnessService, } from "./chord.js";
+export { applyEnvelope, captureActiveTranscript, entries, Harness, isCoreKind, kinds, WATCH_CAPACITY, withAbortSignal, } from "./harness.js";
+export { JsonlStorage } from "./jsonl.js";
+export { MemoryStorage } from "./memory.js";
+export { defineSystemSection, systemSections } from "./system.js";
+export { Closed, CollapseInProgress, ConversationBusy, defineEntry, defineTask, Faulted, Forbidden, GenerationInProgress, memoOnce, ReadAfterWrite, TaskContractFault, toStored, } from "./types.js";
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,58 @@
+import type { Context } from "@earendil-works/chord";
+import { MemoryStorage } from "./memory.ts";
+import type { DocRef, Seq, Storage, Write } from "./types.ts";
+/**
+ * Files in a session directory:
+ *   main.jsonl                   conversations, entries, inputs, rewindable/session doc ops, each task's
+ *                                CREATE and TERMINAL records, and one marker per commit. Append-only, never rewritten.
+ *   sticky-<conversation>.jsonl  sticky doc ops; rewritten from its last base by `truncate` (on the Session line)
+ *   task-<id>.jsonl              a live task's intermediate patches (running, checkpoints); unlinked after its
+ *                                terminal record is published in main
+ *
+ * Publication (§10): one commit `Seq`; sidecar records are appended first, then exactly one main
+ * record, last, listing the sidecar refs it expects — the publication point. Replay applies a sidecar
+ * record only when main has the marker for that seq naming that file; unconfirmed sidecar tails are
+ * ignored. Every record carries the committed-ID high-water. Bytes after the last newline of any file
+ * are a torn write and are truncated before the file is opened for append. There is no compaction.
+ *
+ * With `fsync: false`, recovery covers process termination while the OS and filesystem remain alive.
+ * It does not promise that an acknowledged commit survives power loss, kernel/host failure,
+ * storage-cache loss, or a filesystem that loses/reorders completed writes. An acknowledged tail may
+ * roll back, or a surviving main marker may reference a missing sidecar and make open fail rather
+ * than expose partial state. A lost pre-effect checkpoint can cause an external effect to be attempted
+ * again; external idempotency remains required.
+ *
+ * With `fsync: true`, each sidecar is flushed before the main publication marker is flushed. This
+ * strengthens file-data durability and ordering across machine failure. It is not a complete database
+ * guarantee: newly created files, renames, and unlinks are not followed by a parent-directory fsync,
+ * and storage hardware/filesystems may provide weaker guarantees.
+ *
+ * One process owns a directory at a time; a second process is unsupported.
+ */
+export declare class JsonlStorage extends MemoryStorage implements Storage {
+    private mainFd;
+    private readonly sidecars;
+    private readonly taskSidecars;
+    private readonly dir;
+    readonly fsync: boolean;
+    private closedOnce;
+    private constructor();
+    static open(dir: string, opts?: {
+        fsync?: boolean;
+    }): Promise<JsonlStorage>;
+    /** For tests and tooling: sizes of every file in the directory. */
+    sizes(): {
+        [file: string]: number;
+    };
+    private replay;
+    commit(writes: readonly Write[], ctx: Context): Promise<Seq>;
+    private nextIdAfter;
+    private append;
+    private sidecar;
+    private taskSidecar;
+    private retireTaskSidecar;
+    /** Rewrite the sticky sidecar from its last base: temp file, optional fsync, rename. Called on the Session line. */
+    truncate(ref: DocRef, _ctx?: Context): Promise<void>;
+    close(_ctx?: Context): Promise<void>;
+}
+//# sourceMappingURL=jsonl.d.ts.map

package/dist/harness/pico3/jsonl.js

@@ -0,0 +1,322 @@
+import { closeSync, existsSync, fsyncSync, ftruncateSync, mkdirSync, openSync, readdirSync, readFileSync, renameSync, statSync, unlinkSync, writeSync, } from "node:fs";
+import { join } from "node:path";
+import { BACKGROUND_CONTEXT } from "@earendil-works/chord/context";
+import { isBase } from "@earendil-works/chord/delta";
+import { MemoryStorage } from "./memory.js";
+/**
+ * Files in a session directory:
+ *   main.jsonl                   conversations, entries, inputs, rewindable/session doc ops, each task's
+ *                                CREATE and TERMINAL records, and one marker per commit. Append-only, never rewritten.
+ *   sticky-<conversation>.jsonl  sticky doc ops; rewritten from its last base by `truncate` (on the Session line)
+ *   task-<id>.jsonl              a live task's intermediate patches (running, checkpoints); unlinked after its
+ *                                terminal record is published in main
+ *
+ * Publication (§10): one commit `Seq`; sidecar records are appended first, then exactly one main
+ * record, last, listing the sidecar refs it expects — the publication point. Replay applies a sidecar
+ * record only when main has the marker for that seq naming that file; unconfirmed sidecar tails are
+ * ignored. Every record carries the committed-ID high-water. Bytes after the last newline of any file
+ * are a torn write and are truncated before the file is opened for append. There is no compaction.
+ *
+ * With `fsync: false`, recovery covers process termination while the OS and filesystem remain alive.
+ * It does not promise that an acknowledged commit survives power loss, kernel/host failure,
+ * storage-cache loss, or a filesystem that loses/reorders completed writes. An acknowledged tail may
+ * roll back, or a surviving main marker may reference a missing sidecar and make open fail rather
+ * than expose partial state. A lost pre-effect checkpoint can cause an external effect to be attempted
+ * again; external idempotency remains required.
+ *
+ * With `fsync: true`, each sidecar is flushed before the main publication marker is flushed. This
+ * strengthens file-data durability and ordering across machine failure. It is not a complete database
+ * guarantee: newly created files, renames, and unlinks are not followed by a parent-directory fsync,
+ * and storage hardware/filesystems may provide weaker guarantees.
+ *
+ * One process owns a directory at a time; a second process is unsupported.
+ */
+export class JsonlStorage extends MemoryStorage {
+    constructor(dir, fsync) {
+        super();
+        this.sidecars = new Map(); // sticky docs, by conversation
+        this.taskSidecars = new Map();
+        this.closedOnce = false;
+        this.dir = dir;
+        this.fsync = fsync;
+        this.mainFd = openSync(join(dir, "main.jsonl"), "a");
+    }
+    static async open(dir, opts = {}) {
+        mkdirSync(dir, { recursive: true });
+        for (const f of readdirSync(dir))
+            if (f.endsWith(".jsonl"))
+                truncateTornTail(join(dir, f));
+        const storage = new JsonlStorage(dir, opts.fsync ?? true);
+        try {
+            await storage.replay();
+            return storage;
+        }
+        catch (error) {
+            await storage.close();
+            throw error;
+        }
+    }
+    /** For tests and tooling: sizes of every file in the directory. */
+    sizes() {
+        const out = {};
+        for (const f of readdirSync(this.dir))
+            out[f] = statSync(join(this.dir, f)).size;
+        return out;
+    }
+    async replay() {
+        const read = (file) => {
+            if (!existsSync(file))
+                return [];
+            const bytes = readFileSync(file);
+            const out = [];
+            let start = 0;
+            let last = 0;
+            for (let end = bytes.indexOf(0x0a, start); end >= 0; end = bytes.indexOf(0x0a, start)) {
+                const line = bytes.subarray(start, end).toString("utf8");
+                start = end + 1;
+                if (line === "")
+                    continue;
+                let record;
+                try {
+                    record = JSON.parse(line);
+                }
+                catch (error) {
+                    throw new Error(`${file}: malformed record: ${String(error)}`);
+                }
+                if (typeof record.seq !== "number" || typeof record.maxId !== "number" || !Array.isArray(record.writes))
+                    throw new Error(`${file}: record lacks seq/maxId/writes`);
+                if (record.seq <= last)
+                    throw new Error(`${file}: sequence not increasing at ${record.seq}`);
+                last = record.seq;
+                out.push({ record, end: start });
+            }
+            return out;
+        };
+        let maxId = 0;
+        // Main is the commit log. Confirmed = (seq → refs) for every marker.
+        const main = read(join(this.dir, "main.jsonl")).map(({ record }) => record);
+        const confirmed = new Map();
+        for (const record of main)
+            confirmed.set(record.seq, new Set(record.refs ?? []));
+        // Merge every file's records by seq so batches apply in commit order.
+        const sidecarFiles = readdirSync(this.dir).filter((file) => file.startsWith("sticky-") || file.startsWith("task-"));
+        const bySeq = new Map();
+        const found = new Map();
+        const retainedStickyBase = new Map();
+        const retiredTasks = new Map();
+        for (const record of main) {
+            for (const write of record.writes) {
+                if (write.type === "task.patch" && write.patch.status === "terminal")
+                    retiredTasks.set(write.patch.id, record.seq);
+            }
+            bySeq.set(record.seq, [...record.writes]);
+            maxId = Math.max(maxId, record.maxId);
+        }
+        for (const file of sidecarFiles) {
+            const path = join(this.dir, file);
+            const records = read(path);
+            const first = records[0]?.record;
+            if (file.startsWith("sticky-") &&
+                first !== undefined &&
+                isBase(first.writes.flatMap((write) => (write.type === "doc" ? write.ops : [])))) {
+                retainedStickyBase.set(file, first.seq);
+            }
+            let confirmedEnd = 0;
+            let sawUnconfirmed = false;
+            for (const { record, end } of records) {
+                if (!confirmed.get(record.seq)?.has(file)) {
+                    sawUnconfirmed = true;
+                    continue;
+                }
+                if (sawUnconfirmed)
+                    throw new Error(`${path}: confirmed record follows an unconfirmed tail at ${record.seq}`);
+                confirmedEnd = end;
+                const files = found.get(record.seq) ?? new Set();
+                files.add(file);
+                found.set(record.seq, files);
+                bySeq.get(record.seq).push(...record.writes);
+                maxId = Math.max(maxId, record.maxId);
+            }
+            if (sawUnconfirmed)
+                truncateTo(path, confirmedEnd);
+        }
+        for (const record of main) {
+            for (const file of record.refs ?? []) {
+                if (found.get(record.seq)?.has(file))
+                    continue;
+                const retainedFrom = retainedStickyBase.get(file);
+                if (retainedFrom !== undefined && record.seq < retainedFrom)
+                    continue;
+                if (file.startsWith("task-")) {
+                    const id = Number(file.slice(5, -6));
+                    const retiredAt = retiredTasks.get(id);
+                    if (retiredAt !== undefined && record.seq < retiredAt)
+                        continue;
+                }
+                throw new Error(`${join(this.dir, file)}: missing record for published sequence ${record.seq}`);
+            }
+        }
+        for (const seq of [...bySeq.keys()].sort((a, b) => a - b)) {
+            this.seq = seq - 1;
+            await super.commit(bySeq.get(seq), BACKGROUND_CONTEXT);
+        }
+        this.setNextId(maxId + 1);
+        // Task sidecars belong to live tasks only; a leftover for a terminal (or unknown) task cannot resurrect anything.
+        for (const f of sidecarFiles) {
+            if (!f.startsWith("task-"))
+                continue;
+            const id = Number(f.slice(5, -6));
+            const t = await super.task(id);
+            if (t === undefined || t.status === "terminal")
+                unlinkSync(join(this.dir, f));
+        }
+    }
+    async commit(writes, ctx) {
+        if (this.closedOnce)
+            throw new Error("storage closed");
+        const seq = this.seq + 1;
+        const apply = this.stage(writes, seq); // validates the whole batch first; throws before any file is touched
+        const maxId = this.nextIdAfter(writes);
+        const main = [];
+        const sticky = new Map();
+        const tasks = new Map();
+        const retired = [];
+        for (const w of writes) {
+            if (w.type === "doc" && w.ref.doc === "sticky")
+                (sticky.get(w.ref.conversationId) ?? sticky.set(w.ref.conversationId, []).get(w.ref.conversationId)).push(w);
+            else if (w.type === "task.patch" && w.patch.status !== "terminal")
+                (tasks.get(w.patch.id) ?? tasks.set(w.patch.id, []).get(w.patch.id)).push(w);
+            else {
+                main.push(w);
+                if (w.type === "task.patch" && w.patch.status === "terminal")
+                    retired.push(w.patch.id);
+            }
+        }
+        const refs = [];
+        for (const [id, ws] of tasks) {
+            this.append(this.taskSidecar(id), { seq, maxId, writes: ws });
+            refs.push(`task-${id}.jsonl`);
+        }
+        for (const [c, ws] of sticky) {
+            this.append(this.sidecar(c), { seq, maxId, writes: ws });
+            refs.push(`sticky-${c}.jsonl`);
+        }
+        this.append(this.mainFd, { seq, maxId, writes: main, ...(refs.length ? { refs } : {}) }); // the publication point
+        apply();
+        this.seq = seq;
+        for (const id of retired)
+            this.retireTaskSidecar(id); // after the terminal record is durably published
+        void ctx;
+        return seq;
+    }
+    nextIdAfter(writes) {
+        let max = this.nextIdValue - 1;
+        for (const w of writes) {
+            const id = w.type === "conversation"
+                ? w.conversation.id
+                : w.type === "entry"
+                    ? w.entry.id
+                    : w.type === "task"
+                        ? w.task.id
+                        : w.type === "input"
+                            ? w.input.id
+                            : 0;
+            max = Math.max(max, id);
+        }
+        return max;
+    }
+    append(fd, record) {
+        writeSync(fd, `${JSON.stringify(record)}\n`);
+        if (this.fsync)
+            fsyncSync(fd);
+    }
+    sidecar(conversationId) {
+        let fd = this.sidecars.get(conversationId);
+        if (fd === undefined) {
+            fd = openSync(join(this.dir, `sticky-${conversationId}.jsonl`), "a");
+            this.sidecars.set(conversationId, fd);
+        }
+        return fd;
+    }
+    taskSidecar(id) {
+        let fd = this.taskSidecars.get(id);
+        if (fd === undefined) {
+            fd = openSync(join(this.dir, `task-${id}.jsonl`), "a");
+            this.taskSidecars.set(id, fd);
+        }
+        return fd;
+    }
+    retireTaskSidecar(id) {
+        const fd = this.taskSidecars.get(id);
+        if (fd !== undefined)
+            closeSync(fd);
+        this.taskSidecars.delete(id);
+        try {
+            unlinkSync(join(this.dir, `task-${id}.jsonl`));
+        }
+        catch { }
+    }
+    /** Rewrite the sticky sidecar from its last base: temp file, optional fsync, rename. Called on the Session line. */
+    async truncate(ref, _ctx) {
+        await super.truncate(ref);
+        if (ref.doc !== "sticky")
+            return;
+        const file = join(this.dir, `sticky-${ref.conversationId}.jsonl`);
+        if (!existsSync(file))
+            return;
+        const lines = readFileSync(file, "utf8").split("\n").filter(Boolean);
+        let start = 0;
+        for (let i = lines.length - 1; i >= 0; i--)
+            if (isBase(JSON.parse(lines[i]).writes.flatMap((w) => (w.type === "doc" ? w.ops : [])))) {
+                start = i;
+                break;
+            }
+        if (start === 0)
+            return;
+        const tmp = `${file}.tmp`;
+        const fd = openSync(tmp, "w");
+        writeSync(fd, lines
+            .slice(start)
+            .map((l) => `${l}\n`)
+            .join(""));
+        if (this.fsync)
+            fsyncSync(fd);
+        closeSync(fd);
+        const old = this.sidecars.get(ref.conversationId);
+        if (old !== undefined)
+            closeSync(old);
+        renameSync(tmp, file);
+        this.sidecars.set(ref.conversationId, openSync(file, "a"));
+    }
+    async close(_ctx) {
+        if (this.closedOnce)
+            return;
+        this.closedOnce = true;
+        await super.close();
+        closeSync(this.mainFd);
+        for (const fd of this.sidecars.values())
+            closeSync(fd);
+        for (const fd of this.taskSidecars.values())
+            closeSync(fd);
+    }
+}
+function truncateTo(file, length) {
+    const fd = openSync(file, "r+");
+    try {
+        ftruncateSync(fd, length);
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+/** Bytes after the last newline are a torn write: cut them so a later append cannot extend a corrupt line. */
+function truncateTornTail(file) {
+    const size = statSync(file).size;
+    if (size === 0)
+        return;
+    const buf = readFileSync(file);
+    const end = buf.lastIndexOf(0x0a);
+    if (end + 1 !== buf.length)
+        truncateTo(file, end + 1);
+}
+//# sourceMappingURL=jsonl.js.map

package/dist/harness/pico3/kinds/collapse.d.ts

@@ -0,0 +1,49 @@
+import type { Context } from "@earendil-works/chord";
+import { type CoreKind, type Entry, type HookInfo, type HookResult, type Id, type ModelRef, type RetryPolicy, type ThinkingLevel } from "../types.ts";
+export type CollapseInput = {
+    reason: "threshold" | "manual" | "overflow";
+    through: Id;
+    instructions?: string;
+};
+type Base = {
+    expectedHead: Id | null;
+    instructions?: string;
+    model: ModelRef;
+    thinkingLevel: ThinkingLevel;
+    retry: RetryPolicy;
+    attempt: number;
+};
+export type CollapseCheckpoint = ({
+    phase: "summarizing";
+} & Base) | ({
+    phase: "retrying";
+    untilMs: number;
+    lastError: string;
+} & Base) | ({
+    phase: "prepared";
+    summary: string;
+} & Base);
+export type CollapseFailure = {
+    reason: "stale" | "declined" | "provider" | "retries_exhausted" | "no_model";
+    detail: string;
+};
+export interface CollapseHooks {
+    beforeCollapse(reason: "threshold" | "manual" | "overflow", through: Id, entries: Entry[], info: HookInfo, ctx: Context): HookResult<{
+        decline: true;
+    } | {
+        instructions?: string;
+        summary?: string;
+    }>;
+}
+export declare const collapseConfig: {
+    readonly rewindable: {
+        readonly threshold: number;
+        readonly keepRecent: number;
+    };
+};
+export declare const collapse: CoreKind<CollapseInput, CollapseCheckpoint, {
+    summary: Id;
+}, CollapseFailure, null, CollapseHooks, typeof collapseConfig>;
+export declare function chooseThrough(entries: Entry[], keepRecent: number): Id | undefined;
+export {};
+//# sourceMappingURL=collapse.d.ts.map

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

@@ -0,0 +1,191 @@
+import { estimateContextTokens } from "@earendil-works/pi-ai/utils/estimate";
+import { effectiveTools } from "../system.js";
+import { toStored, } from "../types.js";
+import { retryDecision } from "./generation.js";
+const estimate = (messages) => estimateContextTokens(messages.filter((message) => message.role !== "system")).tokens;
+export const collapseConfig = { rewindable: { threshold: 0, keepRecent: 20_000 } };
+const failed = (reason, detail) => ({
+    status: "failed",
+    failure: { reason, detail },
+});
+const baseOf = (checkpoint) => {
+    const { phase: _phase, ...rest } = checkpoint;
+    const { untilMs: _untilMs, lastError: _lastError, summary: _summary, ...base } = rest;
+    return base;
+};
+export const collapse = {
+    name: "pi.collapse",
+    config: collapseConfig,
+    inflight: ["summarizing"],
+    async initial(task, runtime, ctx) {
+        const state = await runtime.rewindable(task.conversationId, ctx);
+        if (state.model === undefined)
+            return { done: () => failed("no_model", "no model configured") };
+        const sticky = await runtime.sticky(task.conversationId, ctx);
+        const head = await runtime.newestEntry(task.conversationId, { withHead: true }, ctx);
+        const { entries } = await runtime.context(task.conversationId, task.input.through, ctx);
+        let decision = {};
+        await runtime.hooks.each(ctx, (hook, api) => hook.beforeCollapse?.(task.input.reason, task.input.through, entries, api, ctx), (value) => {
+            if (value === undefined)
+                return;
+            decision = value;
+            return true;
+        });
+        if ("decline" in decision)
+            return { done: () => failed("declined", "declined by beforeCollapse") };
+        const choice = decision;
+        const base = {
+            expectedHead: head?.id ?? null,
+            ...((choice.instructions ?? task.input.instructions)
+                ? { instructions: choice.instructions ?? task.input.instructions }
+                : {}),
+            model: state.model,
+            thinkingLevel: state.thinkingLevel,
+            retry: sticky.retry,
+            attempt: 1,
+        };
+        if (choice.summary !== undefined) {
+            return {
+                next: async (tx, current) => (await headMoved(tx, current.conversationId, base))
+                    ? failed("stale", "head moved during beforeCollapse")
+                    : { phase: "prepared", summary: choice.summary, ...base },
+            };
+        }
+        return summarizeNow(task, base, runtime, ctx, "check head");
+    },
+    phases: {
+        async summarizing(task, runtime) {
+            return afterFailure(baseOf(task.checkpoint), null, "interrupted", runtime);
+        },
+        async retrying(task, runtime, ctx) {
+            await runtime.sleep(task.checkpoint.untilMs, ctx);
+            return summarizeNow(task, { ...baseOf(task.checkpoint), attempt: task.checkpoint.attempt + 1 }, runtime, ctx);
+        },
+        async prepared(task, runtime) {
+            const { summary } = task.checkpoint;
+            const base = baseOf(task.checkpoint);
+            return {
+                done: async (tx, current) => {
+                    const { head, entries } = await tx.context(current.conversationId);
+                    if ((head?.id ?? null) !== base.expectedHead)
+                        return failed("stale", "head moved during collapse");
+                    const retained = entries.find((entry) => entry.id > task.input.through);
+                    const id = tx.appendEntry(current.conversationId, {
+                        kind: "pi.summary",
+                        data: { through: task.input.through },
+                        model: [{ role: "user", content: summary, timestamp: runtime.now() }],
+                        head: retained?.id ?? "self",
+                    });
+                    return { status: "completed", result: { summary: id } };
+                },
+            };
+        },
+    },
+    async abort() {
+        return async () => null;
+    },
+};
+const headMoved = async (tx, conversationId, base) => ((await tx.newestEntry(conversationId, { withHead: true }))?.id ?? null) !== base.expectedHead;
+async function summarizeNow(task, base, runtime, ctx, check) {
+    const stale = await runtime.commit(async (tx, current) => {
+        if (check && (await headMoved(tx, current.conversationId, base)))
+            return true;
+        tx.checkpoint({ phase: "summarizing", ...base });
+        return false;
+    }, ctx);
+    if (stale)
+        return { done: () => failed("stale", "head moved during beforeCollapse") };
+    const model = runtime.models.resolve(base.model);
+    if (model === undefined)
+        return { done: () => failed("no_model", "model unavailable") };
+    const { messages } = await runtime.context(task.conversationId, task.input.through, ctx);
+    const tools = effectiveTools(messages);
+    const request = [
+        ...messages,
+        ...(tools.length > 0
+            ? [toStored({ role: "system", content: "", toolsRemoved: tools, timestamp: runtime.now() })]
+            : []),
+        {
+            role: "user",
+            content: `${base.instructions ?? "Summarize the conversation so far for continuation."}\n\nRespond with the summary only.`,
+            timestamp: runtime.now(),
+        },
+    ];
+    let message;
+    try {
+        for await (const event of runtime.models.stream(model, { messages: request, thinkingLevel: base.thinkingLevel }, ctx)) {
+            if (event.type === "done") {
+                message = event.message;
+                break;
+            }
+            if (event.type === "error") {
+                message = event.error;
+                break;
+            }
+        }
+    }
+    catch (error) {
+        if (ctx.abortSignal?.aborted)
+            throw error;
+        return afterFailure(base, null, String(error), runtime);
+    }
+    if (message === undefined)
+        return afterFailure(base, null, "no message", runtime);
+    if (message.content.some((content) => content.type === "toolCall")) {
+        return afterFailure(base, { ...message, stopReason: "error" }, "summarizer returned tool calls", runtime);
+    }
+    if (message.stopReason === "error")
+        return afterFailure(base, message, message.errorMessage ?? "provider error", runtime);
+    const summary = message.content
+        .filter((content) => content.type === "text")
+        .map((content) => content.text)
+        .join("");
+    return { next: { phase: "prepared", summary, ...base } };
+}
+function afterFailure(base, message, detail, runtime) {
+    const decision = retryDecision(base, message, runtime.now());
+    if (decision.kind === "fail")
+        return { done: () => failed(decision.reason, detail) };
+    return {
+        next: (tx, current) => {
+            tx.emit({
+                type: "compaction.retrying",
+                taskId: current.id,
+                attempt: base.attempt,
+                retryAt: decision.untilMs,
+                error: detail,
+            });
+            return { phase: "retrying", ...base, untilMs: decision.untilMs, lastError: detail };
+        },
+    };
+}
+export function chooseThrough(entries, keepRecent) {
+    const exchanges = [];
+    let open;
+    for (const entry of entries) {
+        const role = entry.model?.[0]?.role;
+        const tokens = estimate((entry.model ?? []));
+        if (role === "assistant") {
+            open = { last: entry.id, tokens };
+            exchanges.push(open);
+        }
+        else if (role === "toolResult" && open) {
+            open.last = entry.id;
+            open.tokens += tokens;
+        }
+        else {
+            open = undefined;
+            exchanges.push({ last: entry.id, tokens });
+        }
+    }
+    let retained = 0;
+    let index = exchanges.length - 1;
+    while (index >= 0 && retained + exchanges[index].tokens <= keepRecent)
+        retained += exchanges[index--].tokens;
+    if (index < 0)
+        return undefined;
+    if (index === exchanges.length - 1)
+        return exchanges[index - 1]?.last;
+    return exchanges[index].last;
+}
+//# sourceMappingURL=collapse.js.map