@cydm/pie 1.0.19 → 1.0.20

package/dist/cli.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
 import {
+  VERSION,
   createCliHostCapabilities,
   createCliWebResearchHealthStore,
   getAgentDir,
@@ -14,11 +15,12 @@ import {
   getSettingsPath,
   getThemesDir,
   migrateConfigFromAgentDir
-} from "./chunks/chunk-KZ54RSWP.js";
+} from "./chunks/chunk-ZYOTRKU7.js";
 import {
   AGENTS_CONTEXT_FILE_NAME,
   AgentSessionController,
   BUILTIN_TOOL_CAPABILITY_METADATA,
+  FileSessionStore,
   SessionTraceSnapshotWriter,
   abortExecutionState,
   attachAgentEventsToSessionTrace,
@@ -45,6 +47,7 @@ import {
   evaluateTodoClosureAfterFailedTurn,
   findFirstKeptEntryId,
   formatSkillSummariesForPrompt,
+  generateEntryId,
   getAutoCompactTokenLimit,
   hasInteractionHandler,
   maybeAdvanceTodoExecutionState,
@@ -56,8 +59,8 @@ import {
   selectToolsForRuntimePolicy,
   shouldPreserveExecutionStateForUserText,
   supersedeExecutionState
-} from "./chunks/chunk-GZVSE44O.js";
-import "./chunks/chunk-2R3XTLE2.js";
+} from "./chunks/chunk-NHR6EBM2.js";
+import "./chunks/chunk-L5BJNCNG.js";
 import {
   Deref,
   Errors,
@@ -91,7 +94,7 @@ import {
   setLogger,
   sortToolModelCandidatesByCapability,
   type_exports
-} from "./chunks/chunk-Q2N6B5JN.js";
+} from "./chunks/chunk-VESPMEDG.js";
 import {
   resolveCliProjectRoot
 } from "./chunks/chunk-NTYHFBUA.js";
@@ -1221,12 +1224,12 @@ var require_supports_color = __commonJS({
     "use strict";
     var os6 = __require("os");
     var tty = __require("tty");
-    var hasFlag = require_has_flag();
+    var hasFlag2 = require_has_flag();
     var { env } = process;
     var forceColor;
-    if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) {
+    if (hasFlag2("no-color") || hasFlag2("no-colors") || hasFlag2("color=false") || hasFlag2("color=never")) {
       forceColor = 0;
-    } else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
+    } else if (hasFlag2("color") || hasFlag2("colors") || hasFlag2("color=true") || hasFlag2("color=always")) {
       forceColor = 1;
     }
     if ("FORCE_COLOR" in env) {
@@ -1253,10 +1256,10 @@ var require_supports_color = __commonJS({
       if (forceColor === 0) {
         return 0;
       }
-      if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
+      if (hasFlag2("color=16m") || hasFlag2("color=full") || hasFlag2("color=truecolor")) {
         return 3;
       }
-      if (hasFlag("color=256")) {
+      if (hasFlag2("color=256")) {
         return 2;
       }
       if (haveStream && !streamIsTTY && forceColor === void 0) {
@@ -14068,7 +14071,7 @@ var require_http = __commonJS({
       return joined;
     }
     function http(hljs) {
-      const VERSION = "HTTP/(2|1\\.[01])";
+      const VERSION2 = "HTTP/(2|1\\.[01])";
       const HEADER_NAME = /[A-Za-z][A-Za-z0-9-]*/;
       const HEADER = {
         className: "attribute",
@@ -14101,12 +14104,12 @@ var require_http = __commonJS({
         contains: [
           // response
           {
-            begin: "^(?=" + VERSION + " \\d{3})",
+            begin: "^(?=" + VERSION2 + " \\d{3})",
             end: /$/,
             contains: [
               {
                 className: "meta",
-                begin: VERSION
+                begin: VERSION2
               },
               {
                 className: "number",
@@ -14121,7 +14124,7 @@ var require_http = __commonJS({
           },
           // request
           {
-            begin: "(?=^[A-Z]+ (.*?) " + VERSION + "$)",
+            begin: "(?=^[A-Z]+ (.*?) " + VERSION2 + "$)",
             end: /$/,
             contains: [
               {
@@ -14133,7 +14136,7 @@ var require_http = __commonJS({
               },
               {
                 className: "meta",
-                begin: VERSION
+                begin: VERSION2
               },
               {
                 className: "keyword",
@@ -43943,7 +43946,7 @@ var require_dist = __commonJS({
 });
 
 // src/cli.ts
-import * as fs25 from "fs";
+import * as fs26 from "fs";
 import * as path26 from "path";
 
 // src/cli-args.ts
@@ -45481,6 +45484,356 @@ function parseModelsCommandArgs(args) {
   return parsed;
 }
 
+// src/commands/sessions.ts
+import fs6 from "node:fs";
+async function runSessionsCommand(args) {
+  const command = args[0] || "help";
+  const rest = args.slice(1);
+  try {
+    if (command === "list") {
+      await listSessions(rest);
+      return;
+    }
+    if (command === "read") {
+      await readSession(rest);
+      return;
+    }
+    if (command === "rename") {
+      await renameSession(rest);
+      return;
+    }
+    if (command === "rewind") {
+      await rewindSession(rest);
+      return;
+    }
+    if (command === "fork") {
+      await forkSession(rest);
+      return;
+    }
+    if (command === "help" || command === "--help" || command === "-h") {
+      printSessionsUsage();
+      return;
+    }
+    throw new Error(`Unknown sessions command: ${command}`);
+  } catch (error) {
+    if (hasFlag(args, "--json")) {
+      console.log(JSON.stringify({ ok: false, error: error instanceof Error ? error.message : String(error) }));
+    } else {
+      console.error(error instanceof Error ? error.message : String(error));
+    }
+    process.exitCode = 1;
+  }
+}
+async function listSessions(args) {
+  const json = hasFlag(args, "--json");
+  const limit = numericFlag(args, "--limit", 50);
+  const cwd = stringFlag(args, "--cwd");
+  const cursor = stringFlag(args, "--cursor");
+  const store = new FileSessionStore(getSessionsDir());
+  const cursorState = decodeListCursor(cursor);
+  const queryKey = listCursorQueryKey({ cwd });
+  const after = cursorState.q === queryKey ? cursorState.after : void 0;
+  const page = await store.listMetadataPage({
+    limit,
+    after,
+    filter: (metadata) => !cwd || cwdMatches(typeof metadata.cwd === "string" ? metadata.cwd : void 0, cwd)
+  });
+  const sessions = page.metadata.map(sessionSummary);
+  const hasMore = page.hasMore;
+  const lastSession = sessions.at(-1);
+  const nextCursor = hasMore && lastSession ? encodeListCursor({ v: 2, q: queryKey, after: { updatedAt: lastSession.updatedAt, id: lastSession.id } }) : void 0;
+  if (json) {
+    console.log(JSON.stringify({ ok: true, sessions, hasMore, nextCursor }, null, 2));
+    return;
+  }
+  if (sessions.length === 0) {
+    console.log("No sessions.");
+    return;
+  }
+  for (const session of sessions) {
+    console.log(`${session.id}	${session.name}	${new Date(session.updatedAt).toISOString()}${session.cwd ? `	${session.cwd}` : ""}`);
+  }
+}
+async function readSession(args) {
+  const json = hasFlag(args, "--json");
+  const sessionId = positionalArgs(args, /* @__PURE__ */ new Set(["--limit", "--before"]))[0];
+  if (!sessionId) throw new Error("Usage: pie sessions read <sessionId> [--json] [--limit <n>] [--before <cursor>]");
+  const limit = numericFlag(args, "--limit", 200);
+  const before = stringFlag(args, "--before");
+  const store = new FileSessionStore(getSessionsDir());
+  const data = await store.load(sessionId);
+  if (!data) throw new Error(`Session not found: ${sessionId}`);
+  const events = activeTranscriptEvents(activePathEntries(data));
+  const end = resolveBeforeCursor(events, before);
+  const start = Math.max(0, end - limit);
+  const page = events.slice(start, end);
+  const response = {
+    ok: true,
+    session: sessionSummary(data.metadata),
+    currentHead: data.metadata.activeEntryId,
+    activeEntryId: data.metadata.activeEntryId,
+    events: page,
+    hasMoreBefore: start > 0,
+    nextBefore: start > 0 ? String(start) : void 0
+  };
+  if (json) {
+    console.log(JSON.stringify(response, null, 2));
+    return;
+  }
+  console.log(`${response.session.id}: ${response.session.name}`);
+  for (const entry of page) {
+    console.log(`${entry.logicalSeq}	${entry.type}${entry.role ? `:${entry.role}` : ""}	${entry.content ?? ""}`);
+  }
+}
+async function renameSession(args) {
+  const json = hasFlag(args, "--json");
+  const cwd = stringFlag(args, "--cwd");
+  const positionals = positionalArgs(args, /* @__PURE__ */ new Set(["--cwd"]));
+  const sessionId = positionals[0];
+  const name = positionals.slice(1).join(" ").trim();
+  if (!sessionId || !name) throw new Error("Usage: pie sessions rename <sessionId> <name> [--json] [--cwd <path>]");
+  const store = new FileSessionStore(getSessionsDir());
+  const data = await store.load(sessionId);
+  if (!data) throw new Error(`Session not found: ${sessionId}`);
+  await store.save(sessionId, data.entries, { ...data.metadata, name, ...cwd ? { cwd } : {}, updatedAt: Date.now() });
+  const updated = await store.getMetadata(sessionId);
+  if (!updated) throw new Error(`Session not found after rename: ${sessionId}`);
+  const response = { ok: true, session: sessionSummary(updated) };
+  if (json) {
+    console.log(JSON.stringify(response, null, 2));
+    return;
+  }
+  console.log(`Renamed ${sessionId} to "${name}".`);
+}
+async function rewindSession(args) {
+  const json = hasFlag(args, "--json");
+  const sessionId = positionalArgs(args, /* @__PURE__ */ new Set(["--to"]))[0];
+  const entryId = stringFlag(args, "--to");
+  if (!sessionId || !entryId) throw new Error("Usage: pie sessions rewind <sessionId> --to <entryId> [--json]");
+  const store = new FileSessionStore(getSessionsDir());
+  const data = await store.load(sessionId);
+  if (!data) throw new Error(`Session not found: ${sessionId}`);
+  if (!data.entries.some((entry) => entry.id === entryId)) throw new Error(`Entry not found: ${entryId}`);
+  await store.save(sessionId, data.entries, { ...data.metadata, activeEntryId: entryId, updatedAt: Date.now() });
+  const updated = await store.getMetadata(sessionId);
+  if (!updated) throw new Error(`Session not found after rewind: ${sessionId}`);
+  const response = {
+    ok: true,
+    session: sessionSummary(updated),
+    activeEntryId: entryId,
+    currentHead: entryId
+  };
+  if (json) {
+    console.log(JSON.stringify(response, null, 2));
+    return;
+  }
+  console.log(`Rewound ${sessionId} to ${entryId}.`);
+}
+async function forkSession(args) {
+  const json = hasFlag(args, "--json");
+  const sourceSessionId = positionalArgs(args, /* @__PURE__ */ new Set(["--from", "--target", "--name", "--cwd"]))[0];
+  const sourceEntryId = stringFlag(args, "--from");
+  const targetSessionId = stringFlag(args, "--target");
+  const name = stringFlag(args, "--name");
+  const cwd = stringFlag(args, "--cwd");
+  if (!sourceSessionId || !sourceEntryId || !targetSessionId || !name) {
+    throw new Error("Usage: pie sessions fork <sessionId> --from <entryId> --target <newSessionId> --name <name> [--cwd <path>] [--json]");
+  }
+  const store = new FileSessionStore(getSessionsDir());
+  const source = await store.load(sourceSessionId);
+  if (!source) throw new Error(`Session not found: ${sourceSessionId}`);
+  if (await store.exists(targetSessionId)) throw new Error(`Target session already exists: ${targetSessionId}`);
+  const pathEntries = pathToEntry(source, sourceEntryId);
+  if (pathEntries.length === 0 || pathEntries[pathEntries.length - 1]?.id !== sourceEntryId) {
+    throw new Error(`Entry not found: ${sourceEntryId}`);
+  }
+  const now = Date.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 Error(`Failed to map entry: ${entry.id}`);
+    const parentId = entry.parentId ? idMap.get(entry.parentId) ?? null : null;
+    return {
+      ...cloneJson(entry),
+      id: nextId,
+      parentId,
+      timestamp: entry.timestamp
+    };
+  });
+  const activeEntryId = idMap.get(sourceEntryId) ?? null;
+  await store.save(targetSessionId, forkedEntries, {
+    name,
+    createdAt: now,
+    updatedAt: now,
+    activeEntryId,
+    cwd: cwd ?? source.metadata.cwd,
+    sourceSessionId,
+    sourceEntryId,
+    sourceActiveEntryId: source.metadata.activeEntryId ?? void 0,
+    forkBaseEntryId: activeEntryId ?? void 0
+  });
+  const updated = await store.getMetadata(targetSessionId);
+  if (!updated) throw new Error(`Session not found after fork: ${targetSessionId}`);
+  const response = {
+    ok: true,
+    session: sessionSummary(updated),
+    sourceSessionId,
+    sourceEntryId,
+    sourceActiveEntryId: source.metadata.activeEntryId,
+    forkBaseEntryId: activeEntryId,
+    activeEntryId,
+    currentHead: activeEntryId
+  };
+  if (json) {
+    console.log(JSON.stringify(response, null, 2));
+    return;
+  }
+  console.log(`Forked ${sourceSessionId} at ${sourceEntryId} into ${targetSessionId}.`);
+}
+function printSessionsUsage() {
+  console.log(`Usage:
+  pie sessions list [--json] [--limit <n>] [--cursor <cursor>] [--cwd <path>]
+  pie sessions read <sessionId> [--json] [--limit <n>] [--before <cursor>]
+  pie sessions rename <sessionId> <name> [--json] [--cwd <path>]
+  pie sessions rewind <sessionId> --to <entryId> [--json]
+  pie sessions fork <sessionId> --from <entryId> --target <newSessionId> --name <name> [--cwd <path>] [--json]`);
+}
+function hasFlag(args, flag) {
+  return args.includes(flag);
+}
+function stringFlag(args, flag) {
+  const index = args.indexOf(flag);
+  if (index < 0) return void 0;
+  const value = args[index + 1];
+  return value && !value.startsWith("-") ? value : void 0;
+}
+function numericFlag(args, flag, fallback) {
+  const value = stringFlag(args, flag);
+  if (!value) return fallback;
+  const parsed = Number(value);
+  return Number.isFinite(parsed) && parsed >= 0 ? parsed : fallback;
+}
+function positionalArgs(args, valueFlags) {
+  const result = [];
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg.startsWith("--")) {
+      if (valueFlags.has(arg)) index += 1;
+      continue;
+    }
+    result.push(arg);
+  }
+  return result;
+}
+function sessionSummary(metadata) {
+  return {
+    id: metadata.id,
+    name: metadata.name,
+    createdAt: metadata.createdAt,
+    updatedAt: metadata.updatedAt,
+    cwd: typeof metadata.cwd === "string" ? metadata.cwd : void 0,
+    entryCount: metadata.entryCount,
+    messageCount: metadata.messageCount,
+    activeEntryId: metadata.activeEntryId,
+    rootEntryId: metadata.rootEntryId,
+    sourceSessionId: typeof metadata.sourceSessionId === "string" ? metadata.sourceSessionId : void 0,
+    sourceEntryId: typeof metadata.sourceEntryId === "string" ? metadata.sourceEntryId : void 0,
+    sourceActiveEntryId: typeof metadata.sourceActiveEntryId === "string" ? metadata.sourceActiveEntryId : void 0,
+    forkBaseEntryId: typeof metadata.forkBaseEntryId === "string" ? metadata.forkBaseEntryId : void 0
+  };
+}
+function cwdMatches(sessionCwd, requestedCwd) {
+  if (!sessionCwd) return false;
+  if (sessionCwd === requestedCwd) return true;
+  return realpathOrInput(sessionCwd) === realpathOrInput(requestedCwd);
+}
+function realpathOrInput(value) {
+  try {
+    return fs6.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;
+    return {
+      logicalSeq: index + 1,
+      checkpointId: entry.id,
+      entryId: entry.id,
+      id: entry.id,
+      type: entry.type,
+      timestamp: entry.timestamp,
+      occurredAt: entry.timestamp,
+      role,
+      content: textFromMessage(entry.message),
+      message: entry.message ? cloneJson(entry.message) : void 0
+    };
+  });
+}
+function activePathEntries(data) {
+  const activeEntryId = data.metadata.activeEntryId;
+  if (!activeEntryId) return [];
+  return pathToEntry(data, activeEntryId);
+}
+function pathToEntry(data, entryId) {
+  const byId = new Map(data.entries.map((entry) => [entry.id, entry]));
+  const path27 = [];
+  let current = entryId;
+  while (current) {
+    const entry = byId.get(current);
+    if (!entry) return [];
+    path27.unshift(entry);
+    current = entry.parentId;
+  }
+  return path27;
+}
+function resolveBeforeCursor(events, cursor) {
+  if (!cursor) return events.length;
+  const numeric = Number(cursor);
+  if (Number.isInteger(numeric) && numeric >= 0) {
+    return Math.max(0, Math.min(events.length, numeric));
+  }
+  const index = events.findIndex((event) => event.entryId === cursor || event.checkpointId === cursor);
+  return index >= 0 ? index : events.length;
+}
+function cloneJson(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+function listCursorQueryKey(input) {
+  return JSON.stringify({ cwd: input.cwd ? realpathOrInput(input.cwd) : "" });
+}
+function encodeListCursor(state) {
+  return `list:${Buffer.from(JSON.stringify(state), "utf8").toString("base64url")}`;
+}
+function decodeListCursor(cursor) {
+  if (!cursor?.startsWith("list:")) return { v: 2 };
+  try {
+    const parsed = JSON.parse(Buffer.from(cursor.slice("list:".length), "base64url").toString("utf8"));
+    if (!isRecord2(parsed) || parsed.v !== 2) return { v: 2 };
+    const after = isRecord2(parsed.after) && typeof parsed.after.id === "string" && typeof parsed.after.updatedAt === "number" && Number.isFinite(parsed.after.updatedAt) ? { id: parsed.after.id, updatedAt: parsed.after.updatedAt } : void 0;
+    return {
+      v: 2,
+      q: typeof parsed.q === "string" ? parsed.q : void 0,
+      ...after ? { after } : {}
+    };
+  } catch {
+    return { v: 2 };
+  }
+}
+function textFromMessage(message) {
+  if (!isRecord2(message)) return void 0;
+  const content = message.content;
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return void 0;
+  const text = content.map((block) => isRecord2(block) && block.type === "text" && typeof block.text === "string" ? block.text : "").filter(Boolean).join("\n").trim();
+  return text || void 0;
+}
+function isRecord2(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+
 // ../../packages/tui/src/fuzzy.ts
 function fuzzyMatch(query, text) {
   const queryLower = query.toLowerCase();
@@ -47031,7 +47384,7 @@ var KillRing = class {
 };
 
 // ../../packages/tui/src/tui.ts
-import * as fs6 from "node:fs";
+import * as fs7 from "node:fs";
 import * as os2 from "node:os";
 import * as path5 from "node:path";
 
@@ -47710,10 +48063,10 @@ var TUI = class extends Container {
     const logRedraw = (reason) => {
       if (!debugRedraw) return;
       const logPath = path5.join(os2.homedir(), ".pie", "logs", "pie-cli.log");
-      fs6.mkdirSync(path5.dirname(logPath), { recursive: true });
+      fs7.mkdirSync(path5.dirname(logPath), { recursive: true });
       const msg = `[${(/* @__PURE__ */ new Date()).toISOString()}] [DEBUG] [ui] fullRender: ${reason} (prev=${this.previousLines.length}, new=${newLines.length}, height=${height})
 `;
-      fs6.appendFileSync(logPath, msg);
+      fs7.appendFileSync(logPath, msg);
     };
     if (this.previousLines.length === 0 && !widthChanged) {
       logRedraw("first render");
@@ -47816,8 +48169,8 @@ var TUI = class extends Container {
           ...newLines.map((l, idx) => `[${idx}] (w=${visibleWidth(l)}) ${l}`),
           ""
         ].join("\n");
-        fs6.mkdirSync(path5.dirname(crashLogPath), { recursive: true });
-        fs6.writeFileSync(crashLogPath, crashData);
+        fs7.mkdirSync(path5.dirname(crashLogPath), { recursive: true });
+        fs7.writeFileSync(crashLogPath, crashData);
         this.stop();
         const errorMsg = [
           `Rendered line ${i} exceeds terminal width (${visibleWidth(line)} > ${width}).`,
@@ -47847,7 +48200,7 @@ var TUI = class extends Container {
     buffer += "\x1B[?2026l";
     if (process.env.PIE_TUI_DEBUG === "1") {
       const debugDir = "/tmp/tui";
-      fs6.mkdirSync(debugDir, { recursive: true });
+      fs7.mkdirSync(debugDir, { recursive: true });
       const debugPath = path5.join(debugDir, `render-${Date.now()}-${Math.random().toString(36).slice(2)}.log`);
       const debugData = [
         `firstChanged: ${firstChanged}`,
@@ -47871,7 +48224,7 @@ var TUI = class extends Container {
         "=== buffer ===",
         JSON.stringify(buffer)
       ].join("\n");
-      fs6.writeFileSync(debugPath, debugData);
+      fs7.writeFileSync(debugPath, debugData);
     }
     this.terminal.write(buffer);
     this.cursorRow = Math.max(0, newLines.length - 1);
@@ -52046,7 +52399,7 @@ var StdinBuffer = class extends EventEmitter {
 };
 
 // ../../packages/tui/src/terminal.ts
-import * as fs7 from "node:fs";
+import * as fs8 from "node:fs";
 import koffi from "koffi";
 var ProcessTerminal = class {
   wasRaw = false;
@@ -52207,7 +52560,7 @@ var ProcessTerminal = class {
     process.stdout.write(data);
     if (this.writeLogPath) {
       try {
-        fs7.appendFileSync(this.writeLogPath, data, { encoding: "utf8" });
+        fs8.appendFileSync(this.writeLogPath, data, { encoding: "utf8" });
       } catch {
       }
     }
@@ -52379,7 +52732,7 @@ var KeybindingsManager = class _KeybindingsManager {
 };
 
 // src/project-knowledge.ts
-import fs8 from "node:fs";
+import fs9 from "node:fs";
 import path6 from "node:path";
 function collectAncestorAgentsFiles(cwd) {
   const resolvedCwd = path6.resolve(cwd || process.cwd());
@@ -52399,13 +52752,13 @@ function collectAncestorAgentsFiles(cwd) {
   }
   const files = [];
   for (const candidate of candidates) {
-    if (!fs8.existsSync(candidate)) {
+    if (!fs9.existsSync(candidate)) {
       continue;
     }
     try {
       files.push({
         path: path6.relative(resolvedCwd, candidate) || AGENTS_CONTEXT_FILE_NAME,
-        content: fs8.readFileSync(candidate, "utf-8")
+        content: fs9.readFileSync(candidate, "utf-8")
       });
     } catch {
     }
@@ -52443,7 +52796,7 @@ function buildCliFileAccessOptions(params) {
 }
 
 // src/theme/theme.ts
-import * as fs9 from "node:fs";
+import * as fs10 from "node:fs";
 import * as path8 from "node:path";
 
 // ../../node_modules/@sinclair/typebox/build/esm/compiler/compiler.mjs
@@ -53334,8 +53687,8 @@ function getBuiltinThemes() {
     const darkPath = path8.join(themesDir, "dark.json");
     const lightPath = path8.join(themesDir, "light.json");
     BUILTIN_THEMES = {
-      dark: JSON.parse(fs9.readFileSync(darkPath, "utf-8")),
-      light: JSON.parse(fs9.readFileSync(lightPath, "utf-8"))
+      dark: JSON.parse(fs10.readFileSync(darkPath, "utf-8")),
+      light: JSON.parse(fs10.readFileSync(lightPath, "utf-8"))
     };
   }
   return BUILTIN_THEMES;
@@ -53343,8 +53696,8 @@ function getBuiltinThemes() {
 function getAvailableThemes() {
   const themes = new Set(Object.keys(getBuiltinThemes()));
   const customThemesDir = getCustomThemesDir();
-  if (fs9.existsSync(customThemesDir)) {
-    const files = fs9.readdirSync(customThemesDir);
+  if (fs10.existsSync(customThemesDir)) {
+    const files = fs10.readdirSync(customThemesDir);
     for (const file of files) {
       if (file.endsWith(".json")) {
         themes.add(file.slice(0, -5));
@@ -53405,7 +53758,7 @@ function loadThemeJson(name) {
   }
   const registeredTheme = registeredThemes.get(name);
   if (registeredTheme?.sourcePath) {
-    const content2 = fs9.readFileSync(registeredTheme.sourcePath, "utf-8");
+    const content2 = fs10.readFileSync(registeredTheme.sourcePath, "utf-8");
     return parseThemeJsonContent(registeredTheme.sourcePath, content2);
   }
   if (registeredTheme) {
@@ -53413,10 +53766,10 @@ function loadThemeJson(name) {
   }
   const customThemesDir = getCustomThemesDir();
   const themePath = path8.join(customThemesDir, `${name}.json`);
-  if (!fs9.existsSync(themePath)) {
+  if (!fs10.existsSync(themePath)) {
     throw new Error(`Theme not found: ${name}`);
   }
-  const content = fs9.readFileSync(themePath, "utf-8");
+  const content = fs10.readFileSync(themePath, "utf-8");
   return parseThemeJsonContent(name, content);
 }
 function createTheme(themeJson, mode, sourcePath) {
@@ -53530,11 +53883,11 @@ function startThemeWatcher() {
   }
   const customThemesDir = getCustomThemesDir();
   const themeFile = path8.join(customThemesDir, `${currentThemeName}.json`);
-  if (!fs9.existsSync(themeFile)) {
+  if (!fs10.existsSync(themeFile)) {
     return;
   }
   try {
-    themeWatcher = fs9.watch(themeFile, (eventType) => {
+    themeWatcher = fs10.watch(themeFile, (eventType) => {
       if (eventType === "change") {
         setTimeout(() => {
           try {
@@ -53547,7 +53900,7 @@ function startThemeWatcher() {
         }, 100);
       } else if (eventType === "rename") {
         setTimeout(() => {
-          if (!fs9.existsSync(themeFile)) {
+          if (!fs10.existsSync(themeFile)) {
             currentThemeName = "dark";
             setGlobalTheme(loadTheme("dark"));
             if (themeWatcher) {
@@ -53718,7 +54071,7 @@ function getEditorTheme() {
 }
 
 // src/skills/loader.ts
-import * as fs10 from "fs";
+import * as fs11 from "fs";
 import * as path9 from "path";
 function parseSkillDescription(content) {
   const frontmatterMatch = content.match(/^---\n[\s\S]*?description:\s*["']?(.+?)["']?(?:\n|$)/m);
@@ -53737,18 +54090,18 @@ function parseSkillDescription(content) {
 function loadSkillsFromDir(dir, source) {
   const skills = [];
   const diagnostics = [];
-  if (!fs10.existsSync(dir)) {
+  if (!fs11.existsSync(dir)) {
     return { skills, diagnostics };
   }
-  const entries = fs10.readdirSync(dir, { withFileTypes: true });
+  const entries = fs11.readdirSync(dir, { withFileTypes: true });
   for (const entry of entries) {
     if (entry.name.startsWith(".")) continue;
     const fullPath = path9.join(dir, entry.name);
     if (entry.isDirectory()) {
       const skillMdPath = path9.join(fullPath, "SKILL.md");
-      if (fs10.existsSync(skillMdPath)) {
+      if (fs11.existsSync(skillMdPath)) {
         try {
-          const content = fs10.readFileSync(skillMdPath, "utf-8");
+          const content = fs11.readFileSync(skillMdPath, "utf-8");
           const description = parseSkillDescription(content);
           skills.push({
             name: entry.name,
@@ -53769,7 +54122,7 @@ function loadSkillsFromDir(dir, source) {
     } else if (entry.isFile() && entry.name.endsWith(".md")) {
       const name = entry.name.slice(0, -3);
       try {
-        const content = fs10.readFileSync(fullPath, "utf-8");
+        const content = fs11.readFileSync(fullPath, "utf-8");
         const description = parseSkillDescription(content);
         skills.push({
           name,
@@ -53966,7 +54319,7 @@ function validateSkillName(name) {
 
 // src/capabilities/read-file-understanding.ts
 import * as path18 from "node:path";
-import * as fs18 from "node:fs/promises";
+import * as fs19 from "node:fs/promises";
 
 // src/core/provider-capabilities.ts
 var PLATFORM_DISPLAY_NAMES = {
@@ -53992,7 +54345,7 @@ function getProviderDisplayName(platform2) {
 }
 
 // src/files/adapters/kimi-adapter.ts
-import * as fs11 from "node:fs";
+import * as fs12 from "node:fs";
 import * as path10 from "node:path";
 
 // src/files/errors.ts
@@ -54133,14 +54486,14 @@ var KimiFileAdapter = class {
     const fileName = options.sourceName || path10.basename(filePath);
     const mimeType = options.mimeType || this.guessMimeType(fileName);
     const purpose = this.detectPurpose(filePath, options.purpose, mimeType);
-    const stats = fs11.statSync(filePath);
+    const stats = fs12.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 = fs11.readFileSync(filePath);
+    const fileBuffer = fs12.readFileSync(filePath);
     const file = new File([fileBuffer], fileName, { type: mimeType });
     const formData = new FormData();
     formData.append("file", file);
@@ -54354,7 +54707,7 @@ var KimiFileAdapter = class {
 };
 
 // src/files/adapters/gemini-adapter.ts
-import * as fs12 from "node:fs";
+import * as fs13 from "node:fs";
 import * as path11 from "node:path";
 import { Readable } from "node:stream";
 var GeminiFileAdapter = class {
@@ -54412,7 +54765,7 @@ var GeminiFileAdapter = class {
   // Upload
   // ============================================================================
   async upload(filePath, options = {}) {
-    const stats = fs12.statSync(filePath);
+    const stats = fs13.statSync(filePath);
     if (stats.size > this.capabilities.maxFileSize) {
       throw new FileManagerError(
         "FILE_TOO_LARGE" /* FILE_TOO_LARGE */,
@@ -54451,7 +54804,7 @@ var GeminiFileAdapter = class {
         "No upload URL received"
       );
     }
-    const fileStream = Readable.toWeb(fs12.createReadStream(filePath));
+    const fileStream = Readable.toWeb(fs13.createReadStream(filePath));
     const uploadResponse = await fetch(uploadUrl, {
       method: "POST",
       headers: {
@@ -54655,7 +55008,7 @@ var GeminiFileAdapter = class {
 };
 
 // src/files/adapters/openai-compatible-files-adapter.ts
-import * as fs13 from "node:fs";
+import * as fs14 from "node:fs";
 import * as path12 from "node:path";
 var OpenAICompatibleFilesAdapter = class {
   constructor(apiKey, baseUrl, extraHeaders = {}) {
@@ -54684,14 +55037,14 @@ var OpenAICompatibleFilesAdapter = class {
   async upload(filePath, options = {}) {
     const fileName = options.sourceName || path12.basename(filePath);
     const mimeType = options.mimeType || guessMimeType(fileName);
-    const stats = fs13.statSync(filePath);
+    const stats = fs14.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([fs13.readFileSync(filePath)], fileName, { type: mimeType });
+    const file = new File([fs14.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");
@@ -54824,12 +55177,12 @@ function guessMimeType(filename) {
 }
 
 // src/files/file-manager.ts
-import * as fs17 from "node:fs";
+import * as fs18 from "node:fs";
 import * as path17 from "node:path";
 import * as crypto2 from "node:crypto";
 
 // src/files/file-cache.ts
-import * as fs14 from "node:fs";
+import * as fs15 from "node:fs";
 import * as path14 from "node:path";
 import * as crypto from "node:crypto";
 
@@ -54990,22 +55343,22 @@ var FileCache = class _FileCache {
   // Directory Management
   // ============================================================================
   ensureDirectories() {
-    if (!fs14.existsSync(this.baseDir)) {
-      fs14.mkdirSync(this.baseDir, { recursive: true });
+    if (!fs15.existsSync(this.baseDir)) {
+      fs15.mkdirSync(this.baseDir, { recursive: true });
     }
-    if (!fs14.existsSync(this.dataDir)) {
-      fs14.mkdirSync(this.dataDir, { recursive: true });
+    if (!fs15.existsSync(this.dataDir)) {
+      fs15.mkdirSync(this.dataDir, { recursive: true });
     }
   }
   // ============================================================================
   // Index Management
   // ============================================================================
   loadIndex() {
-    if (!fs14.existsSync(this.indexPath)) {
+    if (!fs15.existsSync(this.indexPath)) {
       return { version: CACHE_VERSION, files: {}, pathHints: {} };
     }
     try {
-      const data = JSON.parse(fs14.readFileSync(this.indexPath, "utf-8"));
+      const data = JSON.parse(fs15.readFileSync(this.indexPath, "utf-8"));
       if (data.version !== CACHE_VERSION) {
         cacheLogger.warn(`Index version mismatch: ${data.version} vs ${CACHE_VERSION}`);
       }
@@ -55021,7 +55374,7 @@ var FileCache = class _FileCache {
   }
   saveIndex() {
     try {
-      fs14.writeFileSync(this.indexPath, JSON.stringify(this.index, null, 2));
+      fs15.writeFileSync(this.indexPath, JSON.stringify(this.index, null, 2));
     } catch (err) {
       cacheLogger.error(" Failed to save index:", err);
       throw err;
@@ -55033,7 +55386,7 @@ var FileCache = class _FileCache {
   async computeHash(filePath) {
     return new Promise((resolve4, reject) => {
       const hash = crypto.createHash("sha256");
-      const stream = fs14.createReadStream(filePath);
+      const stream = fs15.createReadStream(filePath);
       stream.on("data", (chunk) => hash.update(chunk));
       stream.on("end", () => resolve4(hash.digest("hex")));
       stream.on("error", reject);
@@ -55048,8 +55401,8 @@ var FileCache = class _FileCache {
   getStoragePath(hash) {
     const subdir = hash.slice(0, 2);
     const fullDir = path14.join(this.dataDir, subdir);
-    if (!fs14.existsSync(fullDir)) {
-      fs14.mkdirSync(fullDir, { recursive: true });
+    if (!fs15.existsSync(fullDir)) {
+      fs15.mkdirSync(fullDir, { recursive: true });
     }
     return path14.join(fullDir, hash);
   }
@@ -55061,11 +55414,11 @@ var FileCache = class _FileCache {
     const hash = await this.computeHash(sourcePath);
     const storagePath = this.getStoragePath(hash);
     this.rememberPathHint(sourcePath, hash, name);
-    if (fs14.existsSync(storagePath)) {
+    if (fs15.existsSync(storagePath)) {
       return { hash, localPath: storagePath };
     }
-    fs14.copyFileSync(sourcePath, storagePath);
-    const stat2 = fs14.statSync(storagePath);
+    fs15.copyFileSync(sourcePath, storagePath);
+    const stat2 = fs15.statSync(storagePath);
     this.index.files[hash] = {
       hash,
       name,
@@ -55082,10 +55435,10 @@ var FileCache = class _FileCache {
   async storeBuffer(data, name, mimeType) {
     const hash = this.computeHashSync(data);
     const storagePath = this.getStoragePath(hash);
-    if (fs14.existsSync(storagePath)) {
+    if (fs15.existsSync(storagePath)) {
       return { hash, localPath: storagePath };
     }
-    fs14.writeFileSync(storagePath, data);
+    fs15.writeFileSync(storagePath, data);
     this.index.files[hash] = {
       hash,
       name,
@@ -55157,7 +55510,7 @@ var FileCache = class _FileCache {
   getPathHint(filePath) {
     try {
       const resolvedPath = this.getResolvedHintPath(filePath);
-      const stat2 = fs14.statSync(resolvedPath);
+      const stat2 = fs15.statSync(resolvedPath);
       if (!stat2.isFile()) return void 0;
       const normalizedMtimeMs = this.normalizeHintMtimeMs(stat2.mtimeMs);
       const key = this.getPathHintKey(resolvedPath);
@@ -55187,7 +55540,7 @@ var FileCache = class _FileCache {
   rememberPathHint(filePath, hash, name) {
     try {
       const resolvedPath = this.getResolvedHintPath(filePath);
-      const stat2 = fs14.statSync(resolvedPath);
+      const stat2 = fs15.statSync(resolvedPath);
       if (!stat2.isFile()) return;
       const entry = this.index.files[hash];
       const normalizedMtimeMs = this.normalizeHintMtimeMs(stat2.mtimeMs);
@@ -55246,8 +55599,8 @@ var FileCache = class _FileCache {
     entry = entry || this.index.files[hash];
     if (!entry) return;
     const localPath = path14.join(this.dataDir, entry.localPath);
-    if (fs14.existsSync(localPath)) {
-      fs14.unlinkSync(localPath);
+    if (fs15.existsSync(localPath)) {
+      fs15.unlinkSync(localPath);
     }
     delete this.index.files[hash];
     if (this.index.pathHints) {
@@ -55262,8 +55615,8 @@ var FileCache = class _FileCache {
   clear() {
     for (const entry of Object.values(this.index.files)) {
       const localPath = path14.join(this.dataDir, entry.localPath);
-      if (fs14.existsSync(localPath)) {
-        fs14.unlinkSync(localPath);
+      if (fs15.existsSync(localPath)) {
+        fs15.unlinkSync(localPath);
       }
     }
     this.index = { version: CACHE_VERSION, files: {}, pathHints: {} };
@@ -55351,7 +55704,7 @@ var FileCache = class _FileCache {
   getResolvedHintPath(filePath) {
     const resolvedPath = resolvePath(filePath);
     try {
-      return fs14.realpathSync.native ? fs14.realpathSync.native(resolvedPath) : fs14.realpathSync(resolvedPath);
+      return fs15.realpathSync.native ? fs15.realpathSync.native(resolvedPath) : fs15.realpathSync(resolvedPath);
     } catch {
       return resolvedPath;
     }
@@ -55359,7 +55712,7 @@ var FileCache = class _FileCache {
 };
 
 // src/files/session-file-manager.ts
-import * as fs15 from "node:fs";
+import * as fs16 from "node:fs";
 import * as path15 from "node:path";
 var INITIAL_REFRESH_BACKOFF_MS = 6e4;
 var MAX_REFRESH_BACKOFF_MS = 60 * 60 * 1e3;
@@ -55384,15 +55737,15 @@ var SessionFileManager = class {
   // Directory Management
   // ============================================================================
   ensureDirectories() {
-    if (!fs15.existsSync(this.sessionsDir)) {
-      fs15.mkdirSync(this.sessionsDir, { recursive: true });
+    if (!fs16.existsSync(this.sessionsDir)) {
+      fs16.mkdirSync(this.sessionsDir, { recursive: true });
     }
   }
   // ============================================================================
   // State Management
   // ============================================================================
   loadState() {
-    if (!fs15.existsSync(this.statePath)) {
+    if (!fs16.existsSync(this.statePath)) {
       return {
         sessionId: this.sessionId,
         lastSyncedAt: 0,
@@ -55400,7 +55753,7 @@ var SessionFileManager = class {
       };
     }
     try {
-      return JSON.parse(fs15.readFileSync(this.statePath, "utf-8"));
+      return JSON.parse(fs16.readFileSync(this.statePath, "utf-8"));
     } catch (err) {
       sessionLogger.error(" Failed to load state:", err);
       return {
@@ -55413,12 +55766,12 @@ var SessionFileManager = class {
   saveState() {
     try {
       if (Object.keys(this.state.files).length === 0) {
-        if (fs15.existsSync(this.statePath)) {
-          fs15.unlinkSync(this.statePath);
+        if (fs16.existsSync(this.statePath)) {
+          fs16.unlinkSync(this.statePath);
         }
         return;
       }
-      fs15.writeFileSync(this.statePath, JSON.stringify(this.state, null, 2));
+      fs16.writeFileSync(this.statePath, JSON.stringify(this.state, null, 2));
     } catch (err) {
       sessionLogger.error(" Failed to save state:", err);
     }
@@ -55564,7 +55917,7 @@ var SessionFileManager = class {
       return { success: false, coolingDown: true };
     }
     const localPath = this.fileCache.getLocalPath(entry.hash);
-    if (!localPath || !fs15.existsSync(localPath)) {
+    if (!localPath || !fs16.existsSync(localPath)) {
       sessionLogger.warn(`Local file not found for ${fileId}`);
       entry.status = "expired";
       entry.error = "Local file missing";
@@ -55715,15 +56068,15 @@ var SessionFileManager = class {
   // Static Utilities
   // ============================================================================
   static cleanupOldSessions(sessionsDir, maxAge = 30 * 24 * 60 * 60 * 1e3) {
-    if (!fs15.existsSync(sessionsDir)) return;
+    if (!fs16.existsSync(sessionsDir)) return;
     const now = Date.now();
-    const files = fs15.readdirSync(sessionsDir);
+    const files = fs16.readdirSync(sessionsDir);
     for (const file of files) {
       if (!file.endsWith(".json")) continue;
       const filePath = path15.join(sessionsDir, file);
-      const stat2 = fs15.statSync(filePath);
+      const stat2 = fs16.statSync(filePath);
       if (now - stat2.mtime.getTime() > maxAge) {
-        fs15.unlinkSync(filePath);
+        fs16.unlinkSync(filePath);
         sessionLogger.debug(`Cleaned up old session: ${file}`);
       }
     }
@@ -55731,7 +56084,7 @@ var SessionFileManager = class {
 };
 
 // src/files/ffmpeg-processor.ts
-import * as fs16 from "node:fs";
+import * as fs17 from "node:fs";
 import * as path16 from "node:path";
 import { spawn } from "node:child_process";
 var FFmpegProcessor = class {
@@ -55867,7 +56220,7 @@ var FFmpegProcessor = class {
         onProgress?.(percent);
       }
     });
-    const outputStat = fs16.statSync(outputPath);
+    const outputStat = fs17.statSync(outputPath);
     return {
       type: "video",
       output: outputPath,
@@ -55899,7 +56252,7 @@ var FFmpegProcessor = class {
   async extractKeyframes(inputPath, outputDir, info, opts, onProgress) {
     const interval = Math.floor(info.duration / opts.keyframeCount);
     const framesDir = path16.join(outputDir, `keyframes_${Date.now()}`);
-    fs16.mkdirSync(framesDir, { recursive: true });
+    fs17.mkdirSync(framesDir, { recursive: true });
     const outputPattern = path16.join(framesDir, "frame_%03d.jpg");
     const args = [
       "-i",
@@ -55918,10 +56271,10 @@ var FFmpegProcessor = class {
         onProgress?.(percent);
       }
     });
-    let frames = fs16.readdirSync(framesDir).filter((f) => f.endsWith(".jpg")).sort().map((f) => path16.join(framesDir, f));
+    let frames = fs17.readdirSync(framesDir).filter((f) => f.endsWith(".jpg")).sort().map((f) => path16.join(framesDir, f));
     if (frames.length < opts.keyframeCount / 2) {
-      fs16.rmSync(framesDir, { recursive: true, force: true });
-      fs16.mkdirSync(framesDir, { recursive: true });
+      fs17.rmSync(framesDir, { recursive: true, force: true });
+      fs17.mkdirSync(framesDir, { recursive: true });
       const uniformArgs = [
         "-i",
         inputPath,
@@ -55937,10 +56290,10 @@ var FFmpegProcessor = class {
           onProgress?.(percent);
         }
       });
-      frames = fs16.readdirSync(framesDir).filter((f) => f.endsWith(".jpg")).sort().map((f) => path16.join(framesDir, f));
+      frames = fs17.readdirSync(framesDir).filter((f) => f.endsWith(".jpg")).sort().map((f) => path16.join(framesDir, f));
     }
     const totalOutputSize = frames.reduce(
-      (sum, f) => sum + fs16.statSync(f).size,
+      (sum, f) => sum + fs17.statSync(f).size,
       0
     );
     return {
@@ -56160,8 +56513,8 @@ var FileManager = class {
   directoryListingCache = /* @__PURE__ */ new Map();
   authFingerprint;
   ensureDirectories() {
-    if (!fs17.existsSync(this.tempDir)) {
-      fs17.mkdirSync(this.tempDir, { recursive: true });
+    if (!fs18.existsSync(this.tempDir)) {
+      fs18.mkdirSync(this.tempDir, { recursive: true });
     }
   }
   // ============================================================================
@@ -56192,7 +56545,7 @@ var FileManager = class {
   async stageLocal(filePath, options = {}) {
     const resolvedPath = resolvePath(filePath);
     const sourceName = options.sourceName || path17.basename(resolvedPath);
-    if (!fs17.existsSync(resolvedPath)) {
+    if (!fs18.existsSync(resolvedPath)) {
       throw new FileManagerError(
         "LOCAL_FILE_MISSING" /* LOCAL_FILE_MISSING */,
         `File not found: ${filePath}`
@@ -56207,7 +56560,7 @@ var FileManager = class {
     this.fileCache.rememberPathHint(resolvedPath, hash, sourceName);
     this.invalidateDirectoryListingCacheForPath(resolvedPath);
     const entry = this.fileCache.getByHash(hash);
-    const size = entry?.size ?? fs17.statSync(resolvedPath).size;
+    const size = entry?.size ?? fs18.statSync(resolvedPath).size;
     return {
       success: true,
       hash,
@@ -56222,7 +56575,7 @@ var FileManager = class {
   async upload(filePath, options = {}) {
     const resolvedPath = resolvePath(filePath);
     const sourceName = options.sourceName || path17.basename(resolvedPath);
-    if (!fs17.existsSync(resolvedPath)) {
+    if (!fs18.existsSync(resolvedPath)) {
       throw new FileManagerError(
         "LOCAL_FILE_MISSING" /* LOCAL_FILE_MISSING */,
         `File not found: ${filePath}`
@@ -56303,7 +56656,7 @@ var FileManager = class {
   // ============================================================================
   async uploadPic(filePath, options = {}) {
     const resolvedPath = resolvePath(filePath);
-    if (!fs17.existsSync(resolvedPath)) {
+    if (!fs18.existsSync(resolvedPath)) {
       throw new FileManagerError(
         "LOCAL_FILE_MISSING" /* LOCAL_FILE_MISSING */,
         `File not found: ${filePath}`
@@ -56333,7 +56686,7 @@ var FileManager = class {
     this.fileCache.rememberPathHint(resolvedPath, result.hash, path17.basename(resolvedPath));
     this.invalidateDirectoryListingCacheForPath(resolvedPath);
     try {
-      fs17.unlinkSync(optimizedPath);
+      fs18.unlinkSync(optimizedPath);
     } catch {
     }
     return result;
@@ -56343,7 +56696,7 @@ var FileManager = class {
   // ============================================================================
   async uploadVideo(filePath, options = {}) {
     const resolvedPath = resolvePath(filePath);
-    if (!fs17.existsSync(resolvedPath)) {
+    if (!fs18.existsSync(resolvedPath)) {
       throw new FileManagerError(
         "LOCAL_FILE_MISSING" /* LOCAL_FILE_MISSING */,
         `File not found: ${filePath}`
@@ -56737,13 +57090,13 @@ var FileManager = class {
   cleanupTempFiles(output) {
     try {
       if (typeof output === "string") {
-        if (fs17.existsSync(output)) {
-          fs17.unlinkSync(output);
+        if (fs18.existsSync(output)) {
+          fs18.unlinkSync(output);
         }
       } else {
         for (const file of output) {
-          if (fs17.existsSync(file)) {
-            fs17.unlinkSync(file);
+          if (fs18.existsSync(file)) {
+            fs18.unlinkSync(file);
           }
         }
       }
@@ -56775,7 +57128,7 @@ var FileManager = class {
         }];
       }
       const localPath = this.fileCache.getLocalPath(entry.hash);
-      if (localPath && fs17.existsSync(localPath)) {
+      if (localPath && fs18.existsSync(localPath)) {
         return [{
           fileId,
           name: cacheEntry.name,
@@ -56872,7 +57225,7 @@ var FileManager = class {
       directories: []
     };
     try {
-      const entries = fs17.readdirSync(resolvedDir, { withFileTypes: true });
+      const entries = fs18.readdirSync(resolvedDir, { withFileTypes: true });
       for (const entry of entries) {
         if (!entry.name || entry.name.startsWith(".")) {
           continue;
@@ -56886,7 +57239,7 @@ var FileManager = class {
         let isFile = entry.isFile();
         if (entry.isSymbolicLink()) {
           try {
-            const targetStat = fs17.statSync(fullPath);
+            const targetStat = fs18.statSync(fullPath);
             isDirectory = targetStat.isDirectory();
             isFile = targetStat.isFile();
           } catch {
@@ -56904,7 +57257,7 @@ var FileManager = class {
         if (!type) {
           continue;
         }
-        const stat2 = fs17.statSync(fullPath);
+        const stat2 = fs18.statSync(fullPath);
         listing.files.push({
           name: entry.name,
           path: fullPath,
@@ -57003,7 +57356,7 @@ function isInlineMediaRequest(request) {
   return request.kind === "image" || request.kind === "video";
 }
 async function prepareInlineMediaContent(params) {
-  const stat2 = await fs18.stat(params.request.absolutePath);
+  const stat2 = await fs19.stat(params.request.absolutePath);
   const limitMb = getCapabilityLimitMb(params.model, params.request.kind);
   const limitBytes = limitMb * 1024 * 1024;
   if (stat2.size > limitBytes) {
@@ -57011,7 +57364,7 @@ async function prepareInlineMediaContent(params) {
       `${params.request.kind} understanding for ${params.model.provider}/${params.model.id} supports inline files up to ${limitMb}MB; ${path18.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 fs18.readFile(params.request.absolutePath, "base64");
+  const data = await fs19.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,
@@ -57381,22 +57734,22 @@ var ExecutionStateManager = class {
 };
 
 // src/session-trace.ts
-import * as fs19 from "node:fs";
+import * as fs20 from "node:fs";
 import * as path19 from "node:path";
 function saveTraceFileBestEffort(tracePath, content) {
   const tempPath = `${tracePath}.${process.pid}.${Date.now()}.tmp`;
   try {
-    fs19.writeFileSync(tempPath, content, "utf8");
+    fs20.writeFileSync(tempPath, content, "utf8");
     try {
-      fs19.renameSync(tempPath, tracePath);
+      fs20.renameSync(tempPath, tracePath);
       return;
     } catch {
       try {
-        fs19.copyFileSync(tempPath, tracePath);
+        fs20.copyFileSync(tempPath, tracePath);
       } catch {
       } finally {
         try {
-          fs19.unlinkSync(tempPath);
+          fs20.unlinkSync(tempPath);
         } catch {
         }
       }
@@ -57410,9 +57763,9 @@ var SessionTraceWriter = class extends SessionTraceSnapshotWriter {
       getSessionId: () => sessionManager.getActiveSessionId(),
       loadTrace: (sessionId) => {
         const tracePath = path19.join(sessionsDir, `${sessionId}.trace.json`);
-        if (!fs19.existsSync(tracePath)) return null;
+        if (!fs20.existsSync(tracePath)) return null;
         try {
-          return JSON.parse(fs19.readFileSync(tracePath, "utf8"));
+          return JSON.parse(fs20.readFileSync(tracePath, "utf8"));
         } catch {
           return null;
         }
@@ -60129,7 +60482,7 @@ async function handleForkCommand(host) {
 }
 
 // src/commands/interactive-skill-commands.ts
-import * as fs20 from "fs";
+import * as fs21 from "fs";
 import * as os4 from "os";
 import * as path20 from "path";
 
@@ -60473,7 +60826,7 @@ function expandSkillCommand(host, text) {
   const skill = host.skills.find((s) => s.name === skillName);
   if (!skill) return text;
   try {
-    const content = fs20.readFileSync(skill.filePath, "utf-8");
+    const content = fs21.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}.
@@ -60543,13 +60896,13 @@ async function handleSkillsCreate(host, args) {
     const skillDir = path20.join(skillsDir, name);
     const skillFile = path20.join(skillDir, "SKILL.md");
     console.error(`[SkillsCreate] Creating at: ${skillFile}`);
-    if (fs20.existsSync(skillDir)) {
+    if (fs21.existsSync(skillDir)) {
       host.showError(`Skill "${name}" already exists at ${skillDir}`);
       return;
     }
-    fs20.mkdirSync(skillDir, { recursive: true });
+    fs21.mkdirSync(skillDir, { recursive: true });
     const template = createSkillTemplate(name, description);
-    fs20.writeFileSync(skillFile, template, "utf-8");
+    fs21.writeFileSync(skillFile, template, "utf-8");
     console.error(`[SkillsCreate] Successfully created skill`);
     host.chatContainer.addChild(new Spacer(1));
     host.chatContainer.addChild(new Text(theme.fg("accent", `\u2713 Created skill: ${name}`), 1, 0));
@@ -62020,7 +62373,7 @@ function setupInteractiveEditorSubmitHandler(host) {
 }
 
 // src/input/interactive-file-pipeline.ts
-import * as fs23 from "fs";
+import * as fs24 from "fs";
 import * as path23 from "path";
 
 // src/components/file-picker.ts
@@ -62242,7 +62595,7 @@ var FilePickerComponent = class extends Container {
 };
 
 // src/files/commands/file-commands.ts
-import * as fs21 from "node:fs";
+import * as fs22 from "node:fs";
 import * as path21 from "node:path";
 var FileCommands = class {
   context;
@@ -62259,7 +62612,7 @@ var FileCommands = class {
       return;
     }
     const filePath = resolvePath(parsed.path);
-    if (!fs21.existsSync(filePath)) {
+    if (!fs22.existsSync(filePath)) {
       this.context.showError(`File not found: ${parsed.path}`);
       return;
     }
@@ -62298,7 +62651,7 @@ var FileCommands = class {
       return;
     }
     const resolvedPath = resolvePath(filePath);
-    if (!fs21.existsSync(resolvedPath)) {
+    if (!fs22.existsSync(resolvedPath)) {
       this.context.showError(`File not found: ${filePath}`);
       return;
     }
@@ -62329,7 +62682,7 @@ var FileCommands = class {
       return;
     }
     const resolvedPath = resolvePath(parsed.path);
-    if (!fs21.existsSync(resolvedPath)) {
+    if (!fs22.existsSync(resolvedPath)) {
       this.context.showError(`File not found: ${parsed.path}`);
       return;
     }
@@ -62807,7 +63160,7 @@ var FileStatusMonitor = class {
 };
 
 // src/files/mention/mention-handler.ts
-import * as fs22 from "node:fs";
+import * as fs23 from "node:fs";
 import * as path22 from "node:path";
 var MentionHandler = class {
   fileManager;
@@ -63177,8 +63530,8 @@ var MentionHandler = class {
     }
     if (this.isPath(query)) {
       const resolvedPath = resolvePath(query);
-      if (fs22.existsSync(resolvedPath)) {
-        const stats = fs22.statSync(resolvedPath);
+      if (fs23.existsSync(resolvedPath)) {
+        const stats = fs23.statSync(resolvedPath);
         if (stats.isFile()) {
           const type = FileCache.getFileTypeFromName(resolvedPath);
           const name = path22.basename(resolvedPath);
@@ -63202,7 +63555,7 @@ var MentionHandler = class {
       return void 0;
     }
     const queryPath = this.isPath(query) ? resolvePath(query) : void 0;
-    const filter = queryPath ? fs22.existsSync(queryPath) && fs22.statSync(queryPath).isDirectory() ? "" : path22.basename(queryPath) : query;
+    const filter = queryPath ? fs23.existsSync(queryPath) && fs23.statSync(queryPath).isDirectory() ? "" : path22.basename(queryPath) : query;
     const entries = this.fileManager.listPathEntries(currentDir, filter);
     const options = [];
     const homeDir = process.env.HOME || "";
@@ -63243,7 +63596,7 @@ var MentionHandler = class {
   getBrowserDirectory(query = this.currentQuery) {
     if (this.isPath(query)) {
       const resolvedPath = resolvePath(query);
-      if (fs22.existsSync(resolvedPath) && fs22.statSync(resolvedPath).isDirectory()) {
+      if (fs23.existsSync(resolvedPath) && fs23.statSync(resolvedPath).isDirectory()) {
         return resolvedPath;
       }
       return path22.dirname(resolvedPath);
@@ -63607,13 +63960,13 @@ function convertPreparedAttachmentItems(items) {
         break;
       case "image": {
         if (!item.data && !item.path) return void 0;
-        const data = item.data ?? fs23.readFileSync(item.path, "base64");
+        const data = item.data ?? fs24.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 ?? fs23.readFileSync(item.path, "base64");
+        const data = item.data ?? fs24.readFileSync(item.path, "base64");
         converted.push({ type: "video", data, mimeType: item.mimeType });
         break;
       }
@@ -65099,7 +65452,7 @@ var RUNTIME_MODE_CONTEXT_MARKER = "<runtime-mode-context>";
 var RUNTIME_MODE_CONTEXT_END_MARKER = "</runtime-mode-context>";
 var STALE_SYSTEM_REMINDER_RE = /<system-reminder>\s*# Plan Mode[\s\S]*?<\/system-reminder>\s*/gi;
 var STALE_RUNTIME_CONTEXT_RE = /<runtime-mode-context>[\s\S]*?<\/runtime-mode-context>\s*/gi;
-function isRecord2(value) {
+function isRecord3(value) {
   return !!value && typeof value === "object" && !Array.isArray(value);
 }
 function cleanText(text) {
@@ -65115,7 +65468,7 @@ function cleanText(text) {
   return { text: withoutPlanReminder, stripped };
 }
 function stripUserMessage(message) {
-  if (!isRecord2(message) || message.role !== "user") {
+  if (!isRecord3(message) || message.role !== "user") {
     return { message, stripped: 0 };
   }
   const content = message.content;
@@ -65135,13 +65488,13 @@ function stripUserMessage(message) {
   }
   let stripped = 0;
   const nextContent = content.map((block) => {
-    if (!isRecord2(block) || block.type !== "text" || typeof block.text !== "string") {
+    if (!isRecord3(block) || block.type !== "text" || typeof block.text !== "string") {
       return block;
     }
     const cleaned = cleanText(block.text);
     stripped += cleaned.stripped;
     return { ...block, text: cleaned.text };
-  }).filter((block) => !(isRecord2(block) && block.type === "text" && String(block.text ?? "").length === 0));
+  }).filter((block) => !(isRecord3(block) && block.type === "text" && String(block.text ?? "").length === 0));
   if (stripped === 0) return { message, stripped: 0 };
   return {
     message: {
@@ -65157,7 +65510,7 @@ function stripRuntimeModeContext(messages) {
   for (const message of messages) {
     const result = stripUserMessage(message);
     stripped += result.stripped;
-    if (isRecord2(result.message) && result.message.role === "user") {
+    if (isRecord3(result.message) && result.message.role === "user") {
       const content = result.message.content;
       if (typeof content === "string" && content.trim().length === 0) {
         continue;
@@ -65199,7 +65552,7 @@ function buildRuntimeModeContext(state) {
 function findLatestUserIndex(messages) {
   for (let index = messages.length - 1; index >= 0; index--) {
     const message = messages[index];
-    if (isRecord2(message) && message.role === "user") {
+    if (isRecord3(message) && message.role === "user") {
       return index;
     }
   }
@@ -65678,7 +66031,7 @@ var AttachmentResolver = class {
 };
 
 // src/extensions/loader.ts
-import * as fs24 from "node:fs";
+import * as fs25 from "node:fs";
 import * as os5 from "os";
 import * as path24 from "path";
 import { pathToFileURL } from "node:url";
@@ -65862,7 +66215,7 @@ function normalizeExtensionImportPath(extensionPath) {
 }
 async function loadExtension(extensionPath, cwd, uiContext, abortFn, isIdleFn, hasUI, actions) {
   const resolvedPath = resolvePath2(extensionPath, cwd);
-  if (!fs24.existsSync(resolvedPath)) {
+  if (!fs25.existsSync(resolvedPath)) {
     return { extension: null, error: `Extension not found: ${extensionPath}` };
   }
   try {
@@ -65883,12 +66236,12 @@ async function loadExtension(extensionPath, cwd, uiContext, abortFn, isIdleFn, h
   }
 }
 function discoverExtensionsInDir(dir) {
-  if (!fs24.existsSync(dir)) {
+  if (!fs25.existsSync(dir)) {
     return [];
   }
   const discovered = [];
   try {
-    const entries = fs24.readdirSync(dir, { withFileTypes: true });
+    const entries = fs25.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
       const entryPath = path24.join(dir, entry.name);
       if (entry.isFile() && (entry.name.endsWith(".cjs") || entry.name.endsWith(".js") || entry.name.endsWith(".ts"))) {
@@ -65897,13 +66250,13 @@ function discoverExtensionsInDir(dir) {
       }
       if (entry.isDirectory()) {
         const packageJsonPath = path24.join(entryPath, "package.json");
-        if (fs24.existsSync(packageJsonPath)) {
+        if (fs25.existsSync(packageJsonPath)) {
           try {
-            const pkg = JSON.parse(fs24.readFileSync(packageJsonPath, "utf-8"));
+            const pkg = JSON.parse(fs25.readFileSync(packageJsonPath, "utf-8"));
             const manifest = pkg.pie;
             if (manifest?.main) {
               const mainPath = path24.resolve(entryPath, manifest.main);
-              if (fs24.existsSync(mainPath)) {
+              if (fs25.existsSync(mainPath)) {
                 discovered.push({
                   entryPath: mainPath,
                   manifestName: manifest.name || pkg.name
@@ -65915,17 +66268,17 @@ function discoverExtensionsInDir(dir) {
           }
         }
         const indexCjs = path24.join(entryPath, "index.cjs");
-        if (fs24.existsSync(indexCjs)) {
+        if (fs25.existsSync(indexCjs)) {
           discovered.push({ entryPath: indexCjs });
           continue;
         }
         const indexJs = path24.join(entryPath, "index.js");
-        if (fs24.existsSync(indexJs)) {
+        if (fs25.existsSync(indexJs)) {
           discovered.push({ entryPath: indexJs });
           continue;
         }
         const indexTs = path24.join(entryPath, "index.ts");
-        if (fs24.existsSync(indexTs)) {
+        if (fs25.existsSync(indexTs)) {
           discovered.push({ entryPath: indexTs });
           continue;
         }
@@ -65974,11 +66327,11 @@ async function loadExtensions(configuredPaths, cwd, uiContext, abortFn, isIdleFn
   }
   for (const p of configuredPaths) {
     const resolved = resolvePath2(p, cwd);
-    if (!fs24.existsSync(resolved)) {
+    if (!fs25.existsSync(resolved)) {
       errors.push({ path: p, error: `Extension path not found: ${p}` });
       continue;
     }
-    if (!fs24.statSync(resolved).isDirectory()) {
+    if (!fs25.statSync(resolved).isDirectory()) {
       errors.push({ path: p, error: `Extension path must be a directory: ${p}` });
       continue;
     }
@@ -66962,7 +67315,7 @@ var InteractiveMode = class {
     if (savedLevel) {
       this.thinkingLevel = savedLevel;
     }
-    const { Agent } = await import("./chunks/src-7UV3KKGU.js");
+    const { Agent } = await import("./chunks/src-2FHZO63Y.js");
     const activeSession = this.sessionManager.getActiveSession();
     this.agent = new Agent({
       initialState: {
@@ -67364,10 +67717,12 @@ async function composeCliRuntime(params) {
     inputSummary: `provider=${settingsManager.getDefaultProvider() || "unset"} model=${settingsManager.getDefaultModel() || "unset"}`,
     outputSummary: `provider=${provider} model=${modelId} configured=${!initialModel.unconfigured}`
   });
-  const cwd = process.cwd();
+  const cwd = params.cwd ?? process.cwd();
   const sessionManager = createSessionManager({ sessionsDir: paths.sessionsDir });
   if (params.explicitSessionId) {
-    const loaded = await sessionManager.loadSession(params.explicitSessionId);
+    const loaded = await sessionManager.loadSession(params.explicitSessionId, {
+      warnIfMissing: params.warnIfExplicitSessionMissing
+    });
     if (!loaded) {
       await sessionManager.createSession(void 0, void 0, params.explicitSessionId);
     } else {
@@ -67391,6 +67746,11 @@ async function composeCliRuntime(params) {
     await sessionManager.createSession();
   }
   syncSessionModelMetadata(sessionManager, model, settingsManager.getDefaultThinkingLevel() || "off");
+  const activeSession = sessionManager.getActiveSession();
+  if (activeSession && activeSession.metadata.cwd !== cwd) {
+    activeSession.metadata.cwd = cwd;
+    await sessionManager.save();
+  }
   const sessionId = sessionManager.getActiveSession()?.id;
   const fileObservationState = createFileObservationState();
   if (sessionId) {
@@ -67633,7 +67993,7 @@ async function runPrintMode(params) {
 `);
     console.log("Assistant: ");
   }
-  const { Agent: AgentClass } = await import("./chunks/src-7UV3KKGU.js");
+  const { Agent: AgentClass } = await import("./chunks/src-2FHZO63Y.js");
   let agent;
   const printModeExtensions = await loadPrintModeExtensions({
     cwd: runtime.cwd,
@@ -67853,7 +68213,7 @@ function toJsonValue(value, depth = 0) {
   }
   return result;
 }
-function isRecord3(value) {
+function isRecord4(value) {
   return !!value && typeof value === "object" && !Array.isArray(value);
 }
 function parseInput(line) {
@@ -67863,7 +68223,7 @@ function parseInput(line) {
   } catch {
     return null;
   }
-  if (!isRecord3(parsed) || typeof parsed.type !== "string") return null;
+  if (!isRecord4(parsed) || typeof parsed.type !== "string") return null;
   if (parsed.type === "shutdown") {
     return { type: "shutdown", reason: typeof parsed.reason === "string" ? parsed.reason : void 0 };
   }
@@ -67882,7 +68242,7 @@ function parseInput(line) {
       turnId: parsed.turnId,
       prompt: parsed.prompt,
       cwd: typeof parsed.cwd === "string" ? parsed.cwd : void 0,
-      metadata: isRecord3(parsed.metadata) ? parsed.metadata : void 0
+      metadata: isRecord4(parsed.metadata) ? parsed.metadata : void 0
     };
   }
   return null;
@@ -67916,15 +68276,15 @@ function readProgressText(value) {
 function extractJsonEventsToolProgressText(partialResult) {
   const plainText = readProgressText(partialResult).trim();
   if (plainText) return plainText;
-  if (!isRecord3(partialResult)) return "";
+  if (!isRecord4(partialResult)) return "";
   const content = partialResult.content;
   if (Array.isArray(content)) {
-    return content.map((block) => isRecord3(block) && block.type === "text" ? readProgressText(block.text) : "").filter(Boolean).join("\n").trim();
+    return content.map((block) => isRecord4(block) && block.type === "text" ? readProgressText(block.text) : "").filter(Boolean).join("\n").trim();
   }
   const directText = readProgressText(partialResult.text) || readProgressText(partialResult.message);
   if (directText) return directText.trim();
   const details = partialResult.details;
-  if (isRecord3(details)) {
+  if (isRecord4(details)) {
     return (readProgressText(details.text) || readProgressText(details.message)).trim();
   }
   return "";
@@ -68011,12 +68371,14 @@ async function loadJsonModeExtensions(params) {
 async function runJsonEventsMode(params) {
   const sessionId = params.explicitSessionId || params.runtime?.sessionManager.getActiveSession()?.id || `pie-json-${Date.now()}`;
   let activeTurn = null;
+  let runtime = params.runtime;
   let agent;
   let controller;
   let disposeAgentSubscription;
   let disposeSemanticSubscription;
   let trace;
   let lastRetryEvent;
+  let mockActiveEntryId;
   const noProgressTimeoutMs = Number(process.env.PIE_JSON_EVENTS_NO_PROGRESS_MS || 6e5);
   const mockResponseDelayMs = Number(process.env.PIE_TEST_MOCK_RESPONSE_DELAY_MS || 0);
   writeEvent({ type: "agent.ready", sessionId });
@@ -68036,6 +68398,7 @@ async function runJsonEventsMode(params) {
   }
   function display(chunk, options) {
     if (!activeTurn || !chunk) return;
+    activeTurn.outputStarted = true;
     if (options?.appendToSummary !== false) {
       activeTurn.summary += chunk;
     }
@@ -68058,6 +68421,78 @@ async function runJsonEventsMode(params) {
       activeTurn.pendingAssistantOutput = "";
     }
   }
+  function activeHeadEntryId() {
+    return mockActiveEntryId ?? runtime?.sessionManager.getActiveEntryId() ?? void 0;
+  }
+  function persistedMockMetadata(existing, activeEntryId, rootEntryId, cwd) {
+    const metadata = {};
+    if (existing) {
+      for (const [key, value] of Object.entries(existing)) {
+        if (["id", "createdAt", "updatedAt", "entryCount", "messageCount", "activeEntryId", "rootEntryId"].includes(key)) {
+          continue;
+        }
+        metadata[key] = value;
+      }
+    }
+    metadata.name = typeof existing?.name === "string" ? existing.name : `Session ${sessionId.slice(0, 8)}`;
+    if (cwd || existing?.cwd || runtime?.cwd) {
+      metadata.cwd = cwd ?? existing?.cwd ?? runtime?.cwd;
+    }
+    metadata.activeEntryId = activeEntryId;
+    metadata.rootEntryId = existing?.rootEntryId ?? rootEntryId;
+    return metadata;
+  }
+  async function persistMockTurn(message, assistantText) {
+    const store = new FileSessionStore(getSessionsDir());
+    const existing = await store.load(message.sessionId ?? sessionId);
+    const startedAt = activeTurn?.startedAt ?? Date.now();
+    const userEntryId = generateEntryId();
+    const assistantEntryId = generateEntryId();
+    const parentId = existing?.metadata.activeEntryId ?? null;
+    const userEntry = {
+      id: userEntryId,
+      parentId,
+      type: "message",
+      timestamp: startedAt,
+      message: {
+        role: "user",
+        content: message.prompt,
+        timestamp: startedAt
+      }
+    };
+    const assistantTimestamp = Date.now();
+    const assistantMessage = {
+      role: "assistant",
+      content: [{ type: "text", text: assistantText }],
+      api: "mock",
+      provider: "mock",
+      model: "mock",
+      usage: {
+        input: 0,
+        output: 0,
+        cacheRead: 0,
+        cacheWrite: 0,
+        totalTokens: 0,
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 }
+      },
+      stopReason: "stop",
+      timestamp: assistantTimestamp
+    };
+    const assistantEntry = {
+      id: assistantEntryId,
+      parentId: userEntryId,
+      type: "message",
+      timestamp: assistantTimestamp,
+      message: assistantMessage
+    };
+    const entries = [...existing?.entries ?? [], userEntry, assistantEntry];
+    await store.save(
+      message.sessionId ?? sessionId,
+      entries,
+      persistedMockMetadata(existing?.metadata, assistantEntryId, existing?.metadata.rootEntryId ?? userEntryId, message.cwd)
+    );
+    return assistantEntryId;
+  }
   function flushAssistantOutput(fallbackText = "") {
     if (!activeTurn) return;
     const chunk = activeTurn.pendingAssistantOutput || fallbackText;
@@ -68070,21 +68505,38 @@ async function runJsonEventsMode(params) {
     const turn = activeTurn;
     if (!turn || turn.finalized) return;
     turn.finalized = true;
+    const headEntryId = activeHeadEntryId();
+    const base = {
+      sessionId: turn.sessionId,
+      turnId: turn.turnId,
+      headEntryId,
+      activeEntryId: headEntryId
+    };
     switch (kind) {
       case "completed":
-        writeEvent({ type: "turn.completed", sessionId: turn.sessionId, turnId: turn.turnId, summary: (detail ?? turn.summary).trim() });
+        writeEvent({ type: "turn.completed", ...base, summary: (detail ?? turn.summary).trim() });
         break;
       case "failed":
-        writeEvent({ type: "turn.failed", sessionId: turn.sessionId, turnId: turn.turnId, error: detail || "turn failed" });
+        writeEvent({ type: "turn.failed", ...base, error: detail || "turn failed" });
         break;
       case "cancelled":
-        writeEvent({ type: "turn.cancelled", sessionId: turn.sessionId, turnId: turn.turnId, reason: detail || "interrupted" });
+        writeEvent({ type: "turn.cancelled", ...base, reason: detail || "interrupted" });
         break;
       case "stalled":
-        writeEvent({ type: "turn.stalled", sessionId: turn.sessionId, turnId: turn.turnId, reason: detail || "no_progress_timeout" });
+        writeEvent({ type: "turn.stalled", ...base, reason: detail || "no_progress_timeout" });
         break;
     }
   }
+  function emitSettled(turn) {
+    const headEntryId = activeHeadEntryId();
+    writeEvent({
+      type: "turn.settled",
+      sessionId: turn.sessionId,
+      turnId: turn.turnId,
+      headEntryId,
+      activeEntryId: headEntryId
+    });
+  }
   function rememberTerminal(kind, detail, options) {
     if (!activeTurn || activeTurn.finalized) return;
     if (activeTurn.pendingTerminal && options?.overwrite === false) return;
@@ -68144,15 +68596,10 @@ async function runJsonEventsMode(params) {
   function handleControllerEvent(event) {
     trace?.noteRuntimeEvent(event.type, event);
     if (event.type === "auto_compaction_end" && !event.errorMessage) {
-      params.runtime?.fileObservationState.clear();
+      runtime?.fileObservationState.clear();
     }
     if (event.type === "turn_settled" && activeTurn) {
-      finalizePendingTerminal();
-      writeEvent({
-        type: "turn.settled",
-        sessionId: activeTurn.sessionId,
-        turnId: activeTurn.turnId
-      });
+      touch();
       return;
     }
     if (!activeTurn || activeTurn.finalized) return;
@@ -68252,16 +68699,35 @@ async function runJsonEventsMode(params) {
       rememberTerminal("cancelled", event.reason, { overwrite: false });
     }
   }
-  async function ensureRuntime() {
-    if (params.mockResponse !== void 0 || controller) return;
-    const runtime = params.runtime;
+  async function disposeRuntime() {
+    disposeAgentSubscription?.();
+    disposeAgentSubscription = void 0;
+    disposeSemanticSubscription?.();
+    disposeSemanticSubscription = void 0;
+    controller?.dispose();
+    controller = void 0;
+    agent = void 0;
+    try {
+      await runtime?.sessionManager.save();
+    } catch {
+    }
+    trace?.flush();
+    trace = void 0;
+  }
+  async function ensureRuntime(requestedCwd) {
+    if (params.mockResponse !== void 0) return;
+    const effectiveCwd = requestedCwd ?? process.cwd();
+    if (params.createRuntime && (!runtime || runtime.cwd !== effectiveCwd)) {
+      await disposeRuntime();
+      runtime = await params.createRuntime({ cwd: effectiveCwd, sessionId });
+    }
     if (!runtime) {
       throw new Error("JSON events mode requires a CLI runtime");
     }
-    if (runtime.initialModel.unconfigured) {
+    if (runtime.initialModel.unconfigured || controller) {
       return;
     }
-    const { Agent: AgentClass } = await import("./chunks/src-7UV3KKGU.js");
+    const { Agent: AgentClass } = await import("./chunks/src-2FHZO63Y.js");
     const jsonModeExtensions = await loadJsonModeExtensions({ runtime, getAgent: () => agent });
     const tools = [...runtime.tools, ...jsonModeExtensions.extensionTools];
     recordCliCompositionStep(runtime.compositionTrace, {
@@ -68367,6 +68833,7 @@ async function runJsonEventsMode(params) {
       interrupted: false,
       stalled: false,
       finalized: false,
+      outputStarted: false,
       summary: "",
       pendingAssistantOutput: ""
     };
@@ -68380,30 +68847,43 @@ async function runJsonEventsMode(params) {
         return;
       }
       display(params.mockResponse);
+      try {
+        mockActiveEntryId = await persistMockTurn(message, params.mockResponse);
+      } catch (error) {
+        finalize("failed", error instanceof Error ? error.message : String(error));
+        if (activeTurn === turn) emitSettled(turn);
+        if (activeTurn === turn) activeTurn = null;
+        return;
+      }
       finalize("completed");
+      if (activeTurn === turn) emitSettled(turn);
       if (activeTurn === turn) activeTurn = null;
       return;
     }
     if (params.startupError) {
       finalize("failed", params.startupError);
+      if (activeTurn === turn) emitSettled(turn);
       if (activeTurn === turn) activeTurn = null;
       return;
     }
     try {
-      await ensureRuntime();
+      await ensureRuntime(message.cwd);
     } catch (error) {
       finalize("failed", error instanceof Error ? error.message : String(error));
+      if (activeTurn === turn) emitSettled(turn);
       if (activeTurn === turn) activeTurn = null;
       return;
     }
-    const runtime = params.runtime;
-    if (runtime?.initialModel.unconfigured) {
-      finalize("failed", runtime.initialModel.warning || "No models are configured.");
+    const activeRuntime = runtime;
+    if (activeRuntime?.initialModel.unconfigured) {
+      finalize("failed", activeRuntime.initialModel.warning || "No models are configured.");
+      if (activeTurn === turn) emitSettled(turn);
       if (activeTurn === turn) activeTurn = null;
       return;
     }
     if (!controller || !agent) {
       finalize("failed", "JSON events runtime was not initialized");
+      if (activeTurn === turn) emitSettled(turn);
       if (activeTurn === turn) activeTurn = null;
       return;
     }
@@ -68425,31 +68905,36 @@ async function runJsonEventsMode(params) {
       trace?.noteWaitForIdleStart({ mode: "json-events" });
       await controller.waitForSettled();
       trace?.noteWaitForIdleSettled({ mode: "json-events" });
+      await activeRuntime?.sessionManager.save();
       finalizePendingTerminal();
       if (!activeTurn?.finalized) {
         const finalError = assistantErrorFromAgent(agent);
         if (activeTurn?.interrupted) {
           finalize("cancelled", "user_interrupt");
-          return;
-        }
-        if (finalError) {
+        } else if (finalError) {
           finalize("failed", finalError);
-          return;
+        } else {
+          const text = assistantTextFromAgent(agent);
+          flushAssistantOutput(text);
+          finalize("completed", text || activeTurn?.summary.trim());
         }
-        const text = assistantTextFromAgent(agent);
-        flushAssistantOutput(text);
-        finalize("completed", text || activeTurn?.summary.trim());
       }
+      if (activeTurn === turn) emitSettled(turn);
     } catch (error) {
       const messageText = error instanceof Error ? error.message : String(error);
       trace?.noteStalled(messageText, { mode: "json-events" });
+      try {
+        await activeRuntime?.sessionManager.save();
+      } catch {
+      }
       if (!activeTurn?.finalized) {
         finalize(activeTurn?.interrupted ? "cancelled" : "failed", activeTurn?.interrupted ? "user_interrupt" : messageText);
       }
+      if (activeTurn === turn) emitSettled(turn);
     } finally {
       clearInterval(progressTimer);
       trace?.flush();
-      await runtime?.sessionManager.save();
+      await activeRuntime?.sessionManager.save();
       if (activeTurn === turn) activeTurn = null;
     }
   }
@@ -68481,12 +68966,29 @@ async function runJsonEventsMode(params) {
       });
       return;
     }
+    if (params.mockResponse !== void 0) {
+      if (activeTurn.outputStarted) return;
+      activeTurn.interrupted = true;
+      finalize("cancelled", message.reason || "user_interrupt");
+      emitSettled(activeTurn);
+      activeTurn = null;
+      return;
+    }
     activeTurn.interrupted = true;
     controller?.abort();
+  }
+  function shutdownActiveTurn(reason) {
+    if (!activeTurn || activeTurn.finalized) return;
     if (params.mockResponse !== void 0) {
-      finalize("cancelled", message.reason || "user_interrupt");
+      if (activeTurn.outputStarted) return;
+      activeTurn.interrupted = true;
+      finalize("cancelled", reason || "shutdown");
+      emitSettled(activeTurn);
       activeTurn = null;
+      return;
     }
+    activeTurn.interrupted = true;
+    controller?.abort();
   }
   const input = readline.createInterface({ input: process.stdin });
   let activeTurnPromise = null;
@@ -68498,15 +69000,7 @@ async function runJsonEventsMode(params) {
       continue;
     }
     if (message.type === "shutdown") {
-      if (activeTurn && !activeTurn.finalized) {
-        activeTurn.interrupted = true;
-        controller?.abort();
-        if (!controller) {
-          finalize("cancelled", message.reason || "shutdown");
-        } else {
-          rememberTerminal("cancelled", message.reason || "shutdown");
-        }
-      }
+      shutdownActiveTurn(message.reason);
       break;
     }
     if (message.type === "turn.interrupt") {
@@ -68531,11 +69025,7 @@ async function runJsonEventsMode(params) {
     }
   }
   await activeTurnPromise;
-  disposeAgentSubscription?.();
-  disposeSemanticSubscription?.();
-  controller?.dispose();
-  await params.runtime?.sessionManager.save();
-  trace?.flush();
+  await disposeRuntime();
 }
 
 // src/cli.ts
@@ -68544,8 +69034,8 @@ var logError = (msg, err) => {
   const logPath = getRuntimeLogPath();
   const timestamp = (/* @__PURE__ */ new Date()).toISOString();
   const stack = err instanceof Error ? err.stack || "" : "";
-  fs25.mkdirSync(path26.dirname(logPath), { recursive: true });
-  fs25.appendFileSync(logPath, `[${timestamp}] ${msg}
+  fs26.mkdirSync(path26.dirname(logPath), { recursive: true });
+  fs26.appendFileSync(logPath, `[${timestamp}] ${msg}
 ${stack}
 
 `);
@@ -68564,6 +69054,7 @@ Commands:
   doctor           Diagnose local Pie configuration and runtime dependencies
   models init      Create a starter ~/.pie/models.json
   models validate  Validate ~/.pie/models.json
+  sessions         List, read, rename, rewind, and fork Pie sessions
   permissions      Explain Pie tool and shell safety defaults
   help             Show this help message
 
@@ -68688,7 +69179,7 @@ async function createCliTestStreamFnFromEnv() {
   if (!process.env.PIE_TEST_MOCK_STREAM_SEQUENCE) {
     return void 0;
   }
-  const { createTestStreamFnFromSequenceEnv } = await import("./chunks/test-stream-PP63L7MK.js");
+  const { createTestStreamFnFromSequenceEnv } = await import("./chunks/test-stream-UW74PA6T.js");
   return createTestStreamFnFromSequenceEnv();
 }
 async function startChat(initialPrompt, testCommand) {
@@ -68707,23 +69198,15 @@ async function startChat(initialPrompt, testCommand) {
         });
         return;
       }
-      let runtime2;
-      try {
-        runtime2 = await composeCliRuntime({ explicitSessionId, extensionPaths });
-      } catch (error) {
-        if (error instanceof CliMissingApiKeyError) {
-          await runJsonEventsMode({
-            explicitSessionId,
-            startupError: error.message
-          });
-          return;
-        }
-        throw error;
-      }
       await runJsonEventsMode({
-        runtime: runtime2,
         explicitSessionId,
-        streamFn: await createCliTestStreamFnFromEnv()
+        streamFn: await createCliTestStreamFnFromEnv(),
+        createRuntime: async ({ cwd, sessionId }) => composeCliRuntime({
+          explicitSessionId: explicitSessionId ?? sessionId,
+          extensionPaths,
+          cwd,
+          warnIfExplicitSessionMissing: false
+        })
       });
     });
     return;
@@ -68794,6 +69277,10 @@ async function startChat(initialPrompt, testCommand) {
 }
 async function main() {
   const args = process.argv.slice(2);
+  if (args[0] === "--version" || args[0] === "-v") {
+    console.log(VERSION);
+    return;
+  }
   if (args[0] === "doctor") {
     await runDoctorCommand(args.slice(1));
     return;
@@ -68807,6 +69294,10 @@ async function main() {
     }
     return;
   }
+  if (args[0] === "sessions") {
+    await runSessionsCommand(args.slice(1));
+    return;
+  }
   if (args[0] === "permissions") {
     console.log(formatPermissionsHelp());
     return;