@geminixiang/mikan 1.0.0-beta.47 → 1.0.0-beta.49

package/dist/harness/session-store.js

@@ -1,25 +1,20 @@
 /**
- * mikan-owned session storage facade over pi-agent-core's v4 sessions.
+ * mikan-owned facade over Pi's current JSONL v4 SessionRepo.
  *
- * Sessions are pi v4 JSONL files: a `{"kind":"header","version":4,...}` line
- * followed by mutation lines (entries, lane pointers, facts, lane records).
- * pi's `Session`/`JsonlSessionStorage` own the format, tree validation, and
- * torn-tail repair; this facade owns mikan's concerns only: session files
- * live at mikan-chosen paths (session-key layout), mikan header extras ride
- * in the v4 header `metadata`, and a missing file behaves as an empty
- * session whose header materializes on the first append.
- *
- * v3 files (the pre-0.84 layout) are not readable at runtime: `open` throws
- * an actionable error pointing at the `mikan sessions migrate` script.
+ * Pi owns entry, branch, value, transaction, and storage validation. mikan
+ * owns exact file paths, single-writer leases, lazy materialization, lineage
+ * metadata, and the stable inspection API consumed by platform runtimes.
+ * Older session generations are rejected and converted only by the offline
+ * `mikan sessions migrate` command.
  */
 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 { buildSessionContext as buildContextFromEntries, createCustomMessage, InMemorySessionStorage, JsonlSessionRepo, Session, uuidv7, } from "@earendil-works/pi-agent-core";
+import { branchTip, createBranchSummaryMessage, createCompactionSummaryMessage, createCustomMessage, insertEntry, JsonlSessionRepo, MemorySessionRepo, setValue, TODO_CONTEXT, uuidv7, value, } from "@earendil-works/pi-agent-core";
 import { NodeExecutionEnv } from "@earendil-works/pi-agent-core/node";
 import { atomicWritePrivateFile } from "../utils/file-guards.js";
