@geminixiang/mikan 1.0.0-beta.87 → 1.0.0-beta.89

package/dist/sessions/session-store.js

@@ -1,303 +1,421 @@
-import { closeSync, existsSync, fstatSync, ftruncateSync, mkdirSync, mkdtempSync, openSync, readFileSync, readSync, realpathSync, rmSync, statSync, writeFileSync, } from "node:fs";
-import { tmpdir } from "node:os";
-import { basename, dirname, join, resolve } from "node:path";
-import { AgentHarness, laneState, operationResult, createBranchSummaryMessage, createCompactionSummaryMessage, createCustomMessage, JsonlSessionRepo, JSONL_STORAGE_VERSION, MemorySessionRepo, TODO_CONTEXT, uuidv7, value, } from "@earendil-works/pi-agent-core";
-import { NodeExecutionEnv } from "@earendil-works/pi-agent-core/node";
-import { atomicWritePrivateFile } from "../file-guards.js";
-import { CURRENT_SESSION_VERSION } from "./types.js";
+import { chmodSync, existsSync, mkdirSync } from "node:fs";
+import { randomUUID } from "node:crypto";
+import { dirname } from "node:path";
+import { BACKGROUND_CONTEXT } from "@earendil-works/chord/context";
+import { calculateContextTokens } from "@earendil-works/pi-ai/utils/estimate";
+import { AssistantEntry, CompactionEntry, Harness, LiveDoc, MemoryStorage, ROOT_CONVERSATION_ID, ToolResultEntry, UserEntry, createRegistry, defineDoc, defineEntry, } from "@earendil-works/pi-durable";
+import { openNodeSqliteStorage } from "@earendil-works/pi-durable/storage/sqlite/node";
+import { RUN_CAUSE_CUSTOM_TYPE } from "./types.js";
 import { loadMcpTools, formatMcpServerInstructions } from "../harness/mcp.js";
 import * as log from "../log.js";
