ai-whisper 0.5.8 → 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);
@@ -5951,7 +5952,7 @@ function createLiveSessionRuntime(input) {
     input.interactiveSession.sendLocalMessage(CLEAR_LINE2);
   }
   let inputLineBuffer = "";
-  function feedLineBufferedInput(data) {
+  async function feedLineBufferedInput(data) {
     for (const char of data) {
       if (char === "") {
         if (inputLineBuffer.length > 0) {
@@ -5970,7 +5971,7 @@ function createLiveSessionRuntime(input) {
         const completed = inputLineBuffer;
         inputLineBuffer = "";
         const session = input.interactiveSession;
-        if (completed.length > 0 && session.echoUserInput) {
+        if (completed.length > 0) {
           const cols = ttyCols(input.stdout);
           const len = Array.from(completed).length;
           const plainRows = Math.max(1, Math.ceil((STRIPE_COLS + len) / cols));
@@ -5978,13 +5979,18 @@ function createLiveSessionRuntime(input) {
           if (plainRows > 1) erase += `\x1B[${plainRows - 1}A`;
           erase += "\x1B[J";
           input.stdout.write(erase);
-          session.echoUserInput(completed, cols);
+          if (await session.tryConsumeLocalCommand?.(completed)) {
+            continue;
+          }
+          if (session.echoUserInput) {
+            session.echoUserInput(completed, cols);
+          } else {
+            input.stdout.write("\n");
+          }
+          input.interactiveSession.writeUserInput(completed);
         } else {
           input.stdout.write("\n");
         }
-        if (completed.length > 0) {
-          input.interactiveSession.writeUserInput(completed);
-        }
         continue;
       }
       if (char === "\b" || char === "\x7F") {
@@ -5999,6 +6005,10 @@ function createLiveSessionRuntime(input) {
     }
   }
   async function processChunk(raw) {
+    if (overlayPush) {
+      overlayPush(raw);
+      return;
+    }
     const normalized = normalizeTerminalInput({
       raw,
       state: inputState
@@ -6054,7 +6064,7 @@ function createLiveSessionRuntime(input) {
       clearRelayPreview();
       if (decision.kind === "passthrough") {
         if (input.lineBufferedInput) {
-          feedLineBufferedInput(decision.data);
+          await feedLineBufferedInput(decision.data);
         } else {
           input.interactiveSession.writeUserInput(decision.data);
         }
@@ -6141,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));
@@ -7321,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;
@@ -7352,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)`);
@@ -7368,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
@@ -7499,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");
@@ -7689,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() {
@@ -7926,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 });
 
@@ -8209,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())
@@ -8233,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: [] };
   }
@@ -8401,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;
@@ -8545,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 ?? "");
@@ -8596,6 +8841,580 @@ ${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 readFileSync5, statSync as statSync3 } from "node:fs";
+import { join as join13 } from "node:path";
+function configBase(env) {
+  return env.xdgConfigHome && env.xdgConfigHome !== "" ? env.xdgConfigHome : join13(env.home, ".config");
+}
+function skillDirs(env) {
+  const base = configBase(env);
+  return [
+    { source: "project", path: join13(env.cwd, ".agents", "skills"), engineVisible: true },
+    {
+      source: "ai-ezio-global",
+      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: join13(base, "hax", "skills"), engineVisible: true }
+  ];
+}
+function parseSkillDescription(md) {
+  const text = md.replace(/^/, "");
+  if (!/^---\r?\n/.test(text))
+    return null;
+  const end = text.indexOf("\n---", 4);
+  if (end === -1)
+    return null;
+  const front = text.slice(text.indexOf("\n") + 1, end);
+  for (const raw of front.split(/\r?\n/)) {
+    const m = raw.match(/^description:\s*(.*)$/);
+    if (m) {
+      let value = (m[1] ?? "").trim();
+      if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+        value = value.slice(1, -1);
+      }
+      return value.length > 0 ? value : null;
+    }
+  }
+  return null;
+}
+function discoverSkills(env, fs2) {
+  const byName = /* @__PURE__ */ new Map();
+  for (const dir of skillDirs(env)) {
+    if (!fs2.isDirectory(dir.path))
+      continue;
+    for (const name of fs2.listDirs(dir.path)) {
+      if (byName.has(name))
+        continue;
+      const skillMdPath = join13(dir.path, name, "SKILL.md");
+      const md = fs2.readFile(skillMdPath);
+      if (md === null)
+        continue;
+      byName.set(name, {
+        name,
+        description: parseSkillDescription(md),
+        skillMdPath,
+        source: dir.source,
+        engineVisible: dir.engineVisible
+      });
+    }
+  }
+  return [...byName.values()].sort((a, b) => a.name.localeCompare(b.name));
+}
+function nodeSkillFs() {
+  return {
+    isDirectory: (path) => {
+      try {
+        return statSync3(path).isDirectory();
+      } catch {
+        return false;
+      }
+    },
+    listDirs: (path) => {
+      try {
+        return readdirSync2(path, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+      } catch {
+        return [];
+      }
+    },
+    readFile: (path) => {
+      try {
+        return readFileSync5(path, "utf8");
+      } catch {
+        return null;
+      }
+    }
+  };
+}
+
+// ../../node_modules/.pnpm/@ai-ezio+surface@file+..+ai-ezio+packages+surface/node_modules/@ai-ezio/surface/dist/clipboard.js
+import { spawn as spawn6 } from "node:child_process";
+function tryCopy(argv, text, spawnFn) {
+  return new Promise((resolve2, reject) => {
+    const child = spawnFn(argv[0], argv.slice(1), { stdio: ["pipe", "ignore", "ignore"] });
+    child.on("error", reject);
+    child.on("close", (code) => code === 0 ? resolve2() : reject(new Error(`${argv[0]} exited ${code}`)));
+    child.stdin?.end(text);
+  });
+}
+function makeClipboard(platform, spawnFn = spawn6) {
+  const candidates = platform === "darwin" ? [["pbcopy"]] : [["wl-copy"], ["xclip", "-selection", "clipboard"]];
+  return async (text) => {
+    let lastErr = new Error("no clipboard tool available");
+    for (const argv of candidates) {
+      try {
+        await tryCopy(argv, text, spawnFn);
+        return;
+      } catch (e) {
+        lastErr = e;
+      }
+    }
+    throw lastErr;
+  };
+}
+
+// ../../node_modules/.pnpm/@ai-ezio+surface@file+..+ai-ezio+packages+surface/node_modules/@ai-ezio/surface/dist/transcript-view.js
+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 === "") {
+    deps.write("\x1B[2m\u2500 no transcript yet \u2500\x1B[0m\n");
+    return;
+  }
+  if (!deps.interactive) {
+    deps.write(text.endsWith("\n") ? text : `${text}
+`);
+    return;
+  }
+  deps.suspendRaw();
+  try {
+    await deps.spawnPager(deps.path);
+  } catch {
+    deps.write(text.endsWith("\n") ? text : `${text}
+`);
+  } finally {
+    deps.restoreRaw();
+  }
+}
+
+// ../../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) {
+  if (!line.startsWith("/"))
+    return { kind: "submit" };
+  if (line.includes("\n"))
+    return { kind: "submit" };
+  const body = line.slice(1);
+  const ws = body.search(/\s/);
+  const rawName = ws === -1 ? body : body.slice(0, ws);
+  const args = ws === -1 ? "" : body.slice(ws).trim();
+  if (rawName === "")
+    return { kind: "submit" };
+  if (!NAME_RE.test(rawName))
+    return { kind: "submit" };
+  const name = rawName.toLowerCase();
+  return known.has(name) ? { kind: "command", name, args } : { kind: "unknown", name };
+}
+function renderHelp(ctx, cmds) {
+  for (const c of cmds)
+    ctx.write(`  /${c.name}  ${c.summary}
+`);
+  ctx.write("\nshortcuts: Enter submit \xB7 Alt+Enter newline \xB7 paste multiline \xB7 Ctrl-C interrupt \xB7 Ctrl-D exit\n");
+}
+function formatUsage(u) {
+  if (!u)
+    return null;
+  const parts = [];
+  if (u.contextTokens !== void 0)
+    parts.push(`context ${u.contextTokens}`);
+  if (u.outputTokens !== void 0)
+    parts.push(`output ${u.outputTokens}`);
+  if (u.cachedTokens !== void 0)
+    parts.push(`cached ${u.cachedTokens}`);
+  if (u.contextLimit !== void 0)
+    parts.push(`limit ${u.contextLimit}`);
+  if (u.contextTokens !== void 0 && u.contextLimit !== void 0 && u.contextLimit > 0) {
+    parts.push(`${Math.round(u.contextTokens / u.contextLimit * 100)}%`);
+  }
+  return parts.length ? parts.join(" \xB7 ") : null;
+}
+function builtinCommands(listCommands) {
+  return [
+    {
+      name: "help",
+      summary: "list commands and keyboard shortcuts",
+      run: (ctx) => renderHelp(ctx, listCommands())
+    },
+    {
+      name: "new",
+      aliases: ["clear"],
+      summary: "start a new conversation",
+      run: async (ctx) => {
+        ctx.recorder?.noteNewConversation();
+        await ctx.session.newConversation();
+        ctx.write("\u2014 new conversation \u2014\n");
+      }
+    },
+    {
+      name: "status",
+      summary: "show provider, model, and effort",
+      run: async (ctx) => {
+        const s = await ctx.session.status();
+        const effort = s.effort ? ` \xB7 ${s.effort}` : "";
+        ctx.write(`${s.provider} \xB7 ${s.model}${effort}
+`);
+      }
+    },
+    {
+      name: "skills",
+      summary: "list discovered skills",
+      run: (ctx) => {
+        const skills = ctx.skills();
+        if (skills.length === 0) {
+          ctx.write("(no skills found)\n");
+          return;
+        }
+        for (const s of skills)
+          ctx.write(`  ${s.name} \xB7 ${s.source}
+`);
+      }
+    },
+    {
+      name: "copy",
+      summary: "copy the last response to the clipboard",
+      run: async (ctx) => {
+        const text = ctx.lastContent();
+        if (text === "") {
+          ctx.write("no response to copy\n");
+          return;
+        }
+        try {
+          await ctx.clipboard(text);
+          ctx.write(`copied ${Buffer.byteLength(text, "utf8")} bytes
+`);
+        } catch (e) {
+          ctx.write(`clipboard unavailable: ${e.message}
+`);
+        }
+      }
+    },
+    {
+      name: "usage",
+      summary: "show the last turn's token usage",
+      run: (ctx) => {
+        const formatted = formatUsage(ctx.lastUsage());
+        ctx.write(formatted ? `${formatted}
+` : "no usage yet\n");
+      }
+    },
+    {
+      name: "transcript",
+      summary: "view the model-perspective transcript (same as Ctrl+T)",
+      run: async (ctx) => {
+        if (!ctx.showTranscript) {
+          ctx.write("transcript unavailable\n");
+          return;
+        }
+        await ctx.showTranscript();
+      }
+    },
+    {
+      name: "compact",
+      summary: "summarize old history and free context",
+      run: async (ctx) => {
+        if (!ctx.compactor) {
+          ctx.write("compaction unavailable\n");
+          return;
+        }
+        const out = await ctx.compactor.compactNow();
+        if (out.kind === "skipped" && out.reason === "in-progress") {
+          ctx.write("compaction already in progress\n");
+        }
+      }
+    },
+    {
+      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"],
+      summary: "exit ezio",
+      run: () => {
+      }
+      // the controller maps /quit to the exit outcome before run()
+    }
+  ];
+}
+var SlashController = class {
+  ctx;
+  /** name OR alias → command (so classifyLine's `known` set is keys()). */
+  byKey = /* @__PURE__ */ new Map();
+  constructor(ctx, opts) {
+    this.ctx = ctx;
+    const exclude = new Set(opts?.excludeCommands ?? []);
+    for (const cmd of builtinCommands(() => this.summaries())) {
+      if (exclude.has(cmd.name))
+        continue;
+      this.register(cmd);
+    }
+  }
+  /** Register (or override) a command and its aliases. Last registration wins
+   * per key: any command that already owns this command's NAME is fully evicted
+   * (all of its keys removed) so an override replaces it cleanly; an alias key
+   * collision is resolved key-by-key (the alias now points at the new command,
+   * but the prior owner keeps its other keys). */
+  register(cmd) {
+    const displaced = this.byKey.get(cmd.name);
+    if (displaced) {
+      for (const [k, v] of this.byKey)
+        if (v === displaced)
+          this.byKey.delete(k);
+    }
+    this.byKey.set(cmd.name, cmd);
+    for (const a of cmd.aliases ?? [])
+      this.byKey.set(a, cmd);
+  }
+  /** Deduped canonical command list for /help. A command is listed only if it
+   * still OWNS its own name key — this filters out any command reachable only
+   * through a stolen alias key (e.g. another command claimed its name), so
+   * /help never shows a stale entry. */
+  summaries() {
+    const seen = /* @__PURE__ */ new Set();
+    const out = [];
+    for (const cmd of this.byKey.values()) {
+      if (seen.has(cmd))
+        continue;
+      seen.add(cmd);
+      if (this.byKey.get(cmd.name) !== cmd)
+        continue;
+      out.push({ name: cmd.name, summary: cmd.summary });
+    }
+    return out;
+  }
+  async handle(line) {
+    const c = classifyLine(line, new Set(this.byKey.keys()));
+    if (c.kind === "submit")
+      return { action: "submit", text: line };
+    if (c.kind === "unknown") {
+      this.ctx.write(`unknown command: /${c.name}. type /help for the list.
+`);
+      return { action: "handled" };
+    }
+    const cmd = this.byKey.get(c.name);
+    if (!cmd)
+      return { action: "handled" };
+    if (cmd.name === "quit")
+      return { action: "exit" };
+    try {
+      await cmd.run(this.ctx, c.args);
+    } catch (e) {
+      this.ctx.write(`/${c.name} failed: ${e.message}
+`);
+    }
+    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 = [
   "let's draft",
@@ -8632,6 +9451,11 @@ 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 readFileSync6 } from "node:fs";
+import { tmpdir } from "node:os";
+import { join as join15 } from "node:path";
 var defaultBuildAutoCompact = ({ session, host, write }) => {
   const { compaction } = loadConfig();
   return createAutoCompactDriver({
@@ -8649,16 +9473,40 @@ 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;
   let pendingContent = null;
+  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) {
@@ -8667,8 +9515,13 @@ 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;
+          lastUsage = event.usage;
           if (pendingContent !== null) {
             const superseded = pendingContent;
             for (const h of fidelityDecisionHandlers)
@@ -8681,6 +9534,7 @@ function createAiEzioLiveSession(input) {
           pendingContent = event.content;
           break;
         case "idle":
+          inTurn = false;
           if (sawTurn && pendingContent !== null) {
             const candidate = pendingContent;
             if (isMidCompositionShape(candidate)) {
@@ -8722,8 +9576,87 @@ function createAiEzioLiveSession(input) {
         for (const h of exitHandlers)
           h();
       });
-      await session.start();
+      const transcriptPath = join15(tmpdir(), `ezio-mounted-${randomUUID3()}.txt`);
+      await session.start({ transcriptPath });
       await host.start(session);
+      const skillEnv = {
+        cwd: process.cwd(),
+        home: process.env.HOME ?? "",
+        xdgConfigHome: process.env.XDG_CONFIG_HOME
+      };
+      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: {
+          newConversation: async () => {
+            await sessionFacet.newConversation();
+            rename.noteNewConversation();
+          },
+          status: () => sessionFacet.status()
+        },
+        ...driver ? { compactor: { compactNow: () => driver.compactNow() } } : {},
+        lastContent: () => lastContent,
+        lastUsage: () => lastUsage,
+        skills: () => discoverSkills(skillEnv, skillFs).map((s) => ({
+          name: s.name,
+          source: s.source,
+          description: s.description
+        })),
+        clipboard: input.clipboard ?? makeClipboard(process.platform, spawn7),
+        showTranscript: () => showTranscript({
+          path: sessionFacet.transcriptPath ?? "",
+          readText: (p) => {
+            try {
+              return readFileSync6(p, "utf8");
+            } catch {
+              return void 0;
+            }
+          },
+          interactive: false,
+          spawnPager: () => Promise.resolve(),
+          suspendRaw: () => {
+          },
+          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"] });
     },
     async stop() {
       await host.stop();
@@ -8731,11 +9664,18 @@ function createAiEzioLiveSession(input) {
       session = null;
     },
     writeUserInput(data) {
+      inTurn = true;
       session?.submit(data);
     },
     interrupt() {
       session?.interrupt();
     },
+    async tryConsumeLocalCommand(line) {
+      if (!slash)
+        return false;
+      const outcome = await slash.handle(line);
+      return outcome.action !== "submit";
+    },
     echoUserInput(text, cols) {
       renderer.echoUserInput(text, cols);
     },
@@ -8802,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 ?? []];