ai-whisper 0.5.9 → 0.6.0

package/dist/bin/companion-agent.js

@@ -5914,6 +5914,7 @@ function createLiveSessionRuntime(input) {
   let relayPreviewVisible = false;
   let inputState = {};
   let pausedInputDepth = 0;
+  let overlayPush = null;
   function setMountedRawMode(mode) {
     if (canManageRawMode) {
       ttyStdin.setRawMode?.(mode);
@@ -6004,6 +6005,10 @@ function createLiveSessionRuntime(input) {
     }
   }
   async function processChunk(raw) {
+    if (overlayPush) {
+      overlayPush(raw);
+      return;
+    }
     const normalized = normalizeTerminalInput({
       raw,
       state: inputState
@@ -6146,6 +6151,42 @@ function createLiveSessionRuntime(input) {
         }
       }
     },
+    async runInteractiveOverlay(run) {
+      pausedInputDepth += 1;
+      setMountedRawMode(true);
+      const buf = [];
+      const wakeHolder = { fn: null };
+      let done = false;
+      overlayPush = (chunk) => {
+        buf.push(chunk);
+        wakeHolder.fn?.();
+      };
+      const keys = (async function* () {
+        for (; ; ) {
+          if (buf.length) {
+            yield buf.shift();
+            continue;
+          }
+          if (done) return;
+          await new Promise((r) => wakeHolder.fn = r);
+        }
+      })();
+      try {
+        await run({
+          keys,
+          write: (s) => input.stdout.write(s),
+          setRawMode: (on) => setMountedRawMode(on)
+        });
+      } finally {
+        done = true;
+        const fn = wakeHolder.fn;
+        wakeHolder.fn = null;
+        fn?.();
+        overlayPush = null;
+        pausedInputDepth = Math.max(0, pausedInputDepth - 1);
+        setMountedRawMode(true);
+      }
+    },
     async stop() {
       clearRelayPreview();
       setMountedRawMode(Boolean(previousRawMode));
@@ -7326,10 +7367,21 @@ function isProtocolCompatible(theirs, ours = PROTOCOL_VERSION) {
 // ../../node_modules/.pnpm/@ai-ezio+harness@file+..+ai-ezio+packages+harness/node_modules/@ai-ezio/harness/dist/turn-gate.js
 var TurnGate = class {
   tail = Promise.resolve();
+  heldCount = 0;
+  /** True while any acquirer (queued or active) is outstanding. */
+  get held() {
+    return this.heldCount > 0;
+  }
   /** Resolves with a release function once every earlier acquirer released. */
   acquire() {
+    this.heldCount += 1;
     let release;
-    const held = new Promise((r) => release = r);
+    const held = new Promise((r) => {
+      release = () => {
+        this.heldCount -= 1;
+        r();
+      };
+    });
     const turn = this.tail.then(() => release);
     this.tail = this.tail.then(() => held);
     return turn;
@@ -7357,6 +7409,12 @@ var EngineExitedError = class extends Error {
     this.name = "EngineExitedError";
   }
 };
+var EngineBusyError = class extends Error {
+  constructor(message = "cannot resume while a turn is in flight") {
+    super(message);
+    this.name = "EngineBusyError";
+  }
+};
 var CompactTimeoutError = class extends Error {
   constructor(ms) {
     super(`compact control timed out after ${ms}ms (no compacted event)`);
@@ -7373,6 +7431,13 @@ var Session = class {
   closed = false;
   exitHandlers = [];
   ready;
+  /** Bumped on every spawn (start + resume). The pump closure captures its own
+   * generation; a stale generation's events and EOF are dropped, so a closed
+   * child cannot corrupt a freshly-respawned session. */
+  generation = 0;
+  /** Resolves when the CURRENT pump's `for await` loop has fully unwound
+   * (its `finally` ran). `resume()` awaits this to sequence teardown. */
+  pumpDone = Promise.resolve();
   _transcriptPath;
   /** The `HAX_TRANSCRIPT` mirror path this session was started with, if any.
    * Consumers (ezio CLI, ai-whisper) read it here rather than re-deriving the
@@ -7504,25 +7569,40 @@ var Session = class {
   }
   /** Spawn hax, pump events, and gate on the `ready` protocol version. */
   async start(options = {}) {
+    return this.spawnAndPump(options);
+  }
+  /** Spawn the child, launch the (generation-stamped) event pump, and resolve
+   * the `ready` version gate. Shared by start() and resume() so the pump is
+   * stamped in exactly one place. Captures the CURRENT generation — callers that
+   * need a fresh generation (resume) bump it before calling. */
+  async spawnAndPump(options) {
     this._transcriptPath = options.transcriptPath;
-    const spawned = spawnHax(options);
+    const gen = this.generation;
+    const spawned = (this.options.spawn ?? spawnHax)(options);
     this.spawned = spawned;
     spawned.child.on("exit", (code, signal) => {
+      if (gen !== this.generation)
+        return;
       for (const handler of this.exitHandlers)
         handler({ code, signal });
     });
-    const transport = new FdTransport(spawned.eventStream, spawned.controlStream);
+    const transport = (this.options.transportFactory ?? ((e, c) => new FdTransport(e, c)))(spawned.eventStream, spawned.controlStream);
     this.transport = transport;
-    void (async () => {
+    this.pumpDone = (async () => {
       try {
-        for await (const event of transport.events())
+        for await (const event of transport.events()) {
+          if (gen !== this.generation)
+            continue;
           this.deliver(event);
+        }
       } finally {
-        this.ended = true;
-        while (this.idleHooks.length)
-          this.idleHooks.shift()();
-        while (this.waiters.length || this.exclusiveWaiters.length)
-          this.deliver(null);
+        if (gen === this.generation) {
+          this.ended = true;
+          while (this.idleHooks.length)
+            this.idleHooks.shift()();
+          while (this.waiters.length || this.exclusiveWaiters.length)
+            this.deliver(null);
+        }
       }
     })();
     const ready = await this.waitForEvent("ready");
@@ -7694,6 +7774,47 @@ var Session = class {
       throw new Error("unexpected event");
     return { turnId: e.turnId, content: e.content };
   }
+  /** Switch this session to a past one: tear down the current hax child, reset
+   * lifecycle state, and respawn headless hax with `--resume=ID` plus the prior
+   * options. The constructor-bound onEvent stays attached. Rejects (engine left
+   * closed) on spawn/protocol failure. Refuses while a turn holds the gate. */
+  async resume(sessionId, options = {}) {
+    if (this.gate.held) {
+      throw new EngineBusyError();
+    }
+    const release = await this.gate.acquire();
+    try {
+      const dying = this.pumpDone;
+      this.generation += 1;
+      this.close();
+      await dying;
+      this.resetLifecycleLatches();
+      const args = [...options.args ?? [], `--resume=${sessionId}`];
+      return await this.spawnAndPump({
+        ...options,
+        args,
+        transcriptPath: options.transcriptPath ?? this._transcriptPath
+      });
+    } finally {
+      release();
+    }
+  }
+  /** Clear the close()/EOF latches and any parked stream state so the same
+   * Session object is reusable across a respawn. Safe only between turns (resume
+   * holds the gate, so no waiters are outstanding). */
+  resetLifecycleLatches() {
+    this.closed = false;
+    this.ended = false;
+    this.ready = void 0;
+    this.queue.length = 0;
+    this.waiters.length = 0;
+    this.exclusiveQueue.length = 0;
+    this.exclusiveWaiters.length = 0;
+    this.idleHooks.length = 0;
+    this.swallowNextIdle = false;
+    this.staleCompactsPending = 0;
+    this.cycleInternal = false;
+  }
   /** Start a fresh conversation; resolves once the engine is idle again.
    * Gate-serialized like every turn initiator (M11). */
   async newConversation() {
@@ -7931,6 +8052,122 @@ function createAutoCompactDriver(opts) {
   };
 }
 
+// ../../node_modules/.pnpm/@ai-ezio+harness@file+..+ai-ezio+packages+harness/node_modules/@ai-ezio/harness/dist/session-titles.js
+import { join as join11 } from "node:path";
+import { mkdirSync as mkdirSync4, readFileSync as readFileSync3, renameSync, writeFileSync as writeFileSync3 } from "node:fs";
+import { dirname as dirname4 } from "node:path";
+var nodeTitleFs = {
+  readFileSync: (p) => {
+    try {
+      return readFileSync3(p, "utf8");
+    } catch {
+      return void 0;
+    }
+  },
+  writeFileSync: (p, d) => writeFileSync3(p, d),
+  renameSync: (from, to) => renameSync(from, to),
+  mkdirSync: (dir) => void mkdirSync4(dir, { recursive: true })
+};
+function defaultTitleStorePath(env = process.env) {
+  const base = env.XDG_STATE_HOME || join11(env.HOME ?? "", ".local", "state");
+  return join11(base, "ai-ezio", "session-titles.json");
+}
+function createSessionTitleStore(opts = {}) {
+  const filePath = opts.filePath ?? defaultTitleStorePath();
+  const fs2 = opts.fs ?? nodeTitleFs;
+  const read = () => {
+    const raw = fs2.readFileSync(filePath);
+    if (!raw)
+      return {};
+    try {
+      const parsed = JSON.parse(raw);
+      return parsed && typeof parsed === "object" ? parsed : {};
+    } catch {
+      return {};
+    }
+  };
+  return {
+    getTitle: (id) => {
+      const rec = read()[id];
+      return rec && typeof rec.title === "string" ? rec.title : void 0;
+    },
+    setTitle: (id, title) => {
+      const t = title.trim();
+      if (t === "")
+        return;
+      const all = read();
+      all[id] = { title: t, updatedAt: clockNow() };
+      fs2.mkdirSync(dirname4(filePath));
+      const tmp = `${filePath}.tmp`;
+      fs2.writeFileSync(tmp, JSON.stringify(all, null, "	"));
+      fs2.renameSync(tmp, filePath);
+    },
+    loadTitles: () => {
+      const all = read();
+      const map = /* @__PURE__ */ new Map();
+      for (const [id, rec] of Object.entries(all)) {
+        if (rec && typeof rec.title === "string")
+          map.set(id, rec.title);
+      }
+      return map;
+    }
+  };
+}
+function clockNow() {
+  return Date.now();
+}
+function normalizeId(id) {
+  return id && id !== "unknown" ? id : void 0;
+}
+function createRenameController(deps) {
+  let currentId;
+  let pendingTitle;
+  let statusRequested = false;
+  const requestStatusOnce = () => {
+    if (statusRequested)
+      return;
+    statusRequested = true;
+    deps.requestStatus();
+  };
+  const setId = (id) => {
+    const next = normalizeId(id);
+    if (!next || next === currentId)
+      return;
+    currentId = next;
+    if (pendingTitle !== void 0) {
+      deps.store.setTitle(next, pendingTitle);
+      pendingTitle = void 0;
+    }
+  };
+  return {
+    currentSessionId: () => currentId,
+    getSessionTitle: () => pendingTitle ?? (currentId ? deps.store.getTitle(currentId) : void 0),
+    setSessionTitle: (title) => {
+      const t = title.trim();
+      if (t === "")
+        return;
+      if (currentId)
+        deps.store.setTitle(currentId, t);
+      else
+        pendingTitle = t;
+    },
+    noteEvent: (event) => {
+      if (event.type === "ready" || event.type === "status") {
+        statusRequested = false;
+        setId(event.sessionId);
+      } else if (event.type === "idle" && currentId === void 0) {
+        requestStatusOnce();
+      }
+    },
+    noteNewConversation: () => {
+      pendingTitle = void 0;
+      currentId = void 0;
+      statusRequested = false;
+      requestStatusOnce();
+    }
+  };
+}
+
 // ../adapter-ai-ezio/dist/ai-ezio-engine.js
 var defaultCreateEngineSession = ({ onEvent }) => new Session({ onEvent });
 
@@ -8214,11 +8451,11 @@ async function callHostRehydration(host) {
 }
 
 // ../../node_modules/.pnpm/@ai-ezio+mcp-host@file+..+ai-ezio+packages+mcp-host_zod@3.25.76/node_modules/@ai-ezio/mcp-host/dist/config.js
-import { readFileSync as readFileSync3 } from "node:fs";
-import { join as join11 } from "node:path";
+import { readFileSync as readFileSync4 } from "node:fs";
+import { join as join12 } from "node:path";
 function configPath(env = process.env) {
-  const base = env.XDG_CONFIG_HOME?.trim() || join11(env.HOME ?? "", ".config");
-  return join11(base, "ai-ezio", "mcp.json");
+  const base = env.XDG_CONFIG_HOME?.trim() || join12(env.HOME ?? "", ".config");
+  return join12(base, "ai-ezio", "mcp.json");
 }
 function parseConfig(text) {
   if (!text || !text.trim())
@@ -8238,7 +8475,7 @@ function parseConfig(text) {
 }
 function loadConfig2(env = process.env) {
   try {
-    return parseConfig(readFileSync3(configPath(env), "utf8"));
+    return parseConfig(readFileSync4(configPath(env), "utf8"));
   } catch {
     return { servers: [], toolPolicy: {}, hostPrivateTools: [] };
   }
@@ -8406,8 +8643,8 @@ function fmtTokens(n) {
   return `${Math.floor((n + 512 * 1024) / (1024 * 1024))}M`;
 }
 function truncate(s, max = ARG_MAX) {
-  const oneLine = s.replace(/\s+/g, " ").trim();
-  return oneLine.length > max ? `${oneLine.slice(0, max - 1)}\u2026` : oneLine;
+  const oneLine2 = s.replace(/\s+/g, " ").trim();
+  return oneLine2.length > max ? `${oneLine2.slice(0, max - 1)}\u2026` : oneLine2;
 }
 function createMountedRenderer(input) {
   const utf8 = input.utf8 ?? true;
@@ -8550,6 +8787,9 @@ ${prompt}`);
     renderPrompt,
     handle(event) {
       switch (event.type) {
+        case "ready":
+          bannerRendered = false;
+          break;
         case "status":
           if (!bannerRendered) {
             renderBanner(event.provider, event.model, event.effort ?? "");
@@ -8602,23 +8842,23 @@ ${RED}\u258C ${event.message}${RESET2}`);
 }
 
 // ../../node_modules/.pnpm/@ai-ezio+surface@file+..+ai-ezio+packages+surface/node_modules/@ai-ezio/surface/dist/skills.js
-import { readdirSync as readdirSync2, readFileSync as readFileSync4, statSync as statSync3 } from "node:fs";
-import { join as join12 } from "node:path";
+import { readdirSync as readdirSync2, readFileSync as readFileSync5, statSync as statSync3 } from "node:fs";
+import { join as join13 } from "node:path";
 function configBase(env) {
-  return env.xdgConfigHome && env.xdgConfigHome !== "" ? env.xdgConfigHome : join12(env.home, ".config");
+  return env.xdgConfigHome && env.xdgConfigHome !== "" ? env.xdgConfigHome : join13(env.home, ".config");
 }
 function skillDirs(env) {
   const base = configBase(env);
   return [
-    { source: "project", path: join12(env.cwd, ".agents", "skills"), engineVisible: true },
+    { source: "project", path: join13(env.cwd, ".agents", "skills"), engineVisible: true },
     {
       source: "ai-ezio-global",
-      path: join12(base, "ai-ezio", "skills"),
+      path: join13(base, "ai-ezio", "skills"),
       // Engine-visible as of M4: ai-ezio sets HAX_EXTRA_SKILLS_DIR to this dir
       // on launch, so hax injects these skills into the model prompt.
       engineVisible: true
     },
-    { source: "hax-global", path: join12(base, "hax", "skills"), engineVisible: true }
+    { source: "hax-global", path: join13(base, "hax", "skills"), engineVisible: true }
   ];
 }
 function parseSkillDescription(md) {
@@ -8649,7 +8889,7 @@ function discoverSkills(env, fs2) {
     for (const name of fs2.listDirs(dir.path)) {
       if (byName.has(name))
         continue;
-      const skillMdPath = join12(dir.path, name, "SKILL.md");
+      const skillMdPath = join13(dir.path, name, "SKILL.md");
       const md = fs2.readFile(skillMdPath);
       if (md === null)
         continue;
@@ -8682,7 +8922,7 @@ function nodeSkillFs() {
     },
     readFile: (path) => {
       try {
-        return readFileSync4(path, "utf8");
+        return readFileSync5(path, "utf8");
       } catch {
         return null;
       }
@@ -8717,7 +8957,7 @@ function makeClipboard(platform, spawnFn = spawn6) {
 }
 
 // ../../node_modules/.pnpm/@ai-ezio+surface@file+..+ai-ezio+packages+surface/node_modules/@ai-ezio/surface/dist/transcript-view.js
-import { join as join13 } from "node:path";
+import { join as join14 } from "node:path";
 async function showTranscript(deps) {
   const text = deps.path ? deps.readText(deps.path) : void 0;
   if (text === void 0 || text === "") {
@@ -8740,6 +8980,157 @@ async function showTranscript(deps) {
   }
 }
 
+// ../../node_modules/.pnpm/@ai-ezio+surface@file+..+ai-ezio+packages+surface/node_modules/@ai-ezio/surface/dist/resume-picker.js
+var PAGE_SIZE = 15;
+function parseSessions(json) {
+  let raw;
+  try {
+    raw = JSON.parse(json);
+  } catch {
+    return [];
+  }
+  if (!Array.isArray(raw))
+    return [];
+  const rows = [];
+  for (const e of raw) {
+    if (!e || typeof e !== "object")
+      continue;
+    const o = e;
+    if (typeof o.id !== "string" || o.id === "")
+      continue;
+    rows.push({
+      id: o.id,
+      mtime: typeof o.mtime === "number" ? o.mtime : 0,
+      firstPrompt: typeof o.firstPrompt === "string" ? o.firstPrompt : null
+    });
+  }
+  return rows;
+}
+function formatRelativeTime(mtimeSec, nowMs) {
+  const diff = Math.max(0, Math.floor(nowMs / 1e3) - mtimeSec);
+  if (diff < 60)
+    return "just now";
+  if (diff < 3600)
+    return `${Math.floor(diff / 60)}m ago`;
+  if (diff < 86400)
+    return `${Math.floor(diff / 3600)}h ago`;
+  return `${Math.floor(diff / 86400)}d ago`;
+}
+function formatRow(row, nowMs, title) {
+  const age = formatRelativeTime(row.mtime, nowMs);
+  const label = (title ?? row.firstPrompt ?? "(no prompt)").replace(/\s+/g, " ").trim();
+  const clamped = label.length > 70 ? `${label.slice(0, 69)}\u2026` : label;
+  return `${age} \xB7 ${clamped}`;
+}
+function decodeChunk(s) {
+  if (s === "\x1B[A" || s === "\x1BOA" || s === "k")
+    return "up";
+  if (s === "\x1B[B" || s === "\x1BOB" || s === "j")
+    return "down";
+  if (s === "\r" || s === "\n")
+    return "enter";
+  if (s === "\x1B" || s === "" || s === "" || s === "q")
+    return "cancel";
+  if (s === "[")
+    return "pageprev";
+  if (s === "]")
+    return "pagenext";
+  if (s === "
")
+    return "toggleall";
+  return "other";
+}
+function applyKey(state, token) {
+  const { index, count, pageSize, showAll } = state;
+  const pageStart = Math.floor(index / pageSize) * pageSize;
+  const pageEnd = Math.min(count - 1, pageStart + pageSize - 1);
+  const keep = { index, showAll };
+  switch (token) {
+    case "up":
+      return { index: Math.max(showAll ? 0 : pageStart, index - 1), showAll };
+    case "down":
+      return { index: Math.min(showAll ? count - 1 : pageEnd, index + 1), showAll };
+    case "pageprev":
+      return !showAll && pageStart > 0 ? { index: pageStart - pageSize, showAll } : keep;
+    case "pagenext":
+      return !showAll && pageStart + pageSize < count ? { index: pageStart + pageSize, showAll } : keep;
+    case "toggleall":
+      return { index, showAll: !showAll };
+    case "enter":
+      return { index, showAll, done: "select" };
+    case "cancel":
+      return { index, showAll, done: "cancel" };
+    default:
+      return keep;
+  }
+}
+var HINTS_PAGED = "\u2191/\u2193 move \xB7 [ ] page \xB7 Ctrl+A all \xB7 Enter select \xB7 Esc cancel";
+var HINTS_SINGLE = "\u2191/\u2193 move \xB7 Ctrl+A all \xB7 Enter select \xB7 Esc cancel";
+var HINTS_ALL = "\u2191/\u2193 move \xB7 Ctrl+A pages \xB7 Enter select \xB7 Esc cancel";
+function renderView(rows, state, nowMs, titles) {
+  const { index, count, pageSize, showAll } = state;
+  const pageCount = Math.max(1, Math.ceil(count / pageSize));
+  const page = Math.floor(index / pageSize);
+  const sliceStart = showAll ? 0 : page * pageSize;
+  const sliceEnd = showAll ? count : Math.min(count, page * pageSize + pageSize);
+  let header;
+  let footer;
+  if (showAll) {
+    header = `Resume a session  (showing all ${count} sessions)`;
+    footer = HINTS_ALL;
+  } else if (pageCount === 1) {
+    header = `Resume a session  (${count} session${count === 1 ? "" : "s"})`;
+    footer = HINTS_SINGLE;
+  } else {
+    header = `Resume a session  (page ${page + 1}/${pageCount} \xB7 ${count} sessions)`;
+    footer = HINTS_PAGED;
+  }
+  const lines = [header];
+  for (let i = sliceStart; i < sliceEnd; i++) {
+    lines.push(oneLine(rows[i], i, index, nowMs, titles));
+  }
+  lines.push(footer);
+  return `${lines.join("\n")}
+`;
+}
+function oneLine(row, i, selected, nowMs, titles) {
+  const cursor = i === selected ? "\x1B[36m\u276F\x1B[0m" : " ";
+  const n = `${i + 1}.`;
+  const body = formatRow(row, nowMs, titles?.get(row.id));
+  const text = i === selected ? `\x1B[1m${body}\x1B[0m` : `\x1B[2m${body}\x1B[0m`;
+  return `${cursor} ${n} ${text}`;
+}
+async function runResumePicker(deps) {
+  const rows = parseSessions(await deps.listSessions());
+  if (rows.length === 0)
+    return void 0;
+  let state = { index: 0, count: rows.length, pageSize: PAGE_SIZE, showAll: false };
+  let prevLines = 0;
+  const draw = (first) => {
+    const view = renderView(rows, state, deps.now(), deps.titles);
+    const reset = first ? "" : `\x1B[${prevLines}A\r\x1B[0J`;
+    deps.write(reset + view);
+    prevLines = (view.match(/\n/g) ?? []).length;
+  };
+  deps.setRawMode?.(true);
+  try {
+    draw(true);
+    for await (const chunk of deps.keys) {
+      const token = decodeChunk(typeof chunk === "string" ? chunk : String(chunk));
+      const r = applyKey(state, token);
+      state = { ...state, index: r.index, showAll: r.showAll };
+      if (r.done === "cancel")
+        return void 0;
+      if (r.done === "select")
+        return rows[state.index]?.id;
+      draw(false);
+    }
+    return void 0;
+  } finally {
+    deps.setRawMode?.(false);
+    deps.write("\n");
+  }
+}
+
 // ../../node_modules/.pnpm/@ai-ezio+surface@file+..+ai-ezio+packages+surface/node_modules/@ai-ezio/surface/dist/slash.js
 var NAME_RE = /^[a-zA-Z][\w-]*$/;
 function classifyLine(line, known) {
@@ -8875,6 +9266,37 @@ function builtinCommands(listCommands) {
         }
       }
     },
+    {
+      name: "rename",
+      summary: "set a friendly title for this session (shown in /resume)",
+      run: (ctx, args) => {
+        if (!ctx.setSessionTitle) {
+          ctx.write("rename unavailable\n");
+          return;
+        }
+        const title = args.trim();
+        if (title === "") {
+          const current = ctx.getSessionTitle?.();
+          ctx.write(current ? `${current}
+` : "no title set \xB7 usage: /rename <text>\n");
+          return;
+        }
+        ctx.setSessionTitle(title);
+        ctx.write(`\u2014 renamed to "${title}" \u2014
+`);
+      }
+    },
+    {
+      name: "resume",
+      summary: "switch to a past session in this folder",
+      run: async (ctx) => {
+        if (!ctx.resume) {
+          ctx.write("resume unavailable\n");
+          return;
+        }
+        await ctx.resume();
+      }
+    },
     {
       name: "quit",
       aliases: ["exit"],
@@ -8954,6 +9376,44 @@ var SlashController = class {
     return { action: "handled" };
   }
 };
+async function runResumeFlow(deps) {
+  if (deps.isBusy()) {
+    deps.write("finish or interrupt the current turn first\n");
+    return;
+  }
+  const titles = deps.titles();
+  const active = deps.currentSessionId();
+  const rows = parseSessions(await deps.listSessions()).filter((r) => r.id !== active);
+  if (rows.length === 0) {
+    deps.write("no other sessions in this folder\n");
+    return;
+  }
+  let chosen;
+  await deps.runOverlay(async (io) => {
+    chosen = await runResumePicker({
+      listSessions: async () => JSON.stringify(rows),
+      // already parsed+filtered; re-serialize for the picker
+      keys: io.keys,
+      write: io.write,
+      now: deps.now,
+      setRawMode: io.setRawMode,
+      titles
+    });
+  });
+  if (!chosen)
+    return;
+  try {
+    await deps.resume(chosen);
+  } catch (e) {
+    if (e.name === "EngineBusyError") {
+      deps.write("finish or interrupt the current turn first\n");
+      return;
+    }
+    deps.write(`resume failed: ${e.message}
+`);
+    deps.onFatal();
+  }
+}
 
 // ../adapter-ai-ezio/dist/mid-composition-shape.js
 var DRAFTING_PREFIXES = [
@@ -8993,9 +9453,9 @@ function isMidCompositionShape(message) {
 // ../adapter-ai-ezio/dist/create-ai-ezio-live-session.js
 import { spawn as spawn7 } from "node:child_process";
 import { randomUUID as randomUUID3 } from "node:crypto";
-import { readFileSync as readFileSync5 } from "node:fs";
+import { readFileSync as readFileSync6 } from "node:fs";
 import { tmpdir } from "node:os";
-import { join as join14 } from "node:path";
+import { join as join15 } from "node:path";
 var defaultBuildAutoCompact = ({ session, host, write }) => {
   const { compaction } = loadConfig();
   return createAutoCompactDriver({
@@ -9013,6 +9473,17 @@ function createAiEzioLiveSession(input) {
   const create = input.createEngineSession ?? defaultCreateEngineSession;
   const buildCompact = input.buildAutoCompact ?? defaultBuildAutoCompact;
   const host = input.mcpHost ?? loadMcpHost({ mode: "mounted", cwd: process.cwd() });
+  const titleStore = input.titleStore ?? createSessionTitleStore();
+  const listSessions = input.listSessions ?? (() => new Promise((resolve2) => {
+    let out = "";
+    const child = spawn7(resolveHaxBinary(), ["--list-sessions"], {
+      cwd: process.cwd(),
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    child.stdout?.on("data", (d) => void (out += d.toString("utf8")));
+    child.on("error", () => resolve2("[]"));
+    child.on("exit", (code) => resolve2(code === 0 ? out : "[]"));
+  }));
   let session = null;
   let driver = null;
   let sawTurn = false;
@@ -9020,12 +9491,22 @@ function createAiEzioLiveSession(input) {
   let lastContent = "";
   let lastUsage;
   let slash = null;
+  let inTurn = false;
   const outputHandlers = [];
   const turnFinishedHandlers = [];
   const fidelityDecisionHandlers = [];
   const exitHandlers = [];
   const renderer = createMountedRenderer({ stdout: input.stdout });
+  const rename = createRenameController({
+    store: titleStore,
+    // Deferred for the same reason as standalone: noteEvent runs inside the
+    // onEvent tee before the event reaches waiters; queueMicrotask runs status()
+    // after the settling idle is routed to the in-flight turn.
+    requestStatus: () => queueMicrotask(() => void session?.status().catch(() => {
+    }))
+  });
   const onEvent = (event) => {
+    rename.noteEvent(event);
     const compacting = driver?.compacting() ?? false;
     if (!compacting)
       switch (event.type) {
@@ -9034,6 +9515,9 @@ function createAiEzioLiveSession(input) {
           for (const h of outputHandlers)
             h(event.text);
           break;
+        case "assistant_turn_started":
+          inTurn = true;
+          break;
         case "assistant_turn_finished":
           sawTurn = true;
           lastContent = event.content;
@@ -9050,6 +9534,7 @@ function createAiEzioLiveSession(input) {
           pendingContent = event.content;
           break;
         case "idle":
+          inTurn = false;
           if (sawTurn && pendingContent !== null) {
             const candidate = pendingContent;
             if (isMidCompositionShape(candidate)) {
@@ -9091,7 +9576,7 @@ function createAiEzioLiveSession(input) {
         for (const h of exitHandlers)
           h();
       });
-      const transcriptPath = join14(tmpdir(), `ezio-mounted-${randomUUID3()}.txt`);
+      const transcriptPath = join15(tmpdir(), `ezio-mounted-${randomUUID3()}.txt`);
       await session.start({ transcriptPath });
       await host.start(session);
       const skillEnv = {
@@ -9101,9 +9586,45 @@ function createAiEzioLiveSession(input) {
       };
       const skillFs = nodeSkillFs();
       const sessionFacet = session;
+      const resumeThunk = () => runResumeFlow({
+        write: (s) => input.stdout.write(s),
+        isBusy: () => inTurn,
+        listSessions,
+        titles: () => titleStore.loadTitles(),
+        currentSessionId: () => rename.currentSessionId(),
+        runOverlay: async (run) => {
+          if (!input.runInteractiveOverlay) {
+            input.stdout.write("resume unavailable in this host\n");
+            return;
+          }
+          await input.runInteractiveOverlay(run);
+        },
+        resume: async (id) => {
+          if (sessionFacet.transcriptPath !== void 0) {
+            await session.resume(id, { transcriptPath: sessionFacet.transcriptPath });
+          } else {
+            await session.resume(id);
+          }
+          await host.start(session);
+        },
+        // Spec §4: a failed respawn leaves the engine closed — report (in
+        // runResumeFlow) and exit cleanly. Firing the adapter's exit handlers is
+        // the "normal engine-exit path" for a mounted pane.
+        onFatal: () => {
+          for (const h of exitHandlers)
+            h();
+        },
+        now: input.now ?? (() => Date.now())
+      });
       const slashCtx = {
         write: (s) => input.stdout.write(s),
-        session: sessionFacet,
+        session: {
+          newConversation: async () => {
+            await sessionFacet.newConversation();
+            rename.noteNewConversation();
+          },
+          status: () => sessionFacet.status()
+        },
         ...driver ? { compactor: { compactNow: () => driver.compactNow() } } : {},
         lastContent: () => lastContent,
         lastUsage: () => lastUsage,
@@ -9117,7 +9638,7 @@ function createAiEzioLiveSession(input) {
           path: sessionFacet.transcriptPath ?? "",
           readText: (p) => {
             try {
-              return readFileSync5(p, "utf8");
+              return readFileSync6(p, "utf8");
             } catch {
               return void 0;
             }
@@ -9129,7 +9650,11 @@ function createAiEzioLiveSession(input) {
           restoreRaw: () => {
           },
           write: (s) => input.stdout.write(s)
-        })
+        }),
+        currentSessionId: () => rename.currentSessionId(),
+        getSessionTitle: () => rename.getSessionTitle(),
+        setSessionTitle: (t) => rename.setSessionTitle(t),
+        resume: resumeThunk
       };
       slash = new SlashController(slashCtx, { excludeCommands: ["quit"] });
     },
@@ -9139,6 +9664,7 @@ function createAiEzioLiveSession(input) {
       session = null;
     },
     writeUserInput(data) {
+      inTurn = true;
       session?.submit(data);
     },
     interrupt() {
@@ -9216,7 +9742,10 @@ function createProviderForTarget(target) {
 }
 function createInteractiveSessionForTarget(input) {
   if (input.target === "ezio") {
-    return createAiEzioLiveSession({ stdout: input.stdout });
+    return createAiEzioLiveSession({
+      stdout: input.stdout,
+      ...input.runInteractiveOverlay !== void 0 ? { runInteractiveOverlay: input.runInteractiveOverlay } : {}
+    });
   }
   const baseExecArgs = getInteractiveSessionExecArgsForTarget(input.target, input.turnEvents);
   const execArgs = [...baseExecArgs, ...input.passthroughArgs ?? []];