-import { CURRENT_SESSION_VERSION, } from "./types.js";
-/** Live writer claims: lease key → canonical path it was claimed for. */
+import { CURRENT_SESSION_VERSION } from "./types.js";
+const MIKAN_METADATA = value("mikan", "metadata");
 const activeWriterKeys = new Map();
 function canonicalSessionPath(path) {
     const absolute = resolve(path);
@@ -32,21 +27,10 @@ function canonicalSessionPath(path) {
 function sessionWriterKey(path) {
     if (!existsSync(path))
         return `path:${path}`;
-    const stat = statSync(path);
-    // birthtime disambiguates a deleted-and-recreated file that received the
-    // same reused inode (same path or not). Filesystems without birthtime
-    // report 0 and fall back to dev:ino alone.
-    return `inode:${stat.dev}:${stat.ino}:${stat.birthtimeMs}`;
+    const stats = statSync(path);
+    return `inode:${stats.dev}:${stats.ino}:${stats.birthtimeMs}`;
 }
-/**
- * A claim is stale when the file it was taken for no longer resolves to the
- * claimed identity — deleted or replaced since. Filesystems reuse inodes, so
- * without this check a leaked claim for a deleted file would block an
- * unrelated new file that happens to receive the same dev:ino.
- */
 function isStaleClaim(key, claimedPath) {
-    // Pending (`path:`) claims guard a file that legitimately does not exist
-    // yet, so absence proves nothing; they are never stale.
     if (!key.startsWith("inode:"))
         return false;
     return sessionWriterKey(claimedPath) !== key;
@@ -75,31 +59,13 @@ function promotePendingWriter(pathKey, path) {
     activeWriterKeys.delete(pathKey);
     return inodeKey;
 }
-let sharedRepo;
-/**
- * Drop undefined-valued properties before durable persistence. pi's agent
- * loop builds messages with explicit `details: undefined` / `usage: undefined`
- * (e.g. tool results from tools that return only `content`), which pi's own
- * v4 durable-payload validator rejects; persistence is a value boundary, so
- * a JSON round-trip matches the validator's semantics exactly.
- */
-function toDurable(value) {
-    return value === undefined ? value : JSON.parse(JSON.stringify(value));
-}
-function repo() {
-    // The repo is only used to open sessions at explicit paths; its
-    // sessionsRoot layout is never consulted, so one shared instance is fine.
-    sharedRepo ??= new JsonlSessionRepo({
-        fs: new NodeExecutionEnv({ cwd: process.cwd() }),
-        sessionsRoot: process.cwd(),
-    });
-    return sharedRepo;
+function toDurable(input) {
+    return input === undefined ? input : JSON.parse(JSON.stringify(input));
 }
 class SessionFormatError extends Error {
 }
 const HEADER_CHUNK_SIZE = 4096;
 const MAX_HEADER_BYTES = 1024 * 1024;
-/** Read only the first JSONL line rather than loading the complete session. */
 function readHeaderLine(filePath) {
     const fd = openSync(filePath, "r");
     const chunks = [];
@@ -126,23 +92,28 @@ function readHeaderLine(filePath) {
     }
     return Buffer.concat(chunks).toString("utf-8");
 }
-/** Parse the first line of a session file into a v4 header, or explain why not. */
-function parseV4Header(filePath, firstLine) {
-    firstLine = firstLine.trim();
-    if (!firstLine)
+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(firstLine);
+        parsed = JSON.parse(trimmed);
     }
     catch {
         throw new SessionFormatError(`Session file header is not valid JSON: ${filePath}`);
     }
     const record = parsed;
-    if (record.type === "session") {
-        throw new SessionFormatError(`Session file uses the legacy v3 format: ${filePath}. Run \`mikan sessions migrate\` before starting this mikan version.`);
-    }
-    if (record.kind !== "header" || record.version !== 4 || typeof record.id !== "string") {
+    if (record.type === "session" || (record.kind === "header" && record.version === 4)) {
+        const generation = record.type === "session" ? "legacy v3" : "Pi 0.84 v4";
+        throw new SessionFormatError(`Session file uses the ${generation} format: ${filePath}. Run \`mikan sessions migrate\` before starting this mikan version.`);
+    }
+    if (record.kind !== "header" ||
+        record.v !== 4 ||
+        record.storageVersion !== 1 ||
+        typeof record.id !== "string" ||
+        typeof record.createdAt !== "number" ||
+        typeof record.cwd !== "string") {
         throw new SessionFormatError(`Session file has an unrecognized header: ${filePath}`);
     }
     return parsed;
@@ -151,23 +122,57 @@ function metadataFromHeader(header, path) {
     return {
         id: header.id,
         createdAt: header.createdAt,
+        storageVersion: header.storageVersion,
         cwd: header.cwd,
         path,
         modifiedAt: 0,
-        sourceFormat: 4,
         ...(header.parentSessionId !== undefined ? { parentSessionId: header.parentSessionId } : {}),
         ...(header.legacyParentSessionPath !== undefined
             ? { legacyParentSessionPath: header.legacyParentSessionPath }
             : {}),
-        ...(header.metadata !== undefined ? { metadata: header.metadata } : {}),
     };
 }
+function parseMikanMetadata(filePath) {
+    let current;
+    const lines = readFileSync(filePath, "utf-8").split("\n");
+    for (const [index, line] of lines.entries()) {
+        if (index === 0 || line.trim() === "")
+            continue;
+        let transaction;
+        try {
+            transaction = JSON.parse(line);
+        }
+        catch {
+            if (index === lines.length - 1)
+                break;
+            continue;
+        }
+        const writes = Array.isArray(transaction) ? transaction : [transaction];
+        for (const candidate of writes) {
+            if (typeof candidate !== "object" || candidate === null)
+                continue;
+            const write = candidate;
+            if (write.kind !== "value" || write.namespace !== "mikan" || write.key !== "metadata") {
+                continue;
+            }
+            if (write.op === "delete")
+                current = undefined;
+            else if (write.op === "set" &&
+                typeof write.value === "object" &&
+                write.value !== null &&
+                !Array.isArray(write.value)) {
+                current = write.value;
+            }
+        }
+    }
+    return current;
+}
 function fileFingerprint(path) {
     const bytes = readFileSync(path);
     const fd = openSync(path, "r");
     try {
-        const stat = fstatSync(fd);
-        return `${stat.dev}:${stat.ino}:${stat.size}:${stat.mtimeMs}:${bytes.toString("base64")}`;
+        const stats = fstatSync(fd);
+        return `${stats.dev}:${stats.ino}:${stats.size}:${stats.mtimeMs}:${bytes.toString("base64")}`;
     }
     finally {
         closeSync(fd);
@@ -176,6 +181,7 @@ function fileFingerprint(path) {
 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);
@@ -187,10 +193,10 @@ function materializePendingFile(path, header, expectedFingerprint) {
     }
     const fd = openSync(path, "r+");
     try {
-        const stat = fstatSync(fd);
-        const bytes = Buffer.alloc(stat.size);
+        const stats = fstatSync(fd);
+        const bytes = Buffer.alloc(stats.size);
         readSync(fd, bytes, 0, bytes.length, 0);
-        const actual = `${stat.dev}:${stat.ino}:${stat.size}:${stat.mtimeMs}:${bytes.toString("base64")}`;
+        const actual = `${stats.dev}:${stats.ino}:${stats.size}:${stats.mtimeMs}:${bytes.toString("base64")}`;
         if (actual !== expectedFingerprint) {
             throw new Error(`Session file changed before pending session materialization: ${path}`);
         }
@@ -202,22 +208,31 @@ function materializePendingFile(path, header, expectedFingerprint) {
     }
 }
 function buildHeader(cwd, options) {
+    const metadata = options?.parentSession === undefined
+        ? undefined
+        : { parentSessionPath: options.parentSession };
     return {
-        kind: "header",
-        version: 4,
-        id: options?.id ?? uuidv7(),
-        createdAt: Date.now(),
-        cwd,
-        ...(options?.parentSessionId !== undefined ? { parentSessionId: options.parentSessionId } : {}),
-        // The v3 parent *path* has no dedicated v4 slot when the id is known;
-        // preserve it in metadata so lineage debugging keeps working.
-        ...(options?.parentSession !== undefined
-            ? { metadata: { parentSessionPath: options.parentSession } }
-            : {}),
+        header: {
+            v: 4,
+            kind: "header",
+            id: options?.id ?? uuidv7(),
+            storageVersion: 1,
+            createdAt: Date.now(),
+            cwd,
+            ...(options?.parentSessionId !== undefined
+                ? { parentSessionId: options.parentSessionId }
+                : {}),
+            ...(options?.parentSession !== undefined
+                ? { legacyParentSessionPath: options.parentSession }
+                : {}),
+        },
+        ...(metadata !== undefined ? { metadata } : {}),
     };
 }
-function headerView(header) {
-    const metadata = header.metadata;
+function headerView(header, metadata) {
+    const parentSession = typeof metadata?.parentSessionPath === "string"
+        ? metadata.parentSessionPath
+        : header.legacyParentSessionPath;
     return {
         type: "session",
         version: CURRENT_SESSION_VERSION,
@@ -225,124 +240,175 @@ function headerView(header) {
         timestamp: new Date(header.createdAt).toISOString(),
         cwd: header.cwd,
         ...(header.parentSessionId !== undefined ? { parentSessionId: header.parentSessionId } : {}),
-        ...(typeof metadata?.parentSessionPath === "string"
-            ? { parentSession: metadata.parentSessionPath }
-            : {}),
-        ...(header.legacyParentSessionPath !== undefined && metadata?.parentSessionPath === undefined
-            ? { parentSession: header.legacyParentSessionPath }
-            : {}),
+        ...(parentSession !== undefined ? { parentSession } : {}),
         ...(metadata !== undefined ? { metadata } : {}),
     };
 }
-class ReadOnlySessionInspection {
-    constructor(header, session) {
+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 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 = compactionIndex === -1
+        ? entries
+        : [entries[compactionIndex], ...entries.slice(compactionIndex + 1)];
+    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));
+        }
+    }
+    return { messages };
+}
+class CachedSessionInspection {
+    constructor(header, entries, name, branch, context) {
         this.header = header;
-        this.session = session;
+        this.entries = entries;
+        this.name = name;
+        this.branch = branch;
+        this.context = context;
     }
     getHeader() {
-        return headerView(this.header);
+        return structuredClone(this.header);
     }
     async getEntries() {
-        return this.session.findEntries({ order: "oldestFirst" });
+        return structuredClone(this.entries);
     }
     async getSessionName() {
-        return this.session.getName();
+        return this.name;
     }
     async getBranch(fromId) {
-        return this.session.findEntriesOnBranch({
-            order: "oldestFirst",
-            ...(fromId !== undefined ? { start: 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 buildContextFromEntries(await this.getBranch());
+        return structuredClone(this.context);
     }
 }
-/**
- * Async session store over one pi v4 JSONL file at a mikan-chosen path.
- *
- * A missing or empty file opens as an empty session; the header (and file)
- * materialize on the first append. Files with content must carry a valid
- * v4 header — v3 files throw with a pointer at the migration script.
- */
 export class SessionStore {
     constructor(sessionFile, cwd, state, writerKey) {
-        this.mutationTail = Promise.resolve();
-        this.closed = false;
         this.sessionFile = sessionFile;
         this.cwd = cwd;
         this.state = state;
         this.writerKey = writerKey;
+        this.mutationTail = Promise.resolve();
+        this.closed = false;
     }
-    /**
-     * Open a session file. Missing and empty files start an empty session
-     * whose header is written on the first append.
-     * @param cwdOverride Working directory override; defaults to the header cwd.
-     */
     static async open(path, cwdOverride) {
         const writer = acquireWriter(path);
         const writerPath = writer.path;
         try {
             if (!existsSync(writerPath)) {
                 const cwd = cwdOverride ?? process.cwd();
-                return new SessionStore(writerPath, cwd, { kind: "pending", header: buildHeader(cwd), fingerprint: null }, writer.key);
+                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();
-                return new SessionStore(writerPath, cwd, {
-                    kind: "pending",
-                    header: buildHeader(cwd),
-                    fingerprint: fileFingerprint(writerPath),
-                }, writer.key);
+                const built = buildHeader(cwd);
+                return new SessionStore(writerPath, cwd, { kind: "pending", ...built, fingerprint: fileFingerprint(writerPath) }, writer.key);
             }
-            const header = parseV4Header(writerPath, firstLine);
-            const session = await repo().open(metadataFromHeader(header, writerPath));
-            return new SessionStore(writerPath, cwdOverride ?? header.cwd, { kind: "live", session, header }, writer.key);
+            const header = parseCurrentHeader(writerPath, firstLine);
+            const metadata = parseMikanMetadata(writerPath);
+            const opened = await openFileSession(writerPath, header);
+            return new SessionStore(writerPath, cwdOverride ?? header.cwd, { kind: "live", header, metadata, ...opened }, writer.key);
         }
         catch (error) {
             releaseWriter(writer.key);
             throw error;
         }
     }
-    /** Open an immutable inspection handle that does not acquire a writer lease. */
     static async inspect(path) {
         const resolvedPath = canonicalSessionPath(path);
         const snapshotDir = mkdtempSync(join(tmpdir(), "mikan-session-inspect-"));
         const snapshotPath = join(snapshotDir, basename(resolvedPath));
+        let opened;
         try {
             writeFileSync(snapshotPath, readFileSync(resolvedPath), { mode: 0o600, flag: "wx" });
-            const firstLine = readHeaderLine(snapshotPath);
-            const header = parseV4Header(resolvedPath, firstLine);
-            const session = await repo().open(metadataFromHeader(header, snapshotPath));
-            return new ReadOnlySessionInspection(header, session);
+            const header = parseCurrentHeader(resolvedPath, readHeaderLine(snapshotPath));
+            const metadata = parseMikanMetadata(snapshotPath);
+            opened = await openFileSession(snapshotPath, header);
+            const entries = await opened.session.findEntries({ order: "asc" }, TODO_CONTEXT);
+            const name = await opened.session.getName(TODO_CONTEXT);
+            const branchObject = await mainBranch(opened.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);
         }
         finally {
+            if (opened) {
+                await opened.session.close(TODO_CONTEXT);
+                await opened.repo.close(TODO_CONTEXT);
+            }
             rmSync(snapshotDir, { recursive: true, force: true });
         }
     }
-    /** Create a new session file exclusively; existing content is never replaced. */
     static async create(path, cwd, options) {
         const writer = acquireWriter(path);
         const writerPath = writer.path;
         let leaseKey = writer.key;
+        let opened;
         try {
-            const header = buildHeader(cwd, options);
-            writeFileSync(writerPath, `${JSON.stringify(header)}\n`, { mode: 0o600, flag: "wx" });
+            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);
-            const session = await repo().open(metadataFromHeader(header, writerPath));
-            return new SessionStore(writerPath, cwd, { kind: "live", session, header }, leaseKey);
+            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;
         }
     }
-    /**
-     * Synchronously read a session file's header without opening the session.
-     * Returns null for missing, empty, or unreadable files; throws only for
-     * v3 files so callers surface the migration requirement.
-     */
     static readHeader(path) {
         let firstLine;
         try {
@@ -354,31 +420,24 @@ export class SessionStore {
         if (firstLine.trim().length === 0)
             return null;
         try {
-            return headerView(parseV4Header(path, firstLine));
+            const header = parseCurrentHeader(path, firstLine);
+            return headerView(header, parseMikanMetadata(path));
         }
         catch (error) {
-            if (error instanceof SessionFormatError && /legacy v3/.test(error.message))
+            if (error instanceof SessionFormatError && /legacy v3|Pi 0\.84 v4/.test(error.message)) {
                 throw error;
+            }
             return null;
         }
     }
-    /**
-     * Synchronously write a fresh header-only session file, replacing any
-     * existing file. The session is opened later via {@link SessionStore.open}.
-     */
     static writeHeaderFile(path, cwd, options) {
         mkdirSync(dirname(path), { recursive: true });
-        atomicWritePrivateFile(path, `${JSON.stringify(buildHeader(cwd, options))}\n`);
+        const built = buildHeader(cwd, options);
+        atomicWritePrivateFile(path, `${JSON.stringify(built.header)}\n`);
     }
-    /** Create an ephemeral session that never writes a session file. */
     static inMemory(cwd = process.cwd()) {
-        const header = buildHeader(cwd);
-        const storage = new InMemorySessionStorage({
-            id: header.id,
-            createdAt: header.createdAt,
-        });
-        const session = new Session(storage);
-        return new SessionStore(null, cwd, { kind: "live", session, header }, null);
+        const built = buildHeader(cwd);
+        return new SessionStore(null, cwd, { kind: "pending", ...built, fingerprint: null }, null);
     }
     getSessionFile() {
         this.assertOpen();
@@ -392,12 +451,10 @@ export class SessionStore {
         this.assertOpen();
         return this.cwd;
     }
-    /** Compatibility header view for callers that read mikan session lineage. */
     getHeader() {
         this.assertOpen();
-        return headerView(this.state.header);
+        return headerView(this.state.header, this.state.metadata);
     }
-    /** Stable session id: the header id, or a generated id for fresh sessions. */
     getSessionId() {
         this.assertOpen();
         return this.state.header.id;
@@ -406,85 +463,100 @@ export class SessionStore {
         this.assertOpen();
         if (this.state.kind === "pending")
             return null;
-        return this.state.session.getLeafId();
+        return (await mainBranch(this.state.session, false))?.getTipId(TODO_CONTEXT) ?? null;
     }
     async getEntry(id) {
         this.assertOpen();
         if (this.state.kind === "pending")
             return undefined;
-        return this.state.session.getEntry(id);
+        return this.state.session.getEntry(id, TODO_CONTEXT);
     }
-    /** All session entries in append order. */
     async getEntries() {
         this.assertOpen();
         if (this.state.kind === "pending")
             return [];
-        return this.state.session.findEntries({ order: "oldestFirst" });
+        return this.state.session.findEntries({ order: "asc" }, TODO_CONTEXT);
     }
-    /** Latest user-assigned session name, if any. */
     async getSessionName() {
         this.assertOpen();
         if (this.state.kind === "pending")
             return undefined;
-        return this.state.session.getName();
+        return this.state.session.getName(TODO_CONTEXT);
     }
-    /**
-     * Walk from an entry to the root, returning entries in path order
-     * (root first). Defaults to the current leaf.
-     */
     async getBranch(fromId) {
         this.assertOpen();
         if (this.state.kind === "pending")
             return [];
-        return this.state.session.findEntriesOnBranch({
-            order: "oldestFirst",
-            ...(fromId !== undefined ? { start: fromId } : {}),
-        });
+        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) : [];
     }
-    /**
-     * Build the LLM context (messages, thinking level, model) from the current
-     * branch, resolving compaction and branch summaries along the path.
-     */
     async buildSessionContext() {
-        this.assertOpen();
-        return buildContextFromEntries(await this.getBranch());
+        return buildContext(await this.getBranch());
     }
-    /** Append a chat message as a child of the current leaf. Returns the entry id. */
     async appendMessage(message) {
-        return this.mutate(async () => (await this.live()).appendMessage(toDurable(message)));
+        return this.mutate(async () => {
+            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);
+        });
     }
-    /** Append a custom application data entry (never sent to the LLM). */
     async appendCustomEntry(customType, data) {
-        return this.mutate(async () => (await this.live()).appendCustomEntry(customType, toDurable(data)));
+        return this.mutate(async () => {
+            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);
+        });
     }
-    /** Append a custom message that participates in LLM context. */
     async appendCustomMessageEntry(customType, content, display, details) {
-        return this.mutate(async () => (await this.live()).appendMessage(toDurable(createCustomMessage(customType, content, display, details, Date.now()))));
+        return this.appendMessage(toDurable(createCustomMessage(customType, content, display, details, Date.now())));
     }
-    /** Record a user-visible session name. */
     async setSessionName(name) {
-        await this.mutate(async () => (await this.live()).setName(name.trim() || undefined));
+        await this.mutate(async () => (await this.live()).session.setName(name.trim() || undefined, TODO_CONTEXT));
     }
-    /** Persist a compaction summary produced for this session. */
     async appendCompaction(summary, retainedTail, tokensBefore, details) {
         return this.mutate(async () => {
-            const session = await this.live();
-            const entry = await session.appendEntry({
-                type: "compaction",
-                id: session.idGenerator.next(),
-                summary,
-                retainedTail: toDurable(retainedTail),
-                tokensBefore,
-                ...(details !== undefined ? { details: toDurable(details) } : {}),
-            }, "main");
-            return entry.id;
+            const { session } = await this.live();
+            const id = session.idGenerator.next();
+            await session.mutate(async (mutator, context) => {
+                const currentTip = await mutator.getValue(branchTip("main"), context);
+                await mutator.commit([
+                    insertEntry({
+                        type: "compaction",
+                        id,
+                        parentId: currentTip?.value ?? null,
+                        summary,
+                        retainedTail: toDurable(retainedTail),
+                        tokensBefore,
+                        fromHook: false,
+                        ...(details !== undefined ? { details: toDurable(details) } : {}),
+                    }),
+                    setValue(branchTip("main"), id),
+                ], context);
+            }, TODO_CONTEXT);
+            return id;
         });
     }
     async close() {
         if (this.closePromise)
             return this.closePromise;
         this.closed = true;
-        this.closePromise = this.mutationTail.finally(() => {
+        this.closePromise = this.mutationTail
+            .then(async () => {
+            if (this.state.kind !== "live")
+                return;
+            try {
+                await this.state.session.close(TODO_CONTEXT);
+            }
+            finally {
+                await this.state.repo?.close(TODO_CONTEXT);
+            }
+        })
+            .finally(() => {
             if (this.writerKey !== null)
                 releaseWriter(this.writerKey);
         });
@@ -500,22 +572,45 @@ export class SessionStore {
         this.mutationTail = result.then(() => undefined, () => undefined);
         return result;
     }
-    /** Materialize the session file (when persisted) and return the live session. */
     async live() {
         if (this.state.kind === "live")
-            return this.state.session;
+            return this.state;
         const pending = this.state;
-        const header = pending.header;
         const sessionFile = this.sessionFile;
-        if (sessionFile === null)
-            throw new Error("Pending session must have a session file");
-        materializePendingFile(sessionFile, header, pending.fingerprint);
+        if (sessionFile === null) {
+            const repo = new MemorySessionRepo();
+            const session = await repo.create({
+                id: pending.header.id,
+                ...(pending.header.parentSessionId !== undefined
+                    ? { 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 session = await repo().open(metadataFromHeader(header, sessionFile));
-        this.state = { kind: "live", session, header };
-        return session;
+        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