-import { isRecord } from "../unknown-values.js";
-const MIKAN_METADATA = value("mikan", "metadata");
-const activeWriterKeys = new Map();
-function canonicalSessionPath(path) {
-    const absolute = resolve(path);
-    if (existsSync(absolute))
-        return realpathSync(absolute);
-    const parent = dirname(absolute);
-    mkdirSync(parent, { recursive: true });
-    return join(realpathSync(parent), basename(absolute));
+import { compactionSummaryOf, wrapCompactionSummary } from "./compaction-summary.js";
+import { isThreadSessionKey } from "./session-key.js";
+import { errorMessage, isRecord } from "../unknown-values.js";
+const context = BACKGROUND_CONTEXT;
+const ENTRY_PAGE_SIZE = 500;
+const SessionDoc = defineDoc({
+    kind: "mikan.session",
+    version: 1,
+    scope: "conversation",
+    history: "latest",
+    fork: "initial",
+    initial: () => ({}),
+});
+const SessionIndexDoc = defineDoc({
+    kind: "mikan.sessions",
+    version: 1,
+    scope: "session",
+    initial: () => ({ sessions: {} }),
+});
+const CustomSessionEntry = defineEntry("mikan.custom");
+function toJson(input) {
+    if (input === undefined)
+        return null;
+    const copy = JSON.parse(JSON.stringify(input));
+    return copy;
 }
-function sessionWriterKey(path) {
-    if (!existsSync(path))
-        return `path:${path}`;
-    const stats = statSync(path);
-    return `inode:${stats.dev}:${stats.ino}:${stats.birthtimeMs}`;
+function durableMessage(message) {
+    const copy = JSON.parse(JSON.stringify(message));
+    return copy;
 }
-function isStaleClaim(key, claimedPath) {
-    if (!key.startsWith("inode:"))
-        return false;
-    return sessionWriterKey(claimedPath) !== key;
+function messageTimestamp(message) {
+    return message && "timestamp" in message && typeof message.timestamp === "number"
+        ? message.timestamp
+        : 0;
+}
+function contentText(message) {
+    if (!message || !("content" in message))
+        return "";
+    if (typeof message.content === "string")
+        return message.content;
+    return message.content
+        .map((part) => (part.type === "text" ? part.text : ""))
+        .filter(Boolean)
+        .join("\n");
 }
-function claimWriter(key, path) {
-    const claimedPath = activeWriterKeys.get(key);
-    if (claimedPath !== undefined && !isStaleClaim(key, claimedPath)) {
-        throw new Error(`Session file already has an active writer: ${path}`);
+function toSessionEntry(record, sessionId) {
+    const id = `${sessionId}:${record.id}`;
+    const message = record.model?.[0];
+    if (UserEntry.is(record) || AssistantEntry.is(record) || ToolResultEntry.is(record)) {
+        if (!message)
+            return undefined;
+        return { type: "message", id, timestamp: messageTimestamp(message), message };
+    }
+    if (CompactionEntry.is(record)) {
+        return {
+            type: "compaction",
+            id,
+            timestamp: messageTimestamp(message),
+            summary: (message && compactionSummaryOf(message)) ?? contentText(message),
+        };
     }
-    activeWriterKeys.set(key, path);
+    if (CustomSessionEntry.is(record)) {
+        return {
+            type: "custom",
+            id,
+            timestamp: record.data.timestamp,
+            customType: record.data.customType,
+            data: record.data.data ?? undefined,
+        };
+    }
+    return undefined;
 }
-function acquireWriter(path) {
-    const canonical = canonicalSessionPath(path);
-    const key = sessionWriterKey(canonical);
-    claimWriter(key, canonical);
-    return { path: canonical, key };
+function toSessionEntries(records, sessionId) {
+    return records.flatMap((record) => toSessionEntry(record, sessionId) ?? []);
 }
-function releaseWriter(key) {
-    activeWriterKeys.delete(key);
+async function readRecords(conversation) {
+    const records = [];
+    let cursor;
+    do {
+        const page = await conversation.entries({}, ENTRY_PAGE_SIZE, cursor, context);
+        records.push(...page.items);
+        cursor = page.next;
+    } while (cursor !== undefined);
+    return records.toReversed();
 }
-function promotePendingWriter(pathKey, path) {
-    const inodeKey = sessionWriterKey(path);
-    if (inodeKey === pathKey)
-        return pathKey;
-    claimWriter(inodeKey, path);
-    activeWriterKeys.delete(pathKey);
-    return inodeKey;
+async function readContext(conversation) {
+    const view = await conversation.context(context);
+    const messages = view.messages
+        .filter((message) => message.role !== "system")
+        .map(durableMessage);
+    return { messages };
 }
-function toDurable(input) {
-    return input === undefined ? input : JSON.parse(JSON.stringify(input));
+function bindModels(models, property) {
+    const value = Reflect.get(models, property, models);
+    return typeof value === "function" ? value.bind(models) : value;
 }
-class SessionFormatError extends Error {
+function requestOwnerKey(request) {
+    if (typeof request !== "object" || request === null || !("messages" in request))
+        return undefined;
+    const { messages } = request;
+    if (!Array.isArray(messages))
+        return undefined;
+    const last = messages.at(-1);
+    return typeof last === "object" && last !== null ? last : undefined;
 }
-const HEADER_CHUNK_SIZE = 4096;
-const MAX_HEADER_BYTES = 1024 * 1024;
-function readHeaderLine(filePath) {
-    const fd = openSync(filePath, "r");
-    const chunks = [];
-    let total = 0;
-    try {
-        while (total < MAX_HEADER_BYTES) {
-            const chunk = Buffer.allocUnsafe(Math.min(HEADER_CHUNK_SIZE, MAX_HEADER_BYTES - total));
-            const bytesRead = readSync(fd, chunk, 0, chunk.length, null);
-            if (bytesRead === 0)
-                break;
-            const data = chunk.subarray(0, bytesRead);
-            const newline = data.indexOf(0x0a);
-            chunks.push(newline < 0 ? data : data.subarray(0, newline));
-            total += newline < 0 ? bytesRead : newline;
-            if (newline >= 0)
-                break;
-        }
+function protectStorageFiles(path) {
+    for (const file of [path, `${path}-wal`, `${path}-shm`]) {
+        if (existsSync(file))
+            chmodSync(file, 0o600);
     }
-    finally {
-        closeSync(fd);
-    }
-    if (total >= MAX_HEADER_BYTES) {
-        throw new SessionFormatError(`Session file header exceeds ${MAX_HEADER_BYTES} bytes: ${filePath}`);
-    }
-    return Buffer.concat(chunks).toString("utf-8");
 }
-function parseCurrentHeader(filePath, firstLine) {
-    const trimmed = firstLine.trim();
-    if (!trimmed)
-        throw new SessionFormatError(`Session file has a blank header line: ${filePath}`);
-    let parsed;
-    try {
-        parsed = JSON.parse(trimmed);
+const REQUEST_METHODS = new Set(["streamSimple", "completeSimple"]);
+class OfficeStorage {
+    static { this.pool = new Map(); }
+    constructor(path) {
+        this.path = path;
+        this.registry = createRegistry();
+        this.refs = 0;
+        this.bindings = new Map();
+        this.owners = new WeakMap();
+        this.writers = new Set();
+    }
+    get harness() {
+        if (!this.opened)
+            throw new Error("Office session storage is not open");
+        return this.opened;
+    }
+    static async acquire(path) {
+        let pending = OfficeStorage.pool.get(path);
+        if (!pending) {
+            pending = OfficeStorage.openShared(path);
+            OfficeStorage.pool.set(path, pending);
+            pending.catch(() => OfficeStorage.pool.delete(path));
+        }
+        const storage = await pending;
+        storage.refs += 1;
+        return storage;
+    }
+    static async inMemory() {
+        const storage = await OfficeStorage.open(null, new MemoryStorage());
+        storage.refs = 1;
+        return storage;
+    }
+    static async openShared(path) {
+        mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+        const storage = await OfficeStorage.open(path, await openNodeSqliteStorage(path));
+        protectStorageFiles(path);
+        await storage.abortUnfinishedWork();
+        return storage;
+    }
+    static async open(path, backend) {
+        const storage = new OfficeStorage(path);
+        storage.opened = await Harness.open(backend, storage.harnessOptions(), context);
+        return storage;
+    }
+    harnessOptions() {
+        const latest = () => [...this.bindings.values()].at(-1);
+        const fallback = () => {
+            const models = latest()?.models;
+            if (!models)
+                throw new Error("Session has no model binding; start a run to use the model");
+            return models;
+        };
+        const models = new Proxy({}, {
+            get: (_target, property) => {
+                if (!REQUEST_METHODS.has(property))
+                    return bindModels(fallback(), property);
+                return (...args) => {
+                    const key = requestOwnerKey(args[1]);
+                    const owner = key ? this.owners.get(key) : undefined;
+                    const binding = owner === undefined ? undefined : this.bindings.get(owner);
+                    const target = binding?.requestModels ?? binding?.models ?? fallback();
+                    const method = Reflect.get(target, property, target);
+                    return method.apply(target, args);
+                };
+            },
+        });
+        const settings = () => latest()?.settings;
+        return {
+            models,
+            registry: this.registry,
+            settings: {
+                extensions: [],
+                get stream() {
+                    return settings()?.stream;
+                },
+                get retry() {
+                    return settings()?.retry;
+                },
+                get compaction() {
+                    return settings()?.compaction;
+                },
+                get toolExecution() {
+                    return settings()?.toolExecution;
+                },
+                get steeringMode() {
+                    return settings()?.steeringMode;
+                },
+                get followUpMode() {
+                    return settings()?.followUpMode;
+                },
+            },
+            env: (target, envContext) => this.bindings.get(target.conversationId)?.env?.(target, envContext),
+            onReport: (error) => {
+                const report = latest()?.onReport;
+                if (report)
+                    report(error);
+                else
+                    log.logWarning("Durable harness report", errorMessage(error));
+            },
+        };
     }
-    catch {
-        throw new SessionFormatError(`Session file header is not valid JSON: ${filePath}`);
+    async abortUnfinishedWork() {
+        const { tasks } = await this.harness.inspect(context);
+        const unowned = tasks.filter((task) => !task.record.owner);
+        if (unowned.length === 0)
+            return;
+        log.logWarning(`Aborting ${unowned.length} durable tasks left unfinished by a previous process`);
+        for (const task of unowned)
+            await this.harness.abortTask(task.record.id, context);
+    }
+    async index() {
+        return (await this.harness.snapshot(SessionIndexDoc, context))?.sessions ?? {};
+    }
+    claimWriter(conversationId, key) {
+        if (this.writers.has(conversationId)) {
+            throw new Error(`Session already has an active writer: ${key}`);
+        }
+        this.writers.add(conversationId);
     }
-    if (!isMetadataRecord(parsed)) {
-        throw new SessionFormatError(`Session file has an unrecognized header: ${filePath}`);
+    releaseWriter(conversationId) {
+        this.writers.delete(conversationId);
     }
-    const record = parsed;
-    if (record.kind !== "header" ||
-        record.v !== CURRENT_SESSION_VERSION ||
-        record.storageVersion !== JSONL_STORAGE_VERSION ||
-        typeof record.id !== "string" ||
-        typeof record.createdAt !== "number" ||
-        typeof record.cwd !== "string") {
-        throw new SessionFormatError(`Session file has an unrecognized header: ${filePath}`);
+    bind(conversationId, binding) {
+        if (this.bindings.has(conversationId)) {
+            throw new Error("Session already has an attached harness");
+        }
+        this.bindings.set(conversationId, binding);
+    }
+    unbind(conversationId) {
+        this.bindings.delete(conversationId);
+    }
+    tag(conversationId, messages) {
+        const last = messages.at(-1);
+        if (!last)
+            return messages;
+        const tagged = { ...last };
+        this.owners.set(tagged, conversationId);
+        return [...messages.slice(0, -1), tagged];
+    }
+    async release() {
+        this.refs -= 1;
+        if (this.refs > 0)
+            return;
+        if (this.path !== null)
+            OfficeStorage.pool.delete(this.path);
+        await this.harness.close(context);
     }
-    return parsed;
 }
-function metadataFromHeader(header, path) {
-    return {
-        id: header.id,
-        createdAt: header.createdAt,
-        storageVersion: header.storageVersion,
-        cwd: header.cwd,
-        path,
-        modifiedAt: 0,
-        parentSessionId: header.parentSessionId,
-        legacyParentSessionPath: header.legacyParentSessionPath,
+function writeSessionIndex(tx, key, record) {
+    return tx.doc(SessionIndexDoc).then((doc) => {
+        doc.sessions[key] = record;
+    });
+}
+async function lookupSession(storage, key) {
+    const record = (await storage.index())[key];
+    if (!record)
+        return undefined;
+    const conversation = await storage.harness.conversation(record.conversationId, context);
+    return conversation ? { conversation, record } : undefined;
+}
+async function createSession(storage, key) {
+    let record;
+    const init = async (tx, conversationId) => {
+        record = { conversationId, id: randomUUID(), createdAt: Date.now() };
+        await writeSessionIndex(tx, key, record);
     };
+    const conversation = isThreadSessionKey(key)
+        ? await storage.harness.createConversation({ ownership: { kind: "ownerless" }, init }, context)
+        : await storage.harness.root(context, { init });
+    if (!record) {
+        record = { conversationId: conversation.id, id: randomUUID(), createdAt: Date.now() };
+        const created = record;
+        await conversation.commit((tx) => writeSessionIndex(tx, key, created), context);
+    }
+    return { conversation, record };
 }
-function parseMikanMetadata(filePath) {
-    let current;
-    for (const line of readFileSync(filePath, "utf-8").split("\n").slice(1)) {
-        for (const write of parseMetadataWrites(line)) {
-            if (write.op === "delete")
-                current = undefined;
-            else if (write.op === "set" && isMetadataRecord(write.value))
-                current = write.value;
-        }
+async function parentSessionId(storage, conversationId) {
+    const parent = await storage.harness.commit(async (tx) => (await tx.conversation(conversationId))?.parent, context);
+    if (!parent)
+        return undefined;
+    const records = Object.values(await storage.index());
+    return records.find((record) => record.conversationId === parent.conversationId)?.id;
+}
+function isRunCause(record, messageId) {
+    if (!CustomSessionEntry.is(record) || record.data.customType !== RUN_CAUSE_CUSTOM_TYPE) {
+        return false;
     }
-    return current;
+    const { data } = record.data;
+    return messageId === undefined || (isRecord(data) && data.messageId === messageId);
 }
-function isMetadataRecord(input) {
-    return isRecord(input);
+function runEnd(records, messageId) {
+    const start = records.findLastIndex((record) => isRunCause(record, messageId));
+    if (start < 0)
+        return undefined;
+    const next = records.findIndex((record, index) => index > start && isRunCause(record));
+    const run = records.slice(start, next < 0 ? undefined : next);
+    return (run.findLast((record) => AssistantEntry.is(record)) ?? run.at(-1))?.id;
 }
-function parseMetadataWrites(line) {
-    let transaction;
-    try {
-        transaction = JSON.parse(line);
-    }
-    catch {
-        return [];
-    }
-    const writes = Array.isArray(transaction) ? transaction : [transaction];
-    return writes.filter((write) => isMetadataRecord(write) &&
-        write.kind === "value" &&
-        write.namespace === "mikan" &&
-        write.key === "metadata");
+const EARLIER_SESSION_PREFIX = "earlier:";
+export function earlierSessionKey(sessionId) {
+    return `${EARLIER_SESSION_PREFIX}${sessionId}`;
 }
-function fileFingerprint(path) {
-    const fd = openSync(path, "r");
-    try {
-        const stats = fstatSync(fd);
-        return `${stats.dev}:${stats.ino}:${stats.size}:${stats.mtimeMs}`;
-    }
-    finally {
-        closeSync(fd);
-    }
+export function isEarlierSessionKey(key) {
+    return key.startsWith(EARLIER_SESSION_PREFIX);
 }
-function materializePendingFile(path, header, expectedFingerprint) {
-    const content = `${JSON.stringify(header)}\n`;
-    if (expectedFingerprint === null) {
-        mkdirSync(dirname(path), { recursive: true });
-        const fd = openSync(path, "wx", 0o600);
-        try {
-            writeFileSync(fd, content);
-        }
-        finally {
-            closeSync(fd);
+async function appendImportedEntry(tx, conversationId, entry) {
+    switch (entry.type) {
+        case "message": {
+            const model = [durableMessage(entry.message)];
+            if (entry.message.role === "user")
+                await tx.appendEntry(UserEntry, conversationId, { model });
+            else if (entry.message.role === "assistant") {
+                await tx.appendEntry(AssistantEntry, conversationId, { model });
+            }
+            else {
+                await tx.appendEntry(ToolResultEntry, conversationId, {
+                    model,
+                    data: { diagnostics: [] },
+                });
+            }
+            return;
         }
-        return;
+        case "compaction":
+            await tx.appendEntry(CompactionEntry, conversationId, {
+                model: [
+                    {
+                        role: "user",
+                        content: [{ type: "text", text: wrapCompactionSummary(entry.summary) }],
+                        timestamp: entry.timestamp,
+                    },
+                ],
+                data: { reason: "manual" },
+                head: "self",
+            });
+            return;
+        case "custom":
+            await tx.appendEntry(CustomSessionEntry, conversationId, {
+                data: {
+                    customType: entry.customType,
+                    data: toJson(entry.data),
+                    timestamp: entry.timestamp,
+                },
+            });
+            return;
+        default:
+            entry;
     }
-    const fd = openSync(path, "r+");
+}
+export async function importOfficeSessions(path, sessions) {
+    mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+    const harness = await Harness.open(await openNodeSqliteStorage(path), { models: {}, registry: createRegistry(), settings: { extensions: [] } }, context);
     try {
-        const stats = fstatSync(fd);
-        const actual = `${stats.dev}:${stats.ino}:${stats.size}:${stats.mtimeMs}`;
-        if (actual !== expectedFingerprint) {
-            throw new Error(`Session file changed before pending session materialization: ${path}`);
+        for (const session of sessions) {
+            const init = async (tx, conversationId) => {
+                for (const entry of session.entries)
+                    await appendImportedEntry(tx, conversationId, entry);
+                if (session.name)
+                    (await tx.doc(SessionDoc, conversationId)).name = session.name;
+                await writeSessionIndex(tx, session.key, {
+                    conversationId,
+                    id: session.id,
+                    createdAt: session.createdAt,
+                });
+            };
+            if (session.root)
+                await harness.root(context, { init });
+            else
+                await harness.createConversation({ ownership: { kind: "ownerless" }, init }, context);
         }
-        ftruncateSync(fd, 0);
-        writeFileSync(fd, content);
     }
     finally {
-        closeSync(fd);
+        await harness.close(context);
     }
+    protectStorageFiles(path);
 }
-function buildHeader(cwd, options) {
-    const metadata = options?.parentSession === undefined
-        ? undefined
-        : { parentSessionPath: options.parentSession };
-    return {
-        header: {
-            v: CURRENT_SESSION_VERSION,
-            kind: "header",
-            id: options?.id ?? uuidv7(),
-            storageVersion: JSONL_STORAGE_VERSION,
-            createdAt: Date.now(),
-            cwd,
-            parentSessionId: options?.parentSessionId,
-            legacyParentSessionPath: options?.parentSession,
-        },
-        metadata,
-    };
-}
-function headerView(header, metadata) {
-    const parentSession = typeof metadata?.parentSessionPath === "string"
-        ? metadata.parentSessionPath
-        : header.legacyParentSessionPath;
-    return {
-        type: "session",
-        version: CURRENT_SESSION_VERSION,
-        id: header.id,
-        timestamp: new Date(header.createdAt).toISOString(),
-        cwd: header.cwd,
-        parentSessionId: header.parentSessionId,
-        parentSession,
-        metadata,
-    };
-}
-async function openFileSession(path, header) {
-    const sessionRepo = new JsonlSessionRepo({
-        fileSystem: new NodeExecutionEnv({ cwd: process.cwd() }),
-        sessionsRoot: dirname(path),
-    });
-    try {
-        const session = await sessionRepo.open(metadataFromHeader(header, path), TODO_CONTEXT);
-        return { session, repo: sessionRepo };
-    }
-    catch (error) {
-        await sessionRepo.close(TODO_CONTEXT);
-        throw error;
-    }
-}
-async function withSessionSnapshot(path, read) {
-    const resolvedPath = canonicalSessionPath(path);
-    const dir = mkdtempSync(join(tmpdir(), "mikan-session-inspect-"));
-    const snapshot = join(dir, basename(resolvedPath));
-    let opened;
+export async function readImportedContexts(path) {
+    const harness = await Harness.open(await openNodeSqliteStorage(path), { models: {}, registry: createRegistry(), settings: { extensions: [] } }, context);
     try {
-        writeFileSync(snapshot, readFileSync(resolvedPath), { mode: 0o600, flag: "wx" });
-        const header = parseCurrentHeader(resolvedPath, readHeaderLine(snapshot));
-        opened = await openFileSession(snapshot, header);
-        return await read(opened.session, header);
-    }
-    finally {
-        try {
-            await opened?.session.close(TODO_CONTEXT);
-        }
-        finally {
-            try {
-                await opened?.repo.close(TODO_CONTEXT);
-            }
-            finally {
-                rmSync(dir, { recursive: true, force: true });
-            }
+        const index = (await harness.snapshot(SessionIndexDoc, context))?.sessions ?? {};
+        const contexts = new Map();
+        for (const [key, record] of Object.entries(index)) {
+            const conversation = await harness.conversation(record.conversationId, context);
+            if (conversation)
+                contexts.set(key, (await readContext(conversation)).messages);
         }
+        return contexts;
     }
-}
-async function mainBranch(session, create) {
-    const existing = await session.branch("main", TODO_CONTEXT);
-    if (existing || !create)
-        return existing;
-    return session.createBranch("main", null, TODO_CONTEXT);
-}
-function isContextMessage(message) {
-    return (message.role !== "assistant" ||
-        (message.stopReason !== "error" &&
-            message.stopReason !== "aborted" &&
-            message.stopReason !== "deferred"));
-}
-function buildContext(entries) {
-    const compactionIndex = entries.findLastIndex((entry) => entry.type === "compaction");
-    const visibleEntries = entries.slice(Math.max(0, compactionIndex));
-    const messages = [];
-    for (const entry of visibleEntries) {
-        if (entry.type === "message") {
-            if (isContextMessage(entry.message))
-                messages.push(entry.message);
-        }
-        else if (entry.type === "compaction") {
-            messages.push(createCompactionSummaryMessage(entry.summary, entry.tokensBefore, entry.timestamp), ...entry.retainedTail.filter(isContextMessage));
-        }
-        else if (entry.type === "branch_summary" && entry.summary) {
-            messages.push(createBranchSummaryMessage(entry.summary, entry.fromId, entry.timestamp));
-        }
+    finally {
+        await harness.close(context);
     }
-    return { messages };
 }
 class CachedSessionInspection {
-    constructor(header, entries, name, branch, context) {
+    constructor(header, entries, name, sessionContext) {
         this.header = header;
         this.entries = entries;
         this.name = name;
-        this.branch = branch;
-        this.context = context;
+        this.sessionContext = sessionContext;
     }
     getHeader() {
         return structuredClone(this.header);
@@ -308,190 +426,173 @@ class CachedSessionInspection {
     async getSessionName() {
         return this.name;
     }
-    async getBranch(fromId) {
-        if (fromId === undefined)
-            return structuredClone(this.branch);
-        const byId = new Map(this.entries.map((entry) => [entry.id, entry]));
-        const result = [];
-        let current = byId.get(fromId);
-        while (current) {
-            result.push(current);
-            current = current.parentId === null ? undefined : byId.get(current.parentId);
-        }
-        return result.toReversed();
-    }
     async buildSessionContext() {
-        return structuredClone(this.context);
+        return structuredClone(this.sessionContext);
+    }
+}
+async function withOfficeStorage(office, read) {
+    const storage = await OfficeStorage.acquire(office.sessionsPath);
+    try {
+        return await read(storage);
+    }
+    finally {
+        await storage.release();
     }
 }
 export class SessionStore {
-    constructor(sessionFile, cwd, state, writerKey) {
-        this.sessionFile = sessionFile;
-        this.cwd = cwd;
-        this.state = state;
-        this.writerKey = writerKey;
+    constructor(storage, conversation, header) {
+        this.storage = storage;
+        this.conversation = conversation;
+        this.header = header;
         this.mutationTail = Promise.resolve();
         this.closed = false;
+        this.bound = false;
     }
-    static async open(path, cwdOverride) {
-        const writer = acquireWriter(path);
-        const writerPath = writer.path;
+    static async open(office, key) {
+        const storage = await OfficeStorage.acquire(office.sessionsPath);
         try {
-            if (!existsSync(writerPath)) {
-                const cwd = cwdOverride ?? process.cwd();
-                const built = buildHeader(cwd);
-                return new SessionStore(writerPath, cwd, { kind: "pending", ...built, fingerprint: null }, writer.key);
-            }
-            const firstLine = readHeaderLine(writerPath);
-            if (firstLine.trim().length === 0) {
-                const cwd = cwdOverride ?? process.cwd();
-                const built = buildHeader(cwd);
-                return new SessionStore(writerPath, cwd, { kind: "pending", ...built, fingerprint: fileFingerprint(writerPath) }, writer.key);
-            }
-            const header = parseCurrentHeader(writerPath, firstLine);
-            const opened = await openFileSession(writerPath, header);
-            const metadata = (await opened.session.getValue(MIKAN_METADATA, TODO_CONTEXT))?.value;
-            return new SessionStore(writerPath, cwdOverride ?? header.cwd, { kind: "live", header, metadata, ...opened }, writer.key);
+            const session = (await lookupSession(storage, key)) ?? (await createSession(storage, key));
+            storage.claimWriter(session.conversation.id, key);
+            return new SessionStore(storage, session.conversation, {
+                id: session.record.id,
+                createdAt: session.record.createdAt,
+                parentSessionId: await parentSessionId(storage, session.conversation.id),
+            });
         }
         catch (error) {
-            releaseWriter(writer.key);
+            await storage.release();
             throw error;
         }
     }
-    static async inspectExecution(path) {
-        return withSessionSnapshot(path, async (session) => {
-            const state = (await session.getValue(laneState("main"), TODO_CONTEXT))?.value;
-            const result = state?.lastOperationId
-                ? (await session.getValue(operationResult(state.lastOperationId), TODO_CONTEXT))?.value
-                : undefined;
-            return {
-                open: state?.currentOperationId != null,
-                started: state?.currentOperationId != null || state?.lastOperationId != null,
-                result: result ? { status: result.status, endedAt: result.endedAt } : undefined,
-            };
+    static async forkRun(office, key, cause, entries) {
+        return withOfficeStorage(office, async (storage) => {
+            if ((await storage.index())[key])
+                return false;
+            const parent = await lookupSession(storage, cause.sessionKey);
+            if (!parent)
+                return false;
+            const at = runEnd(await readRecords(parent.conversation), cause.messageId);
+            if (at === undefined)
+                return false;
+            await parent.conversation.fork(at, {
+                ownership: { kind: "ownerless" },
+                init: async (tx, conversationId) => {
+                    for (const entry of entries)
+                        await appendImportedEntry(tx, conversationId, entry);
+                    await writeSessionIndex(tx, key, {
+                        conversationId,
+                        id: randomUUID(),
+                        createdAt: Date.now(),
+                    });
+                },
+            }, context);
+            return true;
         });
     }
-    static async inspect(path) {
-        return withSessionSnapshot(path, async (session, header) => {
-            const metadata = (await session.getValue(MIKAN_METADATA, TODO_CONTEXT))?.value;
-            const entries = await session.findEntries({ order: "asc" }, TODO_CONTEXT);
-            const name = await session.getName(TODO_CONTEXT);
-            const branchObject = await mainBranch(session, false);
-            const branch = branchObject
-                ? await branchObject.findEntries({ order: "oldestFirst" }, TODO_CONTEXT)
-                : [];
-            const context = buildContext(branch);
-            return new CachedSessionInspection(headerView(header, metadata), entries, name, branch, context);
-        });
+    static async inMemory() {
+        const storage = await OfficeStorage.inMemory();
+        const conversation = await storage.harness.root(context);
+        return new SessionStore(storage, conversation, { id: randomUUID(), createdAt: Date.now() });
     }
-    static async create(path, cwd, options) {
-        const writer = acquireWriter(path);
-        const writerPath = writer.path;
-        let leaseKey = writer.key;
-        let opened;
-        try {
-            const built = buildHeader(cwd, options);
-            mkdirSync(dirname(writerPath), { recursive: true });
-            writeFileSync(writerPath, `${JSON.stringify(built.header)}\n`, { mode: 0o600, flag: "wx" });
-            leaseKey = promotePendingWriter(leaseKey, writerPath);
-            opened = await openFileSession(writerPath, built.header);
-            if (built.metadata) {
-                await opened.session.setValue(MIKAN_METADATA, built.metadata, TODO_CONTEXT);
-            }
-            return new SessionStore(writerPath, cwd, { kind: "live", ...built, ...opened }, leaseKey);
-        }
-        catch (error) {
-            if (opened) {
-                await opened.session.close(TODO_CONTEXT).catch(() => undefined);
-                await opened.repo.close(TODO_CONTEXT).catch(() => undefined);
-            }
-            releaseWriter(leaseKey);
-            throw error;
-        }
+    static async exists(office, key) {
+        if (!existsSync(office.sessionsPath))
+            return false;
+        return withOfficeStorage(office, async (storage) => (await storage.index())[key] !== undefined);
     }
-    static readHeader(path) {
-        let firstLine;
-        try {
-            firstLine = readHeaderLine(path);
-        }
-        catch {
-            return null;
-        }
-        if (firstLine.trim().length === 0)
-            return null;
-        try {
-            const header = parseCurrentHeader(path, firstLine);
-            return headerView(header, parseMikanMetadata(path));
-        }
-        catch {
-            return null;
-        }
-    }
-    static writeHeaderFile(path, cwd, options) {
-        mkdirSync(dirname(path), { recursive: true });
-        const built = buildHeader(cwd, options);
-        atomicWritePrivateFile(path, `${JSON.stringify(built.header)}\n`);
-    }
-    static inMemory(cwd = process.cwd()) {
-        const built = buildHeader(cwd);
-        return new SessionStore(null, cwd, { kind: "pending", ...built, fingerprint: null }, null);
-    }
-    getSessionFile() {
-        this.assertOpen();
-        return this.sessionFile ?? undefined;
+    static async list(office) {
+        if (!existsSync(office.sessionsPath))
+            return [];
+        return withOfficeStorage(office, async (storage) => {
+            const index = await storage.index();
+            const byConversation = new Map(Object.values(index).map((record) => [record.conversationId, record.id]));
+            return Promise.all(Object.entries(index).map(async ([key, record]) => {
+                const parent = await storage.harness.commit(async (tx) => (await tx.conversation(record.conversationId))?.parent, context);
+                const parentId = parent ? byConversation.get(parent.conversationId) : undefined;
+                return {
+                    key,
+                    id: record.id,
+                    createdAt: record.createdAt,
+                    root: record.conversationId === ROOT_CONVERSATION_ID,
+                    parentSessionId: parentId,
+                    forkEntryId: parent && parentId ? `${parentId}:${parent.at}` : undefined,
+                };
+            }));
+        });
     }
-    isPersisted() {
-        this.assertOpen();
-        return this.sessionFile !== null;
+    static async inspect(office, key) {
+        if (!existsSync(office.sessionsPath))
+            return undefined;
+        return withOfficeStorage(office, async (storage) => {
+            const session = await lookupSession(storage, key);
+            if (!session)
+                return undefined;
+            const { conversation, record } = session;
+            const name = (await storage.harness.snapshot(SessionDoc, conversation.id, context))?.name;
+            return new CachedSessionInspection({
+                id: record.id,
+                createdAt: record.createdAt,
+                parentSessionId: await parentSessionId(storage, conversation.id),
+            }, toSessionEntries(await readRecords(conversation), record.id), name, await readContext(conversation));
+        });
     }
-    getCwd() {
-        this.assertOpen();
-        return this.cwd;
+    static async inspectExecution(office, key) {
+        if (!existsSync(office.sessionsPath))
+            return { open: false, started: false };
+        return withOfficeStorage(office, async (storage) => {
+            const session = await lookupSession(storage, key);
+            if (!session)
+                return { open: false, started: false };
+            const id = session.conversation.id;
+            const live = await storage.harness.snapshot(LiveDoc, id, context);
+            const run = (await storage.harness.snapshot(SessionDoc, id, context))?.run;
+            const open = live?.run !== undefined;
+            return {
+                open,
+                started: open || run !== undefined,
+                result: run?.endedAt !== undefined && run.status !== undefined
+                    ? { status: run.status, endedAt: run.endedAt }
+                    : undefined,
+            };
+        });
     }
     getHeader() {
         this.assertOpen();
-        return headerView(this.state.header, this.state.metadata);
+        return structuredClone(this.header);
     }
     getSessionId() {
         this.assertOpen();
-        return this.state.header.id;
+        return this.header.id;
     }
-    async getLeafId() {
+    async getEntries() {
         this.assertOpen();
-        if (this.state.kind === "pending")
-            return null;
-        return (await mainBranch(this.state.session, false))?.getTipId(TODO_CONTEXT) ?? null;
+        return toSessionEntries(await readRecords(this.conversation), this.header.id);
     }
-    async getEntry(id) {
+    async getContextEntries() {
         this.assertOpen();
-        if (this.state.kind === "pending")
-            return undefined;
-        return this.state.session.getEntry(id, TODO_CONTEXT);
+        const view = await this.conversation.context(context);
+        return toSessionEntries(view.entries, this.header.id);
     }
-    async getEntries() {
+    async getContextTokens() {
         this.assertOpen();
-        if (this.state.kind === "pending")
-            return [];
-        return this.state.session.findEntries({ order: "asc" }, TODO_CONTEXT);
+        const view = await this.conversation.context(context);
+        const after = view.head?.id ?? Number.NEGATIVE_INFINITY;
+        for (const record of view.entries.toReversed()) {
+            const message = record.model?.[0];
+            if (record.id <= after || !AssistantEntry.is(record) || message?.role !== "assistant")
+                continue;
+            if (message.stopReason === "aborted" || message.stopReason === "error")
+                continue;
+            return calculateContextTokens(message.usage);
+        }
+        return undefined;
     }
     async getSessionName() {
         this.assertOpen();
-        if (this.state.kind === "pending")
-            return undefined;
-        return this.state.session.getName(TODO_CONTEXT);
-    }
-    async getBranch(fromId) {
-        this.assertOpen();
-        if (this.state.kind === "pending")
-            return [];
-        if (fromId !== undefined) {
-            return this.state.session.scanBranch({ start: fromId, order: "oldestFirst" }, TODO_CONTEXT);
-        }
-        const branchObject = await mainBranch(this.state.session, false);
-        return branchObject ? branchObject.findEntries({ order: "oldestFirst" }, TODO_CONTEXT) : [];
+        return (await this.storage.harness.snapshot(SessionDoc, this.conversation.id, context))?.name;
     }
     async buildSessionContext() {
-        return buildContext(await this.getBranch());
+        this.assertOpen();
+        return readContext(this.conversation);
     }
     async connectMcp(servers, signal) {
         return this.mutate(async () => {
@@ -509,73 +610,104 @@ export class SessionStore {
         const instructions = formatMcpServerInstructions(this.mcp?.instructions ?? []);
         return instructions ? `${prompt}\n\n${instructions}` : prompt;
     }
-    async createHarness(options) {
+    async bindHarness(binding) {
         return this.mutate(async () => {
-            if (this.harness)
-                throw new Error("SessionStore already has an attached harness");
-            const { session } = await this.live();
-            const { harness } = await AgentHarness.create({ ...options, session }, TODO_CONTEXT);
-            this.harness = harness;
-            this.harnessLane = await harness.lane("main", TODO_CONTEXT);
-            return harness;
+            this.storage.bind(this.conversation.id, binding);
+            this.bound = true;
+            const conversationId = this.conversation.id;
+            return {
+                harness: this.storage.harness,
+                conversation: this.conversation,
+                registry: this.storage.registry,
+                extensionName: `mikan.${conversationId}`,
+                tagRequest: (messages) => this.storage.tag(conversationId, messages),
+            };
         });
     }
     async appendMessage(message) {
         return this.mutate(async () => {
-            if (this.harnessLane)
-                return this.harnessLane.appendMessage(toDurable(message), TODO_CONTEXT);
-            const branchObject = await mainBranch((await this.live()).session, true);
-            if (!branchObject)
-                throw new Error("Failed to create main session branch");
-            return branchObject.appendMessage(toDurable(message), TODO_CONTEXT);
+            const conversation = this.conversation;
+            const model = [durableMessage(message)];
+            const entry = await conversation.commit((tx) => {
+                switch (message.role) {
+                    case "user":
+                        return tx.appendEntry(UserEntry, conversation.id, { model });
+                    case "assistant":
+                        return tx.appendEntry(AssistantEntry, conversation.id, { model });
+                    case "toolResult":
+                        return tx.appendEntry(ToolResultEntry, conversation.id, {
+                            model,
+                            data: { diagnostics: [] },
+                        });
+                    default:
+                        throw new Error("Only user, assistant, and tool result messages enter a session");
+                }
+            }, context);
+            return `${this.header.id}:${entry.id}`;
         });
     }
-    async appendCustomEntry(customType, data) {
+    async appendCustomEntry(customType, data, timestamp = Date.now()) {
         return this.mutate(async () => {
-            if (this.harnessLane) {
-                return this.harnessLane.appendCustomEntry(customType, toDurable(data), TODO_CONTEXT);
-            }
-            const branchObject = await mainBranch((await this.live()).session, true);
-            if (!branchObject)
-                throw new Error("Failed to create main session branch");
-            return branchObject.appendCustomEntry(customType, toDurable(data), TODO_CONTEXT);
+            const conversation = this.conversation;
+            const entry = await conversation.commit((tx) => tx.appendEntry(CustomSessionEntry, conversation.id, {
+                data: { customType, data: toJson(data), timestamp },
+            }), context);
+            return `${this.header.id}:${entry.id}`;
+        });
+    }
+    async appendCompactionSummary(summary, timestamp) {
+        const text = wrapCompactionSummary(summary);
+        return this.mutate(async () => {
+            const conversation = this.conversation;
+            const entry = await conversation.commit((tx) => tx.appendEntry(CompactionEntry, conversation.id, {
+                model: [{ role: "user", content: [{ type: "text", text }], timestamp }],
+                data: { reason: "manual" },
+                head: "self",
+            }), context);
+            return `${this.header.id}:${entry.id}`;
         });
     }
-    async appendCustomMessageEntry(customType, content, display, details) {
-        return this.appendMessage(toDurable(createCustomMessage(customType, content, display, details, Date.now())));
+    async reset() {
+        await this.mutate(() => this.conversation.reset(undefined, context));
     }
     async setSessionName(name) {
-        await this.mutate(async () => (await this.live()).session.setName(name.trim() || undefined, TODO_CONTEXT));
+        await this.updateSessionDoc((doc) => {
+            doc.name = name.trim() || undefined;
+        });
+    }
+    async recordRun(run) {
+        await this.updateSessionDoc((doc) => {
+            doc.run = { ...run };
+        });
     }
     async close() {
         if (this.closePromise)
             return this.closePromise;
         this.closed = true;
-        this.closePromise = this.mutationTail
-            .then(async () => {
+        const conversationId = this.conversation.id;
+        this.closePromise = this.mutationTail.then(async () => {
             try {
                 await this.mcp?.dispose();
             }
             finally {
-                if (this.state.kind === "live") {
-                    try {
-                        if (this.harness)
-                            await this.harness.close(TODO_CONTEXT);
-                        else
-                            await this.state.session.close(TODO_CONTEXT);
-                    }
-                    finally {
-                        await this.state.repo?.close(TODO_CONTEXT);
-                    }
+                if (this.bound) {
+                    this.storage.registry.uninstall({ name: `mikan.${conversationId}` });
+                    this.storage.unbind(conversationId);
                 }
+                this.storage.releaseWriter(conversationId);
+                await this.storage.release();
             }
-        })
-            .finally(() => {
-            if (this.writerKey !== null)
-                releaseWriter(this.writerKey);
         });
         return this.closePromise;
     }
+    async updateSessionDoc(change) {
+        await this.mutate(async () => {
+            const conversation = this.conversation;
+            await conversation.commit(async (tx) => {
+                change(await tx.doc(SessionDoc, conversation.id));
+            }, context);
+        });
+    }
     assertOpen() {
         if (this.closed)
             throw new Error("SessionStore is closed");
@@ -586,43 +718,5 @@ export class SessionStore {
         this.mutationTail = result.then(() => undefined, () => undefined);
         return result;
     }
-    async live() {
-        if (this.state.kind === "live")
-            return this.state;
-        const pending = this.state;
-        const sessionFile = this.sessionFile;
-        if (sessionFile === null) {
-            const repo = new MemorySessionRepo();
-            const session = await repo.create({
-                id: pending.header.id,
-                parentSessionId: pending.header.parentSessionId,
-            }, TODO_CONTEXT);
-            const live = {
-                kind: "live",
-                header: pending.header,
-                metadata: pending.metadata,
-                session,
-                repo,
-            };
-            this.state = live;
-            return live;
-        }
-        materializePendingFile(sessionFile, pending.header, pending.fingerprint);
-        if (this.writerKey === null)
-            throw new Error("Pending session must have a writer lease");
-        this.writerKey = promotePendingWriter(this.writerKey, sessionFile);
-        const opened = await openFileSession(sessionFile, pending.header);
-        if (pending.metadata) {
-            await opened.session.setValue(MIKAN_METADATA, pending.metadata, TODO_CONTEXT);
-        }
-        const live = {
-            kind: "live",
-            header: pending.header,
-            metadata: pending.metadata,
-            ...opened,
-        };
-        this.state = live;
-        return live;
-    }
 }
 //# sourceMappingURL=session-store.js.map