@cydm/pie 2.3.0 → 2.4.0

package/dist/cli.js

@@ -7,7 +7,7 @@ import {
   createCliWebResearchHealthStore,
   formatSize,
   truncateHeadTail
-} from "./chunks/chunk-P3QPJXS7.js";
+} from "./chunks/chunk-XVUV3IM2.js";
 import {
   AGENTS_CONTEXT_FILE_NAME,
   AgentSessionController,
@@ -40,7 +40,7 @@ import {
   evaluateTodoClosureAfterFailedTurn,
   extensionFallbackName,
   extractExtensionSettings,
-  findFirstKeptEntryId,
+  findFirstKeptEntrySummaryId,
   formatSkillSummariesForPrompt,
   generateEntryId,
   getAutoCompactTokenLimit,
@@ -60,8 +60,8 @@ import {
   setExtensionEnabledInSettings,
   shouldPreserveExecutionStateForUserText,
   supersedeExecutionState
-} from "./chunks/chunk-UPPICLVS.js";
-import "./chunks/chunk-QJH6YN2W.js";
+} from "./chunks/chunk-FKUEIYFQ.js";
+import "./chunks/chunk-ZKHMNEXL.js";
 import {
   Deref,
   EMPTY_ASSISTANT_CONTENT_ERROR,
@@ -85,7 +85,7 @@ import {
   setLogger,
   sortToolModelCandidatesByCapability,
   type_exports
-} from "./chunks/chunk-IM43UYVV.js";
+} from "./chunks/chunk-YRXXRLMQ.js";
 import {
   VERSION,
   getAgentDir,
@@ -994,15 +994,15 @@ var require_route = __commonJS({
       };
     }
     function wrapConversion(toModel, graph) {
-      const path33 = [graph[toModel].parent, toModel];
+      const path34 = [graph[toModel].parent, toModel];
       let fn = conversions[graph[toModel].parent][toModel];
       let cur = graph[toModel].parent;
       while (graph[cur].parent) {
-        path33.unshift(graph[cur].parent);
+        path34.unshift(graph[cur].parent);
         fn = link(conversions[graph[cur].parent][cur], fn);
         cur = graph[cur].parent;
       }
-      fn.conversion = path33;
+      fn.conversion = path34;
       return fn;
     }
     module.exports = function(fromModel) {
@@ -1925,7 +1925,7 @@ var require_core = __commonJS({
       return match && match.index === 0;
     }
     var BACKREF_RE = /\[(?:[^\\\]]|\\.)*\]|\(\??|\\([1-9][0-9]*)|\\./;
-    function join21(regexps, separator = "|") {
+    function join22(regexps, separator = "|") {
       let numCaptures = 0;
       return regexps.map((regex) => {
         numCaptures += 1;
@@ -2229,7 +2229,7 @@ var require_core = __commonJS({
             this.exec = () => null;
           }
           const terminators = this.regexes.map((el) => el[1]);
-          this.matcherRe = langRe(join21(terminators), true);
+          this.matcherRe = langRe(join22(terminators), true);
           this.lastIndex = 0;
         }
         /** @param {string} s */
@@ -44042,17 +44042,17 @@ var require_visit = __commonJS({
     visit.BREAK = BREAK;
     visit.SKIP = SKIP;
     visit.REMOVE = REMOVE;
-    function visit_(key, node, visitor, path33) {
-      const ctrl = callVisitor(key, node, visitor, path33);
+    function visit_(key, node, visitor, path34) {
+      const ctrl = callVisitor(key, node, visitor, path34);
       if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-        replaceNode(key, path33, ctrl);
-        return visit_(key, ctrl, visitor, path33);
+        replaceNode(key, path34, ctrl);
+        return visit_(key, ctrl, visitor, path34);
       }
       if (typeof ctrl !== "symbol") {
         if (identity.isCollection(node)) {
-          path33 = Object.freeze(path33.concat(node));
+          path34 = Object.freeze(path34.concat(node));
           for (let i = 0; i < node.items.length; ++i) {
-            const ci = visit_(i, node.items[i], visitor, path33);
+            const ci = visit_(i, node.items[i], visitor, path34);
             if (typeof ci === "number")
               i = ci - 1;
             else if (ci === BREAK)
@@ -44063,13 +44063,13 @@ var require_visit = __commonJS({
             }
           }
         } else if (identity.isPair(node)) {
-          path33 = Object.freeze(path33.concat(node));
-          const ck = visit_("key", node.key, visitor, path33);
+          path34 = Object.freeze(path34.concat(node));
+          const ck = visit_("key", node.key, visitor, path34);
           if (ck === BREAK)
             return BREAK;
           else if (ck === REMOVE)
             node.key = null;
-          const cv = visit_("value", node.value, visitor, path33);
+          const cv = visit_("value", node.value, visitor, path34);
           if (cv === BREAK)
             return BREAK;
           else if (cv === REMOVE)
@@ -44090,17 +44090,17 @@ var require_visit = __commonJS({
     visitAsync.BREAK = BREAK;
     visitAsync.SKIP = SKIP;
     visitAsync.REMOVE = REMOVE;
-    async function visitAsync_(key, node, visitor, path33) {
-      const ctrl = await callVisitor(key, node, visitor, path33);
+    async function visitAsync_(key, node, visitor, path34) {
+      const ctrl = await callVisitor(key, node, visitor, path34);
       if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-        replaceNode(key, path33, ctrl);
-        return visitAsync_(key, ctrl, visitor, path33);
+        replaceNode(key, path34, ctrl);
+        return visitAsync_(key, ctrl, visitor, path34);
       }
       if (typeof ctrl !== "symbol") {
         if (identity.isCollection(node)) {
-          path33 = Object.freeze(path33.concat(node));
+          path34 = Object.freeze(path34.concat(node));
           for (let i = 0; i < node.items.length; ++i) {
-            const ci = await visitAsync_(i, node.items[i], visitor, path33);
+            const ci = await visitAsync_(i, node.items[i], visitor, path34);
             if (typeof ci === "number")
               i = ci - 1;
             else if (ci === BREAK)
@@ -44111,13 +44111,13 @@ var require_visit = __commonJS({
             }
           }
         } else if (identity.isPair(node)) {
-          path33 = Object.freeze(path33.concat(node));
-          const ck = await visitAsync_("key", node.key, visitor, path33);
+          path34 = Object.freeze(path34.concat(node));
+          const ck = await visitAsync_("key", node.key, visitor, path34);
           if (ck === BREAK)
             return BREAK;
           else if (ck === REMOVE)
             node.key = null;
-          const cv = await visitAsync_("value", node.value, visitor, path33);
+          const cv = await visitAsync_("value", node.value, visitor, path34);
           if (cv === BREAK)
             return BREAK;
           else if (cv === REMOVE)
@@ -44144,23 +44144,23 @@ var require_visit = __commonJS({
       }
       return visitor;
     }
-    function callVisitor(key, node, visitor, path33) {
+    function callVisitor(key, node, visitor, path34) {
       if (typeof visitor === "function")
-        return visitor(key, node, path33);
+        return visitor(key, node, path34);
       if (identity.isMap(node))
-        return visitor.Map?.(key, node, path33);
+        return visitor.Map?.(key, node, path34);
       if (identity.isSeq(node))
-        return visitor.Seq?.(key, node, path33);
+        return visitor.Seq?.(key, node, path34);
       if (identity.isPair(node))
-        return visitor.Pair?.(key, node, path33);
+        return visitor.Pair?.(key, node, path34);
       if (identity.isScalar(node))
-        return visitor.Scalar?.(key, node, path33);
+        return visitor.Scalar?.(key, node, path34);
       if (identity.isAlias(node))
-        return visitor.Alias?.(key, node, path33);
+        return visitor.Alias?.(key, node, path34);
       return void 0;
     }
-    function replaceNode(key, path33, node) {
-      const parent = path33[path33.length - 1];
+    function replaceNode(key, path34, node) {
+      const parent = path34[path34.length - 1];
       if (identity.isCollection(parent)) {
         parent.items[key] = node;
       } else if (identity.isPair(parent)) {
@@ -44768,10 +44768,10 @@ var require_Collection = __commonJS({
     var createNode = require_createNode();
     var identity = require_identity();
     var Node = require_Node();
-    function collectionFromPath(schema, path33, value) {
+    function collectionFromPath(schema, path34, value) {
       let v2 = value;
-      for (let i = path33.length - 1; i >= 0; --i) {
-        const k2 = path33[i];
+      for (let i = path34.length - 1; i >= 0; --i) {
+        const k2 = path34[i];
         if (typeof k2 === "number" && Number.isInteger(k2) && k2 >= 0) {
           const a = [];
           a[k2] = v2;
@@ -44790,7 +44790,7 @@ var require_Collection = __commonJS({
         sourceObjects: /* @__PURE__ */ new Map()
       });
     }
-    var isEmptyPath = (path33) => path33 == null || typeof path33 === "object" && !!path33[Symbol.iterator]().next().done;
+    var isEmptyPath = (path34) => path34 == null || typeof path34 === "object" && !!path34[Symbol.iterator]().next().done;
     var Collection = class extends Node.NodeBase {
       constructor(type, schema) {
         super(type);
@@ -44820,11 +44820,11 @@ var require_Collection = __commonJS({
        * be a Pair instance or a `{ key, value }` object, which may not have a key
        * that already exists in the map.
        */
-      addIn(path33, value) {
-        if (isEmptyPath(path33))
+      addIn(path34, value) {
+        if (isEmptyPath(path34))
           this.add(value);
         else {
-          const [key, ...rest] = path33;
+          const [key, ...rest] = path34;
           const node = this.get(key, true);
           if (identity.isCollection(node))
             node.addIn(rest, value);
@@ -44838,8 +44838,8 @@ var require_Collection = __commonJS({
        * Removes a value from the collection.
        * @returns `true` if the item was found and removed.
        */
-      deleteIn(path33) {
-        const [key, ...rest] = path33;
+      deleteIn(path34) {
+        const [key, ...rest] = path34;
         if (rest.length === 0)
           return this.delete(key);
         const node = this.get(key, true);
@@ -44853,8 +44853,8 @@ var require_Collection = __commonJS({
        * scalar values from their surrounding node; to disable set `keepScalar` to
        * `true` (collections are always returned intact).
        */
-      getIn(path33, keepScalar) {
-        const [key, ...rest] = path33;
+      getIn(path34, keepScalar) {
+        const [key, ...rest] = path34;
         const node = this.get(key, true);
         if (rest.length === 0)
           return !keepScalar && identity.isScalar(node) ? node.value : node;
@@ -44872,8 +44872,8 @@ var require_Collection = __commonJS({
       /**
        * Checks if the collection includes a value with the key `key`.
        */
-      hasIn(path33) {
-        const [key, ...rest] = path33;
+      hasIn(path34) {
+        const [key, ...rest] = path34;
         if (rest.length === 0)
           return this.has(key);
         const node = this.get(key, true);
@@ -44883,8 +44883,8 @@ var require_Collection = __commonJS({
        * Sets a value in this collection. For `!!set`, `value` needs to be a
        * boolean to add/remove the item from the set.
        */
-      setIn(path33, value) {
-        const [key, ...rest] = path33;
+      setIn(path34, value) {
+        const [key, ...rest] = path34;
         if (rest.length === 0) {
           this.set(key, value);
         } else {
@@ -47396,9 +47396,9 @@ var require_Document = __commonJS({
           this.contents.add(value);
       }
       /** Adds a value to the document. */
-      addIn(path33, value) {
+      addIn(path34, value) {
         if (assertCollection(this.contents))
-          this.contents.addIn(path33, value);
+          this.contents.addIn(path34, value);
       }
       /**
        * Create a new `Alias` node, ensuring that the target `node` has the required anchor.
@@ -47473,14 +47473,14 @@ var require_Document = __commonJS({
        * Removes a value from the document.
        * @returns `true` if the item was found and removed.
        */
-      deleteIn(path33) {
-        if (Collection.isEmptyPath(path33)) {
+      deleteIn(path34) {
+        if (Collection.isEmptyPath(path34)) {
           if (this.contents == null)
             return false;
           this.contents = null;
           return true;
         }
-        return assertCollection(this.contents) ? this.contents.deleteIn(path33) : false;
+        return assertCollection(this.contents) ? this.contents.deleteIn(path34) : false;
       }
       /**
        * Returns item at `key`, or `undefined` if not found. By default unwraps
@@ -47495,10 +47495,10 @@ var require_Document = __commonJS({
        * scalar values from their surrounding node; to disable set `keepScalar` to
        * `true` (collections are always returned intact).
        */
-      getIn(path33, keepScalar) {
-        if (Collection.isEmptyPath(path33))
+      getIn(path34, keepScalar) {
+        if (Collection.isEmptyPath(path34))
           return !keepScalar && identity.isScalar(this.contents) ? this.contents.value : this.contents;
-        return identity.isCollection(this.contents) ? this.contents.getIn(path33, keepScalar) : void 0;
+        return identity.isCollection(this.contents) ? this.contents.getIn(path34, keepScalar) : void 0;
       }
       /**
        * Checks if the document includes a value with the key `key`.
@@ -47509,10 +47509,10 @@ var require_Document = __commonJS({
       /**
        * Checks if the document includes a value at `path`.
        */
-      hasIn(path33) {
-        if (Collection.isEmptyPath(path33))
+      hasIn(path34) {
+        if (Collection.isEmptyPath(path34))
           return this.contents !== void 0;
-        return identity.isCollection(this.contents) ? this.contents.hasIn(path33) : false;
+        return identity.isCollection(this.contents) ? this.contents.hasIn(path34) : false;
       }
       /**
        * Sets a value in this document. For `!!set`, `value` needs to be a
@@ -47529,13 +47529,13 @@ var require_Document = __commonJS({
        * Sets a value in this document. For `!!set`, `value` needs to be a
        * boolean to add/remove the item from the set.
        */
-      setIn(path33, value) {
-        if (Collection.isEmptyPath(path33)) {
+      setIn(path34, value) {
+        if (Collection.isEmptyPath(path34)) {
           this.contents = value;
         } else if (this.contents == null) {
-          this.contents = Collection.collectionFromPath(this.schema, Array.from(path33), value);
+          this.contents = Collection.collectionFromPath(this.schema, Array.from(path34), value);
         } else if (assertCollection(this.contents)) {
-          this.contents.setIn(path33, value);
+          this.contents.setIn(path34, value);
         }
       }
       /**
@@ -49492,9 +49492,9 @@ var require_cst_visit = __commonJS({
     visit.BREAK = BREAK;
     visit.SKIP = SKIP;
     visit.REMOVE = REMOVE;
-    visit.itemAtPath = (cst, path33) => {
+    visit.itemAtPath = (cst, path34) => {
       let item = cst;
-      for (const [field, index] of path33) {
+      for (const [field, index] of path34) {
         const tok = item?.[field];
         if (tok && "items" in tok) {
           item = tok.items[index];
@@ -49503,23 +49503,23 @@ var require_cst_visit = __commonJS({
       }
       return item;
     };
-    visit.parentCollection = (cst, path33) => {
-      const parent = visit.itemAtPath(cst, path33.slice(0, -1));
-      const field = path33[path33.length - 1][0];
+    visit.parentCollection = (cst, path34) => {
+      const parent = visit.itemAtPath(cst, path34.slice(0, -1));
+      const field = path34[path34.length - 1][0];
       const coll = parent?.[field];
       if (coll && "items" in coll)
         return coll;
       throw new Error("Parent collection not found");
     };
-    function _visit(path33, item, visitor) {
-      let ctrl = visitor(item, path33);
+    function _visit(path34, item, visitor) {
+      let ctrl = visitor(item, path34);
       if (typeof ctrl === "symbol")
         return ctrl;
       for (const field of ["key", "value"]) {
         const token = item[field];
         if (token && "items" in token) {
           for (let i = 0; i < token.items.length; ++i) {
-            const ci = _visit(Object.freeze(path33.concat([[field, i]])), token.items[i], visitor);
+            const ci = _visit(Object.freeze(path34.concat([[field, i]])), token.items[i], visitor);
             if (typeof ci === "number")
               i = ci - 1;
             else if (ci === BREAK)
@@ -49530,10 +49530,10 @@ var require_cst_visit = __commonJS({
             }
           }
           if (typeof ctrl === "function" && field === "key")
-            ctrl = ctrl(item, path33);
+            ctrl = ctrl(item, path34);
         }
       }
-      return typeof ctrl === "function" ? ctrl(item, path33) : ctrl;
+      return typeof ctrl === "function" ? ctrl(item, path34) : ctrl;
     }
     exports.visit = visit;
   }
@@ -50818,14 +50818,14 @@ var require_parser2 = __commonJS({
             case "scalar":
             case "single-quoted-scalar":
             case "double-quoted-scalar": {
-              const fs29 = this.flowScalar(this.type);
+              const fs30 = this.flowScalar(this.type);
               if (atNextItem || it.value) {
-                map.items.push({ start, key: fs29, sep: [] });
+                map.items.push({ start, key: fs30, sep: [] });
                 this.onKeyLine = true;
               } else if (it.sep) {
-                this.stack.push(fs29);
+                this.stack.push(fs30);
               } else {
-                Object.assign(it, { key: fs29, sep: [] });
+                Object.assign(it, { key: fs30, sep: [] });
                 this.onKeyLine = true;
               }
               return;
@@ -50953,13 +50953,13 @@ var require_parser2 = __commonJS({
             case "scalar":
             case "single-quoted-scalar":
             case "double-quoted-scalar": {
-              const fs29 = this.flowScalar(this.type);
+              const fs30 = this.flowScalar(this.type);
               if (!it || it.value)
-                fc.items.push({ start: [], key: fs29, sep: [] });
+                fc.items.push({ start: [], key: fs30, sep: [] });
               else if (it.sep)
-                this.stack.push(fs29);
+                this.stack.push(fs30);
               else
-                Object.assign(it, { key: fs29, sep: [] });
+                Object.assign(it, { key: fs30, sep: [] });
               return;
             }
             case "flow-map-end":
@@ -51268,8 +51268,8 @@ var require_dist2 = __commonJS({
 });
 
 // src/cli.ts
-import * as fs28 from "fs";
-import * as path32 from "path";
+import * as fs29 from "fs";
+import * as path33 from "path";
 
 // src/cli-args.ts
 var FLAGS_WITH_VALUES = /* @__PURE__ */ new Set(["--session-id", "--extension-path", "--developer-instructions", "--developer-instructions-file"]);
@@ -55129,9 +55129,11 @@ function runCapabilitiesCommand(args) {
 }
 
 // src/commands/sessions.ts
-import fs7 from "node:fs";
+import fs8 from "node:fs";
 
 // src/session-control.ts
+import * as fs7 from "node:fs";
+import * as path7 from "node:path";
 var SessionControlError = class extends Error {
   constructor(code, message, recoverable = sessionControlErrorRecoverable(code)) {
     super(message);
@@ -55145,27 +55147,70 @@ var SessionControlError = class extends Error {
 function sessionControlErrorRecoverable(code) {
   return code !== "session_unrecoverable" && code !== "session_mismatch";
 }
-async function loadRequiredSession(store, sessionId) {
-  const exists = await store.exists(sessionId);
-  const data = await store.load(sessionId);
-  if (data) return data;
-  throw new SessionControlError(
-    exists ? "session_unrecoverable" : "session_not_found",
-    exists ? `Session could not be recovered: ${sessionId}` : `Session not found: ${sessionId}`
-  );
+var FORK_BATCH_ENTRIES = 64;
+var FORK_BATCH_BYTES = 256 * 1024;
+var STAGING_SESSION_ID_PREFIX = "__pie-staging-";
+function stagingIdFor(targetSessionId) {
+  return `${STAGING_SESSION_ID_PREFIX}${targetSessionId}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
 }
-async function rewindStoredSession(params) {
-  const data = await loadRequiredSession(params.store, params.sessionId);
-  if (!data.entries.some((entry) => entry.id === params.entryId)) {
-    throw new SessionControlError("entry_not_found", `Entry not found: ${params.entryId}`);
+var PUBLISH_JOURNAL_DIR = ".pie-publish-journal";
+function safeSessionDirName(sessionId) {
+  return sessionId.replace(/[^a-zA-Z0-9_-]/g, "_");
+}
+function canonicalSessionDir(sessionsDir, sessionId) {
+  const dir = path7.join(sessionsDir, safeSessionDirName(sessionId));
+  try {
+    if (!fs7.existsSync(dir)) return null;
+    return fs7.realpathSync(dir);
+  } catch {
+    return null;
   }
+}
+function publishJournalPath(sessionsDir, safeTargetId) {
+  return path7.join(sessionsDir, PUBLISH_JOURNAL_DIR, `${safeTargetId}.json`);
+}
+function writePublishJournal(journalPath, record) {
+  fs7.mkdirSync(path7.dirname(journalPath), { recursive: true });
+  const tempPath = `${journalPath}.tmp`;
+  fs7.writeFileSync(tempPath, JSON.stringify(record, void 0, "	"));
+  fs7.renameSync(tempPath, journalPath);
+}
+function clearPublishJournal(journalPath) {
+  if (!journalPath) return;
   try {
-    await params.store.save(params.sessionId, data.entries, {
-      ...data.metadata,
-      activeEntryId: params.entryId,
-      updatedAt: params.now ?? Date.now()
-    });
-    const metadata = await params.store.getMetadata(params.sessionId);
+    fs7.rmSync(journalPath, { force: true });
+  } catch {
+  }
+}
+function toIoError(error) {
+  if (error instanceof SessionControlError) return error;
+  return new SessionControlError("session_io_error", error instanceof Error ? error.message : String(error));
+}
+function loadRequiredSessionHead(store, sessionId) {
+  const status = store.headStatus(sessionId);
+  if (status === "legacy") {
+    throw new SessionControlError(
+      "session_unsupported_format",
+      `Session uses an unsupported old format: ${sessionId}`
+    );
+  }
+  if (status === "corrupt") {
+    throw new SessionControlError("session_unrecoverable", `Session could not be recovered: ${sessionId}`);
+  }
+  const head = store.readHead(sessionId);
+  if (!head) {
+    throw new SessionControlError("session_not_found", `Session not found: ${sessionId}`);
+  }
+  return head;
+}
+async function rewindStoredSession(params) {
+  try {
+    loadRequiredSessionHead(params.store, params.sessionId);
+    if (params.store.getEntrySummary(params.sessionId, params.entryId) === null) {
+      throw new SessionControlError("entry_not_found", `Entry not found: ${params.entryId}`);
+    }
+    params.store.setActiveEntry(params.sessionId, params.entryId);
+    const metadata = params.store.getMetadata(params.sessionId);
     if (!metadata) {
       throw new SessionControlError("session_unrecoverable", `Session could not be recovered after rewind: ${params.sessionId}`, false);
     }
@@ -55176,52 +55221,179 @@ async function rewindStoredSession(params) {
       metadata
     };
   } catch (error) {
-    if (error instanceof SessionControlError) throw error;
-    throw new SessionControlError("session_io_error", error instanceof Error ? error.message : String(error));
+    throw toIoError(error);
   }
 }
 async function forkStoredSession(params) {
+  let stagingId;
   try {
+    const sanitizedTargetId = params.targetSessionId.replace(/[^a-zA-Z0-9_-]/g, "_");
+    if (sanitizedTargetId.startsWith(STAGING_SESSION_ID_PREFIX)) {
+      throw new SessionControlError(
+        "invalid_request",
+        `Target session id starts with a reserved internal prefix: ${params.targetSessionId}`
+      );
+    }
+    if (params.sourceSessionId.replace(/[^a-zA-Z0-9_-]/g, "_").toLowerCase() === sanitizedTargetId.toLowerCase()) {
+      throw new SessionControlError(
+        "invalid_request",
+        "Fork source and target must be different sessions: " + params.sourceSessionId
+      );
+    }
+    if (params.sessionsDir) {
+      const canonicalSourceDir = canonicalSessionDir(params.sessionsDir, params.sourceSessionId);
+      const canonicalTargetDir = canonicalSessionDir(params.sessionsDir, params.targetSessionId);
+      if (canonicalSourceDir !== null && canonicalTargetDir !== null && canonicalSourceDir === canonicalTargetDir) {
+        throw new SessionControlError(
+          "invalid_request",
+          `Fork source and target resolve to the same session directory: ${params.sourceSessionId} -> ${params.targetSessionId}`
+        );
+      }
+    }
     if (!params.force) {
       const existingTarget = await maybeLoadExistingForkTarget(params);
       if (existingTarget) return existingTarget;
     }
-    const source = await loadRequiredSession(params.store, params.sourceSessionId);
-    const pathEntries = pathToEntry(source, params.sourceEntryId);
-    if (pathEntries.length === 0 || pathEntries[pathEntries.length - 1]?.id !== params.sourceEntryId) {
+    const source = loadRequiredSessionHead(params.store, params.sourceSessionId);
+    const pathSummaries = params.store.getPathSummaries(params.sourceSessionId, params.sourceEntryId);
+    if (pathSummaries.length === 0 || pathSummaries[pathSummaries.length - 1]?.id !== params.sourceEntryId) {
       throw new SessionControlError("entry_not_found", `Entry not found: ${params.sourceEntryId}`);
     }
     const now = params.now ?? Date.now();
+    stagingId = stagingIdFor(params.targetSessionId);
+    params.store.createHead(stagingId, {
+      name: params.name,
+      createdAt: now
+    });
     const idMap = /* @__PURE__ */ new Map();
-    for (const entry of pathEntries) idMap.set(entry.id, generateEntryId());
-    const forkedEntries = pathEntries.map((entry) => {
-      const nextId = idMap.get(entry.id);
-      if (!nextId) throw new SessionControlError("session_io_error", `Failed to map entry: ${entry.id}`);
-      const parentId = entry.parentId ? idMap.get(entry.parentId) ?? null : null;
-      return {
-        ...cloneJson(entry),
-        id: nextId,
-        parentId,
+    let seq = 1;
+    let batch = [];
+    let batchBytes = 0;
+    let lastCopiedId = null;
+    let firstCopiedId = null;
+    const flushBatch = () => {
+      if (batch.length === 0) return;
+      params.store.appendEntries(stagingId, batch, null);
+      batch = [];
+      batchBytes = 0;
+    };
+    for (const summary of pathSummaries) {
+      let entry = null;
+      try {
+        entry = params.store.readEntry(params.sourceSessionId, summary.id);
+      } catch {
+        entry = null;
+      }
+      if (!entry) {
+        throw new SessionControlError(
+          "session_unrecoverable",
+          `Fork source entry is not readable: ${summary.id}`,
+          false
+        );
+      }
+      const copy = {
+        ...entry,
+        id: generateEntryId(seq),
+        parentId: lastCopiedId,
         timestamp: entry.timestamp
       };
-    });
-    const activeEntryId = idMap.get(params.sourceEntryId);
-    if (!activeEntryId) {
-      throw new SessionControlError("session_io_error", `Failed to map active entry: ${params.sourceEntryId}`);
+      if (copy.compactionData) {
+        const keptId = idMap.get(copy.compactionData.firstKeptEntryId);
+        copy.compactionData = {
+          ...copy.compactionData,
+          firstKeptEntryId: keptId ?? firstCopiedId ?? copy.id
+        };
+      }
+      idMap.set(summary.id, copy.id);
+      if (firstCopiedId === null) {
+        firstCopiedId = copy.id;
+      }
+      const copyBytes = Buffer.byteLength(JSON.stringify(copy), "utf8");
+      if (batch.length > 0 && batchBytes + copyBytes > FORK_BATCH_BYTES) flushBatch();
+      batch.push(copy);
+      batchBytes += copyBytes;
+      lastCopiedId = copy.id;
+      seq += 1;
+      if (batch.length >= FORK_BATCH_ENTRIES || batchBytes >= FORK_BATCH_BYTES) {
+        flushBatch();
+      }
+    }
+    flushBatch();
+    if (!lastCopiedId) {
+      throw new SessionControlError("session_unrecoverable", `Fork source has no readable entries: ${params.sourceSessionId}`, false);
     }
-    await params.store.save(params.targetSessionId, forkedEntries, {
+    params.store.setActiveEntry(stagingId, lastCopiedId);
+    params.store.updateMetadata(stagingId, {
       name: params.name,
       createdAt: now,
-      updatedAt: now,
-      activeEntryId,
       cwd: params.cwd ?? source.metadata.cwd,
       sourceSessionId: params.sourceSessionId,
       sourceEntryId: params.sourceEntryId,
       sourceActiveEntryId: source.metadata.activeEntryId ?? void 0,
-      forkBaseEntryId: activeEntryId,
+      forkBaseEntryId: lastCopiedId,
       ...params.requestId ? { sessionControlRequestId: params.requestId } : {}
     });
-    const metadata = await params.store.getMetadata(params.targetSessionId);
+    const backupId = `${params.targetSessionId}-previous-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+    const targetStatus = params.store.headStatus(params.targetSessionId);
+    if (targetStatus === "legacy" || targetStatus === "corrupt") {
+      loadRequiredSessionHead(params.store, params.targetSessionId);
+    }
+    const hadPreviousTarget = targetStatus === "ok";
+    if (hadPreviousTarget && !params.force) {
+      throw new SessionControlError("target_exists", `Target session already exists: ${params.targetSessionId}`);
+    }
+    const safeTargetId = safeSessionDirName(params.targetSessionId);
+    const journalPath = params.sessionsDir ? publishJournalPath(params.sessionsDir, safeTargetId) : null;
+    if (journalPath) {
+      writePublishJournal(journalPath, {
+        v: 1,
+        targetId: safeTargetId,
+        stagingId: safeSessionDirName(stagingId),
+        backupDir: hadPreviousTarget ? safeSessionDirName(backupId) : null,
+        writtenAt: Date.now()
+      });
+    }
+    if (hadPreviousTarget) {
+      try {
+        params.store.moveSession(params.targetSessionId, backupId);
+      } catch (error) {
+        clearPublishJournal(journalPath);
+        throw error;
+      }
+    }
+    try {
+      params.store.moveSession(stagingId, params.targetSessionId);
+    } catch (error) {
+      if (hadPreviousTarget) {
+        try {
+          if (params.store.headStatus(params.targetSessionId) !== "missing") {
+            throw new Error("target path is occupied");
+          }
+          params.store.moveSession(backupId, params.targetSessionId);
+          clearPublishJournal(journalPath);
+        } catch (restoreError) {
+          throw new SessionControlError(
+            "session_io_error",
+            `Fork publication failed; previous session is preserved as ${backupId}. Restore failed: ${String(restoreError)}`,
+            false
+          );
+        }
+      }
+      clearPublishJournal(journalPath);
+      throw error;
+    }
+    let backupDeleted = !hadPreviousTarget;
+    if (hadPreviousTarget) {
+      try {
+        params.store.delete(backupId);
+        backupDeleted = true;
+      } catch {
+      }
+    }
+    if (backupDeleted) {
+      clearPublishJournal(journalPath);
+    }
+    const metadata = params.store.getMetadata(params.targetSessionId);
     if (!metadata) {
       throw new SessionControlError("session_unrecoverable", `Session could not be recovered after fork: ${params.targetSessionId}`, false);
     }
@@ -55232,13 +55404,23 @@ async function forkStoredSession(params) {
       sourceActiveEntryId: source.metadata.activeEntryId ?? null
     });
   } catch (error) {
-    if (error instanceof SessionControlError) throw error;
-    throw new SessionControlError("session_io_error", error instanceof Error ? error.message : String(error));
+    throw toIoError(error);
+  } finally {
+    if (stagingId) {
+      try {
+        params.store.delete(stagingId);
+      } catch {
+      }
+    }
   }
 }
 async function maybeLoadExistingForkTarget(params) {
-  if (!await params.store.exists(params.targetSessionId)) return null;
-  const target = await params.store.load(params.targetSessionId);
+  const status = params.store.headStatus(params.targetSessionId);
+  if (status === "missing") return null;
+  if (status === "legacy") {
+    throw new SessionControlError("session_unsupported_format", `Target session uses an unsupported old format: ${params.targetSessionId}`);
+  }
+  const target = params.store.readHead(params.targetSessionId);
   if (!target) {
     throw new SessionControlError("session_unrecoverable", `Session could not be recovered: ${params.targetSessionId}`, false);
   }
@@ -55269,20 +55451,93 @@ function buildForkResult(params) {
     metadata: params.metadata
   };
 }
-function pathToEntry(data, entryId) {
-  const byId = new Map(data.entries.map((entry) => [entry.id, entry]));
-  const path33 = [];
-  let current = entryId;
-  while (current) {
-    const entry = byId.get(current);
-    if (!entry) return [];
-    path33.unshift(entry);
-    current = entry.parentId;
+function recoverInterruptedPublishes(params) {
+  const outcomes = [];
+  const journalDir = path7.join(params.sessionsDir, PUBLISH_JOURNAL_DIR);
+  let entries;
+  try {
+    entries = fs7.readdirSync(journalDir);
+  } catch {
+    return outcomes;
   }
-  return path33;
+  for (const entry of entries) {
+    if (!entry.endsWith(".json")) continue;
+    outcomes.push(recoverOnePublishJournal({
+      sessionsDir: params.sessionsDir,
+      journalPath: path7.join(journalDir, entry),
+      warn: params.warn
+    }));
+  }
+  return outcomes;
 }
-function cloneJson(value) {
-  return JSON.parse(JSON.stringify(value));
+function recoverOnePublishJournal(params) {
+  const journalName = path7.basename(params.journalPath);
+  const warn = (message) => {
+    (params.warn ?? ((text) => console.warn(text)))(message);
+  };
+  let record;
+  try {
+    const parsed = JSON.parse(fs7.readFileSync(params.journalPath, "utf8"));
+    const safeId = /^[a-zA-Z0-9_-]+$/;
+    if (parsed?.v !== 1 || !safeId.test(parsed.targetId ?? "") || !safeId.test(parsed.stagingId ?? "") || !((parsed.backupDir ?? null) === null || safeId.test(parsed.backupDir))) {
+      throw new Error("journal record has unexpected shape");
+    }
+    record = parsed;
+  } catch (error) {
+    const message = `[session-control] Unreadable publish journal ${journalName}; left in place for manual inspection: ${String(error)}`;
+    warn(message);
+    return { action: "unreadable-journal", journal: journalName, message };
+  }
+  const dirExists = (id) => {
+    try {
+      return fs7.statSync(path7.join(params.sessionsDir, id)).isDirectory();
+    } catch {
+      return false;
+    }
+  };
+  const removeSessionDir = (id) => {
+    fs7.rmSync(path7.join(params.sessionsDir, id), { recursive: true, force: true });
+  };
+  const removeJournal = () => {
+    fs7.rmSync(params.journalPath, { force: true });
+  };
+  const targetExists = dirExists(record.targetId);
+  const backupExists = record.backupDir ? dirExists(record.backupDir) : false;
+  const stagingExists = dirExists(record.stagingId);
+  try {
+    if (targetExists && !stagingExists) {
+      if (backupExists && record.backupDir) removeSessionDir(record.backupDir);
+      removeJournal();
+      return { action: "publish-completed", targetId: record.targetId };
+    }
+    if (!targetExists && backupExists && record.backupDir) {
+      fs7.renameSync(
+        path7.join(params.sessionsDir, record.backupDir),
+        path7.join(params.sessionsDir, record.targetId)
+      );
+      removeJournal();
+      if (stagingExists) {
+        try {
+          removeSessionDir(record.stagingId);
+        } catch (error) {
+          warn(`[session-control] Restored ${record.targetId} but could not remove its abandoned staging copy ${record.stagingId}: ${String(error)}`);
+        }
+      }
+      return { action: "restored-previous-target", targetId: record.targetId };
+    }
+    if (!targetExists && !backupExists) {
+      if (stagingExists) removeSessionDir(record.stagingId);
+      removeJournal();
+      return stagingExists ? { action: "discarded-incomplete-fork", targetId: record.targetId } : { action: "nothing-to-recover", targetId: record.targetId };
+    }
+    const message = `[session-control] Ambiguous interrupted publish for target ${record.targetId} (target=${targetExists}, backup=${backupExists}, staging=${stagingExists}); nothing was deleted \u2014 inspect ${params.sessionsDir} and ${journalName} manually`;
+    warn(message);
+    return { action: "ambiguous-preserved", targetId: record.targetId, message };
+  } catch (error) {
+    const message = `[session-control] Recovery of publish journal ${journalName} failed; state preserved for manual inspection: ${String(error)}`;
+    warn(message);
+    return { action: "ambiguous-preserved", targetId: record.targetId, message };
+  }
 }
 
 // src/commands/sessions.ts
@@ -55339,6 +55594,7 @@ function toSessionCommandError(error, kind) {
   if (error instanceof SessionControlError) {
     const hints = {
       session_not_found: "list sessions: pie sessions list --json",
+      session_unsupported_format: "old-format sessions cannot be read by this version",
       target_exists: "choose a new --target, or add --force to overwrite"
     };
     return new CommandError(kind, error.code, error.message, { hint: hints[error.code] });
@@ -55427,15 +55683,18 @@ async function readSession(parsed) {
     throw new CommandError("sessions.read", "missing_positional", renderCommandUsage(SESSIONS_READ_SPEC), { usage: true });
   }
   const store = new FileSessionStore(getSessionsDir());
-  const data = await loadSession(store, sessionId, "sessions.read");
-  const events = activeTranscriptEvents(activePathEntries(data));
+  const data = loadSessionHead(store, sessionId, "sessions.read");
+  const events = await activeTranscriptEvents(store, sessionId, data.metadata.activeEntryId);
   const end = resolveBeforeCursor(events, before);
   const start = Math.max(0, end - limit);
   const page = events.slice(start, end);
+  for (const event of page) {
+    hydrateTranscriptEvent(store, sessionId, event);
+  }
   if (!json) {
     console.log(`${data.metadata.id}: ${data.metadata.name}`);
-    for (const entry of page) {
-      console.log(`${entry.logicalSeq}	${entry.type}${entry.role ? `:${entry.role}` : ""}	${entry.content ?? ""}`);
+    for (const event of page) {
+      console.log(`${event.logicalSeq}	${event.type}${event.role ? `:${event.role}` : ""}	${event.content ?? ""}`);
     }
     return;
   }
@@ -55481,9 +55740,9 @@ async function renameSession(parsed) {
     throw new CommandError("sessions.rename", "missing_positional", renderCommandUsage(SESSIONS_RENAME_SPEC), { usage: true });
   }
   const store = new FileSessionStore(getSessionsDir());
-  const data = await loadSession(store, sessionId, "sessions.rename");
-  await store.save(sessionId, data.entries, { ...data.metadata, name, nameSource: "manual", ...cwd ? { cwd } : {}, updatedAt: Date.now() });
-  const updated = await store.getMetadata(sessionId);
+  loadSessionHead(store, sessionId, "sessions.rename");
+  store.updateMetadata(sessionId, { name, nameSource: "manual", ...cwd ? { cwd } : {}, updatedAt: Date.now() });
+  const updated = store.getMetadata(sessionId);
   if (!updated) throw new CommandError("sessions.rename", "session_not_found", `Session not found after rename: ${sessionId}`);
   if (json) {
     printSuccessEnvelope("sessions.rename", { session: fullSessionRow(updated) });
@@ -55523,6 +55782,7 @@ async function forkSession(parsed) {
   const store = new FileSessionStore(getSessionsDir());
   const result = await forkStoredSession({
     store,
+    sessionsDir: getSessionsDir(),
     sourceSessionId: sessionId,
     sourceEntryId,
     targetSessionId,
@@ -55542,10 +55802,19 @@ async function forkSession(parsed) {
   }
   console.log(`Forked ${sessionId} at ${sourceEntryId} into ${targetSessionId}.`);
 }
-async function loadSession(store, sessionId, kind) {
-  const data = await store.load(sessionId);
-  if (!data) throw new CommandError(kind, "session_not_found", `Session not found: ${sessionId}`, { hint: "list sessions: pie sessions list --json" });
-  return data;
+function loadSessionHead(store, sessionId, kind) {
+  const status = store.headStatus(sessionId);
+  if (status === "legacy") {
+    throw new CommandError(kind, "session_unsupported_format", `Session uses an unsupported old format: ${sessionId}`, {
+      hint: "old-format sessions cannot be read by this version"
+    });
+  }
+  if (status === "corrupt") {
+    throw new CommandError(kind, "session_unrecoverable", `Session could not be recovered: ${sessionId}`);
+  }
+  const head = store.readHead(sessionId);
+  if (!head) throw new CommandError(kind, "session_not_found", `Session not found: ${sessionId}`, { hint: "list sessions: pie sessions list --json" });
+  return { metadata: head.metadata };
 }
 function fullSessionRow(metadata) {
   return {
@@ -55599,31 +55868,30 @@ function cwdMatches(sessionCwd, requestedCwd) {
 }
 function realpathOrInput(value) {
   try {
-    return fs7.realpathSync.native(value);
+    return fs8.realpathSync.native(value);
   } catch {
     return value;
   }
 }
-function activeTranscriptEvents(entries) {
-  return entries.map((entry, index) => {
-    const role = isRecord2(entry.message) && typeof entry.message.role === "string" ? entry.message.role : void 0;
-    const turnId = isRecord2(entry.message) && typeof entry.message.turnId === "string" ? entry.message.turnId : void 0;
-    return {
-      logicalSeq: index + 1,
-      entryId: entry.id,
-      type: entry.type,
-      timestamp: entry.timestamp,
-      role,
-      turnId,
-      content: textFromMessage(entry.message),
-      message: entry.message ? cloneJson2(entry.message) : void 0
-    };
-  });
-}
-function activePathEntries(data) {
-  const activeEntryId = data.metadata.activeEntryId;
+async function activeTranscriptEvents(store, sessionId, activeEntryId) {
   if (!activeEntryId) return [];
-  return pathToEntry(data, activeEntryId);
+  const summaries = store.getPathSummaries(sessionId, activeEntryId);
+  return summaries.map((summary, index) => ({
+    logicalSeq: index + 1,
+    seq: summary.seq,
+    entryId: summary.id,
+    type: summary.type,
+    timestamp: summary.timestamp,
+    role: summary.role,
+    content: summary.preview || void 0
+  }));
+}
+function hydrateTranscriptEvent(store, sessionId, event) {
+  const entry = store.readEntry(sessionId, event.entryId);
+  if (!entry) return;
+  event.turnId = isRecord2(entry.message) && typeof entry.message.turnId === "string" ? entry.message.turnId : void 0;
+  event.content = textFromMessage(entry.message);
+  event.message = entry.message ? cloneJson(entry.message) : void 0;
 }
 function resolveBeforeCursor(events, cursor) {
   if (!cursor) return events.length;
@@ -55634,7 +55902,7 @@ function resolveBeforeCursor(events, cursor) {
   const index = events.findIndex((event) => event.entryId === cursor);
   return index >= 0 ? index : events.length;
 }
-function cloneJson2(value) {
+function cloneJson(value) {
   return JSON.parse(JSON.stringify(value));
 }
 function listCursorQueryKey(input) {
@@ -55671,9 +55939,9 @@ function isRecord2(value) {
 }
 
 // src/extensions/loader.ts
-import * as fs8 from "node:fs";
+import * as fs9 from "node:fs";
 import * as os2 from "os";
-import * as path7 from "path";
+import * as path8 from "path";
 import { pathToFileURL } from "node:url";
 
 // src/command-tree.ts
@@ -55686,19 +55954,19 @@ var CommandTree = class {
    *   register(["session", "new"], { description, handler })
    *   register(["tools", "subagent", "spawn", "local"], { description, handler })
    */
-  register(path33, info) {
-    if (path33.length === 0) {
+  register(path34, info) {
+    if (path34.length === 0) {
       throw new Error("Command path cannot be empty");
     }
     let current = this.root;
     const fullPath = [];
-    for (let i = 0; i < path33.length; i++) {
-      const segment = path33[i];
+    for (let i = 0; i < path34.length; i++) {
+      const segment = path34[i];
       fullPath.push(segment);
       if (!current.children) {
         current.children = [];
       }
-      const isLast = i === path33.length - 1;
+      const isLast = i === path34.length - 1;
       let node = current.children.find((n) => n.name === segment);
       if (!node) {
         node = {
@@ -55728,31 +55996,31 @@ var CommandTree = class {
   /**
    * Find a node by path
    */
-  find(path33) {
-    if (path33.length === 0) {
+  find(path34) {
+    if (path34.length === 0) {
       return this.root;
     }
-    const key = path33.join("/");
+    const key = path34.join("/");
     return this.pathCache.get(key) || null;
   }
   /**
    * Get children of a path
    */
-  getChildren(path33) {
-    const node = this.find(path33);
+  getChildren(path34) {
+    const node = this.find(path34);
     return (node?.children || []).filter((child) => !child.hidden);
   }
   /**
    * Check if a path exists (as category or command)
    */
-  exists(path33) {
-    return this.find(path33) !== null;
+  exists(path34) {
+    return this.find(path34) !== null;
   }
   /**
    * Check if path is a category (has children)
    */
-  isCategory(path33) {
-    const node = this.find(path33);
+  isCategory(path34) {
+    const node = this.find(path34);
     return node?.isCategory || false;
   }
   /**
@@ -55831,8 +56099,8 @@ var CommandTree = class {
    * Supports dot notation: "tools.subagent.spawn.local"
    */
   registerFromPath(pathStr, info) {
-    const path33 = pathStr.split(/[./]/).filter(Boolean);
-    this.register(path33, info);
+    const path34 = pathStr.split(/[./]/).filter(Boolean);
+    this.register(path34, info);
   }
 };
 var commandTree = new CommandTree();
@@ -55995,19 +56263,19 @@ function createExtension(extensionPath, resolvedPath, identity, source) {
 }
 function expandPath(p) {
   if (p.startsWith("~/")) {
-    return path7.join(os2.homedir(), p.slice(2));
+    return path8.join(os2.homedir(), p.slice(2));
   }
   if (p.startsWith("~")) {
-    return path7.join(os2.homedir(), p.slice(1));
+    return path8.join(os2.homedir(), p.slice(1));
   }
   return p;
 }
 function resolvePath(extPath, cwd) {
   const expanded = expandPath(extPath);
-  if (path7.isAbsolute(expanded)) {
+  if (path8.isAbsolute(expanded)) {
     return expanded;
   }
-  return path7.resolve(cwd, expanded);
+  return path8.resolve(cwd, expanded);
 }
 async function loadExtensionModule(extensionPath) {
   try {
@@ -56027,14 +56295,14 @@ function normalizeExtensionImportPath(extensionPath) {
   if (/^[a-zA-Z]:[\\/]/.test(extensionPath)) {
     return `file:///${extensionPath.replace(/\\/g, "/")}`;
   }
-  if (path7.isAbsolute(extensionPath)) {
+  if (path8.isAbsolute(extensionPath)) {
     return pathToFileURL(extensionPath).href;
   }
   return extensionPath;
 }
 async function loadExtension(extensionPath, cwd, uiContext, abortFn, isIdleFn, hasUI, actions, discovered) {
   const resolvedPath = resolvePath(extensionPath, cwd);
-  if (!fs8.existsSync(resolvedPath)) {
+  if (!fs9.existsSync(resolvedPath)) {
     return { extension: null, error: `Extension not found: ${extensionPath}` };
   }
   try {
@@ -56060,17 +56328,17 @@ async function loadExtension(extensionPath, cwd, uiContext, abortFn, isIdleFn, h
   }
 }
 function discoverExtensionsInDir(dir, source) {
-  if (!fs8.existsSync(dir)) {
+  if (!fs9.existsSync(dir)) {
     return [];
   }
   const discovered = [];
   try {
-    const entries = fs8.readdirSync(dir, { withFileTypes: true });
+    const entries = fs9.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.name.endsWith(".disabled")) {
         continue;
       }
-      const entryPath = path7.join(dir, entry.name);
+      const entryPath = path8.join(dir, entry.name);
       if (entry.isFile() && (entry.name.endsWith(".cjs") || entry.name.endsWith(".js") || entry.name.endsWith(".ts"))) {
         discovered.push({
           entryPath,
@@ -56080,13 +56348,13 @@ function discoverExtensionsInDir(dir, source) {
         continue;
       }
       if (entry.isDirectory()) {
-        const packageJsonPath = path7.join(entryPath, "package.json");
+        const packageJsonPath = path8.join(entryPath, "package.json");
         let packageIdentity;
         let packageDescription;
         let packageMainPath;
-        if (fs8.existsSync(packageJsonPath)) {
+        if (fs9.existsSync(packageJsonPath)) {
           try {
-            const pkg = JSON.parse(fs8.readFileSync(packageJsonPath, "utf-8"));
+            const pkg = JSON.parse(fs9.readFileSync(packageJsonPath, "utf-8"));
             const manifest = pkg.pie && typeof pkg.pie === "object" && !Array.isArray(pkg.pie) ? pkg.pie : void 0;
             packageIdentity = resolveExtensionIdentity({
               pieName: typeof manifest?.name === "string" ? manifest.name : void 0,
@@ -56095,8 +56363,8 @@ function discoverExtensionsInDir(dir, source) {
             });
             packageDescription = typeof pkg.description === "string" ? pkg.description : void 0;
             if (typeof manifest?.main === "string" && manifest.main.trim().length > 0) {
-              const candidate = path7.resolve(entryPath, manifest.main);
-              if (fs8.existsSync(candidate)) {
+              const candidate = path8.resolve(entryPath, manifest.main);
+              if (fs9.existsSync(candidate)) {
                 packageMainPath = candidate;
               }
             }
@@ -56112,8 +56380,8 @@ function discoverExtensionsInDir(dir, source) {
           });
           continue;
         }
-        const indexCjs = path7.join(entryPath, "index.cjs");
-        if (fs8.existsSync(indexCjs)) {
+        const indexCjs = path8.join(entryPath, "index.cjs");
+        if (fs9.existsSync(indexCjs)) {
           discovered.push({
             entryPath: indexCjs,
             source,
@@ -56122,8 +56390,8 @@ function discoverExtensionsInDir(dir, source) {
           });
           continue;
         }
-        const indexJs = path7.join(entryPath, "index.js");
-        if (fs8.existsSync(indexJs)) {
+        const indexJs = path8.join(entryPath, "index.js");
+        if (fs9.existsSync(indexJs)) {
           discovered.push({
             entryPath: indexJs,
             source,
@@ -56132,8 +56400,8 @@ function discoverExtensionsInDir(dir, source) {
           });
           continue;
         }
-        const indexTs = path7.join(entryPath, "index.ts");
-        if (fs8.existsSync(indexTs)) {
+        const indexTs = path8.join(entryPath, "index.ts");
+        if (fs9.existsSync(indexTs)) {
           discovered.push({
             entryPath: indexTs,
             source,
@@ -56154,21 +56422,21 @@ function collectDiscoveredExtensions(configuredPaths, cwd, options) {
   const errors = [];
   if (!options?.noExtensions) {
     if (!options?.noBuiltinExtensions) {
-      const builtinExtDir = path7.join(getBuiltinDir(), "extensions");
+      const builtinExtDir = path8.join(getBuiltinDir(), "extensions");
       discovered.push(...discoverExtensionsInDir(builtinExtDir, "builtin"));
     }
-    const globalExtDir = path7.join(os2.homedir(), ".pie", "extensions");
+    const globalExtDir = path8.join(os2.homedir(), ".pie", "extensions");
     discovered.push(...discoverExtensionsInDir(globalExtDir, "global"));
-    const localExtDir = path7.join(cwd, ".pie", "extensions");
+    const localExtDir = path8.join(cwd, ".pie", "extensions");
     discovered.push(...discoverExtensionsInDir(localExtDir, "project"));
   }
   for (const p of configuredPaths) {
     const resolved = resolvePath(p, cwd);
-    if (!fs8.existsSync(resolved)) {
+    if (!fs9.existsSync(resolved)) {
       errors.push({ path: p, error: `Extension path not found: ${p}` });
       continue;
     }
-    if (!fs8.statSync(resolved).isDirectory()) {
+    if (!fs9.statSync(resolved).isDirectory()) {
       errors.push({ path: p, error: `Extension path must be a directory: ${p}` });
       continue;
     }
@@ -57023,8 +57291,8 @@ function wrapSingleLine(line, width) {
   if (!line) {
     return [""];
   }
-  const visibleLength2 = visibleWidth(line);
-  if (visibleLength2 <= width) {
+  const visibleLength = visibleWidth(line);
+  if (visibleLength <= width) {
     return [line];
   }
   const wrapped = [];
@@ -58056,9 +58324,9 @@ var KillRing = class {
 };
 
 // ../../packages/tui/src/tui.ts
-import * as fs9 from "node:fs";
+import * as fs10 from "node:fs";
 import * as os3 from "node:os";
-import * as path8 from "node:path";
+import * as path9 from "node:path";
 
 // ../../packages/tui/src/terminal-image.ts
 var cachedCapabilities = null;
@@ -58738,11 +59006,11 @@ var TUI = class extends Container {
     const debugRedraw = process.env.PIE_DEBUG_REDRAW === "1";
     const logRedraw = (reason) => {
       if (!debugRedraw) return;
-      const logPath = path8.join(os3.homedir(), ".pie", "logs", "pie-cli.log");
-      fs9.mkdirSync(path8.dirname(logPath), { recursive: true });
+      const logPath = path9.join(os3.homedir(), ".pie", "logs", "pie-cli.log");
+      fs10.mkdirSync(path9.dirname(logPath), { recursive: true });
       const msg = `[${(/* @__PURE__ */ new Date()).toISOString()}] [DEBUG] [ui] fullRender: ${reason} (prev=${this.previousLines.length}, new=${newLines.length}, height=${height})
 `;
-      fs9.appendFileSync(logPath, msg);
+      fs10.appendFileSync(logPath, msg);
     };
     if (this.previousLines.length === 0 && !widthChanged) {
       logRedraw("first render");
@@ -58835,7 +59103,7 @@ var TUI = class extends Container {
       const line = newLines[i];
       const isImage = isImageLine(line);
       if (!isImage && visibleWidth(line) > width) {
-        const crashLogPath = path8.join(os3.homedir(), ".pie", "pie-crash.log");
+        const crashLogPath = path9.join(os3.homedir(), ".pie", "pie-crash.log");
         const crashData = [
           `Crash at ${(/* @__PURE__ */ new Date()).toISOString()}`,
           `Terminal width: ${width}`,
@@ -58845,8 +59113,8 @@ var TUI = class extends Container {
           ...newLines.map((l, idx) => `[${idx}] (w=${visibleWidth(l)}) ${l}`),
           ""
         ].join("\n");
-        fs9.mkdirSync(path8.dirname(crashLogPath), { recursive: true });
-        fs9.writeFileSync(crashLogPath, crashData);
+        fs10.mkdirSync(path9.dirname(crashLogPath), { recursive: true });
+        fs10.writeFileSync(crashLogPath, crashData);
         this.stop();
         const errorMsg = [
           `Rendered line ${i} exceeds terminal width (${visibleWidth(line)} > ${width}).`,
@@ -58876,8 +59144,8 @@ var TUI = class extends Container {
     buffer += "\x1B[?2026l";
     if (process.env.PIE_TUI_DEBUG === "1") {
       const debugDir = "/tmp/tui";
-      fs9.mkdirSync(debugDir, { recursive: true });
-      const debugPath = path8.join(debugDir, `render-${Date.now()}-${Math.random().toString(36).slice(2)}.log`);
+      fs10.mkdirSync(debugDir, { recursive: true });
+      const debugPath = path9.join(debugDir, `render-${Date.now()}-${Math.random().toString(36).slice(2)}.log`);
       const debugData = [
         `firstChanged: ${firstChanged}`,
         `viewportTop: ${viewportTop}`,
@@ -58900,7 +59168,7 @@ var TUI = class extends Container {
         "=== buffer ===",
         JSON.stringify(buffer)
       ].join("\n");
-      fs9.writeFileSync(debugPath, debugData);
+      fs10.writeFileSync(debugPath, debugData);
     }
     this.terminal.write(buffer);
     this.cursorRow = Math.max(0, newLines.length - 1);
@@ -63189,7 +63457,7 @@ var StdinBuffer = class extends EventEmitter {
 };
 
 // ../../packages/tui/src/terminal.ts
-import * as fs10 from "node:fs";
+import * as fs11 from "node:fs";
 import koffi from "koffi";
 var ProcessTerminal = class {
   wasRaw = false;
@@ -63352,7 +63620,7 @@ var ProcessTerminal = class {
     process.stdout.write(data);
     if (this.writeLogPath) {
       try {
-        fs10.appendFileSync(this.writeLogPath, data, { encoding: "utf8" });
+        fs11.appendFileSync(this.writeLogPath, data, { encoding: "utf8" });
       } catch {
       }
     }
@@ -64197,8 +64465,8 @@ function restoreInteractiveSessionState(options) {
 }
 
 // src/keybindings.ts
-import { existsSync as existsSync8, readFileSync as readFileSync7 } from "fs";
-import { join as join7 } from "path";
+import { existsSync as existsSync9, readFileSync as readFileSync8 } from "fs";
+import { join as join8 } from "path";
 var DEFAULT_APP_KEYBINDINGS = {
   interrupt: "escape",
   clear: "ctrl+c",
@@ -64262,7 +64530,7 @@ var KeybindingsManager = class _KeybindingsManager {
    * Create from config file and set up editor keybindings.
    */
   static create(agentDir = getAgentDir()) {
-    const configPath = join7(agentDir, "keybindings.json");
+    const configPath = join8(agentDir, "keybindings.json");
     const config = _KeybindingsManager.loadFromFile(configPath);
     const manager = new _KeybindingsManager(config);
     const editorConfig = {};
@@ -64280,10 +64548,10 @@ var KeybindingsManager = class _KeybindingsManager {
   static inMemory(config = {}) {
     return new _KeybindingsManager(config);
   }
-  static loadFromFile(path33) {
-    if (!existsSync8(path33)) return {};
+  static loadFromFile(path34) {
+    if (!existsSync9(path34)) return {};
     try {
-      return JSON.parse(readFileSync7(path33, "utf-8"));
+      return JSON.parse(readFileSync8(path34, "utf-8"));
     } catch {
       return {};
     }
@@ -64332,19 +64600,19 @@ var KeybindingsManager = class _KeybindingsManager {
 };
 
 // src/project-knowledge.ts
-import fs11 from "node:fs";
-import path9 from "node:path";
+import fs12 from "node:fs";
+import path10 from "node:path";
 function collectAncestorAgentsFiles(cwd) {
-  const resolvedCwd = path9.resolve(cwd || process.cwd());
+  const resolvedCwd = path10.resolve(cwd || process.cwd());
   const projectRoot = resolveCliProjectRoot(resolvedCwd);
   const candidates = [];
   let current = resolvedCwd;
   while (true) {
-    candidates.unshift(path9.join(current, AGENTS_CONTEXT_FILE_NAME));
+    candidates.unshift(path10.join(current, AGENTS_CONTEXT_FILE_NAME));
     if (current === projectRoot) {
       break;
     }
-    const parent = path9.dirname(current);
+    const parent = path10.dirname(current);
     if (parent === current) {
       break;
     }
@@ -64352,13 +64620,13 @@ function collectAncestorAgentsFiles(cwd) {
   }
   const files = [];
   for (const candidate of candidates) {
-    if (!fs11.existsSync(candidate)) {
+    if (!fs12.existsSync(candidate)) {
       continue;
     }
     try {
       files.push({
-        path: path9.relative(resolvedCwd, candidate) || AGENTS_CONTEXT_FILE_NAME,
-        content: fs11.readFileSync(candidate, "utf-8")
+        path: path10.relative(resolvedCwd, candidate) || AGENTS_CONTEXT_FILE_NAME,
+        content: fs12.readFileSync(candidate, "utf-8")
       });
     } catch {
     }
@@ -64370,14 +64638,14 @@ function buildCliProjectContextSection(cwd) {
 }
 
 // src/file-access-context.ts
-import * as path10 from "node:path";
+import * as path11 from "node:path";
 function uniqueNormalizedPaths(paths) {
   const seen = /* @__PURE__ */ new Set();
   const result = [];
   for (const entry of paths) {
     const trimmed = String(entry || "").trim();
     if (!trimmed) continue;
-    const normalized = path10.normalize(trimmed);
+    const normalized = path11.normalize(trimmed);
     if (seen.has(normalized)) continue;
     seen.add(normalized);
     result.push(normalized);
@@ -64396,8 +64664,8 @@ function buildCliFileAccessOptions(params) {
 }
 
 // src/theme/theme.ts
-import * as fs12 from "node:fs";
-import * as path11 from "node:path";
+import * as fs13 from "node:fs";
+import * as path12 from "node:path";
 
 // ../../node_modules/@sinclair/typebox/build/esm/compiler/compiler.mjs
 var TypeCheck = class {
@@ -65284,11 +65552,11 @@ var BUILTIN_THEMES;
 function getBuiltinThemes() {
   if (!BUILTIN_THEMES) {
     const themesDir = getThemesDir();
-    const darkPath = path11.join(themesDir, "dark.json");
-    const lightPath = path11.join(themesDir, "light.json");
+    const darkPath = path12.join(themesDir, "dark.json");
+    const lightPath = path12.join(themesDir, "light.json");
     BUILTIN_THEMES = {
-      dark: JSON.parse(fs12.readFileSync(darkPath, "utf-8")),
-      light: JSON.parse(fs12.readFileSync(lightPath, "utf-8"))
+      dark: JSON.parse(fs13.readFileSync(darkPath, "utf-8")),
+      light: JSON.parse(fs13.readFileSync(lightPath, "utf-8"))
     };
   }
   return BUILTIN_THEMES;
@@ -65296,8 +65564,8 @@ function getBuiltinThemes() {
 function getAvailableThemes() {
   const themes = new Set(Object.keys(getBuiltinThemes()));
   const customThemesDir = getCustomThemesDir();
-  if (fs12.existsSync(customThemesDir)) {
-    const files = fs12.readdirSync(customThemesDir);
+  if (fs13.existsSync(customThemesDir)) {
+    const files = fs13.readdirSync(customThemesDir);
     for (const file of files) {
       if (file.endsWith(".json")) {
         themes.add(file.slice(0, -5));
@@ -65358,18 +65626,18 @@ function loadThemeJson(name) {
   }
   const registeredTheme = registeredThemes.get(name);
   if (registeredTheme?.sourcePath) {
-    const content2 = fs12.readFileSync(registeredTheme.sourcePath, "utf-8");
+    const content2 = fs13.readFileSync(registeredTheme.sourcePath, "utf-8");
     return parseThemeJsonContent(registeredTheme.sourcePath, content2);
   }
   if (registeredTheme) {
     throw new Error(`Theme "${name}" does not have a source path for export`);
   }
   const customThemesDir = getCustomThemesDir();
-  const themePath = path11.join(customThemesDir, `${name}.json`);
-  if (!fs12.existsSync(themePath)) {
+  const themePath = path12.join(customThemesDir, `${name}.json`);
+  if (!fs13.existsSync(themePath)) {
     throw new Error(`Theme not found: ${name}`);
   }
-  const content = fs12.readFileSync(themePath, "utf-8");
+  const content = fs13.readFileSync(themePath, "utf-8");
   return parseThemeJsonContent(name, content);
 }
 function createTheme(themeJson, mode, sourcePath) {
@@ -65482,12 +65750,12 @@ function startThemeWatcher() {
     return;
   }
   const customThemesDir = getCustomThemesDir();
-  const themeFile = path11.join(customThemesDir, `${currentThemeName}.json`);
-  if (!fs12.existsSync(themeFile)) {
+  const themeFile = path12.join(customThemesDir, `${currentThemeName}.json`);
+  if (!fs13.existsSync(themeFile)) {
     return;
   }
   try {
-    themeWatcher = fs12.watch(themeFile, (eventType) => {
+    themeWatcher = fs13.watch(themeFile, (eventType) => {
       if (eventType === "change") {
         setTimeout(() => {
           try {
@@ -65500,7 +65768,7 @@ function startThemeWatcher() {
         }, 100);
       } else if (eventType === "rename") {
         setTimeout(() => {
-          if (!fs12.existsSync(themeFile)) {
+          if (!fs13.existsSync(themeFile)) {
             currentThemeName = "dark";
             setGlobalTheme(loadTheme("dark"));
             if (themeWatcher) {
@@ -65681,9 +65949,9 @@ function getSettingsListTheme() {
 
 // src/skills/loader.ts
 var import_yaml = __toESM(require_dist2(), 1);
-import * as fs13 from "fs";
+import * as fs14 from "fs";
 import * as os4 from "os";
-import * as path12 from "path";
+import * as path13 from "path";
 function parseSkillDescription(content) {
   content = content.replace(/^\uFEFF/, "").replace(/\r\n/g, "\n");
   const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---(?:\n|$)/);
@@ -65707,19 +65975,19 @@ function parseSkillDescription(content) {
 }
 var USER_CONTROLLED_SOURCES = /* @__PURE__ */ new Set(["user-agents", "user"]);
 function pathIsInside(child, parent) {
-  const relative3 = path12.relative(parent, child);
-  return relative3 !== "" && !relative3.startsWith(`..${path12.sep}`) && relative3 !== ".." && !path12.isAbsolute(relative3);
+  const relative3 = path13.relative(parent, child);
+  return relative3 !== "" && !relative3.startsWith(`..${path13.sep}`) && relative3 !== ".." && !path13.isAbsolute(relative3);
 }
 function resolveSkillSymlink(fullPath, dir, source) {
   let target;
   let stats;
   try {
-    target = fs13.realpathSync(fullPath);
-    stats = fs13.statSync(target);
+    target = fs14.realpathSync(fullPath);
+    stats = fs14.statSync(target);
   } catch {
     return { error: `broken skill symlink: ${fullPath}` };
   }
-  if (!USER_CONTROLLED_SOURCES.has(source) && !pathIsInside(target, fs13.realpathSync(dir))) {
+  if (!USER_CONTROLLED_SOURCES.has(source) && !pathIsInside(target, fs14.realpathSync(dir))) {
     return { error: `skill symlink escapes the "${source}" layer (not loaded): ${fullPath} -> ${target}` };
   }
   return { target, isDirectory: stats.isDirectory(), isFile: stats.isFile() };
@@ -65727,13 +65995,13 @@ function resolveSkillSymlink(fullPath, dir, source) {
 function loadSkillsFromDir(dir, source) {
   const skills = [];
   const diagnostics = [];
-  if (!fs13.existsSync(dir)) {
+  if (!fs14.existsSync(dir)) {
     return { skills, diagnostics };
   }
-  const entries = fs13.readdirSync(dir, { withFileTypes: true });
+  const entries = fs14.readdirSync(dir, { withFileTypes: true });
   for (const entry of entries) {
     if (entry.name.startsWith(".")) continue;
-    const fullPath = path12.join(dir, entry.name);
+    const fullPath = path13.join(dir, entry.name);
     let entryPath = fullPath;
     let entryIsDirectory = entry.isDirectory();
     let entryIsFile = entry.isFile();
@@ -65748,10 +66016,10 @@ function loadSkillsFromDir(dir, source) {
       entryIsFile = resolved.isFile;
     }
     if (entryIsDirectory) {
-      const skillMdPath = path12.join(entryPath, "SKILL.md");
-      if (fs13.existsSync(skillMdPath)) {
+      const skillMdPath = path13.join(entryPath, "SKILL.md");
+      if (fs14.existsSync(skillMdPath)) {
         try {
-          const content = fs13.readFileSync(skillMdPath, "utf-8");
+          const content = fs14.readFileSync(skillMdPath, "utf-8");
           const description = parseSkillDescription(content);
           skills.push({
             name: entry.name,
@@ -65772,7 +66040,7 @@ function loadSkillsFromDir(dir, source) {
     } else if (entryIsFile && entry.name.endsWith(".md")) {
       const name = entry.name.slice(0, -3);
       try {
-        const content = fs13.readFileSync(entryPath, "utf-8");
+        const content = fs14.readFileSync(entryPath, "utf-8");
         const description = parseSkillDescription(content);
         skills.push({
           name,
@@ -65780,7 +66048,7 @@ function loadSkillsFromDir(dir, source) {
           content,
           filePath: entryPath,
           source,
-          baseDir: path12.dirname(entryPath)
+          baseDir: path13.dirname(entryPath)
         });
       } catch (e) {
         diagnostics.push({
@@ -65794,18 +66062,18 @@ function loadSkillsFromDir(dir, source) {
   return { skills, diagnostics };
 }
 function discoverAgentsSkillsDirs(cwd) {
-  const resolvedCwd = path12.resolve(cwd || process.cwd());
+  const resolvedCwd = path13.resolve(cwd || process.cwd());
   const projectRoot = resolveCliProjectRoot(resolvedCwd);
   const projectAgentsDirs = [];
   let current = projectRoot;
   while (true) {
-    projectAgentsDirs.push(path12.join(current, ".agents", "skills"));
+    projectAgentsDirs.push(path13.join(current, ".agents", "skills"));
     if (current === resolvedCwd) break;
-    const child = path12.relative(current, resolvedCwd).split(path12.sep)[0];
+    const child = path13.relative(current, resolvedCwd).split(path13.sep)[0];
     if (!child) break;
-    current = path12.join(current, child);
+    current = path13.join(current, child);
   }
-  return { userAgentsDir: path12.join(os4.homedir(), ".agents", "skills"), projectAgentsDirs };
+  return { userAgentsDir: path13.join(os4.homedir(), ".agents", "skills"), projectAgentsDirs };
 }
 function buildSkillDirs(options) {
   const { userAgentsDir, projectAgentsDirs } = discoverAgentsSkillsDirs(options.cwd);
@@ -65976,11 +66244,11 @@ function validateSkillName(name) {
 }
 
 // src/interactive-mode.ts
-import * as path29 from "path";
+import * as path30 from "path";
 
 // src/capabilities/read-file-understanding.ts
-import * as path21 from "node:path";
-import * as fs21 from "node:fs/promises";
+import * as path22 from "node:path";
+import * as fs22 from "node:fs/promises";
 
 // src/core/provider-capabilities.ts
 var PLATFORM_DISPLAY_NAMES = {
@@ -66006,8 +66274,8 @@ function getProviderDisplayName(platform2) {
 }
 
 // src/files/adapters/kimi-adapter.ts
-import * as fs14 from "node:fs";
-import * as path13 from "node:path";
+import * as fs15 from "node:fs";
+import * as path14 from "node:path";
 
 // src/files/errors.ts
 var FileErrorMessages = {
@@ -66144,17 +66412,17 @@ var KimiFileAdapter = class {
   // Upload
   // ============================================================================
   async upload(filePath, options = {}) {
-    const fileName = options.sourceName || path13.basename(filePath);
+    const fileName = options.sourceName || path14.basename(filePath);
     const mimeType = options.mimeType || this.guessMimeType(fileName);
     const purpose = this.detectPurpose(filePath, options.purpose, mimeType);
-    const stats = fs14.statSync(filePath);
+    const stats = fs15.statSync(filePath);
     if (stats.size > this.capabilities.maxFileSize) {
       throw new FileManagerError(
         "FILE_TOO_LARGE" /* FILE_TOO_LARGE */,
         `File size ${(stats.size / 1024 / 1024).toFixed(1)}MB exceeds Kimi limit of 100MB`
       );
     }
-    const fileBuffer = fs14.readFileSync(filePath);
+    const fileBuffer = fs15.readFileSync(filePath);
     const file = new File([fileBuffer], fileName, { type: mimeType });
     const formData = new FormData();
     formData.append("file", file);
@@ -66206,7 +66474,7 @@ var KimiFileAdapter = class {
     return "file-extract";
   }
   guessMimeType(filename) {
-    const ext = path13.extname(filename).toLowerCase();
+    const ext = path14.extname(filename).toLowerCase();
     switch (ext) {
       case ".jpg":
       case ".jpeg":
@@ -66368,8 +66636,8 @@ var KimiFileAdapter = class {
 };
 
 // src/files/adapters/gemini-adapter.ts
-import * as fs15 from "node:fs";
-import * as path14 from "node:path";
+import * as fs16 from "node:fs";
+import * as path15 from "node:path";
 import { Readable } from "node:stream";
 var GeminiFileAdapter = class {
   platform = "gemini";
@@ -66426,7 +66694,7 @@ var GeminiFileAdapter = class {
   // Upload
   // ============================================================================
   async upload(filePath, options = {}) {
-    const stats = fs15.statSync(filePath);
+    const stats = fs16.statSync(filePath);
     if (stats.size > this.capabilities.maxFileSize) {
       throw new FileManagerError(
         "FILE_TOO_LARGE" /* FILE_TOO_LARGE */,
@@ -66434,7 +66702,7 @@ var GeminiFileAdapter = class {
       );
     }
     const mimeType = options.mimeType || this.guessMimeType(filePath);
-    const displayName = options.sourceName || path14.basename(filePath);
+    const displayName = options.sourceName || path15.basename(filePath);
     const startResponse = await fetch(
       `${this.baseUrl}/upload/v1beta/files?key=${this.apiKey}`,
       {
@@ -66465,7 +66733,7 @@ var GeminiFileAdapter = class {
         "No upload URL received"
       );
     }
-    const fileStream = Readable.toWeb(fs15.createReadStream(filePath));
+    const fileStream = Readable.toWeb(fs16.createReadStream(filePath));
     const uploadResponse = await fetch(uploadUrl, {
       method: "POST",
       headers: {
@@ -66669,8 +66937,8 @@ var GeminiFileAdapter = class {
 };
 
 // src/files/adapters/openai-compatible-files-adapter.ts
-import * as fs16 from "node:fs";
-import * as path15 from "node:path";
+import * as fs17 from "node:fs";
+import * as path16 from "node:path";
 var OpenAICompatibleFilesAdapter = class {
   constructor(apiKey, baseUrl, extraHeaders = {}) {
     this.apiKey = apiKey;
@@ -66696,16 +66964,16 @@ var OpenAICompatibleFilesAdapter = class {
     ]
   };
   async upload(filePath, options = {}) {
-    const fileName = options.sourceName || path15.basename(filePath);
+    const fileName = options.sourceName || path16.basename(filePath);
     const mimeType = options.mimeType || guessMimeType(fileName);
-    const stats = fs16.statSync(filePath);
+    const stats = fs17.statSync(filePath);
     if (stats.size > this.capabilities.maxFileSize) {
       throw new FileManagerError(
         "FILE_TOO_LARGE" /* FILE_TOO_LARGE */,
         `File size ${(stats.size / 1024 / 1024).toFixed(1)}MB exceeds OpenAI-compatible Files limit of ${this.capabilities.maxFileSize / 1024 / 1024}MB`
       );
     }
-    const file = new File([fs16.readFileSync(filePath)], fileName, { type: mimeType });
+    const file = new File([fs17.readFileSync(filePath)], fileName, { type: mimeType });
     const formData = new FormData();
     formData.append("file", file);
     formData.append("purpose", options.purpose && options.purpose !== "auto" ? options.purpose : "file-extract");
@@ -66822,7 +67090,7 @@ function extractContentText(raw) {
   return raw;
 }
 function guessMimeType(filename) {
-  const ext = path15.extname(filename).toLowerCase();
+  const ext = path16.extname(filename).toLowerCase();
   switch (ext) {
     case ".pdf":
       return "application/pdf";
@@ -66838,13 +67106,13 @@ function guessMimeType(filename) {
 }
 
 // src/files/file-manager.ts
-import * as fs20 from "node:fs";
-import * as path20 from "node:path";
+import * as fs21 from "node:fs";
+import * as path21 from "node:path";
 import * as crypto2 from "node:crypto";
 
 // src/files/file-cache.ts
-import * as fs17 from "node:fs";
-import * as path17 from "node:path";
+import * as fs18 from "node:fs";
+import * as path18 from "node:path";
 import * as crypto from "node:crypto";
 
 // src/files/logger.ts
@@ -66939,7 +67207,7 @@ var DEFAULT_PIC_OPTIONS = {
 };
 
 // src/files/utils.ts
-import * as path16 from "node:path";
+import * as path17 from "node:path";
 import { homedir as homedir5 } from "node:os";
 var WINDOWS_ABSOLUTE_PATH_RE = /^(?:[a-zA-Z]:[\\/]|[\\/]{2}[^\\/]+[\\/][^\\/]+)/;
 function isWindowsAbsolutePath(filePath) {
@@ -66960,13 +67228,13 @@ function formatBytes(bytes) {
 }
 function resolvePath2(inputPath) {
   if (inputPath.startsWith("~")) {
-    return path16.join(getHomeDirectory(), inputPath.slice(1));
+    return path17.join(getHomeDirectory(), inputPath.slice(1));
   }
   if (isWindowsAbsolutePath(inputPath)) {
     return inputPath;
   }
-  if (!path16.isAbsolute(inputPath)) {
-    return path16.resolve(process.cwd(), inputPath);
+  if (!path17.isAbsolute(inputPath)) {
+    return path17.resolve(process.cwd(), inputPath);
   }
   return inputPath;
 }
@@ -66994,8 +67262,8 @@ var FileCache = class _FileCache {
   maxEntries;
   constructor(baseDir, maxEntries = DEFAULT_MAX_CACHE_ENTRIES) {
     this.baseDir = baseDir;
-    this.dataDir = path17.join(baseDir, "data");
-    this.indexPath = path17.join(baseDir, "index.json");
+    this.dataDir = path18.join(baseDir, "data");
+    this.indexPath = path18.join(baseDir, "index.json");
     this.maxEntries = maxEntries;
     this.index = this.loadIndex();
     this.ensureDirectories();
@@ -67004,22 +67272,22 @@ var FileCache = class _FileCache {
   // Directory Management
   // ============================================================================
   ensureDirectories() {
-    if (!fs17.existsSync(this.baseDir)) {
-      fs17.mkdirSync(this.baseDir, { recursive: true });
+    if (!fs18.existsSync(this.baseDir)) {
+      fs18.mkdirSync(this.baseDir, { recursive: true });
     }
-    if (!fs17.existsSync(this.dataDir)) {
-      fs17.mkdirSync(this.dataDir, { recursive: true });
+    if (!fs18.existsSync(this.dataDir)) {
+      fs18.mkdirSync(this.dataDir, { recursive: true });
     }
   }
   // ============================================================================
   // Index Management
   // ============================================================================
   loadIndex() {
-    if (!fs17.existsSync(this.indexPath)) {
+    if (!fs18.existsSync(this.indexPath)) {
       return { version: CACHE_VERSION, files: {}, pathHints: {} };
     }
     try {
-      const data = JSON.parse(fs17.readFileSync(this.indexPath, "utf-8"));
+      const data = JSON.parse(fs18.readFileSync(this.indexPath, "utf-8"));
       if (data.version !== CACHE_VERSION) {
         cacheLogger.warn(`Index version mismatch: ${data.version} vs ${CACHE_VERSION}`);
       }
@@ -67035,7 +67303,7 @@ var FileCache = class _FileCache {
   }
   saveIndex() {
     try {
-      fs17.writeFileSync(this.indexPath, JSON.stringify(this.index, null, 2));
+      fs18.writeFileSync(this.indexPath, JSON.stringify(this.index, null, 2));
     } catch (err) {
       cacheLogger.error(" Failed to save index:", err);
       throw err;
@@ -67047,7 +67315,7 @@ var FileCache = class _FileCache {
   async computeHash(filePath) {
     return new Promise((resolve7, reject) => {
       const hash = crypto.createHash("sha256");
-      const stream = fs17.createReadStream(filePath);
+      const stream = fs18.createReadStream(filePath);
       stream.on("data", (chunk) => hash.update(chunk));
       stream.on("end", () => resolve7(hash.digest("hex")));
       stream.on("error", reject);
@@ -67061,25 +67329,25 @@ var FileCache = class _FileCache {
   // ============================================================================
   getStoragePath(hash) {
     const subdir = hash.slice(0, 2);
-    const fullDir = path17.join(this.dataDir, subdir);
-    if (!fs17.existsSync(fullDir)) {
-      fs17.mkdirSync(fullDir, { recursive: true });
+    const fullDir = path18.join(this.dataDir, subdir);
+    if (!fs18.existsSync(fullDir)) {
+      fs18.mkdirSync(fullDir, { recursive: true });
     }
-    return path17.join(fullDir, hash);
+    return path18.join(fullDir, hash);
   }
   getStorageRelativePath(hash) {
     const subdir = hash.slice(0, 2);
-    return path17.join(subdir, hash);
+    return path18.join(subdir, hash);
   }
   async storeFile(sourcePath, name, mimeType) {
     const hash = await this.computeHash(sourcePath);
     const storagePath = this.getStoragePath(hash);
     this.rememberPathHint(sourcePath, hash, name);
-    if (fs17.existsSync(storagePath)) {
+    if (fs18.existsSync(storagePath)) {
       return { hash, localPath: storagePath };
     }
-    fs17.copyFileSync(sourcePath, storagePath);
-    const stat2 = fs17.statSync(storagePath);
+    fs18.copyFileSync(sourcePath, storagePath);
+    const stat2 = fs18.statSync(storagePath);
     this.index.files[hash] = {
       hash,
       name,
@@ -67096,10 +67364,10 @@ var FileCache = class _FileCache {
   async storeBuffer(data, name, mimeType) {
     const hash = this.computeHashSync(data);
     const storagePath = this.getStoragePath(hash);
-    if (fs17.existsSync(storagePath)) {
+    if (fs18.existsSync(storagePath)) {
       return { hash, localPath: storagePath };
     }
-    fs17.writeFileSync(storagePath, data);
+    fs18.writeFileSync(storagePath, data);
     this.index.files[hash] = {
       hash,
       name,
@@ -67131,7 +67399,7 @@ var FileCache = class _FileCache {
   getLocalPath(hash) {
     const entry = this.index.files[hash];
     if (!entry) return void 0;
-    return path17.join(this.dataDir, entry.localPath);
+    return path18.join(this.dataDir, entry.localPath);
   }
   exists(hash) {
     return hash in this.index.files;
@@ -67171,7 +67439,7 @@ var FileCache = class _FileCache {
   getPathHint(filePath) {
     try {
       const resolvedPath = this.getResolvedHintPath(filePath);
-      const stat2 = fs17.statSync(resolvedPath);
+      const stat2 = fs18.statSync(resolvedPath);
       if (!stat2.isFile()) return void 0;
       const normalizedMtimeMs = this.normalizeHintMtimeMs(stat2.mtimeMs);
       const key = this.getPathHintKey(resolvedPath);
@@ -67201,7 +67469,7 @@ var FileCache = class _FileCache {
   rememberPathHint(filePath, hash, name) {
     try {
       const resolvedPath = this.getResolvedHintPath(filePath);
-      const stat2 = fs17.statSync(resolvedPath);
+      const stat2 = fs18.statSync(resolvedPath);
       if (!stat2.isFile()) return;
       const entry = this.index.files[hash];
       const normalizedMtimeMs = this.normalizeHintMtimeMs(stat2.mtimeMs);
@@ -67211,7 +67479,7 @@ var FileCache = class _FileCache {
       this.index.pathHints[this.getPathHintKey(resolvedPath)] = {
         path: resolvedPath,
         hash,
-        name: name || entry?.name || path17.basename(resolvedPath),
+        name: name || entry?.name || path18.basename(resolvedPath),
         size: stat2.size,
         mtimeMs: normalizedMtimeMs,
         lastSeenAt: Date.now(),
@@ -67259,9 +67527,9 @@ var FileCache = class _FileCache {
   deleteEntry(hash, entry) {
     entry = entry || this.index.files[hash];
     if (!entry) return;
-    const localPath = path17.join(this.dataDir, entry.localPath);
-    if (fs17.existsSync(localPath)) {
-      fs17.unlinkSync(localPath);
+    const localPath = path18.join(this.dataDir, entry.localPath);
+    if (fs18.existsSync(localPath)) {
+      fs18.unlinkSync(localPath);
     }
     delete this.index.files[hash];
     if (this.index.pathHints) {
@@ -67275,9 +67543,9 @@ var FileCache = class _FileCache {
   }
   clear() {
     for (const entry of Object.values(this.index.files)) {
-      const localPath = path17.join(this.dataDir, entry.localPath);
-      if (fs17.existsSync(localPath)) {
-        fs17.unlinkSync(localPath);
+      const localPath = path18.join(this.dataDir, entry.localPath);
+      if (fs18.existsSync(localPath)) {
+        fs18.unlinkSync(localPath);
       }
     }
     this.index = { version: CACHE_VERSION, files: {}, pathHints: {} };
@@ -67330,11 +67598,11 @@ var FileCache = class _FileCache {
     };
   }
   static getMimeType(fileName) {
-    const ext = path17.extname(fileName).toLowerCase();
+    const ext = path18.extname(fileName).toLowerCase();
     return MIME_TYPES[ext] || "application/octet-stream";
   }
   static getFileTypeFromName(fileName) {
-    const baseName = path17.basename(fileName);
+    const baseName = path18.basename(fileName);
     if (!baseName || baseName.startsWith(".")) {
       return void 0;
     }
@@ -67365,7 +67633,7 @@ var FileCache = class _FileCache {
   getResolvedHintPath(filePath) {
     const resolvedPath = resolvePath2(filePath);
     try {
-      return fs17.realpathSync.native ? fs17.realpathSync.native(resolvedPath) : fs17.realpathSync(resolvedPath);
+      return fs18.realpathSync.native ? fs18.realpathSync.native(resolvedPath) : fs18.realpathSync(resolvedPath);
     } catch {
       return resolvedPath;
     }
@@ -67373,8 +67641,8 @@ var FileCache = class _FileCache {
 };
 
 // src/files/session-file-manager.ts
-import * as fs18 from "node:fs";
-import * as path18 from "node:path";
+import * as fs19 from "node:fs";
+import * as path19 from "node:path";
 var INITIAL_REFRESH_BACKOFF_MS = 6e4;
 var MAX_REFRESH_BACKOFF_MS = 60 * 60 * 1e3;
 var SessionFileManager = class {
@@ -67388,7 +67656,7 @@ var SessionFileManager = class {
   constructor(sessionId, sessionsDir, fileCache, authFingerprint) {
     this.sessionId = sessionId;
     this.sessionsDir = sessionsDir;
-    this.statePath = path18.join(this.sessionsDir, `${sessionId}-files.json`);
+    this.statePath = path19.join(this.sessionsDir, `${sessionId}-files.json`);
     this.fileCache = fileCache;
     this.authFingerprint = authFingerprint;
     this.state = this.loadState();
@@ -67398,15 +67666,15 @@ var SessionFileManager = class {
   // Directory Management
   // ============================================================================
   ensureDirectories() {
-    if (!fs18.existsSync(this.sessionsDir)) {
-      fs18.mkdirSync(this.sessionsDir, { recursive: true });
+    if (!fs19.existsSync(this.sessionsDir)) {
+      fs19.mkdirSync(this.sessionsDir, { recursive: true });
     }
   }
   // ============================================================================
   // State Management
   // ============================================================================
   loadState() {
-    if (!fs18.existsSync(this.statePath)) {
+    if (!fs19.existsSync(this.statePath)) {
       return {
         sessionId: this.sessionId,
         lastSyncedAt: 0,
@@ -67414,7 +67682,7 @@ var SessionFileManager = class {
       };
     }
     try {
-      return JSON.parse(fs18.readFileSync(this.statePath, "utf-8"));
+      return JSON.parse(fs19.readFileSync(this.statePath, "utf-8"));
     } catch (err) {
       sessionLogger.error(" Failed to load state:", err);
       return {
@@ -67427,12 +67695,12 @@ var SessionFileManager = class {
   saveState() {
     try {
       if (Object.keys(this.state.files).length === 0) {
-        if (fs18.existsSync(this.statePath)) {
-          fs18.unlinkSync(this.statePath);
+        if (fs19.existsSync(this.statePath)) {
+          fs19.unlinkSync(this.statePath);
         }
         return;
       }
-      fs18.writeFileSync(this.statePath, JSON.stringify(this.state, null, 2));
+      fs19.writeFileSync(this.statePath, JSON.stringify(this.state, null, 2));
     } catch (err) {
       sessionLogger.error(" Failed to save state:", err);
     }
@@ -67578,7 +67846,7 @@ var SessionFileManager = class {
       return { success: false, coolingDown: true };
     }
     const localPath = this.fileCache.getLocalPath(entry.hash);
-    if (!localPath || !fs18.existsSync(localPath)) {
+    if (!localPath || !fs19.existsSync(localPath)) {
       sessionLogger.warn(`Local file not found for ${fileId}`);
       entry.status = "expired";
       entry.error = "Local file missing";
@@ -67729,15 +67997,15 @@ var SessionFileManager = class {
   // Static Utilities
   // ============================================================================
   static cleanupOldSessions(sessionsDir, maxAge = 30 * 24 * 60 * 60 * 1e3) {
-    if (!fs18.existsSync(sessionsDir)) return;
+    if (!fs19.existsSync(sessionsDir)) return;
     const now = Date.now();
-    const files = fs18.readdirSync(sessionsDir);
+    const files = fs19.readdirSync(sessionsDir);
     for (const file of files) {
       if (!file.endsWith(".json")) continue;
-      const filePath = path18.join(sessionsDir, file);
-      const stat2 = fs18.statSync(filePath);
+      const filePath = path19.join(sessionsDir, file);
+      const stat2 = fs19.statSync(filePath);
       if (now - stat2.mtime.getTime() > maxAge) {
-        fs18.unlinkSync(filePath);
+        fs19.unlinkSync(filePath);
         sessionLogger.debug(`Cleaned up old session: ${file}`);
       }
     }
@@ -67745,8 +68013,8 @@ var SessionFileManager = class {
 };
 
 // src/files/ffmpeg-processor.ts
-import * as fs19 from "node:fs";
-import * as path19 from "node:path";
+import * as fs20 from "node:fs";
+import * as path20 from "node:path";
 import { spawn } from "node:child_process";
 var FFmpegProcessor = class {
   ffmpegPath = "ffmpeg";
@@ -67850,7 +68118,7 @@ var FFmpegProcessor = class {
   }
   async compressVideo(inputPath, outputDir, info, opts, onProgress) {
     const outputName = `compressed_${Date.now()}.mp4`;
-    const outputPath = path19.join(outputDir, outputName);
+    const outputPath = path20.join(outputDir, outputName);
     const adaptiveParams = this.calculateAdaptiveParams(info.duration, opts);
     const args = [
       "-i",
@@ -67881,7 +68149,7 @@ var FFmpegProcessor = class {
         onProgress?.(percent);
       }
     });
-    const outputStat = fs19.statSync(outputPath);
+    const outputStat = fs20.statSync(outputPath);
     return {
       type: "video",
       output: outputPath,
@@ -67912,9 +68180,9 @@ var FFmpegProcessor = class {
   }
   async extractKeyframes(inputPath, outputDir, info, opts, onProgress) {
     const interval = Math.floor(info.duration / opts.keyframeCount);
-    const framesDir = path19.join(outputDir, `keyframes_${Date.now()}`);
-    fs19.mkdirSync(framesDir, { recursive: true });
-    const outputPattern = path19.join(framesDir, "frame_%03d.jpg");
+    const framesDir = path20.join(outputDir, `keyframes_${Date.now()}`);
+    fs20.mkdirSync(framesDir, { recursive: true });
+    const outputPattern = path20.join(framesDir, "frame_%03d.jpg");
     const args = [
       "-i",
       inputPath,
@@ -67932,10 +68200,10 @@ var FFmpegProcessor = class {
         onProgress?.(percent);
       }
     });
-    let frames = fs19.readdirSync(framesDir).filter((f) => f.endsWith(".jpg")).sort().map((f) => path19.join(framesDir, f));
+    let frames = fs20.readdirSync(framesDir).filter((f) => f.endsWith(".jpg")).sort().map((f) => path20.join(framesDir, f));
     if (frames.length < opts.keyframeCount / 2) {
-      fs19.rmSync(framesDir, { recursive: true, force: true });
-      fs19.mkdirSync(framesDir, { recursive: true });
+      fs20.rmSync(framesDir, { recursive: true, force: true });
+      fs20.mkdirSync(framesDir, { recursive: true });
       const uniformArgs = [
         "-i",
         inputPath,
@@ -67951,10 +68219,10 @@ var FFmpegProcessor = class {
           onProgress?.(percent);
         }
       });
-      frames = fs19.readdirSync(framesDir).filter((f) => f.endsWith(".jpg")).sort().map((f) => path19.join(framesDir, f));
+      frames = fs20.readdirSync(framesDir).filter((f) => f.endsWith(".jpg")).sort().map((f) => path20.join(framesDir, f));
     }
     const totalOutputSize = frames.reduce(
-      (sum, f) => sum + fs19.statSync(f).size,
+      (sum, f) => sum + fs20.statSync(f).size,
       0
     );
     return {
@@ -67975,7 +68243,7 @@ var FFmpegProcessor = class {
     const opts = { ...DEFAULT_PIC_OPTIONS, ...options };
     const ext = opts.format === "webp" ? ".webp" : ".jpg";
     const outputName = `optimized_${Date.now()}${ext}`;
-    const outputPath = path19.join(outputDir, outputName);
+    const outputPath = path20.join(outputDir, outputName);
     const args = [
       "-i",
       inputPath,
@@ -68150,8 +68418,8 @@ var DIRECTORY_LISTING_TTL_MS = 1500;
 var FileManager = class {
   constructor(options) {
     this.options = options;
-    const baseDir = options.baseDir || path20.join(process.env.HOME || ".", ".pie", "files");
-    const sessionsDir = options.sessionsDir || path20.join(process.env.HOME || ".", ".pie", "sessions");
+    const baseDir = options.baseDir || path21.join(process.env.HOME || ".", ".pie", "files");
+    const sessionsDir = options.sessionsDir || path21.join(process.env.HOME || ".", ".pie", "sessions");
     this.fileCache = new FileCache(baseDir);
     this.authFingerprint = options.apiKey ? this.buildAuthFingerprint(options.apiKey) : void 0;
     this.sessionManager = new SessionFileManager(
@@ -68162,7 +68430,7 @@ var FileManager = class {
     );
     this.ffmpeg = new FFmpegProcessor(options.ffmpegPath);
     this.platform = normalizeFileManagerPlatform(options.platform);
-    this.tempDir = path20.join(baseDir, "temp");
+    this.tempDir = path21.join(baseDir, "temp");
     this.ensureDirectories();
   }
   options;
@@ -68174,8 +68442,8 @@ var FileManager = class {
   directoryListingCache = /* @__PURE__ */ new Map();
   authFingerprint;
   ensureDirectories() {
-    if (!fs20.existsSync(this.tempDir)) {
-      fs20.mkdirSync(this.tempDir, { recursive: true });
+    if (!fs21.existsSync(this.tempDir)) {
+      fs21.mkdirSync(this.tempDir, { recursive: true });
     }
   }
   // ============================================================================
@@ -68209,8 +68477,8 @@ var FileManager = class {
   // ============================================================================
   async stageLocal(filePath, options = {}) {
     const resolvedPath = resolvePath2(filePath);
-    const sourceName = options.sourceName || path20.basename(resolvedPath);
-    if (!fs20.existsSync(resolvedPath)) {
+    const sourceName = options.sourceName || path21.basename(resolvedPath);
+    if (!fs21.existsSync(resolvedPath)) {
       throw new FileManagerError(
         "LOCAL_FILE_MISSING" /* LOCAL_FILE_MISSING */,
         `File not found: ${filePath}`
@@ -68225,7 +68493,7 @@ var FileManager = class {
     this.fileCache.rememberPathHint(resolvedPath, hash, sourceName);
     this.invalidateDirectoryListingCacheForPath(resolvedPath);
     const entry = this.fileCache.getByHash(hash);
-    const size = entry?.size ?? fs20.statSync(resolvedPath).size;
+    const size = entry?.size ?? fs21.statSync(resolvedPath).size;
     return {
       success: true,
       hash,
@@ -68239,8 +68507,8 @@ var FileManager = class {
   }
   async upload(filePath, options = {}) {
     const resolvedPath = resolvePath2(filePath);
-    const sourceName = options.sourceName || path20.basename(resolvedPath);
-    if (!fs20.existsSync(resolvedPath)) {
+    const sourceName = options.sourceName || path21.basename(resolvedPath);
+    if (!fs21.existsSync(resolvedPath)) {
       throw new FileManagerError(
         "LOCAL_FILE_MISSING" /* LOCAL_FILE_MISSING */,
         `File not found: ${filePath}`
@@ -68321,7 +68589,7 @@ var FileManager = class {
   // ============================================================================
   async uploadPic(filePath, options = {}) {
     const resolvedPath = resolvePath2(filePath);
-    if (!fs20.existsSync(resolvedPath)) {
+    if (!fs21.existsSync(resolvedPath)) {
       throw new FileManagerError(
         "LOCAL_FILE_MISSING" /* LOCAL_FILE_MISSING */,
         `File not found: ${filePath}`
@@ -68329,7 +68597,7 @@ var FileManager = class {
     }
     const cachedResult = await this.tryReuseCachedSourceUpload(
       resolvedPath,
-      options.sourceName || path20.basename(resolvedPath),
+      options.sourceName || path21.basename(resolvedPath),
       options.platform || this.platform
     );
     if (cachedResult) {
@@ -68346,12 +68614,12 @@ var FileManager = class {
     const result = await this.upload(optimizedPath, {
       ...options,
       purpose: "image",
-      sourceName: path20.basename(resolvedPath)
+      sourceName: path21.basename(resolvedPath)
     });
-    this.fileCache.rememberPathHint(resolvedPath, result.hash, path20.basename(resolvedPath));
+    this.fileCache.rememberPathHint(resolvedPath, result.hash, path21.basename(resolvedPath));
     this.invalidateDirectoryListingCacheForPath(resolvedPath);
     try {
-      fs20.unlinkSync(optimizedPath);
+      fs21.unlinkSync(optimizedPath);
     } catch {
     }
     return result;
@@ -68361,7 +68629,7 @@ var FileManager = class {
   // ============================================================================
   async uploadVideo(filePath, options = {}) {
     const resolvedPath = resolvePath2(filePath);
-    if (!fs20.existsSync(resolvedPath)) {
+    if (!fs21.existsSync(resolvedPath)) {
       throw new FileManagerError(
         "LOCAL_FILE_MISSING" /* LOCAL_FILE_MISSING */,
         `File not found: ${filePath}`
@@ -68369,7 +68637,7 @@ var FileManager = class {
     }
     const cachedResult = await this.tryReuseCachedSourceUpload(
       resolvedPath,
-      options.sourceName || path20.basename(resolvedPath),
+      options.sourceName || path21.basename(resolvedPath),
       options.platform || this.platform
     );
     if (cachedResult) {
@@ -68419,9 +68687,9 @@ var FileManager = class {
       result = await this.upload(preprocessResult.output, {
         ...options,
         purpose: "video",
-        sourceName: path20.basename(resolvedPath)
+        sourceName: path21.basename(resolvedPath)
       });
-      this.fileCache.rememberPathHint(resolvedPath, result.hash, path20.basename(resolvedPath));
+      this.fileCache.rememberPathHint(resolvedPath, result.hash, path21.basename(resolvedPath));
       this.invalidateDirectoryListingCacheForPath(resolvedPath);
     } else {
       throw new FileManagerError(
@@ -68713,7 +68981,7 @@ var FileManager = class {
    * Detect purpose from file path based on extension
    */
   detectPurpose(filePath) {
-    const ext = path20.extname(filePath).toLowerCase();
+    const ext = path21.extname(filePath).toLowerCase();
     switch (ext) {
       case ".mp4":
       case ".mov":
@@ -68755,13 +69023,13 @@ var FileManager = class {
   cleanupTempFiles(output) {
     try {
       if (typeof output === "string") {
-        if (fs20.existsSync(output)) {
-          fs20.unlinkSync(output);
+        if (fs21.existsSync(output)) {
+          fs21.unlinkSync(output);
         }
       } else {
         for (const file of output) {
-          if (fs20.existsSync(file)) {
-            fs20.unlinkSync(file);
+          if (fs21.existsSync(file)) {
+            fs21.unlinkSync(file);
           }
         }
       }
@@ -68793,7 +69061,7 @@ var FileManager = class {
         }];
       }
       const localPath = this.fileCache.getLocalPath(entry.hash);
-      if (localPath && fs20.existsSync(localPath)) {
+      if (localPath && fs21.existsSync(localPath)) {
         return [{
           fileId,
           name: cacheEntry.name,
@@ -68890,12 +69158,12 @@ var FileManager = class {
       directories: []
     };
     try {
-      const entries = fs20.readdirSync(resolvedDir, { withFileTypes: true });
+      const entries = fs21.readdirSync(resolvedDir, { withFileTypes: true });
       for (const entry of entries) {
         if (!entry.name || entry.name.startsWith(".")) {
           continue;
         }
-        const fullPath = path20.join(resolvedDir, entry.name);
+        const fullPath = path21.join(resolvedDir, entry.name);
         if (entry.isDirectory()) {
           listing.directories.push({ name: entry.name, path: fullPath });
           continue;
@@ -68904,7 +69172,7 @@ var FileManager = class {
         let isFile = entry.isFile();
         if (entry.isSymbolicLink()) {
           try {
-            const targetStat = fs20.statSync(fullPath);
+            const targetStat = fs21.statSync(fullPath);
             isDirectory = targetStat.isDirectory();
             isFile = targetStat.isFile();
           } catch {
@@ -68922,7 +69190,7 @@ var FileManager = class {
         if (!type) {
           continue;
         }
-        const stat2 = fs20.statSync(fullPath);
+        const stat2 = fs21.statSync(fullPath);
         listing.files.push({
           name: entry.name,
           path: fullPath,
@@ -68936,7 +69204,7 @@ var FileManager = class {
     return listing;
   }
   invalidateDirectoryListingCacheForPath(filePath) {
-    this.directoryListingCache.delete(path20.dirname(resolvePath2(filePath)));
+    this.directoryListingCache.delete(path21.dirname(resolvePath2(filePath)));
   }
   buildAuthFingerprint(apiKey) {
     return crypto2.createHash("sha256").update(apiKey).digest("hex").slice(0, 16);
@@ -68985,8 +69253,8 @@ function createFileManagerForModel(params) {
     sessionId: params.sessionId,
     platform: platform2,
     apiKey: params.apiKey,
-    baseDir: path21.join(params.configDir, "files"),
-    sessionsDir: path21.join(params.configDir, "sessions")
+    baseDir: path22.join(params.configDir, "files"),
+    sessionsDir: path22.join(params.configDir, "sessions")
   });
   switch (getFileManagerAdapterKind(platform2)) {
     case "kimi":
@@ -69021,15 +69289,15 @@ function isInlineMediaRequest(request) {
   return request.kind === "image" || request.kind === "video";
 }
 async function prepareInlineMediaContent(params) {
-  const stat2 = await fs21.stat(params.request.absolutePath);
+  const stat2 = await fs22.stat(params.request.absolutePath);
   const limitMb = getCapabilityLimitMb(params.model, params.request.kind);
   const limitBytes = limitMb * 1024 * 1024;
   if (stat2.size > limitBytes) {
     throw new Error(
-      `${params.request.kind} understanding for ${params.model.provider}/${params.model.id} supports inline files up to ${limitMb}MB; ${path21.basename(params.request.displayPath)} is ${(stat2.size / 1024 / 1024).toFixed(1)}MB. Configure a model with a file upload adapter, or compress/trim the file before reading it.`
+      `${params.request.kind} understanding for ${params.model.provider}/${params.model.id} supports inline files up to ${limitMb}MB; ${path22.basename(params.request.displayPath)} is ${(stat2.size / 1024 / 1024).toFixed(1)}MB. Configure a model with a file upload adapter, or compress/trim the file before reading it.`
     );
   }
-  const data = await fs21.readFile(params.request.absolutePath, "base64");
+  const data = await fs22.readFile(params.request.absolutePath, "base64");
   const content = params.request.kind === "video" ? [{ type: "video", data, mimeType: params.request.mimeType }] : [{ type: "image", data, mimeType: params.request.mimeType }];
   return {
     content,
@@ -69065,7 +69333,7 @@ async function prepareFileContent(configDir, params) {
   });
   if (params.request.kind === "document") {
     const upload2 = await manager.upload(params.request.absolutePath, {
-      sourceName: path21.basename(params.request.displayPath),
+      sourceName: path22.basename(params.request.displayPath),
       purpose: "file-extract"
     });
     await waitForReady({ manager, fileId: upload2.fileId, timeoutMs: 12e4, signal: params.request.signal });
@@ -69088,8 +69356,8 @@ async function prepareFileContent(configDir, params) {
       }
     };
   }
-  const upload = params.request.kind === "video" ? await manager.uploadVideo(params.request.absolutePath, { sourceName: path21.basename(params.request.displayPath), strategy: "compress" }) : await manager.upload(params.request.absolutePath, {
-    sourceName: path21.basename(params.request.displayPath),
+  const upload = params.request.kind === "video" ? await manager.uploadVideo(params.request.absolutePath, { sourceName: path22.basename(params.request.displayPath), strategy: "compress" }) : await manager.upload(params.request.absolutePath, {
+    sourceName: path22.basename(params.request.displayPath),
     purpose: params.request.kind === "image" ? "image" : "file-extract"
   });
   if (params.request.kind !== "video") {
@@ -69510,22 +69778,22 @@ var ExecutionStateManager = class {
 };
 
 // src/session-trace.ts
-import * as fs22 from "node:fs";
-import * as path22 from "node:path";
+import * as fs23 from "node:fs";
+import * as path23 from "node:path";
 function saveTraceFileBestEffort(tracePath, content) {
   const tempPath = `${tracePath}.${process.pid}.${Date.now()}.tmp`;
   try {
-    fs22.writeFileSync(tempPath, content, "utf8");
+    fs23.writeFileSync(tempPath, content, "utf8");
     try {
-      fs22.renameSync(tempPath, tracePath);
+      fs23.renameSync(tempPath, tracePath);
       return;
     } catch {
       try {
-        fs22.copyFileSync(tempPath, tracePath);
+        fs23.copyFileSync(tempPath, tracePath);
       } catch {
       } finally {
         try {
-          fs22.unlinkSync(tempPath);
+          fs23.unlinkSync(tempPath);
         } catch {
         }
       }
@@ -69538,16 +69806,16 @@ var SessionTraceWriter = class extends SessionTraceSnapshotWriter {
     super({
       getSessionId: () => sessionManager.getActiveSessionId(),
       loadTrace: (sessionId) => {
-        const tracePath = path22.join(sessionsDir, `${sessionId}.trace.json`);
-        if (!fs22.existsSync(tracePath)) return null;
+        const tracePath = path23.join(sessionsDir, `${sessionId}.trace.json`);
+        if (!fs23.existsSync(tracePath)) return null;
         try {
-          return JSON.parse(fs22.readFileSync(tracePath, "utf8"));
+          return JSON.parse(fs23.readFileSync(tracePath, "utf8"));
         } catch {
           return null;
         }
       },
       saveTrace: (trace) => {
-        const tracePath = path22.join(sessionsDir, `${trace.sessionId}.trace.json`);
+        const tracePath = path23.join(sessionsDir, `${trace.sessionId}.trace.json`);
         saveTraceFileBestEffort(tracePath, JSON.stringify(trace, null, 2));
       }
     });
@@ -69837,7 +70105,7 @@ function normalizeSessionTitle(raw) {
 }
 
 // src/components/extension-selector.ts
-import * as path23 from "node:path";
+import * as path24 from "node:path";
 var ExtensionSelectorComponent = class extends Container {
   selectList;
   shortcuts;
@@ -69893,8 +70161,8 @@ function selectRuntimeExtensionWinners(infos) {
   return reversed.reverse();
 }
 function unidentifiedLabel(info) {
-  const parentName = path23.basename(path23.dirname(info.entryPath));
-  const fileName = path23.basename(info.entryPath);
+  const parentName = path24.basename(path24.dirname(info.entryPath));
+  const fileName = path24.basename(info.entryPath);
   return `(unidentified) ${parentName || fileName}`;
 }
 var ExtensionEnablementSelectorComponent = class extends Container {
@@ -70442,7 +70710,7 @@ async function handleDebugPackageCommand(host) {
 import * as os6 from "os";
 
 // src/components/session-selector.ts
-import * as path24 from "node:path";
+import * as path25 from "node:path";
 function formatDate(timestamp) {
   const date = new Date(timestamp);
   const now = /* @__PURE__ */ new Date();
@@ -70473,7 +70741,7 @@ function getPathFlavor(value, peer) {
   return "posix";
 }
 function getPathApi(flavor) {
-  return flavor === "windows" ? path24.win32 : path24.posix;
+  return flavor === "windows" ? path25.win32 : path25.posix;
 }
 function normalizeForComparison(value, flavor) {
   const pathApi = getPathApi(flavor);
@@ -70630,102 +70898,37 @@ var SessionSelectorComponent = class extends Container {
 var RESET = "\x1B[0m";
 var INVERSE = "\x1B[7m";
 var DIM = "\x1B[2m";
-function visibleLength(str2) {
-  return visibleWidth(str2);
-}
+var searchSegmenter = new Intl.Segmenter(void 0, { granularity: "grapheme" });
 var TREE_CHARS = {
   branch: "\u251C\u2500\u2500 ",
   corner: "\u2514\u2500\u2500 ",
   pipe: "\u2502   ",
   space: "    ",
   active: "\u25CF ",
-  inactive: "\u25CB "
+  inactive: "\u25CB ",
+  /** Marks rows whose full ancestry is not visible in the window. */
+  hiddenAncestry: "\u2026"
 };
-function extractContent(entry) {
-  if (entry.type === "fork" && entry.forkData) {
-    return `fork from "${entry.forkData.name}"`;
-  }
-  if (entry.type === "compaction" && entry.compactionData) {
-    const firstLine = entry.compactionData.summary.split("\n").find((line) => line.trim().length > 0) ?? "context compacted";
-    return firstLine;
-  }
-  if (!entry.message) return "";
-  const msg = entry.message;
-  const extractTextFromContent = (content) => {
-    if (typeof content === "string") return content;
-    if (Array.isArray(content)) {
-      const parts = [];
-      for (const c of content) {
-        if (typeof c !== "object" || c === null) continue;
-        if ("type" in c) {
-          if (c.type === "text") {
-            parts.push(c.text || "");
-          } else if (c.type === "thinking") {
-            parts.push("(thinking...)");
-          } else if (c.type === "toolCall") {
-            const name = c.name || "tool";
-            parts.push(`[${name}]`);
-          }
-        }
-      }
-      return parts.join(" ");
-    }
-    return "";
-  };
-  if (msg.role === "user") {
-    return extractTextFromContent(msg.content) || "(empty)";
-  }
-  if (msg.role === "assistant") {
-    const textContent = extractTextFromContent(msg.content);
-    if (textContent) {
-      return textContent;
-    }
-    if (msg.stopReason === "aborted") {
-      return "(aborted)";
-    }
-    if (msg.errorMessage) {
-      return `(error: ${msg.errorMessage.slice(0, 50)})`;
-    }
-    return "(no content)";
-  }
-  if (msg.role === "toolResult") {
-    const content = msg.content;
-    let contentPreview = "";
-    if (Array.isArray(content)) {
-      const textParts = content.filter((c) => typeof c === "object" && c !== null && "type" in c && c.type === "text").map((c) => c.text || "").join("");
-      contentPreview = textParts.slice(0, 80);
-      if (textParts.length > 80) contentPreview += "...";
-    }
-    const toolName = msg.toolName || "tool";
-    if (contentPreview) {
-      return `[${toolName}]: ${contentPreview}`;
-    }
-    return `[${toolName}]`;
-  }
-  return `[${msg.role || "unknown"}]`;
-}
-function getRoleName(entry) {
-  if (entry.type === "fork") return "fork";
-  if (entry.type === "compaction") return "compact";
-  if (!entry.message) return "unknown";
-  const role = entry.message.role;
-  switch (role) {
-    case "user":
-      return "user";
-    case "assistant":
-      return "assistant";
-    case "toolResult":
-      return "tool";
-    default:
-      return role || "unknown";
-  }
-}
-function getRoleColor(role) {
+var MIN_PAGE_SIZE = 48;
+var MAX_PAGE_SIZE = 256;
+var SEGMENT_WIDTH = 4;
+var MIN_BODY_WIDTH = 12;
+var PREFIX_DEPTH_ABS_CAP = 24;
+var SEARCH_SCAN_PAGE_LIMIT = 16;
+var COLLAPSED_CAP = 256;
+function roleName(summary) {
+  if (summary.type === "fork") return "fork";
+  if (summary.type === "compaction") return "compact";
+  if (summary.type === "custom") return "custom";
+  return summary.role ?? "entry";
+}
+function roleColor(role) {
   switch (role) {
     case "user":
       return theme.fg("accent", role);
     case "assistant":
       return theme.fg("text", role);
+    case "toolResult":
     case "tool":
       return theme.fg("dim", role);
     case "fork":
@@ -70736,57 +70939,47 @@ function getRoleColor(role) {
       return theme.fg("muted", role);
   }
 }
+function seqFromEntryId(entryId) {
+  if (!entryId) return null;
+  const match = /^e(\d+)-/.exec(entryId);
+  if (!match) return null;
+  const seq = Number(match[1]);
+  return Number.isInteger(seq) && seq > 0 ? seq : null;
+}
 function createLine(content, width, isSelected) {
-  const normalized = content.replace(/[\r\n]+/g, " ").replace(/\s+/g, " ");
-  let line;
-  if (isSelected) {
-    line = INVERSE + normalized + RESET;
-  } else {
-    line = RESET + normalized;
-  }
-  const visibleLen = line.replace(/\x1b\[[0-9;]*m/g, "").length;
-  if (visibleLen < width) {
-    line += " ".repeat(width - visibleLen);
-  }
-  line += RESET;
-  return truncateToWidth(line, width);
+  const normalized = content.replace(/[\r\n]+/g, " ");
+  const body = isSelected ? INVERSE + normalized : normalized;
+  return truncateToWidth(body + RESET, width, "...", true);
 }
-function flattenTree(nodes, parentPrefixes = [], startIndex = 0) {
-  const result = [];
-  let currentIndex = startIndex;
-  for (let i = 0; i < nodes.length; i++) {
-    const node = nodes[i];
-    const isLast = i === nodes.length - 1;
-    result.push({
-      node,
-      depth: node.depth,
-      isLast,
-      parentPrefixes: [...parentPrefixes],
-      index: currentIndex++
-    });
-    if (node.children.length > 0) {
-      const childPrefix = isLast ? TREE_CHARS.space : TREE_CHARS.pipe;
-      const childItems = flattenTree(
-        node.children,
-        [...parentPrefixes, childPrefix],
-        currentIndex
-      );
-      result.push(...childItems);
-      currentIndex += childItems.length;
-    }
-  }
-  return result;
+function clampPrefixForDisplay(prefix, budget) {
+  if (budget <= 0) return "";
+  if (prefix.length <= budget) return prefix;
+  const keep = Math.floor((budget - 1) / SEGMENT_WIDTH) * SEGMENT_WIDTH;
+  return TREE_CHARS.hiddenAncestry + (keep > 0 ? prefix.slice(-keep) : "");
 }
 var TreeSelectorComponent = class {
-  tree;
-  flatItems = [];
-  filteredItems = [];
+  options;
+  /** The single resident window of headers (bounded by pageSize). */
+  pageSummaries = [];
+  totalEntries;
+  hasPrev = false;
+  hasNext = false;
+  rows = [];
+  filteredRows = [];
   selectedIndex = 0;
   maxVisibleLines;
+  pageSizeValue;
+  prefixDepthCap;
   filterMode = "all";
   searchQuery = "";
-  expandedNodes = /* @__PURE__ */ new Set();
-  // Node IDs that are expanded
+  statusMessage = null;
+  collapsed = /* @__PURE__ */ new Map();
+  // Bounded-memory instrumentation (tests/telemetry).
+  maxResidentHeadersSeen = 0;
+  maxPrefixCharsSeen = 0;
+  currentTotalPrefixChars = 0;
+  fetchCallCount = 0;
+  headersFetchedTotal = 0;
   onSelect;
   onCancel;
   _focused = false;
@@ -70796,189 +70989,387 @@ var TreeSelectorComponent = class {
   set focused(value) {
     this._focused = value;
   }
-  constructor(tree, terminalHeight, onSelect, onCancel, activeEntryId) {
-    this.maxVisibleLines = Math.max(15, Math.floor(terminalHeight * 0.6));
-    this.onSelect = onSelect;
-    this.onCancel = onCancel;
-    this.tree = tree;
-    this.expandActivePath(activeEntryId);
-    this.refreshFlatItems();
-    if (activeEntryId) {
-      const activeIndex = this.flatItems.findIndex(
-        (item) => item.node.id === activeEntryId
-      );
-      if (activeIndex >= 0) {
-        this.selectedIndex = activeIndex;
+  constructor(options) {
+    this.options = options;
+    this.totalEntries = options.totalEntries;
+    this.maxVisibleLines = Math.max(15, Math.floor(options.terminalHeight * 0.6));
+    this.pageSizeValue = Math.max(MIN_PAGE_SIZE, Math.min(MAX_PAGE_SIZE, this.maxVisibleLines * 3));
+    this.prefixDepthCap = Math.max(3, Math.min(PREFIX_DEPTH_ABS_CAP, this.maxVisibleLines));
+    this.onSelect = options.onSelect;
+    this.onCancel = options.onCancel;
+    if (options.totalEntries === 0) {
+      setTimeout(() => options.onCancel(), 100);
+      return;
+    }
+    const activeSeq = this.resolveActiveSeq() ?? options.totalEntries;
+    const afterSeq = Math.max(0, activeSeq - Math.floor(this.pageSizeValue / 2));
+    this.loadWindow(afterSeq);
+    this.selectNearestSeq(activeSeq);
+  }
+  /**
+   * Locate the active entry without loading bodies: prefer the commit
+   * sequence encoded in the entry id, then the deepest active-path seq
+   * (children always commit after parents, so the max is the active leaf).
+   */
+  resolveActiveSeq() {
+    const fromId = seqFromEntryId(this.options.activeEntryId);
+    if (fromId !== null) return fromId;
+    let deepest = 0;
+    for (const seq of this.options.activePathSeqs) {
+      if (seq > deepest) deepest = seq;
+    }
+    return deepest > 0 ? deepest : null;
+  }
+  /** Select the row whose seq equals `target`, else the nearest earlier row. */
+  selectNearestSeq(target) {
+    let chosen = -1;
+    for (let i = 0; i < this.filteredRows.length; i++) {
+      const seq = this.filteredRows[i].summary.seq;
+      if (seq === target) {
+        chosen = i;
+        break;
       }
-    } else if (this.flatItems.length > 0) {
-      this.selectedIndex = this.flatItems.length - 1;
+      if (seq < target) chosen = i;
     }
-    if (tree.length === 0) {
-      setTimeout(() => onCancel(), 100);
+    this.selectedIndex = chosen === -1 ? 0 : chosen;
+  }
+  /** Current resident header count (tests/telemetry; one window only). */
+  get loadedCount() {
+    return this.pageSummaries.length;
+  }
+  /** High-water mark of resident headers across the component lifetime. */
+  get maxResidentHeaders() {
+    return this.maxResidentHeadersSeen;
+  }
+  /** High-water mark of per-row prefix characters. */
+  get maxPrefixChars() {
+    return this.maxPrefixCharsSeen;
+  }
+  /** Sum of prefix characters across the current rows. */
+  get totalPrefixChars() {
+    return this.currentTotalPrefixChars;
+  }
+  /** Configured header window size. */
+  get pageSize() {
+    return this.pageSizeValue;
+  }
+  /** Number of fetchSummaries calls issued. */
+  get fetchCount() {
+    return this.fetchCallCount;
+  }
+  /** Cumulative headers returned by fetchSummaries (all pages ever fetched). */
+  get headersFetched() {
+    return this.headersFetchedTotal;
+  }
+  /** Current collapsed-id count (bounded by COLLAPSED_CAP). */
+  get collapsedCount() {
+    return this.collapsed.size;
+  }
+  /** Seq of the selected row, or null when nothing is selected. */
+  get selectedSeq() {
+    return this.filteredRows[this.selectedIndex]?.summary.seq ?? null;
+  }
+  /** First and last seq of the resident window, or null when empty. */
+  get windowSeqRange() {
+    if (this.pageSummaries.length === 0) return null;
+    return [this.pageSummaries[0].seq, this.pageSummaries[this.pageSummaries.length - 1].seq];
+  }
+  /**
+   * Fetch one window of headers and adopt it as the single resident page.
+   * The previous window is replaced (not merged), keeping residency at
+   * O(pageSize). `upperExclusiveSeq` trims overlap when paging backward;
+   * entries trimmed away still count toward hasNext so the forward
+   * direction never strands a short history behind a backward page.
+   * Returns false when the fetch adopted nothing (boundary/gap).
+   */
+  fetchWindow(afterSeq, upperExclusiveSeq) {
+    const page = this.options.fetchSummaries(afterSeq > 0 ? afterSeq : void 0, this.pageSizeValue);
+    this.fetchCallCount++;
+    this.headersFetchedTotal += page.summaries.length;
+    let summaries = page.summaries.length > this.pageSizeValue ? page.summaries.slice(0, this.pageSizeValue) : page.summaries;
+    let trimmedAway = 0;
+    if (upperExclusiveSeq !== null) {
+      const kept = summaries.filter((summary) => summary.seq < upperExclusiveSeq);
+      trimmedAway = summaries.length - kept.length;
+      summaries = kept;
+    }
+    this.hasNext = page.hasMore || trimmedAway > 0;
+    this.totalEntries = page.total;
+    if (summaries.length === 0) {
+      return false;
     }
+    this.pageSummaries = summaries;
+    this.maxResidentHeadersSeen = Math.max(this.maxResidentHeadersSeen, this.pageSummaries.length);
+    this.hasPrev = summaries[0].seq > 1;
+    this.rebuildRows();
+    return true;
   }
-  expandAll() {
-    const expand = (nodes) => {
-      for (const node of nodes) {
-        this.expandedNodes.add(node.id);
-        if (node.children.length > 0) {
-          expand(node.children);
-        }
+  loadWindow(afterSeq) {
+    this.fetchWindow(afterSeq, null);
+  }
+  /**
+   * Load the window immediately before the current one. Backs off (up to a
+   * few attempts) around seq gaps, then reports the oldest boundary.
+   */
+  goToPreviousPage() {
+    if (this.pageSummaries.length === 0 || !this.hasPrev) return false;
+    const firstSeq = this.pageSummaries[0].seq;
+    let back = Math.max(0, firstSeq - 1 - this.pageSizeValue);
+    for (let attempt = 0; attempt < 4; attempt++) {
+      if (this.fetchWindow(back, firstSeq)) {
+        this.selectedIndex = Math.max(0, this.filteredRows.length - 1);
+        return true;
       }
-    };
-    expand(this.tree);
+      if (back === 0) break;
+      back = Math.max(0, back - this.pageSizeValue);
+    }
+    this.hasPrev = false;
+    return false;
   }
-  expandActivePath(activeEntryId) {
-    const expandAll = (nodes) => {
-      for (const node of nodes) {
-        this.expandedNodes.add(node.id);
-        if (node.children.length > 0) {
-          expandAll(node.children);
-        }
+  /** Load the window immediately after the current one. */
+  goToNextPage() {
+    if (this.pageSummaries.length === 0 || !this.hasNext) return false;
+    const lastSeq = this.pageSummaries[this.pageSummaries.length - 1].seq;
+    let anchor = lastSeq;
+    for (let attempt = 0; attempt < 4; attempt++) {
+      if (this.fetchWindow(anchor, null)) {
+        this.selectedIndex = 0;
+        return true;
       }
-    };
-    expandAll(this.tree);
-  }
-  refreshFlatItems() {
-    const filterExpanded = (nodes) => {
-      return nodes.filter((node) => {
-        if (node.parentId === null) return true;
-        return this.expandedNodes.has(node.parentId);
-      }).map((node) => ({
-        ...node,
-        children: this.expandedNodes.has(node.id) ? filterExpanded(node.children) : []
-      }));
-    };
-    const visibleTree = filterExpanded(this.tree);
-    this.flatItems = flattenTree(visibleTree);
+      if (!this.hasNext) break;
+      anchor += this.pageSizeValue;
+    }
+    return false;
+  }
+  /**
+   * Iteratively flatten the resident window. Parents always commit before
+   * children, so one forward pass resolves in-window ancestry; an explicit
+   * stack (no recursion) emits DFS rows whose prefixes are capped to
+   * prefixDepthCap segments, so prefix memory stays O(rows).
+   */
+  rebuildRows() {
+    const count = this.pageSummaries.length;
+    const seqToIndex = /* @__PURE__ */ new Map();
+    const depth = new Int32Array(count);
+    const parentIndex = new Int32Array(count).fill(-1);
+    const childLists = new Array(count);
+    for (let i = 0; i < count; i++) {
+      const summary = this.pageSummaries[i];
+      seqToIndex.set(summary.seq, i);
+      const parent = summary.parentSeq === null ? -1 : seqToIndex.get(summary.parentSeq) ?? -1;
+      if (parent >= 0) {
+        depth[i] = depth[parent] + 1;
+        parentIndex[i] = parent;
+        const bucket = childLists[parent];
+        if (bucket) bucket.push(i);
+        else childLists[parent] = [i];
+      }
+    }
+    const capChars = this.prefixDepthCap * SEGMENT_WIDTH;
+    const capSegments = (segments) => segments.length > capChars ? segments.slice(segments.length - capChars) : segments;
+    const roots = [];
+    for (let i = 0; i < count; i++) {
+      if (parentIndex[i] === -1) roots.push(i);
+    }
+    const rows = [];
+    const stack = [];
+    for (let i = roots.length - 1; i >= 0; i--) {
+      stack.push({ index: roots[i], base: "", isLast: i === roots.length - 1 });
+    }
+    while (stack.length > 0) {
+      const item = stack.pop();
+      const summary = this.pageSummaries[item.index];
+      const rowDepth = depth[item.index];
+      const connector = rowDepth === 0 ? "" : item.isLast ? TREE_CHARS.corner : TREE_CHARS.branch;
+      const segments = capSegments(item.base + connector);
+      const ancestryHidden = rowDepth > this.prefixDepthCap || summary.parentSeq !== null && parentIndex[item.index] === -1;
+      const prefix = ancestryHidden ? TREE_CHARS.hiddenAncestry + segments : segments;
+      rows.push({
+        summary,
+        prefix,
+        hasChildren: summary.childCount > 0,
+        inWindowChildren: childLists[item.index] !== void 0
+      });
+      if (prefix.length > this.maxPrefixCharsSeen) this.maxPrefixCharsSeen = prefix.length;
+      if (this.collapsed.has(summary.id)) continue;
+      const children = childLists[item.index];
+      if (children === void 0) continue;
+      const childBase = capSegments(item.base + (item.isLast ? TREE_CHARS.space : TREE_CHARS.pipe));
+      for (let i = children.length - 1; i >= 0; i--) {
+        stack.push({ index: children[i], base: childBase, isLast: i === children.length - 1 });
+      }
+    }
+    this.rows = rows;
+    let totalPrefix = 0;
+    for (const row of rows) totalPrefix += row.prefix.length;
+    this.currentTotalPrefixChars = totalPrefix;
     this.applyFilter();
   }
   applyFilter() {
     if (!this.searchQuery && this.filterMode === "all") {
-      this.filteredItems = this.flatItems;
-      return;
-    }
-    const searchTokens = this.searchQuery.toLowerCase().split(/\s+/).filter(Boolean);
-    this.filteredItems = this.flatItems.filter((item) => {
-      const entry = item.node.entry;
-      if (this.filterMode === "user-only") {
-        if (entry.type !== "message" || entry.message?.role !== "user") {
+      this.filteredRows = this.rows;
+    } else {
+      const tokens = this.searchQuery.toLowerCase().split(/\s+/).filter(Boolean);
+      this.filteredRows = this.rows.filter((row) => {
+        if (this.filterMode === "user-only" && (row.summary.type !== "message" || row.summary.role !== "user")) {
           return false;
         }
-      }
-      if (searchTokens.length > 0) {
-        const text = extractContent(entry).toLowerCase();
-        const role = getRoleName(entry).toLowerCase();
-        return searchTokens.every(
-          (token) => text.includes(token) || role.includes(token)
-        );
-      }
-      return true;
-    });
-    this.selectedIndex = Math.max(
-      0,
-      Math.min(this.selectedIndex, this.filteredItems.length - 1)
-    );
+        if (tokens.length === 0) return true;
+        const text = `${row.summary.preview ?? ""} ${roleName(row.summary)} ${row.summary.customType ?? ""} ${row.summary.label ?? ""} ${row.summary.seq}`.toLowerCase();
+        return tokens.every((token) => text.includes(token));
+      });
+    }
+    this.selectedIndex = Math.max(0, Math.min(this.selectedIndex, this.filteredRows.length - 1));
   }
-  buildPrefix(item) {
-    const parts = [];
-    const prefixes = item.parentPrefixes;
-    const MAX_VISIBLE_DEPTH = 3;
-    if (prefixes.length > MAX_VISIBLE_DEPTH) {
-      parts.push("\u2026 ");
-      parts.push(...prefixes.slice(-MAX_VISIBLE_DEPTH));
+  moveUp() {
+    if (this.selectedIndex > 0) {
+      this.selectedIndex--;
+      this.statusMessage = null;
+      return;
+    }
+    if (this.goToPreviousPage()) {
+      this.statusMessage = null;
+      return;
+    }
+    this.selectedIndex = 0;
+    this.statusMessage = "at oldest entry";
+  }
+  moveDown() {
+    if (this.selectedIndex < this.filteredRows.length - 1) {
+      this.selectedIndex++;
+      this.statusMessage = null;
+      return;
+    }
+    if (this.goToNextPage()) {
+      this.statusMessage = null;
+      return;
+    }
+    this.statusMessage = this.filteredRows.length === 0 && this.searchQuery ? "no matches on this page - tab scans ahead" : "at latest entry";
+  }
+  pageNext() {
+    if (this.goToNextPage()) {
+      this.statusMessage = null;
+    } else {
+      this.statusMessage = this.pageSummaries.length === 0 ? "no entries" : "latest page";
+    }
+  }
+  pagePrev() {
+    if (this.goToPreviousPage()) {
+      this.statusMessage = null;
+    } else {
+      this.statusMessage = this.pageSummaries.length === 0 ? "no entries" : "oldest page";
+    }
+  }
+  /**
+   * Bounded "next match": step to the next in-page match, otherwise scan
+   * forward at most SEARCH_SCAN_PAGE_LIMIT pages per press. Never scans
+   * the whole history eagerly and never accumulates fetched pages.
+   */
+  findNextMatch() {
+    if (!this.searchQuery && this.filterMode === "all") {
+      this.pageNext();
+      return;
+    }
+    if (this.filteredRows.length > 1 && this.selectedIndex < this.filteredRows.length - 1) {
+      this.selectedIndex++;
+      this.statusMessage = null;
+      return;
+    }
+    let scanned = 0;
+    while (this.hasNext && scanned < SEARCH_SCAN_PAGE_LIMIT) {
+      if (!this.goToNextPage()) break;
+      scanned++;
+      if (this.filteredRows.length > 0) {
+        this.selectedIndex = 0;
+        this.statusMessage = scanned === 1 ? "match on next page" : `match ${scanned} pages ahead`;
+        return;
+      }
+    }
+    if (!this.hasNext) {
+      this.statusMessage = "no more matches - end of history";
     } else {
-      parts.push(...prefixes);
+      this.statusMessage = `no matches in next ${scanned} pages - tab to continue`;
     }
-    if (item.depth > 0) {
-      parts.push(item.isLast ? TREE_CHARS.corner : TREE_CHARS.branch);
+  }
+  toggleCollapse() {
+    const selected = this.filteredRows[this.selectedIndex];
+    if (!selected) return;
+    if (this.collapsed.has(selected.summary.id)) {
+      this.collapsed.delete(selected.summary.id);
+    } else {
+      if (this.collapsed.size >= COLLAPSED_CAP) {
+        const oldest = this.collapsed.keys().next().value;
+        if (oldest !== void 0) this.collapsed.delete(oldest);
+      }
+      this.collapsed.set(selected.summary.id, true);
     }
-    return parts.join("");
+    this.rebuildRows();
   }
   render(width) {
     const lines = [];
     const totalLines = this.maxVisibleLines + 5;
+    const range = this.windowSeqRange;
+    const rangeLabel = range === null ? "empty" : `seqs ${range[0]}-${range[1]} of ${this.totalEntries}`;
     lines.push(createLine("  Conversation Tree", width, false));
     lines.push(
       createLine(
-        "  \u2191\u2193:move  \u2190\u2192:page  e:expand/collapse  F:fork  Enter:navigate  Esc:cancel",
+        "  \u2191\u2193:move  \u2190\u2192:page  e:collapse  tab:next match  F:fork  Enter:navigate  Esc:cancel",
         width,
         false
       )
     );
     lines.push(
       createLine(
-        this.searchQuery ? `  Search: ${this.searchQuery}` : "  Type to search",
+        this.searchQuery ? `  Search: ${this.searchQuery} (${this.filteredRows.length} on this page, tab:next match)` : `  Type to search (${rangeLabel})`,
         width,
         false
       )
     );
-    lines.push(createLine("", width, false));
-    if (this.filteredItems.length === 0) {
-      for (let i = 0; i < this.maxVisibleLines; i++) {
+    lines.push(createLine(this.statusMessage ? `  ${this.statusMessage}` : "", width, false));
+    if (this.filteredRows.length === 0) {
+      const notice = this.searchQuery || this.filterMode === "user-only" ? "  (no matching entries on this page)" : "  (no entries)";
+      lines.push(createLine(notice, width, false));
+      for (let i = 1; i < this.maxVisibleLines; i++) {
         lines.push(createLine("", width, false));
       }
     } else {
-      this.selectedIndex = Math.max(
-        0,
-        Math.min(this.selectedIndex, this.filteredItems.length - 1)
-      );
+      this.selectedIndex = Math.max(0, Math.min(this.selectedIndex, this.filteredRows.length - 1));
       let startIndex = Math.max(
         0,
         Math.min(
           this.selectedIndex - Math.floor(this.maxVisibleLines / 2),
-          this.filteredItems.length - this.maxVisibleLines
+          this.filteredRows.length - this.maxVisibleLines
         )
       );
-      let endIndex = Math.min(
-        startIndex + this.maxVisibleLines,
-        this.filteredItems.length
-      );
+      const endIndex = Math.min(startIndex + this.maxVisibleLines, this.filteredRows.length);
       if (endIndex - startIndex < this.maxVisibleLines && startIndex > 0) {
         startIndex = Math.max(0, endIndex - this.maxVisibleLines);
       }
       for (let i = startIndex; i < endIndex; i++) {
-        const item = this.filteredItems[i];
-        const entry = item.node.entry;
-        const isSelected = i === this.selectedIndex;
-        const prefix = this.buildPrefix(item);
-        const findOriginalNode = (nodes, id) => {
-          for (const node of nodes) {
-            if (node.id === id) return node;
-            if (node.children.length > 0) {
-              const found = findOriginalNode(node.children, id);
-              if (found) return found;
-            }
-          }
-          return null;
-        };
-        const originalNode = findOriginalNode(this.tree, item.node.id);
-        const hasChildren = originalNode ? originalNode.children.length > 0 : false;
-        const isExpanded = this.expandedNodes.has(item.node.id);
-        const activeIndicator = item.node.isActive ? theme.fg("success", TREE_CHARS.active) : DIM + TREE_CHARS.inactive + RESET;
-        const expandIndicator = hasChildren ? isExpanded ? theme.fg("dim", "\u25BC ") : theme.fg("dim", "\u25B6 ") : "  ";
-        const roleName = getRoleName(entry);
-        const roleColored = getRoleColor(roleName);
-        const content = extractContent(entry);
-        const availableWidth = width - visibleLength(prefix) - visibleLength(activeIndicator) - visibleLength(expandIndicator) - visibleLength(roleColored) - 2;
-        const truncatedContent = availableWidth > 0 ? truncateToWidth(content, availableWidth) : "";
-        const lineContent = `${prefix}${activeIndicator}${expandIndicator}${roleColored}: ${truncatedContent}`;
-        lines.push(createLine(lineContent, width, isSelected));
-      }
-      const visibleCount = endIndex - startIndex;
-      for (let i = visibleCount; i < this.maxVisibleLines; i++) {
+        const row = this.filteredRows[i];
+        const activeIndicator = this.options.activePathSeqs.has(row.summary.seq) ? theme.fg("success", TREE_CHARS.active) : DIM + TREE_CHARS.inactive + RESET;
+        const expandIndicator = row.inWindowChildren ? theme.fg("dim", this.collapsed.has(row.summary.id) ? "\u25B6 " : "\u25BC ") : row.hasChildren ? theme.fg("dim", "\xB7\xB7") : "  ";
+        const role = roleColor(roleName(row.summary));
+        const indicatorWidth = visibleWidth(activeIndicator) + visibleWidth(expandIndicator) + visibleWidth(role) + 2;
+        const prefixBudget = Math.max(0, Math.min(Math.floor(width * 0.35), width - indicatorWidth - MIN_BODY_WIDTH));
+        const displayPrefix = clampPrefixForDisplay(row.prefix, prefixBudget);
+        const availableWidth = Math.max(0, width - visibleWidth(displayPrefix) - indicatorWidth);
+        const content = truncateToWidth(row.summary.preview ?? "", availableWidth);
+        lines.push(createLine(`${displayPrefix}${activeIndicator}${expandIndicator}${role}: ${content}`, width, i === this.selectedIndex));
+      }
+      for (let i = endIndex - startIndex; i < this.maxVisibleLines; i++) {
         lines.push(createLine("", width, false));
       }
-      const selectedItem = this.filteredItems[this.selectedIndex];
-      const activePath = selectedItem?.node.isActive ? " [active]" : "";
-      lines.push(
-        createLine(
-          `  (${this.selectedIndex + 1}/${this.filteredItems.length})${this.filterMode === "user-only" ? " [user]" : ""}${activePath}`,
-          width,
-          false
-        )
-      );
     }
+    const selectedRow = this.filteredRows[this.selectedIndex];
+    const activePath = selectedRow && this.options.activePathSeqs.has(selectedRow.summary.seq) ? " [active]" : "";
+    lines.push(
+      createLine(
+        `  (${selectedRow ? this.selectedIndex + 1 : 0}/${this.filteredRows.length})${this.filterMode === "user-only" ? " [user]" : ""}${activePath} \xB7 ${rangeLabel}`,
+        width,
+        false
+      )
+    );
     while (lines.length < totalLines) {
       lines.push(createLine("", width, false));
     }
@@ -70987,51 +71378,24 @@ var TreeSelectorComponent = class {
   handleInput(keyData) {
     const kb = getEditorKeybindings();
     if (kb.matches(keyData, "selectUp")) {
-      this.selectedIndex = Math.max(0, this.selectedIndex - 1);
+      this.moveUp();
     } else if (kb.matches(keyData, "selectDown")) {
-      this.selectedIndex = Math.min(
-        this.filteredItems.length - 1,
-        this.selectedIndex + 1
-      );
-    } else if (kb.matches(keyData, "cursorRight")) {
-      this.selectedIndex = Math.min(
-        this.filteredItems.length - 1,
-        this.selectedIndex + this.maxVisibleLines
-      );
-    } else if (kb.matches(keyData, "cursorLeft")) {
-      this.selectedIndex = Math.max(0, this.selectedIndex - this.maxVisibleLines);
+      this.moveDown();
+    } else if (kb.matches(keyData, "cursorRight") || kb.matches(keyData, "selectPageDown")) {
+      this.pageNext();
+    } else if (kb.matches(keyData, "cursorLeft") || kb.matches(keyData, "selectPageUp")) {
+      this.pagePrev();
     } else if (keyData === "e" || keyData === "E") {
-      const selected = this.filteredItems[this.selectedIndex];
-      if (selected) {
-        const findOriginalNode = (nodes, id) => {
-          for (const node of nodes) {
-            if (node.id === id) return node;
-            if (node.children.length > 0) {
-              const found = findOriginalNode(node.children, id);
-              if (found) return found;
-            }
-          }
-          return null;
-        };
-        const originalNode = findOriginalNode(this.tree, selected.node.id);
-        if (originalNode && originalNode.children.length > 0) {
-          if (this.expandedNodes.has(selected.node.id)) {
-            this.expandedNodes.delete(selected.node.id);
-          } else {
-            this.expandedNodes.add(selected.node.id);
-          }
-          this.refreshFlatItems();
-        }
-      }
+      this.toggleCollapse();
     } else if (kb.matches(keyData, "selectConfirm")) {
-      const selected = this.filteredItems[this.selectedIndex];
+      const selected = this.filteredRows[this.selectedIndex];
       if (selected && this.onSelect) {
-        this.onSelect(selected.node.id, "navigate");
+        this.onSelect(selected.summary.id, "navigate");
       }
     } else if (keyData === "f" || keyData === "F") {
-      const selected = this.filteredItems[this.selectedIndex];
+      const selected = this.filteredRows[this.selectedIndex];
       if (selected && this.onSelect) {
-        this.onSelect(selected.node.id, "fork");
+        this.onSelect(selected.summary.id, "fork");
       }
     } else if (kb.matches(keyData, "selectCancel")) {
       if (this.searchQuery) {
@@ -71040,12 +71404,15 @@ var TreeSelectorComponent = class {
       } else {
         this.onCancel?.();
       }
+    } else if (matchesKey(keyData, "tab")) {
+      this.findNextMatch();
     } else if (matchesKey(keyData, "ctrl+u")) {
       this.filterMode = this.filterMode === "user-only" ? "all" : "user-only";
       this.applyFilter();
     } else if (kb.matches(keyData, "deleteCharBackward")) {
       if (this.searchQuery.length > 0) {
-        this.searchQuery = this.searchQuery.slice(0, -1);
+        const last = searchSegmenter.segment(this.searchQuery).containing(this.searchQuery.length - 1);
+        this.searchQuery = this.searchQuery.slice(0, last?.index ?? 0);
         this.applyFilter();
       }
     } else {
@@ -71060,10 +71427,10 @@ var TreeSelectorComponent = class {
     }
   }
   invalidate() {
-    this.refreshFlatItems();
+    this.rebuildRows();
   }
   getSelectedEntryId() {
-    return this.filteredItems[this.selectedIndex]?.node.id ?? null;
+    return this.filteredRows[this.selectedIndex]?.summary.id ?? null;
   }
 };
 
@@ -71265,16 +71632,16 @@ var Diff = class {
       }
     }
   }
-  addToPath(path33, added, removed, oldPosInc, options) {
-    const last = path33.lastComponent;
+  addToPath(path34, added, removed, oldPosInc, options) {
+    const last = path34.lastComponent;
     if (last && !options.oneChangePerToken && last.added === added && last.removed === removed) {
       return {
-        oldPos: path33.oldPos + oldPosInc,
+        oldPos: path34.oldPos + oldPosInc,
         lastComponent: { count: last.count + 1, added, removed, previousComponent: last.previousComponent }
       };
     } else {
       return {
-        oldPos: path33.oldPos + oldPosInc,
+        oldPos: path34.oldPos + oldPosInc,
         lastComponent: { count: 1, added, removed, previousComponent: last }
       };
     }
@@ -71722,13 +72089,13 @@ function formatSize2(bytes) {
 }
 var DEFAULT_MAX_BYTES = 102400;
 var DEFAULT_MAX_LINES = 100;
-function shortenPath(path33) {
-  if (typeof path33 !== "string") return "";
+function shortenPath(path34) {
+  if (typeof path34 !== "string") return "";
   const home = os5.homedir();
-  if (path33.startsWith(home)) {
-    return `~${path33.slice(home.length)}`;
+  if (path34.startsWith(home)) {
+    return `~${path34.slice(home.length)}`;
   }
-  return path33;
+  return path34;
 }
 function replaceTabs(text) {
   return text.replace(/\t/g, "   ");
@@ -71738,6 +72105,18 @@ function str(value) {
   if (value == null) return "";
   return null;
 }
+function projectResultForDisplay(result) {
+  const content = result.content;
+  if (!Array.isArray(content) || !content.some((block) => typeof block?.data === "string" && block.data.length > 0)) {
+    return result;
+  }
+  return {
+    ...result,
+    content: content.map(
+      (block) => typeof block?.data === "string" && block.data.length > 0 ? { ...block, data: "" } : block
+    )
+  };
+}
 function partialStr(value, maxLen = 30) {
   if (typeof value === "string") {
     if (value.length === 0) return "...";
@@ -71772,7 +72151,7 @@ var ToolExecutionComponent = class extends Container {
     this.updateDisplay();
   }
   updateResult(result, isPartial = false) {
-    this.result = result;
+    this.result = projectResultForDisplay(result);
     this.isPartial = isPartial;
     this.updateDisplay();
   }
@@ -71811,14 +72190,14 @@ ${renderManageTodoListResult(this.result, { expanded: this.expanded }, theme)}`;
       }
     } else if (this.toolName === "read_file") {
       const rawPath = str(this.args?.file_path ?? this.args?.path);
-      const path33 = rawPath !== null ? shortenPath(rawPath) : null;
+      const path34 = rawPath !== null ? shortenPath(rawPath) : null;
       const offset = typeof this.args?.offset === "number" ? this.args.offset : void 0;
       const limit = typeof this.args?.limit === "number" ? this.args.limit : void 0;
       let pathDisplay;
-      if (path33 === null) {
+      if (path34 === null) {
         pathDisplay = invalidArg;
-      } else if (path33) {
-        pathDisplay = theme.fg("accent", path33);
+      } else if (path34) {
+        pathDisplay = theme.fg("accent", path34);
       } else {
         const partialPath = partialStr(this.args?.file_path ?? this.args?.path);
         pathDisplay = theme.fg("toolOutput", partialPath);
@@ -71865,12 +72244,12 @@ ${renderManageTodoListResult(this.result, { expanded: this.expanded }, theme)}`;
     } else if (this.toolName === "write_file") {
       const rawPath = str(this.args?.file_path ?? this.args?.path);
       const fileContent = str(this.args?.content);
-      const path33 = rawPath !== null ? shortenPath(rawPath) : null;
+      const path34 = rawPath !== null ? shortenPath(rawPath) : null;
       let pathDisplay;
-      if (path33 === null) {
+      if (path34 === null) {
         pathDisplay = invalidArg;
-      } else if (path33) {
-        pathDisplay = theme.fg("accent", path33);
+      } else if (path34) {
+        pathDisplay = theme.fg("accent", path34);
       } else {
         const partialPath = partialStr(this.args?.file_path ?? this.args?.path);
         pathDisplay = theme.fg("toolOutput", partialPath);
@@ -71907,12 +72286,12 @@ ${theme.fg("error", errorText)}`;
       }
     } else if (this.toolName === "edit_file") {
       const rawPath = str(this.args?.file_path ?? this.args?.path);
-      const path33 = rawPath !== null ? shortenPath(rawPath) : null;
+      const path34 = rawPath !== null ? shortenPath(rawPath) : null;
       let pathDisplay;
-      if (path33 === null) {
+      if (path34 === null) {
         pathDisplay = invalidArg;
-      } else if (path33) {
-        pathDisplay = theme.fg("accent", path33);
+      } else if (path34) {
+        pathDisplay = theme.fg("accent", path34);
       } else {
         const partialPath = partialStr(this.args?.file_path ?? this.args?.path);
         pathDisplay = theme.fg("toolOutput", partialPath);
@@ -71937,7 +72316,7 @@ ${theme.fg("error", errorText)}`;
         const diff = this.result.details.diff;
         const firstChangedLine = this.result.details.firstChangedLine;
         if (firstChangedLine) {
-          text = `${theme.fg("toolTitle", theme.bold("edit_file"))} ${theme.fg("accent", path33 || rawPath)}${theme.fg("warning", `:${firstChangedLine}`)}`;
+          text = `${theme.fg("toolTitle", theme.bold("edit_file"))} ${theme.fg("accent", path34 || rawPath)}${theme.fg("warning", `:${firstChangedLine}`)}`;
         }
         const lines = diff.split("\n");
         const maxLines = this.expanded ? lines.length : 15;
@@ -71957,7 +72336,7 @@ ${theme.fg("error", errorText)}`;
         const diff = generateEditDiff(oldText, newText, rawPath);
         const firstChangedLine = findFirstChangedLine(oldText, newText);
         if (firstChangedLine) {
-          text = `${theme.fg("toolTitle", theme.bold("edit_file"))} ${theme.fg("accent", path33 || rawPath)}${theme.fg("warning", `:${firstChangedLine}`)}`;
+          text = `${theme.fg("toolTitle", theme.bold("edit_file"))} ${theme.fg("accent", path34 || rawPath)}${theme.fg("warning", `:${firstChangedLine}`)}`;
         }
         const lines = diff.split("\n");
         const maxLines = this.expanded ? lines.length : 15;
@@ -71976,9 +72355,9 @@ ${theme.fg("error", errorText)}`;
       }
     } else if (this.toolName === "list_dir") {
       const rawPath = str(this.args?.path);
-      const path33 = rawPath !== null ? shortenPath(rawPath || ".") : null;
+      const path34 = rawPath !== null ? shortenPath(rawPath || ".") : null;
       const limit = this.args?.limit;
-      text = `${theme.fg("toolTitle", theme.bold("list_dir"))} ${path33 === null ? invalidArg : theme.fg("accent", path33)}`;
+      text = `${theme.fg("toolTitle", theme.bold("list_dir"))} ${path34 === null ? invalidArg : theme.fg("accent", path34)}`;
       if (limit !== void 0) {
         text += theme.fg("toolOutput", ` (limit ${limit})`);
       }
@@ -72014,9 +72393,9 @@ ${theme.fg("warning", `[Truncated: ${warnings.join(", ")}]`)}`;
     } else if (this.toolName === "find_files") {
       const pattern = str(this.args?.pattern);
       const rawPath = str(this.args?.path);
-      const path33 = rawPath !== null ? shortenPath(rawPath || ".") : null;
+      const path34 = rawPath !== null ? shortenPath(rawPath || ".") : null;
       const limit = this.args?.limit;
-      text = theme.fg("toolTitle", theme.bold("find_files")) + " " + (pattern === null ? invalidArg : theme.fg("accent", pattern || "")) + theme.fg("toolOutput", ` in ${path33 === null ? invalidArg : path33}`);
+      text = theme.fg("toolTitle", theme.bold("find_files")) + " " + (pattern === null ? invalidArg : theme.fg("accent", pattern || "")) + theme.fg("toolOutput", ` in ${path34 === null ? invalidArg : path34}`);
       if (limit !== void 0) {
         text += theme.fg("toolOutput", ` (limit ${limit})`);
       }
@@ -72052,10 +72431,10 @@ ${theme.fg("warning", `[Truncated: ${warnings.join(", ")}]`)}`;
     } else if (this.toolName === "grep_text") {
       const pattern = str(this.args?.pattern);
       const rawPath = str(this.args?.path);
-      const path33 = rawPath !== null ? shortenPath(rawPath || ".") : null;
+      const path34 = rawPath !== null ? shortenPath(rawPath || ".") : null;
       const glob = str(this.args?.glob);
       const limit = this.args?.limit;
-      text = theme.fg("toolTitle", theme.bold("grep_text")) + " " + (pattern === null ? invalidArg : theme.fg("accent", `/${pattern || ""}/`)) + theme.fg("toolOutput", ` in ${path33 === null ? invalidArg : path33}`);
+      text = theme.fg("toolTitle", theme.bold("grep_text")) + " " + (pattern === null ? invalidArg : theme.fg("accent", `/${pattern || ""}/`)) + theme.fg("toolOutput", ` in ${path34 === null ? invalidArg : path34}`);
       if (glob) {
         text += theme.fg("toolOutput", ` (${glob})`);
       }
@@ -72278,7 +72657,7 @@ async function handleResumeCommand(host) {
     return { component: selector, focus: selector.getSelectList() };
   });
 }
-async function loadSession2(host, sessionId) {
+async function loadSession(host, sessionId) {
   const beforeSwitch = await host.extensionRunner?.emitSessionBeforeSwitch({
     type: "session:before_switch",
     reason: "resume",
@@ -72475,29 +72854,31 @@ function setWaitingForUser(host, waiting) {
   syncTitleActivity(host);
 }
 async function handleTreeCommand(host) {
-  const entries = host.sessionManager.getEntries();
-  const tree = host.sessionManager.getTree();
-  if (tree.length === 0) {
-    host.showStatus(`No entries in current session (entries: ${entries.length})`);
+  const head = host.sessionManager.getEntrySummariesPage({ limit: 1 });
+  if (head.total === 0) {
+    host.showStatus(`No entries in current session (entries: 0)`);
     return;
   }
   host.showSelector((done) => {
     const selector = new TreeSelectorComponent(
-      tree,
-      host.ui.terminal.rows,
-      async (entryId, action) => {
-        done();
-        if (action === "fork") {
-          await host.forkAtEntry(entryId);
-        } else {
-          await host.navigateToEntry(entryId);
+      {
+        terminalHeight: host.ui.terminal.rows,
+        activeEntryId: host.sessionManager.getActiveEntryId(),
+        activePathSeqs: host.sessionManager.getActivePathSeqs(),
+        totalEntries: head.total,
+        fetchSummaries: (afterSeq, limit) => host.sessionManager.getEntrySummariesPage({ limit, afterSeq }),
+        onSelect: async (entryId, action) => {
+          done();
+          if (action === "fork") {
+            await host.forkAtEntry(entryId);
+          } else {
+            await host.navigateToEntry(entryId);
+          }
+        },
+        onCancel: () => {
+          done();
         }
-      },
-      () => {
-        done();
-      },
-      host.sessionManager.getActiveEntryId()
-      // Start at active entry
+      }
     );
     return { component: selector, focus: selector };
   });
@@ -72514,8 +72895,8 @@ async function forkAtEntry(host, entryId) {
       host.showError("Failed to branch at entry");
       return;
     }
-    const path33 = host.sessionManager.getPathToEntry(entryId);
-    const pathNames = path33.map((e) => e.message?.role || "entry").join(" \u2192 ");
+    const path34 = host.sessionManager.getPathSummaries(entryId);
+    const pathNames = path34.map((summary) => summary.role || summary.type).join(" \u2192 ");
     const messages = host.sessionManager.getMessages();
     host.syncAgentFromActiveSession(messages);
     await host.syncSessionScopedState(messages);
@@ -72528,7 +72909,7 @@ async function forkAtEntry(host, entryId) {
     host.updatePendingMessagesDisplay();
     host.renderMessageHistory(messages);
     await host.sessionManager.save();
-    host.showStatus(`Branched at: ${pathNames} (${path33.length} messages). Continue to add to this branch.`);
+    host.showStatus(`Branched at: ${pathNames} (${path34.length} messages). Continue to add to this branch.`);
   } catch (error) {
     host.showError(
       `Failed to branch: ${error instanceof Error ? error.message : String(error)}`
@@ -72556,10 +72937,10 @@ async function navigateToEntry(host, entryId) {
     host.sessionManager.save().catch((err) => {
       console.error("[Session] Save after navigation failed:", err);
     });
-    const path33 = host.sessionManager.getPathToEntry(entryId);
-    const entry = host.sessionManager.getEntry(entryId);
-    const role = entry?.message?.role || "entry";
-    host.showStatus(`Switched to branch: ${role} (${path33.length} messages in path)`);
+    const path34 = host.sessionManager.getPathSummaries(entryId);
+    const summary = host.sessionManager.getEntrySummary(entryId);
+    const role = summary?.role || summary?.type || "entry";
+    host.showStatus(`Switched to branch: ${role} (${path34.length} entries in path)`);
   } catch (error) {
     host.showError(
       `Failed to navigate: ${error instanceof Error ? error.message : String(error)}`
@@ -72654,9 +73035,9 @@ async function handleForkCommand(host) {
 }
 
 // src/commands/interactive-skill-commands.ts
-import * as fs23 from "fs";
+import * as fs24 from "fs";
 import * as os7 from "os";
-import * as path25 from "path";
+import * as path26 from "path";
 
 // src/commands/subagent-command.ts
 async function handleSubagentCommand(host, args) {
@@ -72793,9 +73174,9 @@ function handleSkillsCommand(host) {
   });
 }
 function discoverSkills(host) {
-  const builtinDir = path25.join(getBuiltinDir(), "skills");
-  const userDir = path25.join(os7.homedir(), ".pie", "skills");
-  const projectDir = path25.join(process.cwd(), ".pie", "skills");
+  const builtinDir = path26.join(getBuiltinDir(), "skills");
+  const userDir = path26.join(os7.homedir(), ".pie", "skills");
+  const projectDir = path26.join(process.cwd(), ".pie", "skills");
   return loadSkills({ dirs: buildSkillDirs({ builtinDir, userDir, projectDir, cwd: process.cwd() }) });
 }
 function listDiscoveredSkills(host) {
@@ -72927,7 +73308,7 @@ function expandSkillCommand(host, text) {
   const skill = host.skills.find((s) => s.name === skillName);
   if (!skill) return text;
   try {
-    const content = fs23.readFileSync(skill.filePath, "utf-8");
+    const content = fs24.readFileSync(skill.filePath, "utf-8");
     const body = host.stripFrontmatter(content).trim();
     const skillBlock = `<skill name="${skill.name}" location="${skill.filePath}">
 References are relative to ${skill.baseDir}.
@@ -72954,9 +73335,9 @@ async function handleSkillToggleCommand(host, args, enabled) {
     host.showError(`Usage: /skills/${enabled ? "enable" : "disable"} <name>`);
     return;
   }
-  const builtinDir = path25.join(getBuiltinDir(), "skills");
-  const userDir = path25.join(os7.homedir(), ".pie", "skills");
-  const projectDir = path25.join(process.cwd(), ".pie", "skills");
+  const builtinDir = path26.join(getBuiltinDir(), "skills");
+  const userDir = path26.join(os7.homedir(), ".pie", "skills");
+  const projectDir = path26.join(process.cwd(), ".pie", "skills");
   const discovered = loadSkills({ dirs: buildSkillDirs({ builtinDir, userDir, projectDir, cwd: process.cwd() }) }).skills;
   if (!discovered.some((skill) => skill.name === name)) {
     host.showError(`Skill not found: ${name}`);
@@ -73022,17 +73403,17 @@ async function handleSkillsCreate(host, args) {
     if (!description) {
       description = `Skill for ${name}`;
     }
-    const skillsDir = path25.join(os7.homedir(), ".pie", "skills");
-    const skillDir = path25.join(skillsDir, name);
-    const skillFile = path25.join(skillDir, "SKILL.md");
+    const skillsDir = path26.join(os7.homedir(), ".pie", "skills");
+    const skillDir = path26.join(skillsDir, name);
+    const skillFile = path26.join(skillDir, "SKILL.md");
     debugLog2(`Creating at: ${skillFile}`);
-    if (fs23.existsSync(skillDir)) {
+    if (fs24.existsSync(skillDir)) {
       host.showError(`Skill "${name}" already exists at ${skillDir}`);
       return;
     }
-    fs23.mkdirSync(skillDir, { recursive: true });
+    fs24.mkdirSync(skillDir, { recursive: true });
     const template = createSkillTemplate(name, description);
-    fs23.writeFileSync(skillFile, template, "utf-8");
+    fs24.writeFileSync(skillFile, template, "utf-8");
     debugLog2("Successfully created skill");
     host.chatContainer.addChild(new Spacer(1));
     host.chatContainer.addChild(new Text(theme.fg("accent", `\u2713 Created skill: ${name}`), 1, 0));
@@ -73968,8 +74349,7 @@ async function handleCompactCommand(host) {
       host.showStatus("Nothing to compact yet");
       return;
     }
-    const pathEntries = host.sessionManager.getPathToEntry(activeEntryId);
-    const firstKeptEntryId = findFirstKeptEntryId(pathEntries);
+    const firstKeptEntryId = findFirstKeptEntrySummaryId(host.sessionManager.getActiveContextSummaries());
     if (!firstKeptEntryId) {
       host.showStatus("Need at least one real user message before compacting");
       return;
@@ -74885,8 +75265,8 @@ function setupInteractiveEditorSubmitHandler(host) {
 }
 
 // src/input/interactive-file-pipeline.ts
-import * as fs26 from "fs";
-import * as path28 from "path";
+import * as fs27 from "fs";
+import * as path29 from "path";
 
 // src/components/file-picker.ts
 var FilePickerComponent = class extends Container {
@@ -75107,8 +75487,8 @@ var FilePickerComponent = class extends Container {
 };
 
 // src/files/commands/file-commands.ts
-import * as fs24 from "node:fs";
-import * as path26 from "node:path";
+import * as fs25 from "node:fs";
+import * as path27 from "node:path";
 var FileCommands = class {
   context;
   constructor(context) {
@@ -75124,11 +75504,11 @@ var FileCommands = class {
       return;
     }
     const filePath = resolvePath2(parsed.path);
-    if (!fs24.existsSync(filePath)) {
+    if (!fs25.existsSync(filePath)) {
       this.context.showError(`File not found: ${parsed.path}`);
       return;
     }
-    this.context.showStatus(`Uploading ${path26.basename(filePath)}...`);
+    this.context.showStatus(`Uploading ${path27.basename(filePath)}...`);
     try {
       const result = await this.context.fileManager.upload(filePath, {
         purpose: parsed.purpose,
@@ -75163,7 +75543,7 @@ var FileCommands = class {
       return;
     }
     const resolvedPath = resolvePath2(filePath);
-    if (!fs24.existsSync(resolvedPath)) {
+    if (!fs25.existsSync(resolvedPath)) {
       this.context.showError(`File not found: ${filePath}`);
       return;
     }
@@ -75194,7 +75574,7 @@ var FileCommands = class {
       return;
     }
     const resolvedPath = resolvePath2(parsed.path);
-    if (!fs24.existsSync(resolvedPath)) {
+    if (!fs25.existsSync(resolvedPath)) {
       this.context.showError(`File not found: ${parsed.path}`);
       return;
     }
@@ -75672,8 +76052,8 @@ var FileStatusMonitor = class {
 };
 
 // src/files/mention/mention-handler.ts
-import * as fs25 from "node:fs";
-import * as path27 from "node:path";
+import * as fs26 from "node:fs";
+import * as path28 from "node:path";
 var MentionHandler = class {
   fileManager;
   onShowPicker;
@@ -75728,7 +76108,7 @@ var MentionHandler = class {
   navigateBrowseParent() {
     const currentDir = this.getBrowserDirectory();
     if (!currentDir) return;
-    const parentDir = path27.dirname(currentDir);
+    const parentDir = path28.dirname(currentDir);
     if (parentDir === currentDir) return;
     this.browsingDirectory = parentDir;
     this.showMentionPicker("");
@@ -75748,7 +76128,7 @@ var MentionHandler = class {
     if (option.type === "parent") {
       const currentDir = this.getBrowserDirectory();
       if (currentDir) {
-        this.browsingDirectory = path27.dirname(currentDir);
+        this.browsingDirectory = path28.dirname(currentDir);
         this.showMentionPicker("");
         this.isPickerVisible = true;
       }
@@ -75888,7 +76268,7 @@ var MentionHandler = class {
         id: part.content,
         name: part.name || fileInfo.name,
         mimeType: fileInfo.mimeType,
-        ext: path27.extname(part.name || fileInfo.name).toLowerCase(),
+        ext: path28.extname(part.name || fileInfo.name).toLowerCase(),
         size: fileInfo.size,
         source: fileInfo.platforms.length > 0 ? "session" : "local",
         fileId: part.content,
@@ -76046,11 +76426,11 @@ var MentionHandler = class {
     }
     if (this.isPath(query)) {
       const resolvedPath = resolvePath2(query);
-      if (fs25.existsSync(resolvedPath)) {
-        const stats = fs25.statSync(resolvedPath);
+      if (fs26.existsSync(resolvedPath)) {
+        const stats = fs26.statSync(resolvedPath);
         if (stats.isFile()) {
           const type = FileCache.getFileTypeFromName(resolvedPath);
-          const name = path27.basename(resolvedPath);
+          const name = path28.basename(resolvedPath);
           if (!seenNames.has(name.toLowerCase())) {
             options.push({
               type: "upload",
@@ -76071,16 +76451,16 @@ var MentionHandler = class {
       return void 0;
     }
     const queryPath = this.isPath(query) ? resolvePath2(query) : void 0;
-    const filter = queryPath ? fs25.existsSync(queryPath) && fs25.statSync(queryPath).isDirectory() ? "" : path27.basename(queryPath) : query;
+    const filter = queryPath ? fs26.existsSync(queryPath) && fs26.statSync(queryPath).isDirectory() ? "" : path28.basename(queryPath) : query;
     const entries = this.fileManager.listPathEntries(currentDir, filter);
     const options = [];
     const homeDir = process.env.HOME || "";
     const displayDir = currentDir.startsWith(homeDir) ? `~${currentDir.slice(homeDir.length)}` : currentDir;
-    if (path27.dirname(currentDir) !== currentDir) {
+    if (path28.dirname(currentDir) !== currentDir) {
       options.push({
         type: "parent",
         name: "..",
-        path: path27.dirname(currentDir),
+        path: path28.dirname(currentDir),
         icon: "\u21A9",
         meta: "Parent directory"
       });
@@ -76112,10 +76492,10 @@ var MentionHandler = class {
   getBrowserDirectory(query = this.currentQuery) {
     if (this.isPath(query)) {
       const resolvedPath = resolvePath2(query);
-      if (fs25.existsSync(resolvedPath) && fs25.statSync(resolvedPath).isDirectory()) {
+      if (fs26.existsSync(resolvedPath) && fs26.statSync(resolvedPath).isDirectory()) {
         return resolvedPath;
       }
-      return path27.dirname(resolvedPath);
+      return path28.dirname(resolvedPath);
     }
     return this.browsingDirectory;
   }
@@ -76202,8 +76582,8 @@ async function initializeFileManager(host) {
     sessionId,
     platform: platform2,
     apiKey: host.options.apiKey,
-    baseDir: path28.join(host.options.configDir, "files"),
-    sessionsDir: path28.join(host.options.configDir, "sessions")
+    baseDir: path29.join(host.options.configDir, "files"),
+    sessionsDir: path29.join(host.options.configDir, "sessions")
   });
   switch (getFileManagerAdapterKind(platform2)) {
     case "kimi":
@@ -76483,13 +76863,13 @@ function convertPreparedAttachmentItems(items) {
         break;
       case "image": {
         if (!item.data && !item.path) return void 0;
-        const data = item.data ?? fs26.readFileSync(item.path, "base64");
+        const data = item.data ?? fs27.readFileSync(item.path, "base64");
         converted.push({ type: "image", data, mimeType: item.mimeType });
         break;
       }
       case "video": {
         if (!item.data && !item.path) return void 0;
-        const data = item.data ?? fs26.readFileSync(item.path, "base64");
+        const data = item.data ?? fs27.readFileSync(item.path, "base64");
         converted.push({ type: "video", data, mimeType: item.mimeType });
         break;
       }
@@ -77075,8 +77455,7 @@ async function createCliAutoCompactionResult(params) {
   if (!activeEntryId) {
     return { aborted: true };
   }
-  const pathEntries = params.context.sessionManager.getPathToEntry(activeEntryId);
-  const firstKeptEntryId = findFirstKeptEntryId(pathEntries);
+  const firstKeptEntryId = findFirstKeptEntrySummaryId(params.context.sessionManager.getActiveContextSummaries());
   if (!firstKeptEntryId) {
     return { aborted: true };
   }
@@ -77638,11 +78017,11 @@ var HierarchicalSelectorComponent = class extends Container {
 // src/runtime/interactive-ui-helpers.ts
 function showHierarchicalMenu(host, initialPath = []) {
   const basePath = [...initialPath];
-  const showAtPath = (path33) => {
+  const showAtPath = (path34) => {
     host.showSelector((done) => {
       const selector = new HierarchicalSelectorComponent({
         tree: commandTree,
-        path: path33,
+        path: path34,
         basePath,
         onNavigate: (newPath) => {
           done();
@@ -77650,7 +78029,7 @@ function showHierarchicalMenu(host, initialPath = []) {
         },
         onSelect: async (selectedPath, node, searchArgs) => {
           if (node.handler) {
-            const args = searchArgs || (selectedPath.length > path33.length ? selectedPath.slice(path33.length).join(" ") : void 0);
+            const args = searchArgs || (selectedPath.length > path34.length ? selectedPath.slice(path34.length).join(" ") : void 0);
             const commandPath = "/" + selectedPath.join("/");
             if (!args && host.isInteractiveCommand(commandPath)) {
               done();
@@ -77904,6 +78283,18 @@ async function prepareAgentTurn(host, context) {
   };
 }
 function createInteractiveAgentSessionController(host) {
+  try {
+    recoverInterruptedPublishes({
+      sessionsDir: getSessionsDir(),
+      warn: (message) => {
+        console.warn(message);
+        if (typeof host.appendWarningSummary === "function") {
+          host.appendWarningSummary(message);
+        }
+      }
+    });
+  } catch {
+  }
   let retryElapsedTicker;
   let retryElapsedStartedAt = 0;
   const stopRetryElapsedTicker = () => {
@@ -77963,8 +78354,7 @@ function createInteractiveAgentSessionController(host) {
           return { aborted: true };
         }
         if (beforeCompact?.summary) {
-          const activeEntryId = context.sessionManager.getActiveEntryId();
-          const firstKeptEntryId = activeEntryId ? findFirstKeptEntryId(context.sessionManager.getPathToEntry(activeEntryId)) : void 0;
+          const firstKeptEntryId = findFirstKeptEntrySummaryId(context.sessionManager.getActiveContextSummaries());
           if (!firstKeptEntryId) return { aborted: true };
           return { summary: beforeCompact.summary, firstKeptEntryId };
         }
@@ -78138,6 +78528,14 @@ function createInteractiveAgentSessionController(host) {
           return;
         }
         host.resetFileObservationState();
+        if (!event.result?.aborted) {
+          host.streamingComponent = void 0;
+          host.pendingTools.clear();
+          host.chatContainer.clear();
+          host.lastStatusSpacer = void 0;
+          host.lastStatusText = void 0;
+          host.renderMessageHistory(host.sessionManager.getMessages());
+        }
         const contextUsage = host.calculateContextUsage();
         const contextWindow = host.options.model?.contextWindow ?? 0;
         const contextPercent = contextWindow > 0 && contextUsage.tokens !== null ? contextUsage.tokens / contextWindow * 100 : 0;
@@ -79093,8 +79491,8 @@ async function loadInteractiveExtensions(host) {
   host.extensionRunner.setUIContext(host.extensionUIContext);
   await restoreExtensionProviderCredentials(host.options.modelRegistry);
   if (process.env.PIE_VERBOSE) {
-    for (const { path: path33, error } of errors) {
-      console.error(`[Extension] Failed to load ${path33}: ${error}`);
+    for (const { path: path34, error } of errors) {
+      console.error(`[Extension] Failed to load ${path34}: ${error}`);
     }
   }
   const extensionTools = filterEnabledTools(convertExtensionTools(extensions), host.options.settingsManager);
@@ -79464,8 +79862,8 @@ var InteractiveMode = class {
   waitForAgentIdle() {
     return this.agentSessionController.waitForIdle();
   }
-  replaceAgentMessagesAndMarkSynced(messages, options) {
-    this.agentSessionController.replaceMessagesAndMarkSynced(messages, options);
+  replaceAgentMessagesAndMarkSynced(messages) {
+    this.agentSessionController.replaceMessagesAndMarkSynced(messages);
     this.lastSyncedMessageCount = this.agentSessionController.syncedMessageCount;
   }
   syncAgentFromActiveSession(messages) {
@@ -79493,7 +79891,7 @@ var InteractiveMode = class {
   async init() {
     const activeSession = this.sessionManager.getActiveSession();
     this.thinkingLevel = resolveInitialThinkingLevel({ session: activeSession, settingsManager: this.options.settingsManager });
-    const { Agent } = await import("./chunks/src-QSP2OPHU.js");
+    const { Agent } = await import("./chunks/src-SXUQ7OY6.js");
     this.agent = new Agent({
       initialState: {
         systemPrompt: this.buildSystemPrompt(),
@@ -79603,9 +80001,9 @@ var InteractiveMode = class {
     if (this.isProcessing) {
       throw new Error("Cannot reload while a response is being processed. Wait for the turn to finish or abort it first.");
     }
-    const builtinDir = path29.join(getBuiltinDir(), "skills");
-    const userDir = path29.join(os8.homedir(), ".pie", "skills");
-    const projectDir = path29.join(this.options.cwd, ".pie", "skills");
+    const builtinDir = path30.join(getBuiltinDir(), "skills");
+    const userDir = path30.join(os8.homedir(), ".pie", "skills");
+    const projectDir = path30.join(this.options.cwd, ".pie", "skills");
     const { skills, diagnostics } = loadSkills({
       dirs: buildSkillDirs({ builtinDir, userDir, projectDir, cwd: this.options.cwd })
     });
@@ -79767,7 +80165,7 @@ var InteractiveMode = class {
     return handleResumeCommand(this);
   }
   async loadSession(sessionId) {
-    return loadSession2(this, sessionId);
+    return loadSession(this, sessionId);
   }
   updateTerminalTitle() {
     return updateTerminalTitle(this);
@@ -79908,8 +80306,8 @@ var InteractiveMode = class {
 };
 
 // src/app/runtime-composition.ts
-import { existsSync as existsSync18, mkdirSync as mkdirSync13 } from "fs";
-import * as path30 from "path";
+import { existsSync as existsSync19, mkdirSync as mkdirSync14 } from "fs";
+import * as path31 from "path";
 var CliMissingApiKeyError = class extends Error {
   constructor(message) {
     super(message);
@@ -79930,13 +80328,13 @@ var CliSessionResumeError = class extends Error {
 function getCliRuntimePaths() {
   const configDir = getConfigDir();
   const sessionsDir = getSessionsDir();
-  const skillsDir = path30.join(configDir, "skills");
-  const builtinSkillsDir = path30.join(getBuiltinDir(), "skills");
+  const skillsDir = path31.join(configDir, "skills");
+  const builtinSkillsDir = path31.join(getBuiltinDir(), "skills");
   return { configDir, sessionsDir, skillsDir, builtinSkillsDir };
 }
 function ensureCliRuntimePaths(paths = getCliRuntimePaths()) {
-  if (!existsSync18(paths.skillsDir)) {
-    mkdirSync13(paths.skillsDir, { recursive: true });
+  if (!existsSync19(paths.skillsDir)) {
+    mkdirSync14(paths.skillsDir, { recursive: true });
   }
   return paths;
 }
@@ -80051,7 +80449,7 @@ async function composeCliRuntime(params) {
   fileLogger.log("cli", `Using API key for provider ${provider}`, {
     keyPrefix: apiKey ? maskApiKey2(apiKey) : "none"
   });
-  const projectSkillsDir = path30.join(cwd, ".pie", "skills");
+  const projectSkillsDir = path31.join(cwd, ".pie", "skills");
   const { skills: discoveredSkills, diagnostics } = loadSkills({
     dirs: buildSkillDirs({
       builtinDir: paths.builtinSkillsDir,
@@ -80326,7 +80724,7 @@ async function runPrintMode(params) {
 `);
     console.log("Assistant: ");
   }
-  const { Agent: AgentClass } = await import("./chunks/src-QSP2OPHU.js");
+  const { Agent: AgentClass } = await import("./chunks/src-SXUQ7OY6.js");
   let agent;
   const printModeExtensions = await loadPrintModeExtensions({
     cwd: runtime.cwd,
@@ -80414,7 +80812,7 @@ async function runPrintMode(params) {
         if (beforeCompact.cancel) return { aborted: true };
         if (beforeCompact.summary) {
           const activeEntryId = context.sessionManager.getActiveEntryId();
-          const firstKeptEntryId = activeEntryId ? findFirstKeptEntryId(context.sessionManager.getPathToEntry(activeEntryId)) : void 0;
+          const firstKeptEntryId = activeEntryId ? findFirstKeptEntrySummaryId(context.sessionManager.getActiveContextSummaries()) : void 0;
           if (!firstKeptEntryId) return { aborted: true };
           return { summary: beforeCompact.summary, firstKeptEntryId };
         }
@@ -80804,6 +81202,7 @@ async function runJsonEventsMode(params) {
   let thinkingLevelInitialized = false;
   let defaultRuntime;
   let defaultModelState;
+  let publishRecoveryDone = false;
   const completedSessionControlRequests = /* @__PURE__ */ new Map();
   const completedSidechatRequests = /* @__PURE__ */ new Map();
   const ensureRuntimeInFlight = /* @__PURE__ */ new Map();
@@ -80893,12 +81292,22 @@ async function runJsonEventsMode(params) {
     metadata.rootEntryId = existing?.rootEntryId ?? rootEntryId;
     return metadata;
   }
-  async function persistMockTurn(message, assistantText) {
+  function persistMockTurn(message, assistantText) {
     const store = new FileSessionStore(getSessionsDir());
-    const existing = await store.load(message.sessionId ?? sessionId);
+    const targetSessionId = message.sessionId ?? sessionId;
+    const status = store.headStatus(targetSessionId);
+    if (status === "legacy") {
+      throw new SessionControlError("session_unsupported_format", `Session uses an unsupported old format: ${targetSessionId}`);
+    }
+    if (status === "corrupt") {
+      throw new SessionControlError("session_unrecoverable", `Session could not be recovered: ${targetSessionId}`);
+    }
+    const existing = store.readHead(targetSessionId);
+    if (existing) store.createHead(targetSessionId, { name: void 0, createdAt: existing.metadata.createdAt });
     const startedAt = activeTurn?.startedAt ?? Date.now();
-    const userEntryId = generateEntryId();
-    const assistantEntryId = generateEntryId();
+    const baseSeq = existing?.committedSeq ?? store.readHead(targetSessionId)?.committedSeq ?? 0;
+    const userEntryId = generateEntryId(baseSeq + 1);
+    const assistantEntryId = generateEntryId(baseSeq + 2);
     const parentId = existing?.metadata.activeEntryId ?? null;
     const userEntry = {
       id: userEntryId,
@@ -80936,10 +81345,13 @@ async function runJsonEventsMode(params) {
       timestamp: assistantTimestamp,
       message: assistantMessage
     };
-    const entries = [...existing?.entries ?? [], userEntry, assistantEntry];
-    await store.save(
-      message.sessionId ?? sessionId,
-      entries,
+    if (!existing) {
+      store.createHead(targetSessionId);
+    }
+    store.appendEntries(
+      targetSessionId,
+      [userEntry, assistantEntry],
+      assistantEntryId,
       persistedMockMetadata(existing?.metadata, assistantEntryId, existing?.metadata.rootEntryId ?? userEntryId, message.cwd)
     );
     return assistantEntryId;
@@ -80962,7 +81374,7 @@ async function runJsonEventsMode(params) {
     };
   }
   function errorToFailureDetail(error) {
-    if (error instanceof CliSessionResumeError) {
+    if (error instanceof CliSessionResumeError || error instanceof SessionControlError) {
       return {
         message: error.message,
         code: error.code,
@@ -80972,7 +81384,10 @@ async function runJsonEventsMode(params) {
     return error instanceof Error ? error.message : String(error);
   }
   function sessionControlStore() {
-    return new FileSessionStore(runtime?.paths.sessionsDir ?? getSessionsDir());
+    return new FileSessionStore(sessionControlSessionsDir());
+  }
+  function sessionControlSessionsDir() {
+    return runtime?.paths.sessionsDir ?? getSessionsDir();
   }
   function invalidSessionControl(message) {
     return new SessionControlError("invalid_request", message);
@@ -81081,6 +81496,7 @@ async function runJsonEventsMode(params) {
       await saveRuntimeSessionForControl();
       const result = await forkStoredSession({
         store: sessionControlStore(),
+        sessionsDir: sessionControlSessionsDir(),
         sourceSessionId: controlSessionId,
         sourceEntryId,
         targetSessionId,
@@ -81168,7 +81584,7 @@ async function runJsonEventsMode(params) {
         return;
       }
       const parent = agent;
-      const { Agent: AgentClass } = await import("./chunks/src-QSP2OPHU.js");
+      const { Agent: AgentClass } = await import("./chunks/src-SXUQ7OY6.js");
       const sideAgent = new AgentClass({
         initialState: {
           systemPrompt: parent.state.systemPrompt,
@@ -81495,6 +81911,16 @@ async function runJsonEventsMode(params) {
     if (!runtime) {
       throw new Error("JSON events mode requires a CLI runtime");
     }
+    if (!publishRecoveryDone) {
+      publishRecoveryDone = true;
+      try {
+        recoverInterruptedPublishes({
+          sessionsDir: runtime.paths.sessionsDir ?? getSessionsDir(),
+          warn: (message) => console.warn(message)
+        });
+      } catch {
+      }
+    }
     if (defaultRuntime !== runtime) {
       defaultRuntime = runtime;
       defaultModelState = configuredDefaultModelState(runtime);
@@ -81502,7 +81928,7 @@ async function runJsonEventsMode(params) {
     if (runtime.initialModel.unconfigured || controller) {
       return;
     }
-    const { Agent: AgentClass } = await import("./chunks/src-QSP2OPHU.js");
+    const { Agent: AgentClass } = await import("./chunks/src-SXUQ7OY6.js");
     const jsonModeExtensions = await loadJsonModeExtensions({ runtime, getAgent: () => agent });
     extensionRunner = jsonModeExtensions.runner;
     const tools = [...runtime.tools, ...jsonModeExtensions.extensionTools];
@@ -81695,9 +82121,9 @@ async function runJsonEventsMode(params) {
       }
       display(params.mockResponse);
       try {
-        mockActiveEntryId = await persistMockTurn(message, params.mockResponse);
+        mockActiveEntryId = persistMockTurn(message, params.mockResponse);
       } catch (error) {
-        finalize("failed", error instanceof Error ? error.message : String(error));
+        finalize("failed", errorToFailureDetail(error));
         if (activeTurn === turn) emitSettled(turn);
         if (activeTurn === turn) activeTurn = null;
         return;
@@ -81965,19 +82391,19 @@ async function runJsonEventsMode(params) {
 }
 
 // src/developer-instructions.ts
-import * as fs27 from "fs";
-import * as path31 from "path";
+import * as fs28 from "fs";
+import * as path32 from "path";
 var MAX_DEVELOPER_INSTRUCTIONS_CHARS = 64e3;
 function readTextFileBounded(filePath) {
-  const resolved = path31.resolve(filePath);
-  const stat2 = fs27.statSync(resolved);
+  const resolved = path32.resolve(filePath);
+  const stat2 = fs28.statSync(resolved);
   if (!stat2.isFile()) {
     throw new Error(`Developer instructions file is not a regular file: ${filePath}`);
   }
   if (stat2.size > MAX_DEVELOPER_INSTRUCTIONS_CHARS * 4) {
     throw new Error(`Developer instructions file is too large: ${filePath}`);
   }
-  return fs27.readFileSync(resolved, "utf8");
+  return fs28.readFileSync(resolved, "utf8");
 }
 function collectFlagValues(args, flag) {
   const values = [];
@@ -82056,8 +82482,8 @@ var logError = (msg, err) => {
   const logPath = getRuntimeLogPath();
   const timestamp = (/* @__PURE__ */ new Date()).toISOString();
   const stack = err instanceof Error ? err.stack || "" : "";
-  fs28.mkdirSync(path32.dirname(logPath), { recursive: true });
-  fs28.appendFileSync(logPath, `[${timestamp}] ${msg}
+  fs29.mkdirSync(path33.dirname(logPath), { recursive: true });
+  fs29.appendFileSync(logPath, `[${timestamp}] ${msg}
 ${stack}
 
 `);
@@ -82091,7 +82517,7 @@ async function runWithJsonEventsConsoleIsolation(fn) {
 }
 async function createCliTestStreamFnFromEnv() {
   if (!process.env.PIE_TEST_MOCK_STREAM_SEQUENCE) return void 0;
-  return (await import("./chunks/test-stream-CVGWFLSX.js")).createTestStreamFnFromSequenceEnv();
+  return (await import("./chunks/test-stream-OD3B57AS.js")).createTestStreamFnFromSequenceEnv();
 }
 function resolveJsonEventsDetailFlag() {
   for (let index = 0; index < process.argv.length; index += 1) {