mixdog 0.9.95 → 0.9.96

package/src/tui/dist/index.mjs

@@ -27,10 +27,6 @@ var __commonJS = (cb, mod) => function __require2() {
     throw mod = 0, e;
   }
 };
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -210,11 +206,11 @@ function cleanPathText(value) {
   }
   return text;
 }
-function mimeForPath(path3) {
-  return IMAGE_MIME[extname(String(path3 || "")).toLowerCase()] || null;
+function mimeForPath(path2) {
+  return IMAGE_MIME[extname(String(path2 || "")).toLowerCase()] || null;
 }
 function execFileBuffer(cmd, args, options = {}) {
-  return new Promise((resolve5) => {
+  return new Promise((resolve4) => {
     execFile(cmd, args, {
       windowsHide: true,
       encoding: "buffer",
@@ -222,7 +218,7 @@ function execFileBuffer(cmd, args, options = {}) {
       timeout: 5e3,
       ...options
     }, (error, stdout2, stderr) => {
-      resolve5({ ok: !error, code: error?.code ?? 0, stdout: stdout2, stderr, error });
+      resolve4({ ok: !error, code: error?.code ?? 0, stdout: stdout2, stderr, error });
     });
   });
 }
@@ -419,16 +415,16 @@ var init_paste_attachments = __esm({
 // src/runtime/shared/atomic-file.mjs
 import {
   closeSync,
-  existsSync as existsSync4,
+  existsSync as existsSync3,
   fsyncSync,
   linkSync,
-  mkdirSync as mkdirSync3,
+  mkdirSync as mkdirSync2,
   openSync,
-  readFileSync as readFileSync3,
-  renameSync as renameSync2,
-  statSync as statSync2,
+  readFileSync as readFileSync2,
+  renameSync,
+  statSync,
   unlinkSync as unlinkSync2,
-  writeFileSync as writeFileSync3
+  writeFileSync as writeFileSync2
 } from "fs";
 import {
   link as linkAsync,
@@ -439,11 +435,41 @@ import {
   unlink as unlinkAsync,
   writeFile as writeFileAsync
 } from "node:fs/promises";
-import { dirname as dirname4, basename as basename4, join as join4 } from "path";
+import { dirname as dirname3, basename as basename3, join as join3 } from "path";
 import { randomBytes as randomBytes2 } from "crypto";
 import { execFile as execFile2, execFileSync } from "child_process";
 import { promisify } from "util";
 import { AsyncLocalStorage } from "node:async_hooks";
+function _drainAdaptiveFileIo() {
+  while (_ioActive < _ioLimit && _ioQueue.length > 0) {
+    const item = _ioQueue.shift();
+    _ioActive += 1;
+    const startedAt = Date.now();
+    Promise.resolve().then(item.run).then(item.resolve, item.reject).finally(() => {
+      const elapsed = Date.now() - startedAt;
+      _ioActive = Math.max(0, _ioActive - 1);
+      if (elapsed >= 250) {
+        _ioLimit = Math.max(1, Math.ceil(_ioLimit / 2));
+        _ioFastStreak = 0;
+      } else if (elapsed <= 40 && _ioLimit < _ioCeiling) {
+        _ioFastStreak += 1;
+        if (_ioFastStreak >= _ioLimit * 4) {
+          _ioLimit += 1;
+          _ioFastStreak = 0;
+        }
+      } else {
+        _ioFastStreak = 0;
+      }
+      _drainAdaptiveFileIo();
+    });
+  }
+}
+function _runAdaptiveFileIo(run) {
+  return new Promise((resolve4, reject) => {
+    _ioQueue.push({ run, resolve: resolve4, reject });
+    _drainAdaptiveFileIo();
+  });
+}
 function sleepSync(ms) {
   try {
     const buf = new SharedArrayBuffer(4);
@@ -456,7 +482,7 @@ function sleepSync(ms) {
 }
 function _describeLockHolder(lockPath) {
   try {
-    const st = statSync2(lockPath);
+    const st = statSync(lockPath);
     const owner = _readLockOwner(lockPath);
     const ageMs = Math.max(0, Math.round(Date.now() - st.mtimeMs));
     const live = owner.pid === null ? "unknown" : _ownerIsLive(owner) ? "live" : "dead";
@@ -466,12 +492,28 @@ function _describeLockHolder(lockPath) {
     return "holder unknown (lock file unreadable/absent)";
   }
 }
+function _reportLockWait(lockPath, waitedMs, mode) {
+  if (waitedMs < LOCK_WAIT_WARN_MS) return;
+  const now = Date.now();
+  if (now - (_lockWaitWarnedAt.get(lockPath) || 0) < LOCK_WAIT_WARN_INTERVAL_MS) return;
+  _lockWaitWarnedAt.set(lockPath, now);
+  if (_lockWaitWarnedAt.size > 64) {
+    for (const [path2, at] of _lockWaitWarnedAt) {
+      if (now - at >= LOCK_WAIT_WARN_INTERVAL_MS * 6) _lockWaitWarnedAt.delete(path2);
+    }
+  }
+  try {
+    process.stderr.write(`[atomic-file] ${mode} lock wait ${waitedMs}ms: ${lockPath}
+`);
+  } catch {
+  }
+}
 function renameWithRetrySync(src, dst, opts = {}) {
   const backoffs = Array.isArray(opts.backoffs) && opts.backoffs.length > 0 ? opts.backoffs : DEFAULT_BACKOFFS_MS;
   let lastErr = null;
   for (let attempt = 0; attempt <= backoffs.length; attempt++) {
     try {
-      renameSync2(src, dst);
+      renameSync(src, dst);
       return true;
     } catch (err) {
       lastErr = err;
@@ -500,7 +542,7 @@ async function renameWithRetry(src, dst, opts = {}) {
 }
 function _readLockOwner(lockPath) {
   try {
-    const raw = readFileSync3(lockPath, "utf8");
+    const raw = readFileSync2(lockPath, "utf8");
     const parts = String(raw).trim().split(/\s+/);
     const pid = Number.parseInt(parts[0], 10);
     return {
@@ -529,7 +571,7 @@ function _lockOwnedBySelf(lockPath) {
 function _tryReclaimStaleLock(lockPath, staleMs) {
   let initial;
   try {
-    initial = statSync2(lockPath);
+    initial = statSync(lockPath);
   } catch {
     return false;
   }
@@ -542,7 +584,7 @@ function _tryReclaimStaleLock(lockPath, staleMs) {
   try {
     let cur;
     try {
-      cur = statSync2(lockPath);
+      cur = statSync(lockPath);
     } catch {
       return false;
     }
@@ -569,7 +611,7 @@ function _tryAcquireReclaimGuard(lockPath, staleMs) {
 `;
   const stagedPath = `${guardPath}.${process.pid}.${randomBytes2(8).toString("hex")}.tmp`;
   try {
-    writeFileSync3(stagedPath, token, { encoding: "utf8", mode: 384, flag: "wx" });
+    writeFileSync2(stagedPath, token, { encoding: "utf8", mode: 384, flag: "wx" });
     linkSync(stagedPath, guardPath);
     unlinkSync2(stagedPath);
     return { guardPath };
@@ -591,8 +633,8 @@ function _releaseReclaimGuard(reclaim) {
   }
 }
 function _asyncSleep(ms) {
-  return new Promise((resolve5) => {
-    setTimeout(resolve5, Math.max(1, Number(ms) || 1));
+  return new Promise((resolve4) => {
+    setTimeout(resolve4, Math.max(1, Number(ms) || 1));
   });
 }
 async function withFileLock(lockPath, fn, opts = {}) {
@@ -618,7 +660,8 @@ async function _withOsFileLock(lockPath, fn, opts = {}) {
   const timeoutMs = Number.isFinite(opts.timeoutMs) ? opts.timeoutMs : DEFAULT_LOCK_TIMEOUT_MS;
   const staleMs = Number.isFinite(opts.staleMs) ? opts.staleMs : 3e4;
   const deadline = Date.now() + timeoutMs;
-  mkdirSync3(dirname4(lockPath), { recursive: true });
+  mkdirSync2(dirname3(lockPath), { recursive: true });
+  const waitStartedAt = Date.now();
   let attempt = 0;
   let lastErr = null;
   while (true) {
@@ -646,10 +689,11 @@ async function _withOsFileLock(lockPath, fn, opts = {}) {
       continue;
     }
     try {
-      writeFileSync3(fd, `${process.pid} ${Date.now()} ${_OWNER_TOKEN}
+      writeFileSync2(fd, `${process.pid} ${Date.now()} ${_OWNER_TOKEN}
 `, "utf8");
     } catch {
     }
+    _reportLockWait(lockPath, Date.now() - waitStartedAt, "async");
     _osHeldPaths.add(lockPath);
     try {
       if (opts.secret === true) await _enforceOwnerOnlyAclWin32Async(lockPath);
@@ -677,8 +721,8 @@ function _icaclsPrincipal(principal) {
 async function _resolveCurrentUserPrincipalAsync() {
   const systemRoot = process.env.SystemRoot || process.env.windir;
   if (systemRoot) {
-    const whoami = join4(systemRoot, "System32", "whoami.exe");
-    if (existsSync4(whoami)) {
+    const whoami = join3(systemRoot, "System32", "whoami.exe");
+    if (existsSync3(whoami)) {
       try {
         const { stdout: stdout2 } = await _execFileAsync(whoami, ["/user", "/fo", "csv", "/nh"], {
           encoding: "utf8",
@@ -702,8 +746,8 @@ async function _enforceOwnerOnlyAclWin32Async(targetPath) {
     err.code = "EACLNOROOT";
     throw err;
   }
-  const icacls = join4(systemRoot, "System32", "icacls.exe");
-  if (!existsSync4(icacls)) {
+  const icacls = join3(systemRoot, "System32", "icacls.exe");
+  if (!existsSync3(icacls)) {
     const err = new Error(`icacls.exe not found at ${icacls}; refusing to leave secret world-readable`);
     err.code = "EACLNOICACLS";
     throw err;
@@ -722,9 +766,9 @@ async function _enforceOwnerOnlyAclWin32Async(targetPath) {
 }
 async function writeFileAtomicAsync(filePath, data, opts = {}) {
   const run = async () => {
-    const dir = dirname4(filePath);
+    const dir = dirname3(filePath);
     await mkdirAsync(dir, { recursive: true });
-    const tmp = join4(dir, `.${basename4(filePath)}.${randomBytes2(12).toString("hex")}.tmp`);
+    const tmp = join3(dir, `.${basename3(filePath)}.${randomBytes2(12).toString("hex")}.tmp`);
     try {
       const writeOpts = { encoding: opts.encoding || "utf8", flag: "wx", mode: opts.mode !== void 0 ? opts.mode : 384 };
       await writeFileAsync(tmp, data, writeOpts);
@@ -785,18 +829,20 @@ async function writeFileAtomicAsync(filePath, data, opts = {}) {
       throw err;
     }
   };
-  if (opts.lock === true) {
-    return withFileLock(`${filePath}.lock`, run, opts);
-  }
-  return run();
+  return _runAdaptiveFileIo(() => opts.lock === true ? withFileLock(`${filePath}.lock`, run, opts) : run());
 }
 function writeJsonAtomicAsync(filePath, value, opts = {}) {
   return writeFileAtomicAsync(filePath, JSON.stringify(value, null, opts.compact ? 0 : 2) + "\n", opts);
 }
-var _execFileAsync, RETRY_CODES, LOCK_WAIT_CODES, DEFAULT_BACKOFFS_MS, _configuredLockTimeoutMs, DEFAULT_LOCK_TIMEOUT_MS, _OWNER_TOKEN, _osHeldPaths, _lockQueues, _heldLockPaths, _cachedUserSid;
+var _execFileAsync, _ioCeiling, _ioLimit, _ioActive, _ioFastStreak, _ioQueue, RETRY_CODES, LOCK_WAIT_CODES, DEFAULT_BACKOFFS_MS, _configuredLockTimeoutMs, DEFAULT_LOCK_TIMEOUT_MS, _OWNER_TOKEN, _osHeldPaths, LOCK_WAIT_WARN_MS, LOCK_WAIT_WARN_INTERVAL_MS, _lockWaitWarnedAt, _lockQueues, _heldLockPaths, _cachedUserSid;
 var init_atomic_file = __esm({
   "src/runtime/shared/atomic-file.mjs"() {
     _execFileAsync = promisify(execFile2);
+    _ioCeiling = Math.max(1, Math.floor(Number(process.env.MIXDOG_FILE_IO_MAX_CONCURRENCY) || 16));
+    _ioLimit = Math.min(4, _ioCeiling);
+    _ioActive = 0;
+    _ioFastStreak = 0;
+    _ioQueue = [];
     RETRY_CODES = /* @__PURE__ */ new Set(["EPERM", "EACCES", "EBUSY", "EEXIST"]);
     LOCK_WAIT_CODES = /* @__PURE__ */ new Set(["EEXIST", "EPERM", "EACCES", "EBUSY"]);
     DEFAULT_BACKOFFS_MS = Object.freeze([25, 50, 100, 200, 400, 800, 1200, 1600]);
@@ -804,6 +850,9 @@ var init_atomic_file = __esm({
     DEFAULT_LOCK_TIMEOUT_MS = Number.isFinite(_configuredLockTimeoutMs) && _configuredLockTimeoutMs >= 0 ? _configuredLockTimeoutMs : 2e3;
     _OWNER_TOKEN = randomBytes2(12).toString("hex");
     _osHeldPaths = /* @__PURE__ */ new Set();
+    LOCK_WAIT_WARN_MS = 500;
+    LOCK_WAIT_WARN_INTERVAL_MS = 1e4;
+    _lockWaitWarnedAt = /* @__PURE__ */ new Map();
     _lockQueues = /* @__PURE__ */ new Map();
     _heldLockPaths = new AsyncLocalStorage();
     _cachedUserSid = null;
@@ -813,13 +862,13 @@ var init_atomic_file = __esm({
 // src/runtime/shared/user-data-guard.mjs
 import {
   copyFileSync,
-  existsSync as existsSync5,
-  mkdirSync as mkdirSync4,
+  existsSync as existsSync4,
+  mkdirSync as mkdirSync3,
   readdirSync,
-  readFileSync as readFileSync4,
+  readFileSync as readFileSync3,
   rmSync,
-  statSync as statSync3,
-  writeFileSync as writeFileSync4
+  statSync as statSync2,
+  writeFileSync as writeFileSync3
 } from "fs";
 import {
   copyFile as copyFileP,
@@ -828,14 +877,14 @@ import {
   rm as rmP,
   stat as statP
 } from "fs/promises";
-import { dirname as dirname5, join as join5, resolve as resolve3 } from "path";
-import { homedir as homedir3 } from "os";
+import { dirname as dirname4, join as join4, resolve as resolve2 } from "path";
+import { homedir as homedir2 } from "os";
 import { createHash } from "crypto";
 function mixdogConfigBaseDir() {
-  return process.env.MIXDOG_CONFIG_DIR || join5(homedir3(), ".mixdog");
+  return process.env.MIXDOG_CONFIG_DIR || join4(homedir2(), ".mixdog");
 }
 function getBackupRoot() {
-  return process.env.MIXDOG_USER_DATA_BACKUP_ROOT || join5(mixdogConfigBaseDir(), "backups", "user-data");
+  return process.env.MIXDOG_USER_DATA_BACKUP_ROOT || join4(mixdogConfigBaseDir(), "backups", "user-data");
 }
 function stamp() {
   return (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
@@ -845,13 +894,13 @@ function safeReason(reason) {
 }
 function initMarkerPath(dataDir) {
   const id = createHash("sha256").update(String(dataDir || "unknown")).digest("hex").slice(0, 16);
-  return join5(getBackupRoot(), `.initialized-${id}.json`);
+  return join4(getBackupRoot(), `.initialized-${id}.json`);
 }
 function isPlainObject(value) {
   return !!value && typeof value === "object" && !Array.isArray(value);
 }
 function hasUserDataInitMarker(dataDir) {
-  return existsSync5(initMarkerPath(dataDir));
+  return existsSync4(initMarkerPath(dataDir));
 }
 function isStructurallyCompleteMixdogConfigBackup(parsed) {
   if (!isPlainObject(parsed)) return false;
@@ -868,10 +917,10 @@ function loadLatestMixdogConfigFromBackup(_dataDir) {
     return null;
   }
   for (const name of entries) {
-    const cfgPath = join5(root, name, "mixdog-config.json");
-    if (!existsSync5(cfgPath)) continue;
+    const cfgPath = join4(root, name, "mixdog-config.json");
+    if (!existsSync4(cfgPath)) continue;
     try {
-      const parsed = JSON.parse(readFileSync4(cfgPath, "utf8"));
+      const parsed = JSON.parse(readFileSync3(cfgPath, "utf8"));
       if (isStructurallyCompleteMixdogConfigBackup(parsed)) return parsed;
     } catch {
       continue;
@@ -881,8 +930,8 @@ function loadLatestMixdogConfigFromBackup(_dataDir) {
 }
 function markUserDataInitialized(dataDir) {
   try {
-    mkdirSync4(getBackupRoot(), { recursive: true });
-    writeFileSync4(initMarkerPath(dataDir), JSON.stringify({
+    mkdirSync3(getBackupRoot(), { recursive: true });
+    writeFileSync3(initMarkerPath(dataDir), JSON.stringify({
       dataDir,
       updatedAt: (/* @__PURE__ */ new Date()).toISOString()
     }, null, 2) + "\n", "utf8");
@@ -893,12 +942,12 @@ async function copyTreeAsync(src, dst, copied) {
   const st = await statP(src);
   if (st.isDirectory()) {
     for (const name of await readdirP(src)) {
-      await copyTreeAsync(join5(src, name), join5(dst, name), copied);
+      await copyTreeAsync(join4(src, name), join4(dst, name), copied);
     }
     return;
   }
   if (!st.isFile()) return;
-  await mkdirP(dirname5(dst), { recursive: true });
+  await mkdirP(dirname4(dst), { recursive: true });
   await copyFileP(src, dst);
   copied.push(dst);
 }
@@ -911,7 +960,7 @@ async function pruneBackupsAsync(keep = 40) {
   }
   for (const name of entries.slice(keep)) {
     try {
-      await rmP(join5(getBackupRoot(), name), { recursive: true, force: true });
+      await rmP(join4(getBackupRoot(), name), { recursive: true, force: true });
     } catch {
     }
   }
@@ -920,16 +969,16 @@ async function backupUserDataAsync(dataDir, reason = "snapshot") {
   if (process.env.MIXDOG_SKIP_USER_DATA_BACKUP === "1" || process.env.MIXDOG_SKIP_USER_DATA_BACKUP === "true") {
     return { dir: null, copied: [] };
   }
-  if (!dataDir || !existsSync5(dataDir)) return { dir: null, copied: [] };
-  const backupDir = join5(getBackupRoot(), `${stamp()}-${safeReason(reason)}`);
+  if (!dataDir || !existsSync4(dataDir)) return { dir: null, copied: [] };
+  const backupDir = join4(getBackupRoot(), `${stamp()}-${safeReason(reason)}`);
   const copied = [];
   for (const rel of USER_DATA_FILES) {
-    const src = join5(dataDir, rel);
-    if (existsSync5(src)) await copyTreeAsync(src, join5(backupDir, rel), copied);
+    const src = join4(dataDir, rel);
+    if (existsSync4(src)) await copyTreeAsync(src, join4(backupDir, rel), copied);
   }
   for (const rel of USER_DATA_DIRS) {
-    const src = join5(dataDir, rel);
-    if (existsSync5(src)) await copyTreeAsync(src, join5(backupDir, rel), copied);
+    const src = join4(dataDir, rel);
+    if (existsSync4(src)) await copyTreeAsync(src, join4(backupDir, rel), copied);
   }
   if (copied.length > 0) {
     markUserDataInitialized(dataDir);
@@ -980,8 +1029,8 @@ var init_provider_api_key = __esm({
 });
 
 // src/runtime/shared/config.mjs
-import { readFileSync as readFileSync5, statSync as statSync4, mkdirSync as mkdirSync5, existsSync as existsSync6 } from "fs";
-import { join as join6, dirname as dirname6 } from "path";
+import { readFileSync as readFileSync4, statSync as statSync3, mkdirSync as mkdirSync4, existsSync as existsSync5 } from "fs";
+import { join as join5, dirname as dirname5 } from "path";
 import { createRequire as createRequire3 } from "module";
 function invalidateConfigReadCache() {
   _configReadCache = null;
@@ -993,7 +1042,7 @@ function readConfigRawCached() {
       return _configReadCache.raw;
     }
     try {
-      const st2 = statSync4(CONFIG_PATH);
+      const st2 = statSync3(CONFIG_PATH);
       if (st2.mtimeMs === _configReadCache.mtimeMs && st2.size === _configReadCache.size) {
         _configReadCache.atMs = now;
         return _configReadCache.raw;
@@ -1003,7 +1052,7 @@ function readConfigRawCached() {
   }
   let st = null;
   try {
-    st = statSync4(CONFIG_PATH);
+    st = statSync3(CONFIG_PATH);
   } catch (err) {
     if (err.code === "ENOENT") {
       _configReadCache = null;
@@ -1015,7 +1064,7 @@ function readConfigRawCached() {
   }
   let raw;
   try {
-    raw = readFileSync5(CONFIG_PATH, "utf8");
+    raw = readFileSync4(CONFIG_PATH, "utf8");
   } catch (err) {
     if (err.code === "ENOENT") {
       _configReadCache = null;
@@ -1031,21 +1080,112 @@ function readConfigRawCached() {
 function isPlainObject2(value) {
   return !!value && typeof value === "object" && !Array.isArray(value);
 }
+function hasOwn(value, key) {
+  return Object.prototype.hasOwnProperty.call(value || {}, key);
+}
+function canonicalizeStoredChannelsConfig(value = {}) {
+  const next = isPlainObject2(value) ? { ...value } : {};
+  delete next.promptInjection;
+  delete next.schedules;
+  delete next.nonInteractive;
+  delete next.interactive;
+  const channel = isPlainObject2(next.channel) ? { ...next.channel } : {};
+  const legacyId = String(channel.channelId || "").trim();
+  const discordId = String(channel.discordChannelId || "").trim();
+  const telegramId = String(channel.telegramChatId || "").trim();
+  const backend = next.backend === "telegram" ? "telegram" : "discord";
+  if (legacyId) {
+    if (!discordId && !telegramId) {
+      if (backend === "telegram") channel.telegramChatId = legacyId;
+      else channel.discordChannelId = legacyId;
+      delete channel.channelId;
+    } else if (backend === "telegram" && telegramId || backend === "discord" && discordId || discordId && telegramId) {
+      delete channel.channelId;
+    }
+  } else {
+    delete channel.channelId;
+  }
+  next.channel = channel;
+  return next;
+}
+function canonicalizeUnifiedConfig(value = {}) {
+  const next = isPlainObject2(value) ? { ...value } : {};
+  const hadAgent = isPlainObject2(next.agent);
+  const agent = hadAgent ? { ...next.agent } : {};
+  if (!String(next.outputStyle || "").trim() && String(agent.outputStyle || "").trim()) {
+    next.outputStyle = agent.outputStyle;
+  }
+  delete agent.outputStyle;
+  for (const key of ["autoClear", "compaction", "shell"]) {
+    if (!isPlainObject2(agent[key]) && isPlainObject2(next[key])) agent[key] = next[key];
+    delete next[key];
+  }
+  if (isPlainObject2(next.mcpServers)) {
+    agent.mcpServers = {
+      ...next.mcpServers,
+      ...isPlainObject2(agent.mcpServers) ? agent.mcpServers : {}
+    };
+    delete next.mcpServers;
+  }
+  if (!isPlainObject2(agent.searchRoute) && isPlainObject2(agent.search)) {
+    agent.searchRoute = agent.search;
+  }
+  delete agent.search;
+  delete agent.capabilities;
+  const modules = isPlainObject2(agent.modules) ? { ...agent.modules } : {};
+  if (hasOwn(modules, "memory")) {
+    const legacyMemory = modules.memory;
+    const explicitRecap = isPlainObject2(agent.recap) && hasOwn(agent.recap, "enabled");
+    if (!explicitRecap) {
+      const enabled = isPlainObject2(legacyMemory) ? legacyMemory.enabled !== false : legacyMemory !== false;
+      agent.recap = { ...isPlainObject2(agent.recap) ? agent.recap : {}, enabled };
+    }
+    delete modules.memory;
+    agent.modules = modules;
+  }
+  if (isPlainObject2(next.memory)) {
+    const memory = { ...next.memory };
+    const user = isPlainObject2(memory.user) ? { ...memory.user } : {};
+    const legacyTitle = String(user.title || "").trim();
+    if (legacyTitle && !String(agent.profile?.title || "").trim()) {
+      agent.profile = { ...isPlainObject2(agent.profile) ? agent.profile : {}, title: legacyTitle };
+    }
+    delete user.title;
+    if (Object.keys(user).length) memory.user = user;
+    else delete memory.user;
+    if (hasOwn(memory, "enabled")) {
+      const explicitRecap = isPlainObject2(agent.recap) && hasOwn(agent.recap, "enabled");
+      if (!explicitRecap) {
+        agent.recap = { ...isPlainObject2(agent.recap) ? agent.recap : {}, enabled: memory.enabled !== false };
+      }
+      delete memory.enabled;
+    }
+    if (Object.keys(memory).length) next.memory = memory;
+    else delete next.memory;
+  }
+  if (isPlainObject2(next.channels)) {
+    next.channels = canonicalizeStoredChannelsConfig(next.channels);
+  }
+  delete next.search;
+  delete next.capabilities;
+  if (hadAgent || Object.keys(agent).length) next.agent = agent;
+  return next;
+}
 function stripGeneratedMarker(data) {
   if (!isPlainObject2(data) || !Object.prototype.hasOwnProperty.call(data, GENERATED_KEY)) return data;
   const { [GENERATED_KEY]: _generated, ...rest } = data;
   return rest;
 }
-function readJsonFile(path3) {
+function readJsonFile(path2) {
   let raw;
-  if (path3 === CONFIG_PATH) {
+  if (path2 === CONFIG_PATH) {
     raw = readConfigRawCached();
   } else {
     try {
-      raw = readFileSync5(path3, "utf8");
+      raw = readFileSync4(path2, "utf8");
     } catch (err) {
       if (err.code === "ENOENT") return null;
-      process.stderr.write(`[config] readJsonFile: unexpected read error for ${path3}: ${err.message}
+      process.stderr.write(`[config] readJsonFile: unexpected read error for ${path2}: ${err.message}
 `);
       throw err;
     }
@@ -1054,11 +1194,11 @@ function readJsonFile(path3) {
   try {
     return JSON.parse(raw);
   } catch (err) {
-    if (path3 === CONFIG_PATH) {
+    if (path2 === CONFIG_PATH) {
       invalidateConfigReadCache();
-      const corrupt = `${path3}.corrupt-${Date.now()}`;
+      const corrupt = `${path2}.corrupt-${Date.now()}`;
       try {
-        renameWithRetrySync(path3, corrupt);
+        renameWithRetrySync(path2, corrupt);
       } catch {
       }
       process.stderr.write(`[config] mixdog-config.json is malformed (${err.message}). Renamed to ${corrupt}. Restore it or delete to start fresh.
@@ -1069,12 +1209,12 @@ function readJsonFile(path3) {
 }
 function readAll() {
   const parsed = readJsonFile(CONFIG_PATH);
-  if (parsed != null) return parsed;
+  if (parsed != null) return canonicalizeUnifiedConfig(parsed);
   if (hasUserDataInitMarker(DATA_DIR)) {
     const restored = loadLatestMixdogConfigFromBackup(DATA_DIR);
     if (restored && isPlainObject2(restored)) {
       process.stderr.write("[config] read: restored mixdog-config.json from latest user-data backup (missing after init)\n");
-      return restored;
+      return canonicalizeUnifiedConfig(restored);
     }
   }
   return {};
@@ -1082,7 +1222,7 @@ function readAll() {
 function quarantineMalformedConfig(parseErr) {
   const corrupt = `${CONFIG_PATH}.corrupt-${Date.now()}`;
   try {
-    if (existsSync6(CONFIG_PATH)) renameWithRetrySync(CONFIG_PATH, corrupt);
+    if (existsSync5(CONFIG_PATH)) renameWithRetrySync(CONFIG_PATH, corrupt);
   } catch {
   }
   process.stderr.write(
@@ -1104,7 +1244,7 @@ function restoreAllForRmWOrThrow(reason) {
 function readAllForRmW() {
   let raw;
   try {
-    raw = readFileSync5(CONFIG_PATH, "utf8");
+    raw = readFileSync4(CONFIG_PATH, "utf8");
   } catch (err) {
     if (err.code === "ENOENT") {
       if (hasUserDataInitMarker(DATA_DIR)) {
@@ -1128,16 +1268,16 @@ function readAllForRmW() {
 function readSection(section) {
   return stripGeneratedMarker(readAll()[section] ?? null) ?? {};
 }
-async function writeJsonFileAsync(path3, data) {
-  mkdirSync5(dirname6(path3), { recursive: true, mode: 448 });
-  if (path3 === CONFIG_PATH) {
+async function writeJsonFileAsync(path2, data) {
+  mkdirSync4(dirname5(path2), { recursive: true, mode: 448 });
+  if (path2 === CONFIG_PATH) {
     try {
       await backupUserDataAsync(DATA_DIR, "pre-config-write");
     } catch {
     }
   }
-  await writeJsonAtomicAsync(path3, data, { lock: false, fsyncDir: true, mode: 384, secret: true });
-  if (path3 === CONFIG_PATH) {
+  await writeJsonAtomicAsync(path2, data, { lock: false, fsyncDir: true, mode: 384, secret: true });
+  if (path2 === CONFIG_PATH) {
     invalidateConfigReadCache();
     try {
       markUserDataInitialized(DATA_DIR);
@@ -1150,10 +1290,10 @@ async function writeJsonFileAsync(path3, data) {
   }
 }
 async function writeAllAsync(data) {
-  await writeJsonFileAsync(CONFIG_PATH, data);
+  await writeJsonFileAsync(CONFIG_PATH, canonicalizeUnifiedConfig(data));
 }
 function withConfigLockAsync(fn) {
-  return withFileLock(`${CONFIG_PATH}.lock`, fn, { secret: true });
+  return withFileLock(`${CONFIG_PATH}.lock`, fn);
 }
 function trackConfigWrite(work) {
   let promise;
@@ -1177,981 +1317,37 @@ function updateSectionAsync(section, updater) {
     await writeAllAsync(all);
   }));
 }
-var _require, _getSecret, _setSecret, _deleteSecret, _hasSecret, _invalidateSecretCache, DATA_DIR, CONFIG_PATH, GENERATED_KEY, _configReadCache, CONFIG_READ_TTL_MS, _pendingConfigWrites, CAPABILITY_DEFAULTS, SECRET_ACCOUNTS;
+var _require, _getSecret, _setSecret, _deleteSecret, _hasSecret, _invalidateSecretCache, DATA_DIR, CONFIG_PATH, GENERATED_KEY, _configReadCache, CONFIG_READ_TTL_MS, _pendingConfigWrites, SECRET_ACCOUNTS;
 var init_config = __esm({
   "src/runtime/shared/config.mjs"() {
     init_plugin_paths();
     init_atomic_file();
     init_user_data_guard();
-    init_provider_api_key();
-    _require = createRequire3(import.meta.url);
-    ({
-      getSecret: _getSecret,
-      setSecret: _setSecret,
-      deleteSecret: _deleteSecret,
-      hasSecret: _hasSecret,
-      invalidateSecretCache: _invalidateSecretCache
-    } = _require("../../lib/keychain-cjs.cjs"));
-    DATA_DIR = resolvePluginData();
-    CONFIG_PATH = join6(DATA_DIR, "mixdog-config.json");
-    GENERATED_KEY = "_generated";
-    _configReadCache = null;
-    CONFIG_READ_TTL_MS = (() => {
-      const n = Number(process.env.MIXDOG_CONFIG_READ_TTL_MS);
-      return Number.isFinite(n) && n >= 0 ? n : 0;
-    })();
-    _pendingConfigWrites = /* @__PURE__ */ new Set();
-    CAPABILITY_DEFAULTS = Object.freeze({ homeAccess: false });
-    SECRET_ACCOUNTS = Object.freeze({
-      discordToken: "discord.token",
-      telegramToken: "telegram.token",
-      agentApiKey: (provider) => `agent.${provider}.apiKey`,
-      openaiUsageSessionKey: "agent.openai.usageSessionKey",
-      opencodeGoAuthCookie: "agent.opencode-go.authCookie"
-    });
-  }
-});
-
-// src/standalone/engine-daemon-protocol.mjs
-var ENGINE_DAEMON_PROTOCOL;
-var init_engine_daemon_protocol = __esm({
-  "src/standalone/engine-daemon-protocol.mjs"() {
-    ENGINE_DAEMON_PROTOCOL = 3;
-  }
-});
-
-// src/standalone/engine-daemon-local-bridge.mjs
-function engineDaemonLocalBridge() {
-  return globalThis[LOCAL_ENGINE_BRIDGE_KEY] ?? null;
-}
-var LOCAL_ENGINE_BRIDGE_KEY;
-var init_engine_daemon_local_bridge = __esm({
-  "src/standalone/engine-daemon-local-bridge.mjs"() {
-    LOCAL_ENGINE_BRIDGE_KEY = /* @__PURE__ */ Symbol.for("mixdog.engine-daemon.local-bridge.v1");
-  }
-});
-
-// src/standalone/engine-daemon-client.mjs
-var engine_daemon_client_exports = {};
-__export(engine_daemon_client_exports, {
-  attachEngineDaemon: () => attachEngineDaemon,
-  callDaemonSession: () => callDaemonSession,
-  createRemoteEngineSession: () => createRemoteEngineSession,
-  engineDaemonDiscoveryPath: () => engineDaemonDiscoveryPath,
-  ensureEngineDaemon: () => ensureEngineDaemon,
-  negotiateEngineDaemon: () => negotiateEngineDaemon,
-  probeEngineDaemonHealth: () => probeEngineDaemonHealth,
-  readEngineDaemonDiscovery: () => readEngineDaemonDiscovery,
-  shutdownEngineDaemon: () => shutdownEngineDaemon
-});
-import http from "node:http";
-import os from "node:os";
-import path2 from "node:path";
-import { fork } from "node:child_process";
-import { readFileSync as readFileSync7 } from "node:fs";
-import { randomUUID as randomUUID2 } from "node:crypto";
-import { fileURLToPath as fileURLToPath3 } from "node:url";
-function runtimeRoot() {
-  return process.env.MIXDOG_RUNTIME_ROOT ? path2.resolve(process.env.MIXDOG_RUNTIME_ROOT) : path2.join(os.tmpdir(), "mixdog");
-}
-function engineDaemonDiscoveryPath() {
-  return path2.join(runtimeRoot(), "engine-daemon.json");
-}
-function daemonEntry() {
-  return fileURLToPath3(new URL("./backend-daemon.mjs", import.meta.url));
-}
-function request({
-  port,
-  token,
-  method = "GET",
-  path: urlPath,
-  body = null,
-  timeoutMs = 12e4,
-  control = false
-}) {
-  return new Promise((resolve5, reject) => {
-    const payload = body ? JSON.stringify(body) : null;
-    const req = http.request({
-      hostname: "127.0.0.1",
-      port,
-      path: urlPath,
-      method,
-      agent: control ? daemonControlAgent : daemonCallAgent,
-      headers: {
-        "X-Mixdog-Daemon-Token": token,
-        ...payload ? { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(payload) } : {}
-      },
-      timeout: timeoutMs
-    }, (res) => {
-      let data = "";
-      res.setEncoding("utf8");
-      res.on("data", (chunk) => {
-        data += chunk;
-      });
-      res.on("end", () => {
-        let parsed = null;
-        try {
-          parsed = data ? JSON.parse(data) : {};
-        } catch {
-          parsed = null;
-        }
-        if (res.statusCode && res.statusCode >= 400) {
-          const err = new Error(parsed?.error || data || `HTTP ${res.statusCode}`);
-          err.statusCode = res.statusCode;
-          reject(err);
-          return;
-        }
-        resolve5(parsed ?? {});
-      });
-    });
-    req.on("timeout", () => {
-      req.destroy(new Error(`engine daemon timeout: ${method} ${urlPath}`));
-    });
-    req.on("error", reject);
-    if (payload) req.write(payload);
-    req.end();
-  });
-}
-async function probeEngineDaemonHealth({ port, token, timeoutMs = 800 } = {}) {
-  try {
-    const health = await request({ port, token, path: "/health", timeoutMs, control: true });
-    return health?.status === "ok" ? health : null;
-  } catch {
-    return null;
-  }
-}
-function readEngineDaemonDiscovery(discoveryPath = engineDaemonDiscoveryPath()) {
-  try {
-    const parsed = JSON.parse(readFileSync7(discoveryPath, "utf8"));
-    if (!parsed?.port || !parsed?.token || !parsed?.pid) return null;
-    return parsed;
-  } catch {
-    return null;
-  }
-}
-function delay(ms) {
-  return new Promise((resolve5) => setTimeout(resolve5, ms));
-}
-function negotiateEngineDaemon(health) {
-  const protocol = Number(health?.protocol) || 0;
-  if (protocol > ENGINE_DAEMON_PROTOCOL) return "defer";
-  if (protocol < ENGINE_DAEMON_PROTOCOL) return "restart";
-  return "ok";
-}
-async function waitForDaemonExit(discovery, timeoutMs = 5e3) {
-  const deadline = Date.now() + timeoutMs;
-  while (Date.now() < deadline) {
-    const health = await probeEngineDaemonHealth({ port: discovery.port, token: discovery.token, timeoutMs: 400 });
-    if (!health || Number(health.pid) !== Number(discovery.pid)) return true;
-    await delay(150);
-  }
-  return false;
-}
-function spawnDaemonCandidate({ cwd, log }) {
-  return new Promise((resolve5) => {
-    let settled = false;
-    const done = () => {
-      if (!settled) {
-        settled = true;
-        resolve5();
-      }
-    };
-    let child;
-    try {
-      child = fork(daemonEntry(), [], {
-        cwd,
-        stdio: ["ignore", "ignore", "pipe", "ipc"],
-        detached: process.platform !== "win32",
-        windowsHide: true,
-        env: {
-          ...process.env,
-          MIXDOG_ENGINE_DAEMON_HOST: "1",
-          // Engine-only spawn: the backend stays dormant on the channels side
-          // until a channels client registers.
-          MIXDOG_DAEMON_SPAWNED_FOR: "engine",
-          MIXDOG_SUPERVISOR_PID: process.env.MIXDOG_SUPERVISOR_PID || String(process.pid)
-        }
-      });
-    } catch (err) {
-      log(`daemon spawn failed: ${err?.message || err}`);
-      done();
-      return;
-    }
-    const mirror = (chunk) => {
-      const text = String(chunk || "").trimEnd();
-      if (text) log(text);
-    };
-    child.stderr?.on("data", mirror);
-    child.once("message", (msg) => {
-      if (msg?.type !== "ready") return;
-      try {
-        child.stderr?.off?.("data", mirror);
-      } catch {
-      }
-      try {
-        child.disconnect?.();
-      } catch {
-      }
-      try {
-        child.unref?.();
-      } catch {
-      }
-      try {
-        child.stderr?.unref?.();
-      } catch {
-      }
-      done();
-    });
-    child.once("exit", done);
-    child.once("error", (err) => {
-      log(`daemon spawn error: ${err?.message || err}`);
-      done();
-    });
-    const timer2 = setTimeout(done, 3e4);
-    timer2.unref?.();
-  });
-}
-async function ensureEngineDaemon({ cwd = process.cwd(), log = () => {
-}, attempts = 5 } = {}) {
-  let upgradeBlocked = null;
-  for (let attempt = 0; attempt < attempts; attempt += 1) {
-    const discovery = readEngineDaemonDiscovery();
-    if (discovery) {
-      const health = await probeEngineDaemonHealth({ port: discovery.port, token: discovery.token });
-      if (health && Number(health.pid) === Number(discovery.pid)) {
-        const verdict = negotiateEngineDaemon(health);
-        if (verdict === "ok") return discovery;
-        if (verdict === "defer") {
-          const err = new Error(
-            `engine daemon ${health.version || "?"} (protocol ${health.protocol ?? 0}) is newer than this client`
-          );
-          err.daemonNewerThanClient = true;
-          throw err;
-        }
-        log(`stopping older engine daemon ${health.version || "?"} (protocol ${health.protocol ?? 0})`);
-        await shutdownEngineDaemon(discovery);
-        upgradeBlocked = await waitForDaemonExit(discovery) ? null : health;
-      }
-    }
-    await spawnDaemonCandidate({ cwd, log });
-    await delay(100);
-  }
-  if (upgradeBlocked) {
-    const err = new Error(
-      `an older Mixdog backend (protocol ${upgradeBlocked.protocol ?? 0}) is still serving live clients \u2014 close the running Mixdog windows and terminals, then start again`
-    );
-    err.daemonUpgradeBlocked = true;
-    throw err;
-  }
-  throw new Error("engine daemon is unavailable");
-}
-async function attachEngineDaemon({
-  discovery,
-  leadPid = process.pid,
-  cwd = process.cwd(),
-  lifecycle = true,
-  registrationId = randomUUID2(),
-  onFrame = () => {
-  },
-  onFatal = () => {
-  },
-  log = () => {
-  }
-} = {}) {
-  if (!discovery?.port || !discovery?.token) throw new Error("daemon discovery {port, token} required");
-  const { port, token: serverToken } = discovery;
-  const stableRegistrationId = String(registrationId || randomUUID2());
-  let reg = null;
-  let registrationError = null;
-  for (let attempt = 0; attempt < 3; attempt += 1) {
-    try {
-      reg = await request({
-        port,
-        token: serverToken,
-        method: "POST",
-        path: "/client/register",
-        body: {
-          leadPid,
-          cwd,
-          lifecycle: lifecycle !== false,
-          registrationId: stableRegistrationId
-        },
-        timeoutMs: 3e3,
-        control: true
-      });
-      break;
-    } catch (error) {
-      registrationError = error;
-      if (Number(error?.statusCode) >= 400 && Number(error?.statusCode) < 500) throw error;
-      if (attempt < 2) await delay(100 * (attempt + 1));
-    }
-  }
-  if (!reg) throw registrationError || new Error("engine daemon registration failed");
-  const clientToken = reg?.token;
-  if (!clientToken) throw new Error("engine daemon register returned no client token");
-  let closed = false;
-  let streamRequest = null;
-  function openStream() {
-    if (closed) return;
-    const req = http.request({
-      hostname: "127.0.0.1",
-      port,
-      path: `/events?token=${encodeURIComponent(clientToken)}&server_token=${encodeURIComponent(serverToken)}`,
-      method: "GET",
-      headers: { Accept: "text/event-stream", "X-Mixdog-Daemon-Token": serverToken }
-    }, (res) => {
-      if (req !== streamRequest || closed) {
-        res.resume();
-        return;
-      }
-      if (res.statusCode !== 200) {
-        res.resume();
-        if (!closed) {
-          try {
-            onFatal(`bad sse status ${res.statusCode}`);
-          } catch {
-          }
-        }
-        return;
-      }
-      res.setEncoding("utf8");
-      let buffer = "";
-      res.on("data", (chunk) => {
-        if (req !== streamRequest || closed) return;
-        buffer += chunk;
-        let index;
-        while ((index = buffer.indexOf("\n\n")) >= 0) {
-          const raw = buffer.slice(0, index);
-          buffer = buffer.slice(index + 2);
-          for (const line of raw.split("\n")) {
-            if (!line.startsWith("data:")) continue;
-            const json = line.slice(5).trim();
-            if (!json) continue;
-            let frame = null;
-            try {
-              frame = JSON.parse(json);
-            } catch {
-              continue;
-            }
-            try {
-              onFrame(frame);
-            } catch (err) {
-              log(`onFrame threw: ${err?.message || err}`);
-            }
-          }
-        }
-      });
-      const lost = (reason) => {
-        if (req !== streamRequest || closed) return;
-        try {
-          onFatal(reason);
-        } catch {
-        }
-      };
-      res.on("end", () => lost("sse ended"));
-      res.on("error", () => lost("sse error"));
-    });
-    req.on("error", () => {
-      if (req === streamRequest && !closed) {
-        try {
-          onFatal("sse request error");
-        } catch {
-        }
-      }
-    });
-    streamRequest = req;
-    req.end();
-  }
-  openStream();
-  async function call(name, args = {}, { timeoutMs = 3e5, callId = null } = {}) {
-    let out;
-    try {
-      out = await request({
-        port,
-        token: serverToken,
-        method: "POST",
-        path: "/call",
-        body: { token: clientToken, name, args: args || {}, ...callId ? { callId } : {} },
-        timeoutMs
-      });
-    } catch (err) {
-      err.daemonTransportError = true;
-      throw err;
-    }
-    if (out && out.error) throw new Error(out.error);
-    return out?.result;
-  }
-  async function close(reason = "client close") {
-    if (closed) return;
-    closed = true;
-    try {
-      streamRequest?.destroy?.();
-    } catch {
-    }
-    try {
-      await request({
-        port,
-        token: serverToken,
-        method: "POST",
-        path: "/client/deregister",
-        body: { token: clientToken },
-        timeoutMs: 1500,
-        control: true
-      });
-    } catch {
-    }
-    log(`detached (${reason})`);
-  }
-  return { call, close, clientToken, port, pid: Number(discovery.pid) };
-}
-async function shutdownEngineDaemon(discovery = readEngineDaemonDiscovery()) {
-  if (!discovery?.port) return false;
-  try {
-    await request({
-      port: discovery.port,
-      token: discovery.token,
-      method: "POST",
-      path: "/shutdown",
-      body: {},
-      timeoutMs: 3e3,
-      control: true
-    });
-    return true;
-  } catch {
-    return false;
-  }
-}
-function addSessionView(views, sessionId, view) {
-  let bucket = views.get(sessionId);
-  if (!bucket) {
-    bucket = /* @__PURE__ */ new Set();
-    views.set(sessionId, bucket);
-  }
-  bucket.add(view);
-}
-function removeSessionView(views, sessionId, view) {
-  const bucket = views.get(sessionId);
-  if (!bucket) return;
-  bucket.delete(view);
-  if (bucket.size === 0) views.delete(sessionId);
-}
-function sessionViewCount(views, sessionId) {
-  return views.get(sessionId)?.size ?? 0;
-}
-function applyStatePatch(state, patch) {
-  const next = { ...state, ...patch.set || {} };
-  if (patch.itemsAppend) {
-    const base = Array.isArray(state.items) ? state.items : [];
-    next.items = base.slice(0, patch.itemsAppend.from).concat(patch.itemsAppend.values || []);
-  }
-  for (const key of patch.remove || []) delete next[key];
-  return next;
-}
-function scheduleReattach({ cwd, log }) {
-  if (reattachTimer || liveViews.size === 0) return;
-  reattachTimer = setTimeout(() => {
-    reattachTimer = null;
-    if (liveViews.size === 0) return;
-    void ensureSharedAttachment({ cwd, log }).catch((err) => {
-      log(`backend daemon re-attach failed: ${err?.message || err}`);
-      scheduleReattach({ cwd, log });
-    });
-  }, 500);
-  reattachTimer.unref?.();
-}
-async function ensureSharedAttachment({ cwd, log }) {
-  if (shared?.client) return shared;
-  if (shared?.pending) return shared.pending;
-  const pending = (async () => {
-    const localBridge = process.env.MIXDOG_ENGINE_DAEMON_HOST === "1" ? engineDaemonLocalBridge() : null;
-    const discovery = localBridge ? { pid: process.pid, local: true } : await ensureEngineDaemon({ cwd, log });
-    const views = /* @__PURE__ */ new Map();
-    const state = { client: null, views, discovery, refs: liveViews.size, log, cwd };
-    const attachmentOptions = {
-      cwd,
-      log,
-      onFrame: (frame) => {
-        const bucket = views.get(String(frame?.sessionId || ""));
-        if (!bucket) return;
-        for (const view of [...bucket]) {
-          if (frame.type === "session-state") view.applyFrame(frame);
-          else if (frame.type === "session-gone") view.applyGone(frame.reason || "session unloaded");
-        }
-      },
-      onFatal: (reason) => {
-        log(`backend daemon attachment lost (${reason})`);
-        if (shared === state) shared = null;
-        for (const bucket of views.values()) {
-          for (const view of [...bucket]) view.applyDetached(reason);
-        }
-        scheduleReattach({ cwd: state.cwd, log });
-      }
-    };
-    state.client = localBridge ? await localBridge.attach(attachmentOptions) : await attachEngineDaemon({ discovery, ...attachmentOptions });
-    shared = state;
-    for (const view of liveViews) {
-      addSessionView(views, view.sessionId(), view);
-      void view.recover(state).catch((err) => {
-        log(`session ${view.sessionId()} recovery failed: ${err?.message || err}`);
-      });
-    }
-    return state;
-  })();
-  shared = { pending };
-  try {
-    return await pending;
-  } catch (err) {
-    shared = null;
-    throw err;
-  }
-}
-async function createRemoteEngineSession(options = {}) {
-  const log = typeof options.log === "function" ? options.log : () => {
-  };
-  const cwd = options.cwd || process.cwd();
-  const openParams = {
-    cwd,
-    provider: options.provider,
-    model: options.model,
-    toolMode: options.toolMode || "full",
-    remote: options.remote === true,
-    desktopSession: options.desktopSession ?? null
-  };
-  let attachment = await ensureSharedAttachment({ cwd, log });
-  const created = await attachment.client.call("session.create", openParams, {
-    callId: `session-create:${process.pid}:${randomUUID2()}`
-  });
-  let sessionId = String(created?.sessionId || "");
-  if (!sessionId) throw new Error("session.create returned no sessionId");
-  let state = created?.full ?? {};
-  let revision = Number(created?.revision) || 0;
-  let sync = created?.sync ?? {};
-  let disposed = false;
-  const listeners = /* @__PURE__ */ new Set();
-  function emit() {
-    for (const listener of [...listeners]) {
-      try {
-        listener();
-      } catch (err) {
-        log(`session listener threw: ${err?.message || err}`);
-      }
-    }
-  }
-  function applyBody(body) {
-    if (disposed || !body) return false;
-    if (body.full !== void 0 && body.full !== null) {
-      state = body.full;
-      revision = Number(body.revision) || revision;
-      emit();
-      return true;
-    }
-    if (body.patch) {
-      if (Number(body.revision) === revision && Number(body.baseRevision) === revision - 1) return true;
-      if (Number(body.baseRevision) !== revision) return false;
-      state = applyStatePatch(state, body.patch);
-      revision = Number(body.revision) || revision;
-      emit();
-      return true;
-    }
-    if (Number.isFinite(Number(body.revision))) {
-      revision = Number(body.revision);
-      return true;
-    }
-    return false;
-  }
-  let resyncing = false;
-  function resync(reason) {
-    if (disposed || resyncing) return;
-    resyncing = true;
-    void attachment.client.call("session.read", {
-      sessionId,
-      open: openParams,
-      baseRevision: revision
-    }).then((result) => {
-      if (disposed) return;
-      if (result?.sync) sync = result.sync;
-      if (!applyBody(result) && result?.revision !== void 0) {
-        log(`session ${sessionId} resync returned an unusable body`);
-      }
-    }).catch((err) => {
-      log(`session ${sessionId} resync after ${reason} failed: ${err?.message || err}`);
-    }).finally(() => {
-      resyncing = false;
-    });
-  }
-  let recoveryPromise = null;
-  let view;
-  async function recover(nextAttachment) {
-    if (disposed) return;
-    if (recoveryPromise) return recoveryPromise;
-    recoveryPromise = (async () => {
-      const previousAttachment = attachment;
-      if (previousAttachment !== nextAttachment) {
-        removeSessionView(previousAttachment.views, sessionId, view);
-        attachment = nextAttachment;
-      }
-      let result;
-      try {
-        result = await attachment.client.call("session.subscribe", {
-          sessionId,
-          open: openParams,
-          baseRevision: revision
-        });
-      } catch {
-        result = await attachment.client.call("session.create", {
-          ...openParams,
-          sessionId
-        }, { callId: `session-recreate:${sessionId}` });
-      }
-      addSessionView(attachment.views, sessionId, view);
-      if (result?.sync) sync = result.sync;
-      if (!applyBody(result) && result?.revision !== void 0) resync("recovery body gap");
-      log(`session ${sessionId} projection recovered`);
-    })();
-    try {
-      return await recoveryPromise;
-    } finally {
-      recoveryPromise = null;
-    }
-  }
-  view = {
-    sessionId: () => sessionId,
-    applyFrame(frame) {
-      if (disposed) return;
-      if (!applyBody(frame)) resync("revision gap");
-    },
-    applyGone(reason) {
-      if (disposed) return;
-      void recover(attachment).catch((err) => {
-        log(`session ${sessionId} reload after ${reason} failed: ${err?.message || err}`);
-      });
-    },
-    applyDetached(reason) {
-      log(`session ${sessionId} projection detached (${reason})`);
-    },
-    recover
-  };
-  addSessionView(attachment.views, sessionId, view);
-  attachment.refs += 1;
-  liveViews.add(view);
-  async function sendCall(route, payload, callId) {
-    const send = () => attachment.client.call(route, payload, { callId });
-    try {
-      return await send();
-    } catch (err) {
-      const recoverable = err?.daemonTransportError || /unknown client token/i.test(String(err?.message || ""));
-      if (!recoverable || disposed) throw err;
-      if (shared === attachment) shared = null;
-      const next = await ensureSharedAttachment({ cwd, log });
-      await recover(next);
-      return await send();
-    }
-  }
-  async function applyResult(result, reason) {
-    const nextSessionId = String(result?.sessionId || sessionId);
-    if (nextSessionId && nextSessionId !== sessionId) {
-      const previousSessionId = sessionId;
-      addSessionView(attachment.views, nextSessionId, view);
-      removeSessionView(attachment.views, previousSessionId, view);
-      sessionId = nextSessionId;
-    }
-    if (result?.sync) sync = result.sync;
-    if (!applyBody(result) && result?.revision !== void 0) resync(`${reason} body gap`);
-    return result;
-  }
-  let callChain = Promise.resolve();
-  function serialize(task) {
-    const run = callChain.then(task);
-    callChain = run.then(() => {
-    }, () => {
-    });
-    return run;
-  }
-  function remoteCall(method, args, callOptions = {}) {
-    return serialize(async () => {
-      if (disposed) throw new Error("This session view is disposed.");
-      const stableCallId = typeof callOptions.callId === "string" && callOptions.callId.trim() ? callOptions.callId.trim() : randomUUID2();
-      const result = await sendCall("session.invoke", {
-        sessionId,
-        method,
-        args,
-        open: openParams,
-        baseRevision: revision
-      }, stableCallId);
-      await applyResult(result, method);
-      return result?.value ?? null;
-    });
-  }
-  function dispatch(method, args) {
-    void remoteCall(method, args).catch((err) => {
-      log(`session ${method} failed: ${err?.message || err}`);
-    });
-  }
-  async function rebindTo(result, previousSessionId) {
-    const nextSessionId = String(result?.sessionId || "");
-    if (!nextSessionId) throw new Error("session route returned no sessionId");
-    const lastLocalView = sessionViewCount(attachment.views, previousSessionId) <= 1;
-    addSessionView(attachment.views, nextSessionId, view);
-    removeSessionView(attachment.views, previousSessionId, view);
-    sessionId = nextSessionId;
-    if (result?.sync) sync = result.sync;
-    if (!applyBody(result) && result?.revision !== void 0) resync("session rebind body gap");
-    if (previousSessionId && previousSessionId !== nextSessionId && lastLocalView) {
-      try {
-        await attachment.client.call("session.unsubscribe", { sessionId: previousSessionId });
-      } catch (err) {
-        log(`session ${previousSessionId} unsubscribe failed: ${err?.message || err}`);
-      }
-    }
-    return nextSessionId;
-  }
-  async function createReservedSession() {
-    return serialize(async () => {
-      if (disposed) throw new Error("This session view is disposed.");
-      const previousSessionId = sessionId;
-      const result = await sendCall(
-        "session.create",
-        openParams,
-        `session-create:${process.pid}:${randomUUID2()}`
-      );
-      return await rebindTo(result, previousSessionId);
-    });
-  }
-  async function resumeSession(targetSessionId, resumeOptions) {
-    const target = String(targetSessionId || "");
-    if (!target) return false;
-    return serialize(async () => {
-      if (disposed) throw new Error("This session view is disposed.");
-      if (target === sessionId) {
-        const result2 = await sendCall("session.read", {
-          sessionId,
-          open: openParams,
-          baseRevision: revision
-        }, randomUUID2());
-        await applyResult(result2, "resume");
-        return true;
-      }
-      const previousSessionId = sessionId;
-      const result = await sendCall("session.subscribe", {
-        sessionId: target,
-        open: { ...openParams, resumeOptions: resumeOptions || void 0 },
-        baseRevision: null
-      }, randomUUID2());
-      await rebindTo(result, previousSessionId);
-      return true;
-    });
-  }
-  let submitSeq = 0;
-  async function submitAsync(prompt, options2 = {}) {
-    if (disposed) throw new Error("This session view is disposed.");
-    const submissionId = String(options2?.id || "").trim() || `session-submit-${process.pid}-${Date.now()}-${submitSeq += 1}`;
-    return serialize(async () => {
-      const result = await sendCall("session.submit", {
-        sessionId,
-        prompt,
-        options: { ...options2 || {}, id: submissionId },
-        open: openParams,
-        baseRevision: revision
-      }, `session-submit:${sessionId}:${submissionId}`);
-      await applyResult(result, "submit");
-      return result?.accepted === true;
-    });
-  }
-  const base = {
-    isRemoteEngine: true,
-    get disposedView() {
-      return disposed;
-    },
-    getState: () => state,
-    subscribe(listener) {
-      listeners.add(listener);
-      return () => listeners.delete(listener);
-    },
-    listSessions(options2) {
-      if (options2?.refreshFromStorage) dispatch("listSessions", [options2]);
-      return Array.isArray(sync.sessions) ? sync.sessions : [];
-    },
-    sessionStoreDir() {
-      return typeof sync.sessionStoreDir === "string" ? sync.sessionStoreDir : null;
-    },
-    async newSession() {
-      await createReservedSession();
-      return true;
-    },
-    resume: resumeSession,
-    async prefetchSession(targetSessionId) {
-      const target = String(targetSessionId || "");
-      if (!target) return false;
-      await callDaemonSession({
-        sessionId: target,
-        method: "read",
-        open: openParams,
-        cwd,
-        log,
-        attempts: 1
-      });
-      return true;
-    },
-    submitAsync,
-    submit(prompt, options2) {
-      if (disposed) return false;
-      void submitAsync(prompt, options2).catch((err) => {
-        log(`legacy submit failed: ${err?.message || err}`);
-      });
-      return true;
-    },
-    abort() {
-      void serialize(async () => {
-        const result = await sendCall("session.abort", {
-          sessionId,
-          open: openParams,
-          baseRevision: revision
-        }, randomUUID2());
-        await applyResult(result, "abort");
-      }).catch((err) => log(`session abort failed: ${err?.message || err}`));
-      return true;
-    },
-    resolveToolApproval(id, decision) {
-      void serialize(async () => {
-        const result = await sendCall("session.approve", {
-          sessionId,
-          approvalId: id,
-          decision,
-          open: openParams,
-          baseRevision: revision
-        }, randomUUID2());
-        await applyResult(result, "approval");
-      }).catch((err) => log(`session approval failed: ${err?.message || err}`));
-      return true;
-    },
-    async dispose(reason = "view dispose") {
-      if (disposed) return;
-      disposed = true;
-      liveViews.delete(view);
-      const releasedSessionId = sessionId;
-      const lastLocalView = sessionViewCount(attachment.views, releasedSessionId) <= 1;
-      if (lastLocalView) {
-        try {
-          await attachment.client.call("session.unsubscribe", { sessionId: releasedSessionId });
-        } catch (err) {
-          log(`session ${releasedSessionId} unsubscribe failed: ${err?.message || err}`);
-        }
-      }
-      removeSessionView(attachment.views, releasedSessionId, view);
-      listeners.clear();
-      attachment.refs = Math.max(0, attachment.refs - 1);
-      if (attachment.refs === 0 && liveViews.size === 0) {
-        try {
-          await attachment.client.close(reason);
-        } catch {
-        }
-        try {
-          daemonCallAgent.destroy();
-        } catch {
-        }
-        try {
-          daemonControlAgent.destroy();
-        } catch {
-        }
-        if (shared === attachment) shared = null;
-      }
-    }
-  };
-  return new Proxy(base, {
-    get(target, property, receiver) {
-      if (property in target || LOCAL_ENGINE_KEYS.has(property)) {
-        return Reflect.get(target, property, receiver);
-      }
-      if (typeof property === "symbol") return void 0;
-      return (...args) => remoteCall(property, args);
-    },
-    has(target, property) {
-      return typeof property === "string" ? true : Reflect.has(target, property);
-    }
-  });
-}
-async function callDaemonSession({
-  sessionId,
-  method,
-  args = [],
-  open: openHints = {},
-  cwd = process.cwd(),
-  log = () => {
-  },
-  attempts = 3
-} = {}) {
-  const id = String(sessionId || "");
-  if (!id) throw new TypeError("sessionId is required");
-  const name = String(method || "");
-  if (!name) throw new TypeError("method is required");
-  let route = "session.invoke";
-  let payload = { sessionId: id, method: name, args, open: openHints || {} };
-  if (name === "submit") {
-    route = "session.submit";
-    payload = {
-      sessionId: id,
-      prompt: args?.[0],
-      options: args?.[1] || {},
-      open: openHints || {}
-    };
-  } else if (name === "abort") {
-    route = "session.abort";
-    payload = { sessionId: id, open: openHints || {} };
-  } else if (name === "resolveToolApproval") {
-    route = "session.approve";
-    payload = {
-      sessionId: id,
-      approvalId: args?.[0],
-      decision: args?.[1],
-      open: openHints || {}
-    };
-  } else if (name === "read") {
-    route = "session.read";
-    payload = { sessionId: id, open: openHints || {}, baseRevision: null };
-  }
-  const submissionId = name === "submit" ? String(args?.[1]?.id || "").trim() : "";
-  const callId = submissionId ? `session-submit:${id}:${submissionId}` : randomUUID2();
-  let lastError = null;
-  for (let attempt = 0; attempt < Math.max(1, attempts); attempt += 1) {
-    const attachment = await ensureSharedAttachment({ cwd, log });
-    try {
-      const result = await attachment.client.call(route, payload, { callId });
-      if (name === "submit") return { ...result, value: result?.accepted === true };
-      if (name === "abort") return { ...result, value: result?.aborted === true };
-      if (name === "resolveToolApproval") return { ...result, value: result?.approved === true };
-      return result;
-    } catch (err) {
-      if (!err?.daemonTransportError) throw err;
-      lastError = err;
-      if (shared === attachment) shared = null;
-      await delay(200 * (attempt + 1));
-    }
-  }
-  throw lastError || new Error("engine daemon session call failed");
-}
-var daemonCallAgent, daemonControlAgent, shared, liveViews, reattachTimer, LOCAL_ENGINE_KEYS;
-var init_engine_daemon_client = __esm({
-  "src/standalone/engine-daemon-client.mjs"() {
-    init_engine_daemon_protocol();
-    init_engine_daemon_local_bridge();
-    daemonCallAgent = new http.Agent({ keepAlive: true, keepAliveMsecs: 5e3, maxSockets: 8 });
-    daemonControlAgent = new http.Agent({ keepAlive: true, keepAliveMsecs: 5e3, maxSockets: 4 });
-    shared = null;
-    liveViews = /* @__PURE__ */ new Set();
-    reattachTimer = null;
-    LOCAL_ENGINE_KEYS = /* @__PURE__ */ new Set([
-      "getState",
-      "subscribe",
-      "dispose",
-      "isRemoteEngine",
-      "disposedView",
-      "then",
-      "catch",
-      "finally",
-      "toJSON",
-      "inspect",
-      Symbol.toStringTag
-    ]);
+    init_provider_api_key();
+    _require = createRequire3(import.meta.url);
+    ({
+      getSecret: _getSecret,
+      setSecret: _setSecret,
+      deleteSecret: _deleteSecret,
+      hasSecret: _hasSecret,
+      invalidateSecretCache: _invalidateSecretCache
+    } = _require("../../lib/keychain-cjs.cjs"));
+    DATA_DIR = resolvePluginData();
+    CONFIG_PATH = join5(DATA_DIR, "mixdog-config.json");
+    GENERATED_KEY = "_generated";
+    _configReadCache = null;
+    CONFIG_READ_TTL_MS = (() => {
+      const n = Number(process.env.MIXDOG_CONFIG_READ_TTL_MS);
+      return Number.isFinite(n) && n >= 0 ? n : 0;
+    })();
+    _pendingConfigWrites = /* @__PURE__ */ new Set();
+    SECRET_ACCOUNTS = Object.freeze({
+      discordToken: "discord.token",
+      telegramToken: "telegram.token",
+      agentApiKey: (provider) => `agent.${provider}.apiKey`,
+      openaiUsageSessionKey: "agent.openai.usageSessionKey",
+      opencodeGoAuthCookie: "agent.opencode-go.authCookie"
+    });
   }
 });
 
@@ -2160,7 +1356,7 @@ var require_mixdog_debug = __commonJS({
   "src/lib/mixdog-debug.cjs"(exports, module) {
     "use strict";
     var fs = __require("fs");
-    var path3 = __require("path");
+    var path2 = __require("path");
     function isTruthyEnv(value) {
       if (value == null || value === "") return false;
       const s = String(value).trim().toLowerCase();
@@ -2173,12 +1369,12 @@ var require_mixdog_debug = __commonJS({
     function _detectFromSourceCheckout() {
       if (_cachedFromSource !== null) return _cachedFromSource;
       try {
-        const moduleDir = module && module.filename ? path3.dirname(module.filename) : process.cwd();
+        const moduleDir = module && module.filename ? path2.dirname(module.filename) : process.cwd();
         const roots = [
-          path3.resolve(moduleDir, "..", ".."),
+          path2.resolve(moduleDir, "..", ".."),
           process.cwd()
         ];
-        _cachedFromSource = roots.some((root) => fs.existsSync(path3.join(root, ".git")));
+        _cachedFromSource = roots.some((root) => fs.existsSync(path2.join(root, ".git")));
       } catch {
         _cachedFromSource = false;
       }
@@ -2244,7 +1440,7 @@ var require_mixdog_debug = __commonJS({
       }
       const candidates = [];
       for (const e of entries) {
-        const p = path3.join(dataDir, e.name);
+        const p = path2.join(dataDir, e.name);
         try {
           const st = fs.statSync(p);
           if (now - st.mtimeMs < minAgeMs) continue;
@@ -2285,7 +1481,7 @@ var require_mixdog_debug = __commonJS({
     function appendSessionStartCriticalLog(dataDir, line) {
       if (!dataDir || !line) return;
       try {
-        const p = path3.join(dataDir, SESSION_START_CRITICAL_LOG);
+        const p = path2.join(dataDir, SESSION_START_CRITICAL_LOG);
         fs.mkdirSync(dataDir, { recursive: true });
         rotateBoundedLog2(p, SESSION_START_CRITICAL_MAX_BYTES, SESSION_START_CRITICAL_KEEP_BYTES);
         fs.appendFileSync(p, line.endsWith("\n") ? line : `${line}
@@ -2312,14 +1508,14 @@ var require_mixdog_debug = __commonJS({
 // src/tui/index.jsx
 import React22 from "react";
 import { render } from "../../../vendor/ink/build/index.js";
-import { closeSync as closeSync2, constants as fsConstants, createWriteStream, mkdirSync as mkdirSync7, openSync as openSync2, readSync } from "node:fs";
+import { closeSync as closeSync2, constants as fsConstants, createWriteStream, mkdirSync as mkdirSync6, openSync as openSync2, readSync } from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
-import { dirname as dirname8, join as join9 } from "node:path";
+import { dirname as dirname7, join as join8 } from "node:path";
 import { performance as performance3 } from "node:perf_hooks";
 import { format } from "node:util";
 
 // src/tui/App.jsx
-import React21, { useState as useState11, useCallback as useCallback12, useEffect as useEffect13, useLayoutEffect as useLayoutEffect5, useMemo as useMemo4, useRef as useRef13 } from "react";
+import React21, { useState as useState11, useCallback as useCallback13, useEffect as useEffect14, useLayoutEffect as useLayoutEffect5, useMemo as useMemo5, useRef as useRef14 } from "react";
 import { Box as Box19, Text as Text21, useApp, useInput as useInput6, useStdin as useStdin3, useStdout as useStdout2 } from "../../../vendor/ink/build/index.js";
 
 // src/tui/themes/base.mjs
@@ -3992,8 +3188,8 @@ function parseToolArgs(args) {
   }
   return { value: args };
 }
-function displayToolPath(path3) {
-  const text = String(path3 ?? "");
+function displayToolPath(path2) {
+  const text = String(path2 ?? "");
   return text.replace(/\\/g, "/").split("/").filter(Boolean).at(-1) || text;
 }
 function compactParts(parts) {
@@ -4187,16 +3383,16 @@ function looksLikeZeroResultText(text) {
   return /^\(?\s*(?:no|0)\s+(?:fuzzy\s+)?(?:match(?:es)?|results?|files?|entries|candidates?|hits?)\b/i.test(trimmed) || /^\(?\s*(?:empty|none)\s*\)?$/i.test(trimmed) || /^no\s+\S+\s+(?:found|matched)\b/i.test(trimmed);
 }
 function splitPathAndDelta(value, explicitDelta = "") {
-  let path3 = String(value ?? "").trim();
+  let path2 = String(value ?? "").trim();
   let delta = String(explicitDelta ?? "").trim();
   if (!delta) {
-    const sep = path3.lastIndexOf(" \u2014 ");
+    const sep = path2.lastIndexOf(" \u2014 ");
     if (sep !== -1) {
-      delta = path3.slice(sep + 3).trim();
-      path3 = path3.slice(0, sep).trim();
+      delta = path2.slice(sep + 3).trim();
+      path2 = path2.slice(0, sep).trim();
     }
   }
-  return { path: path3, delta };
+  return { path: path2, delta };
 }
 function parseLineDelta(delta) {
   const totals = { added: 0, removed: 0, seen: false };
@@ -4230,14 +3426,14 @@ function summarizeUpdateResult(text, args) {
   for (const line of String(text ?? "").split("\n")) {
     const ok = /^\s*OK\s+(modify|add|delete|create)\s+(.+?)\s*$/i.exec(line);
     if (ok) {
-      const { path: path3, delta } = splitPathAndDelta(ok[2]);
-      changed.push({ action: ok[1].toLowerCase(), path: path3, delta });
+      const { path: path2, delta } = splitPathAndDelta(ok[2]);
+      changed.push({ action: ok[1].toLowerCase(), path: path2, delta });
       continue;
     }
     const edited = /^\s*(Edited|Created|Updated|Wrote):\s+(.+?)(?:\s+\(([^)]+)\))?\s*$/i.exec(line);
     if (edited) {
-      const { path: path3, delta } = splitPathAndDelta(edited[2], edited[3] || "");
-      changed.push({ action: edited[1].toLowerCase(), path: path3, delta });
+      const { path: path2, delta } = splitPathAndDelta(edited[2], edited[3] || "");
+      changed.push({ action: edited[1].toLowerCase(), path: path2, delta });
     }
   }
   if (changed.length === 1) {
@@ -4957,11 +4153,6 @@ function toolWorkUnit(name, args = {}, category = "") {
       }
       return unitDescriptor("Patch", {
         count: patchFileCount(a) || 1,
-        // post_shell is NOT named here: the turn engine already splits such a
-        // call into this edit card plus a trailing Shell card that carries the
-        // real command, its output and its failure banner (turn.mjs
-        // postShellTwins). Repeating "& verifying" in the header declared the
-        // verify phase twice and truncated the label on narrow panes.
         active: creating ? "Creating" : deleting ? "Deleting" : "Editing",
         done: creating ? "Created" : deleting ? "Deleted" : "Edited",
         noun: "file"
@@ -5179,9 +4370,9 @@ function reconcileTimer() {
     clearTimeout(timer);
     timer = null;
   }
-  const delay2 = nextDelayMs(Date.now());
-  if (delay2 == null) return;
-  timer = setTimeout(onTick, delay2);
+  const delay = nextDelayMs(Date.now());
+  if (delay == null) return;
+  timer = setTimeout(onTick, delay);
   timer.unref?.();
 }
 function onTick() {
@@ -5411,6 +4602,16 @@ var SPINNER_VERBS = [
   "Zigzagging"
 ];
 var SPINNER_VERB_ROTATE_MS = 3e4;
+var SPINNER_VERB_CHANGE_ODDS = 0.5;
+function boundarySwaps(anchor, boundary) {
+  let h = Math.floor(anchor / 1e3) + Math.imul(boundary, 2654435761) | 0;
+  h = Math.imul(h ^ h >>> 16, 569420461);
+  h = Math.imul(h ^ h >>> 15, 1935289751);
+  h = (h ^ h >>> 15) >>> 0;
+  return h / 4294967296 < SPINNER_VERB_CHANGE_ODDS;
+}
+var MAX_COUNTED_BOUNDARIES = 4096;
+var MAX_HELD_BOUNDARIES = 3;
 var SPINNER_MODE_OVERRIDE_VERBS = {
   compacting: "Compacting conversation",
   "auto-clear": "Auto-clearing conversation",
@@ -5420,14 +4621,24 @@ function spinnerVerbFor(startedAt = 0, now = 0, pool = SPINNER_VERBS) {
   const list = Array.isArray(pool) && pool.length ? pool : SPINNER_VERBS;
   const anchor = Math.max(0, Number(startedAt) || 0);
   const elapsed = anchor > 0 ? Math.max(0, (Number(now) || 0) - anchor) : 0;
-  const slot = Math.floor(elapsed / SPINNER_VERB_ROTATE_MS);
-  const seed = Math.floor(anchor / 1e3) + slot;
+  const boundaries = Math.floor(elapsed / SPINNER_VERB_ROTATE_MS);
+  const counted = Math.min(boundaries, MAX_COUNTED_BOUNDARIES);
+  let swaps = boundaries - counted;
+  let held = 0;
+  for (let boundary = 1; boundary <= counted; boundary += 1) {
+    if (held >= MAX_HELD_BOUNDARIES || boundarySwaps(anchor, boundary)) {
+      swaps += 1;
+      held = 0;
+    } else {
+      held += 1;
+    }
+  }
+  const seed = Math.floor(anchor / 1e3) + swaps;
   return list[(seed * 7 + 3) % list.length];
 }
 var SPINNER_FRAMES = ["\u25C7", "\u25C6", "\u25C8", "\u25C6", "\u25C7"];
 
 // src/tui/spinner-meta.mjs
-var SHOW_TOKENS_AFTER_MS = 3e4;
 var compactNumberFormatter = new Intl.NumberFormat("en-US", {
   notation: "compact",
   maximumFractionDigits: 1,
@@ -5462,7 +4673,10 @@ function buildSpinnerMeta({
   const thinkingText = spinnerThinkingLabel({ thinking, thinkingSince, thinkingMs, effort });
   return {
     tokensText: tokens > 0 ? `${formatSpinnerTokens(tokens)} tokens` : "",
-    showTokens: tokens > 0 && (Boolean(verbose) || Number(elapsedMs) > SHOW_TOKENS_AFTER_MS),
+    // The count appears with the FIRST token (user: 30초가 아니라 바로).
+    // Elapsed was never gated, so the byline used to grow a second field
+    // mid-turn for no reason the reader could see; now both arrive together.
+    showTokens: tokens > 0,
     thinkingText,
     thinkingActive: Boolean(thinking || Number(thinkingSince) > 0)
   };
@@ -6001,8 +5215,8 @@ function hasActiveStatuslineWork(line, agentWorkers = [], agentJobs = [], active
 function bootFullRenderEligible(mountAtMs, line, agentWorkers = [], agentJobs = [], activeTools = null) {
   const elapsed = Date.now() - mountAtMs;
   const active = hasActiveStatuslineWork(line, agentWorkers, agentJobs, activeTools);
-  const delay2 = active ? STATUSLINE_BOOT_FULL_DELAY_ACTIVE_MS : STATUSLINE_BOOT_FULL_DELAY_MS;
-  return elapsed >= delay2;
+  const delay = active ? STATUSLINE_BOOT_FULL_DELAY_ACTIVE_MS : STATUSLINE_BOOT_FULL_DELAY_MS;
+  return elapsed >= delay;
 }
 function canAttemptBootFullRender(nextAttemptAtMs = 0) {
   return Date.now() >= nextAttemptAtMs;
@@ -6775,15 +5989,15 @@ function singleTrailingLineBreakPrefix(text) {
 function draftStateEqual(a, b) {
   return a.value === b.value && a.cursor === b.cursor && a.selectionAnchor === b.selectionAnchor;
 }
-var MODIFIED_ENTER_SHIFT_OR_CTRL = 1 | 4;
+var MODIFIED_ENTER_NEWLINE = 1 | 2 | 4;
 function isModifiedEnterSequence(input) {
   const text = String(input ?? "");
   const body = text.startsWith("\x1B[") ? text.slice(2) : text.startsWith("[") ? text.slice(1) : "";
   if (!body) return false;
   const kitty = /^13;(\d+)(?::\d+)?(?:;[\d:]+)?u$/.exec(body);
-  if (kitty) return (Number(kitty[1]) - 1 & MODIFIED_ENTER_SHIFT_OR_CTRL) !== 0;
+  if (kitty) return (Number(kitty[1]) - 1 & MODIFIED_ENTER_NEWLINE) !== 0;
   const modifyOtherKeys = /^27;(\d+);13~$/.exec(body);
-  return Boolean(modifyOtherKeys && (Number(modifyOtherKeys[1]) - 1 & MODIFIED_ENTER_SHIFT_OR_CTRL) !== 0);
+  return Boolean(modifyOtherKeys && (Number(modifyOtherKeys[1]) - 1 & MODIFIED_ENTER_NEWLINE) !== 0);
 }
 function isAnyModifiedEnterSequence(input) {
   const text = String(input ?? "");
@@ -6796,9 +6010,6 @@ function isAnyModifiedEnterSequence(input) {
 }
 
 // src/tui/components/prompt-input/immediate-render.mjs
-function suppressed(value) {
-  return typeof value === "function" ? value() === true : value === true;
-}
 function cancelPromptImmediateFlush(throttle, clearTimer = clearTimeout) {
   if (!throttle || throttle.timer === null) return false;
   clearTimer(throttle.timer);
@@ -6807,7 +6018,6 @@ function cancelPromptImmediateFlush(throttle, clearTimer = clearTimeout) {
 }
 function schedulePromptImmediateFlush({
   throttle,
-  isSuppressed = false,
   flush,
   intervalMs = 16,
   now = Date.now,
@@ -6818,10 +6028,6 @@ function schedulePromptImmediateFlush({
   if (!throttle || typeof flush !== "function") {
     throw new TypeError("schedulePromptImmediateFlush requires throttle state and a flush function");
   }
-  if (suppressed(isSuppressed)) {
-    cancelPromptImmediateFlush(throttle, clearTimer);
-    return false;
-  }
   const current = now();
   const elapsed = current - throttle.lastAt;
   if (elapsed >= intervalMs) {
@@ -6833,13 +6039,35 @@ function schedulePromptImmediateFlush({
   if (throttle.timer !== null) return false;
   throttle.timer = setTimer(() => {
     throttle.timer = null;
-    if (suppressed(isSuppressed)) return;
     throttle.lastAt = now();
     flush();
   }, intervalMs - elapsed);
   return true;
 }
 
+// src/tui/components/prompt-input/escape-policy.mjs
+var PROMPT_ESCAPE_CLEAR_WINDOW_MS = 800;
+function classifyPromptEscape({
+  interruptActive = false,
+  hasQueuedMessages = false,
+  hasMessages = false,
+  value = "",
+  lastClearPressAt = 0,
+  now = Date.now()
+} = {}) {
+  if (interruptActive) return { action: "interrupt", nextClearPressAt: 0 };
+  if (hasQueuedMessages) return { action: "restore-queue", nextClearPressAt: 0 };
+  const current = Number(now);
+  const previous = Number(lastClearPressAt);
+  const repeated = Number.isFinite(current) && Number.isFinite(previous) && previous > 0 && current >= previous && current - previous <= PROMPT_ESCAPE_CLEAR_WINDOW_MS;
+  const armed = Number.isFinite(current) && current > 0 ? current : 1;
+  if (String(value ?? "") === "") {
+    if (!hasMessages) return { action: "idle", nextClearPressAt: 0 };
+    return repeated ? { action: "message-selector", nextClearPressAt: 0 } : { action: "arm-select", nextClearPressAt: armed };
+  }
+  return repeated ? { action: "clear", nextClearPressAt: 0 } : { action: "arm-clear", nextClearPressAt: armed };
+}
+
 // src/tui/components/PromptInput.jsx
 import { Fragment as Fragment2, jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
 var IME_LEFT_GUARD_COLUMNS = 0;
@@ -6862,6 +6090,7 @@ function PromptInput({
   interruptActive = false,
   onInterrupt,
   commandPaletteActive = false,
+  commandPaletteOpen = commandPaletteActive,
   mask = false,
   hint = "",
   hintTone = "info",
@@ -6874,6 +6103,8 @@ function PromptInput({
   onCommandPaletteCancel,
   onCommandPaletteComplete,
   onRestoreQueued,
+  hasQueuedMessages = false,
+  hasMessages = false,
   onHistoryNavigate,
   onPasteText,
   selectionRef,
@@ -6888,10 +6119,10 @@ function PromptInput({
   });
   const [, bumpCursorAnchorEpoch] = useState3(0);
   const draftRef = useRef4(draft);
-  const interruptActiveRef = useRef4(interruptActive);
   const lastReportedValueRef = useRef4(draft.value);
   const pasteGenerationRef = useRef4(0);
   const submitGateRef = useRef4(false);
+  const escapeClearAtRef = useRef4(0);
   if (valueRef) valueRef.current = draftRef.current.value;
   const { isRawModeSupported } = useStdin();
   const boxRef = useRef4(null);
@@ -6903,7 +6134,6 @@ function PromptInput({
   const undoRef = useRef4({ past: [], future: [], lastPushAt: 0, lastValue: null });
   const { value, cursor } = draft;
   draftRef.current = draft;
-  interruptActiveRef.current = interruptActive;
   if (selectionRef) {
     const range = selectionRange(draft);
     selectionRef.current = range ? { range, text: mask ? "" : draft.value.slice(range.start, range.end) } : null;
@@ -6928,7 +6158,6 @@ function PromptInput({
   const scheduleImmediateFlush = () => {
     schedulePromptImmediateFlush({
       throttle: flushThrottleRef.current,
-      isSuppressed: () => interruptActiveRef.current,
       flush: flushImmediate
     });
   };
@@ -6936,6 +6165,7 @@ function PromptInput({
     cancelPromptImmediateFlush(flushThrottleRef.current);
   }, []);
   const commitDraft = (next, options = {}) => {
+    escapeClearAtRef.current = 0;
     const sameDraft = draftStateEqual(draftRef.current, next);
     if (!options.keepPreferredColumn) preferredColumnRef.current = null;
     if (sameDraft) {
@@ -7144,8 +6374,12 @@ function PromptInput({
     commitDraft(moveCursor(current, moved.cursor, { extend }), { keepPreferredColumn: true });
     return true;
   };
-  const restoreQueuedToDraft = () => {
-    return onRestoreQueued?.(draftRef.current.value) === true;
+  const restoreQueuedToDraft = ({ showHint = false } = {}) => {
+    return onRestoreQueued?.({
+      restoreDraft: true,
+      showHint,
+      currentText: draftRef.current.value
+    }) === true;
   };
   const applyHistoryNavigation = (direction, meta = {}) => {
     const nextValue = onHistoryNavigate?.(direction, draftRef.current.value, meta);
@@ -7237,6 +6471,7 @@ function PromptInput({
     if (disabled) return;
     const rawInput = String(input ?? "");
     const inputKey = rawInput.toLowerCase();
+    if (!key.escape) escapeClearAtRef.current = 0;
     const rawShiftArrowForGrid = rawInput === "\x1B[1;2A" || rawInput === "\x1B[a" || rawInput === "[1;2A" || rawInput === "\x1B[1;2B" || rawInput === "\x1B[b" || rawInput === "[1;2B" || rawInput === "\x1B[1;2C" || rawInput === "\x1B[c" || rawInput === "[1;2C" || rawInput === "\x1B[1;2D" || rawInput === "\x1B[d" || rawInput === "[1;2D" || rawInput === "\x1B[1;6A" || rawInput === "[1;6A" || rawInput === "\x1B[1;6B" || rawInput === "[1;6B" || rawInput === "\x1B[1;6C" || rawInput === "[1;6C" || rawInput === "\x1B[1;6D" || rawInput === "[1;6D";
     const gridSelectionActive = typeof suppressShiftNavRef === "function" ? suppressShiftNavRef() : typeof suppressShiftNavRef?.current === "function" ? suppressShiftNavRef.current() : Boolean(suppressShiftNavRef?.current);
     if (gridSelectionActive) {
@@ -7264,13 +6499,13 @@ function PromptInput({
     const lineBreakIndex = rawInput.search(/[\r\n]/);
     const rawEnter = rawInput === "\r" || rawInput === "\n" || rawInput === "\r\n";
     const trailingEnterPrefix = singleTrailingLineBreakPrefix(rawInput);
-    const rawCtrlEnter = isModifiedEnterSequence(rawInput);
-    const modifiedLineBreak = key.shift || key.meta || key.ctrl || rawCtrlEnter;
+    const rawModifiedEnter = isModifiedEnterSequence(rawInput);
+    const modifiedLineBreak = key.shift || key.meta || key.ctrl || rawModifiedEnter;
     if (rawInput === "\n" && !key.return || key.ctrl && inputKey === "j") {
       updateDraft((d) => replaceSelection(d, "\n"));
       return;
     }
-    if (!rawCtrlEnter && isAnyModifiedEnterSequence(rawInput)) {
+    if (!rawModifiedEnter && isAnyModifiedEnterSequence(rawInput)) {
       return;
     }
     const pasteFallback = lineBreakIndex !== -1 && trailingEnterPrefix === null && !rawEnter && (rawInput.length > 1 || !key.return);
@@ -7287,7 +6522,7 @@ function PromptInput({
       submitEnterChunk(trailingEnterPrefix);
       return;
     }
-    if (rawCtrlEnter) {
+    if (rawModifiedEnter) {
       updateDraft((d) => replaceSelection(d, "\n"));
       return;
     }
@@ -7340,12 +6575,10 @@ ${d.value.slice(d.cursor)}`,
           if (!moveDraftVertically(-1, { extend: true })) {
             updateDraft((d) => moveCursor(d, 0, { extend: true }));
           }
-        } else {
-          const hasDraftText = String(draftRef.current.value || "").trim().length > 0;
-          if (!hasDraftText) {
-            if (!restoreQueuedToDraft()) applyHistoryNavigation("up", { emptyDraft: true });
-          } else if (!moveDraftVertically(-1, { extend: false })) {
-            applyHistoryNavigation("up", { emptyDraft: false });
+        } else if (!moveDraftVertically(-1, { extend: false })) {
+          const emptyDraft = String(draftRef.current.value || "").length === 0;
+          if (!hasQueuedMessages || !restoreQueuedToDraft()) {
+            applyHistoryNavigation("up", { emptyDraft });
           }
         }
       }
@@ -7360,7 +6593,7 @@ ${d.value.slice(d.cursor)}`,
             updateDraft((d) => moveCursor(d, d.value.length, { extend: true }));
           }
         } else if (!moveDraftVertically(1, { extend: false })) {
-          applyHistoryNavigation("down", { emptyDraft: String(draftRef.current.value || "").trim().length === 0 });
+          applyHistoryNavigation("down", { emptyDraft: String(draftRef.current.value || "").length === 0 });
         }
       }
       return;
@@ -7392,9 +6625,8 @@ ${d.value.slice(d.cursor)}`,
       if (onTab?.(draftRef.current.value) === true) return;
     }
     if (key.escape) {
-      if (commandPaletteActive) {
+      if (commandPaletteOpen) {
         onCommandPaletteCancel?.(draftRef.current.value);
-        commitDraft({ value: "", cursor: 0, selectionAnchor: null });
         return;
       }
       if (selectionRange(draftRef.current)) {
@@ -7405,19 +6637,48 @@ ${d.value.slice(d.cursor)}`,
       if (onEscape?.(currentValue, { phase: "before" }) === true) {
         return;
       }
-      if (currentValue) {
+      let escape = classifyPromptEscape({
+        interruptActive,
+        hasQueuedMessages,
+        hasMessages,
+        value: currentValue,
+        lastClearPressAt: escapeClearAtRef.current
+      });
+      if (escape.action === "restore-queue") {
+        if (restoreQueuedToDraft()) {
+          escapeClearAtRef.current = 0;
+          return;
+        }
+        escape = classifyPromptEscape({
+          interruptActive,
+          hasMessages,
+          value: currentValue,
+          lastClearPressAt: escapeClearAtRef.current
+        });
+      }
+      escapeClearAtRef.current = escape.nextClearPressAt;
+      if (escape.action === "interrupt") {
+        const restoredText = onInterrupt?.(currentValue);
+        if (!currentValue && typeof restoredText === "string") {
+          commitDraft({ value: restoredText, cursor: restoredText.length, selectionAnchor: null });
+        }
+        return;
+      }
+      if (escape.action === "arm-clear") {
+        onEscape?.(currentValue, { phase: "clear-arm" });
+        return;
+      }
+      if (escape.action === "clear") {
         onEscape?.(currentValue, { phase: "clear" });
         commitDraft({ value: "", cursor: 0, selectionAnchor: null });
         return;
       }
-      if (interruptActive) {
-        const restoredText = onInterrupt?.("");
-        if (typeof restoredText === "string") {
-          commitDraft({ value: restoredText, cursor: restoredText.length, selectionAnchor: null });
-        }
+      if (escape.action === "arm-select") {
+        onEscape?.("", { phase: "select-arm" });
         return;
       }
-      if (restoreQueuedToDraft()) {
+      if (escape.action === "message-selector") {
+        onEscape?.("", { phase: "select" });
         return;
       }
       onEscape?.("", { phase: "empty" });
@@ -8254,11 +7515,11 @@ function ContextUsageView({ detail, columns }) {
   const usage = detail?.usage || {};
   const compaction = detail?.compaction || {};
   const messages = detail?.messages || {};
-  const request2 = detail?.request || {};
+  const request = detail?.request || {};
   const lastApi = detail?.lastApi || {};
   const cache = detail?.cache || {};
   const semantic = messages.semantic || {};
-  const schema = request2.toolSchemaBreakdown || {};
+  const schema = request.toolSchemaBreakdown || {};
   const usedTokens = finiteNumber(usage.usedTokens);
   const windowTokens = finiteNumber(usage.windowTokens);
   const freeTokens = windowTokens ? Math.max(0, windowTokens - usedTokens) : finiteNumber(usage.freeTokens);
@@ -8839,15 +8100,15 @@ function singleTrailingLineBreakPrefix2(text) {
   const prefix = normalized.slice(0, -1);
   return prefix.includes("\n") ? null : prefix;
 }
-var MODIFIED_ENTER_SHIFT_OR_CTRL2 = 1 | 4;
+var MODIFIED_ENTER_SHIFT_OR_CTRL = 1 | 4;
 function isModifiedEnterSequence2(input) {
   const text = String(input ?? "");
   const body = text.startsWith("\x1B[") ? text.slice(2) : text.startsWith("[") ? text.slice(1) : "";
   if (!body) return false;
   const kitty = /^13;(\d+)(?::\d+)?(?:;[\d:]+)?u$/.exec(body);
-  if (kitty) return (Number(kitty[1]) - 1 & MODIFIED_ENTER_SHIFT_OR_CTRL2) !== 0;
+  if (kitty) return (Number(kitty[1]) - 1 & MODIFIED_ENTER_SHIFT_OR_CTRL) !== 0;
   const modifyOtherKeys = /^27;(\d+);13~$/.exec(body);
-  return Boolean(modifyOtherKeys && (Number(modifyOtherKeys[1]) - 1 & MODIFIED_ENTER_SHIFT_OR_CTRL2) !== 0);
+  return Boolean(modifyOtherKeys && (Number(modifyOtherKeys[1]) - 1 & MODIFIED_ENTER_SHIFT_OR_CTRL) !== 0);
 }
 function isAnyModifiedEnterSequence2(input) {
   const text = String(input ?? "");
@@ -9211,169 +8472,17 @@ function TextEntryPanel({
 // src/tui/App.jsx
 init_paste_attachments();
 
-// src/standalone/projects.mjs
-import { homedir as homedir2 } from "node:os";
-import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync2, renameSync, statSync, writeFileSync as writeFileSync2 } from "node:fs";
-import { basename as basename3, dirname as dirname3, isAbsolute as isAbsolute2, join as join3, resolve as resolve2 } from "node:path";
-var MIXDOG_HOME = process.env.MIXDOG_HOME || join3(homedir2(), ".mixdog");
-var PROJECTS_FILE = process.env.MIXDOG_PROJECTS_FILE ? resolve2(process.env.MIXDOG_PROJECTS_FILE) : join3(MIXDOG_HOME, "projects.json");
-function toAbsolute(rawPath) {
-  const text = String(rawPath || "").trim();
-  if (!text) return "";
-  return isAbsolute2(text) ? resolve2(text) : resolve2(process.cwd(), text);
-}
-function normalizeKey(absPath) {
-  const text = String(absPath || "");
-  return process.platform === "win32" ? text.replace(/[\\/]+$/, "").toLowerCase() : text.replace(/\/+$/, "");
-}
-function readStore() {
-  try {
-    if (!existsSync3(PROJECTS_FILE)) return { projects: [] };
-    const raw = readFileSync2(PROJECTS_FILE, "utf8");
-    const parsed = JSON.parse(raw);
-    const projects = Array.isArray(parsed?.projects) ? parsed.projects : [];
-    return {
-      projects: projects.filter((entry) => entry && typeof entry.path === "string" && entry.path.trim()).map((entry) => ({
-        name: String(entry.name || basename3(entry.path) || entry.path),
-        path: String(entry.path),
-        addedAt: Number(entry.addedAt) || 0,
-        ...Number(entry.lastSelectedAt) > 0 ? { lastSelectedAt: Number(entry.lastSelectedAt) } : {}
-      }))
-    };
-  } catch {
-    return { projects: [] };
-  }
-}
-function writeStore(store) {
-  try {
-    mkdirSync2(dirname3(PROJECTS_FILE), { recursive: true });
-    const tmp = `${PROJECTS_FILE}.${process.pid}.tmp`;
-    writeFileSync2(tmp, `${JSON.stringify(store, null, 2)}
-`, "utf8");
-    renameSync(tmp, PROJECTS_FILE);
-  } catch {
-  }
-}
-function ensureProjectIdMarker(absPath, name) {
-  try {
-    if (process.env.MIXDOG_DISABLE_PROJECT_MARKERS === "1") return;
-    if (!absPath) return;
-    try {
-      if (!statSync(absPath).isDirectory()) return;
-    } catch {
-      return;
-    }
-    const markerPath = join3(absPath, ".mixdog", "project.id");
-    if (existsSync3(markerPath)) return;
-    const value = String(name || basename3(absPath) || "").trim();
-    if (!value || value.toLowerCase() === "common") return;
-    const markerDir = join3(absPath, ".mixdog");
-    mkdirSync2(markerDir, { recursive: true });
-    const tmp = `${markerPath}.${process.pid}.tmp`;
-    writeFileSync2(tmp, `${value}
-`, "utf8");
-    renameSync(tmp, markerPath);
-  } catch {
-  }
-}
-function projectRecency(entry) {
-  const last = Number(entry?.lastSelectedAt);
-  if (Number.isFinite(last) && last > 0) return last;
-  return Number(entry?.addedAt) || 0;
-}
-function compareProjects(a, b) {
-  const byRecency = projectRecency(b) - projectRecency(a);
-  if (byRecency !== 0) return byRecency;
-  const byName = String(a.name).localeCompare(String(b.name));
-  if (byName !== 0) return byName;
-  return String(a.path).localeCompare(String(b.path));
-}
-function listProjects() {
-  const { projects } = readStore();
-  return projects.slice().sort(compareProjects);
-}
-function addProject(rawPath) {
-  const absPath = toAbsolute(rawPath);
-  if (!absPath) return null;
-  const store = readStore();
-  const key = normalizeKey(absPath);
-  const existing = store.projects.find((entry2) => normalizeKey(entry2.path) === key);
-  if (existing) {
-    ensureProjectIdMarker(absPath, existing.name);
-    return existing;
-  }
-  const entry = {
-    name: basename3(absPath) || absPath,
-    path: absPath,
-    addedAt: Date.now()
-  };
-  store.projects.push(entry);
-  writeStore(store);
-  ensureProjectIdMarker(absPath, entry.name);
-  return entry;
-}
-function touchProjectSelected(rawPath) {
-  const absPath = toAbsolute(rawPath);
-  if (!absPath) return null;
-  const store = readStore();
-  const key = normalizeKey(absPath);
-  const entry = store.projects.find((item) => normalizeKey(item.path) === key);
-  if (!entry) return null;
-  entry.lastSelectedAt = Date.now();
-  writeStore(store);
-  ensureProjectIdMarker(absPath, entry.name);
-  return entry;
-}
-function renameProject(rawPath, nextName) {
-  const absPath = toAbsolute(rawPath);
-  if (!absPath) return null;
-  const store = readStore();
-  const key = normalizeKey(absPath);
-  const entry = store.projects.find((item) => normalizeKey(item.path) === key);
-  if (!entry) return null;
-  const trimmed = String(nextName || "").trim();
-  entry.name = trimmed || basename3(absPath) || absPath;
-  writeStore(store);
-  return entry;
-}
-function pathExists(rawPath) {
-  const absPath = toAbsolute(rawPath);
-  return !!absPath && existsSync3(absPath);
-}
-function isDirectory(rawPath) {
-  const absPath = toAbsolute(rawPath);
-  if (!absPath) return false;
-  try {
-    return statSync(absPath).isDirectory();
-  } catch {
-    return false;
-  }
-}
-function ensureDir(rawPath) {
-  const absPath = toAbsolute(rawPath);
-  if (!absPath) return "";
-  try {
-    mkdirSync2(absPath, { recursive: true });
-    return absPath;
-  } catch {
-    return "";
-  }
-}
-function resolveProjectPath(rawPath) {
-  return toAbsolute(rawPath);
-}
-
 // src/standalone/folder-dialog.mjs
 import { spawn } from "node:child_process";
 import path from "node:path";
 var DIALOG_TIMEOUT_MS = 5 * 60 * 1e3;
 function runCapture(cmd, args, { timeoutMs = DIALOG_TIMEOUT_MS } = {}) {
-  return new Promise((resolve5) => {
+  return new Promise((resolve4) => {
     let child;
     try {
       child = spawn(cmd, args, { stdio: ["ignore", "pipe", "ignore"], windowsHide: true });
     } catch (error) {
-      resolve5({ ok: false, code: -1, stdout: "", error });
+      resolve4({ ok: false, code: -1, stdout: "", error });
       return;
     }
     let stdout2 = "";
@@ -9385,7 +8494,7 @@ function runCapture(cmd, args, { timeoutMs = DIALOG_TIMEOUT_MS } = {}) {
         child.kill();
       } catch {
       }
-      resolve5({ ok: false, code: -1, stdout: "", error: new Error("dialog timed out") });
+      resolve4({ ok: false, code: -1, stdout: "", error: new Error("dialog timed out") });
     }, timeoutMs);
     timer2.unref?.();
     child.stdout.on("data", (chunk) => {
@@ -9395,13 +8504,13 @@ function runCapture(cmd, args, { timeoutMs = DIALOG_TIMEOUT_MS } = {}) {
       if (settled) return;
       settled = true;
       clearTimeout(timer2);
-      resolve5({ ok: false, code: -1, stdout: "", error });
+      resolve4({ ok: false, code: -1, stdout: "", error });
     });
     child.on("close", (code) => {
       if (settled) return;
       settled = true;
       clearTimeout(timer2);
-      resolve5({ ok: code === 0, code, stdout: stdout2 });
+      resolve4({ ok: code === 0, code, stdout: stdout2 });
     });
   });
 }
@@ -9409,10 +8518,10 @@ function spawnFailed(result) {
   return !!result && result.code === -1;
 }
 function commandExists(cmd) {
-  return new Promise((resolve5) => {
+  return new Promise((resolve4) => {
     const probe = process.platform === "win32" ? spawn("where", [cmd], { stdio: "ignore", windowsHide: true }) : spawn("which", [cmd], { stdio: "ignore" });
-    probe.on("error", () => resolve5(false));
-    probe.on("close", (code) => resolve5(code === 0));
+    probe.on("error", () => resolve4(false));
+    probe.on("close", (code) => resolve4(code === 0));
   });
 }
 function psSingleQuoted(value) {
@@ -9615,9 +8724,9 @@ async function pickFolder({ title = "Select a project folder", initialPath = ""
       powershellScript(title, resolvedInitial)
     ]);
     if (spawnFailed(result)) return { available: false, path: null };
-    const path3 = String(result.stdout || "").trim();
-    if (!result.ok && !path3) return { available: false, path: null };
-    return { available: true, path: path3 || null };
+    const path2 = String(result.stdout || "").trim();
+    if (!result.ok && !path2) return { available: false, path: null };
+    return { available: true, path: path2 || null };
   }
   if (platform2 === "darwin") {
     const safeTitle = String(title).replace(/"/g, '\\"');
@@ -9625,8 +8734,8 @@ async function pickFolder({ title = "Select a project folder", initialPath = ""
 POSIX path of f`;
     const result = await runCapture("osascript", ["-e", script]);
     if (spawnFailed(result)) return { available: false, path: null };
-    const path3 = String(result.stdout || "").trim();
-    return { available: true, path: path3 || null };
+    const path2 = String(result.stdout || "").trim();
+    return { available: true, path: path2 || null };
   }
   if (await commandExists("zenity")) {
     const result = await runCapture("zenity", [
@@ -9635,16 +8744,16 @@ POSIX path of f`;
       `--title=${title}`
     ]);
     if (spawnFailed(result)) return { available: false, path: null };
-    const path3 = String(result.stdout || "").trim();
-    if (!result.ok && !path3) return { available: true, path: null };
-    return { available: true, path: path3 || null };
+    const path2 = String(result.stdout || "").trim();
+    if (!result.ok && !path2) return { available: true, path: null };
+    return { available: true, path: path2 || null };
   }
   if (await commandExists("kdialog")) {
     const result = await runCapture("kdialog", ["--getexistingdirectory", "."]);
     if (spawnFailed(result)) return { available: false, path: null };
-    const path3 = String(result.stdout || "").trim();
-    if (!result.ok && !path3) return { available: true, path: null };
-    return { available: true, path: path3 || null };
+    const path2 = String(result.stdout || "").trim();
+    if (!result.ok && !path2) return { available: true, path: null };
+    return { available: true, path: path2 || null };
   }
   return { available: false, path: null };
 }
@@ -9967,13 +9076,13 @@ function nativeClipboardCommand(text) {
 function copyToClipboard(text) {
   const value = String(text ?? "");
   const wroteOsc52 = writeOsc52Clipboard(value);
-  return new Promise((resolve5, reject) => {
+  return new Promise((resolve4, reject) => {
     const { cmd, args, input } = nativeClipboardCommand(value);
     let child;
     try {
       child = spawn2(cmd, args, { stdio: ["pipe", "ignore", "ignore"], windowsHide: true });
     } catch (e) {
-      if (wroteOsc52) resolve5();
+      if (wroteOsc52) resolve4();
       else reject(e);
       return;
     }
@@ -9982,7 +9091,7 @@ function copyToClipboard(text) {
     });
     if (!wroteOsc52) {
       child.on("close", (code) => {
-        if (code === 0) resolve5();
+        if (code === 0) resolve4();
         else reject(new Error(`${cmd} exited with code ${code}`));
       });
     }
@@ -9991,7 +9100,7 @@ function copyToClipboard(text) {
     child.stdin.end(input);
     if (wroteOsc52) {
       child.unref?.();
-      resolve5();
+      resolve4();
     }
   });
 }
@@ -10168,7 +9277,7 @@ var DIFF_STAT_SUMMARY_RE = /^\s*\d+\s+files?\s+changed\b/;
 function colorizeDiffStatLine(line, c) {
   const m = DIFF_STAT_FILE_RE.exec(line);
   if (m) {
-    const [, indent, path3, sep, tail] = m;
+    const [, indent, path2, sep, tail] = m;
     const countMatch = /^(\d+)(\s*)([+\-]*)\s*$/.exec(tail);
     let coloredTail;
     if (countMatch) {
@@ -10179,7 +9288,7 @@ function colorizeDiffStatLine(line, c) {
     } else {
       coloredTail = c.diffContext(tail);
     }
-    return `${indent}${c.diffContext(path3)}${c.diffContext(sep)}${coloredTail}`;
+    return `${indent}${c.diffContext(path2)}${c.diffContext(sep)}${coloredTail}`;
   }
   return c.diffContext(line);
 }
@@ -12447,6 +11556,16 @@ var TRANSCRIPT_WINDOW_TAIL_MAX_ITEMS = positiveIntEnv("MIXDOG_TUI_TRANSCRIPT_WIN
 var SELECTION_PAINT_INTERVAL_MS = positiveIntEnv("MIXDOG_TUI_SELECTION_PAINT_MS", 24);
 var SCROLL_COALESCE_MS = positiveIntEnv("MIXDOG_TUI_SCROLL_COALESCE_MS", 16);
 var PROMPT_HISTORY_LIMIT = 50;
+function accumulateDirectionalScrollDelta(state, deltaRows) {
+  const delta = Number(deltaRows) || 0;
+  if (!delta) return false;
+  const direction = Math.sign(delta);
+  const reversed = Boolean(state.direction && state.direction !== direction);
+  if (reversed) state.pendingRows = 0;
+  state.direction = direction;
+  state.pendingRows += delta;
+  return reversed;
+}
 function boolEnvDefaultTrue(name) {
   const raw = process.env[name];
   if (raw == null) return true;
@@ -12784,6 +11903,17 @@ function transcriptRowAt(values, index) {
   if (!values || index < 0 || index >= values.length) return 0;
   return typeof values.atIndex === "function" ? values.atIndex(index) : Number(values[index]) || 0;
 }
+function transcriptSwapReturnsToTail({
+  count = 0,
+  previousCount = 0,
+  firstId = null,
+  previousFirstId = null
+} = {}) {
+  if (previousCount === 0) return true;
+  if (count < previousCount) return true;
+  if (count === 0) return false;
+  return firstId != null && previousFirstId != null && firstId !== previousFirstId;
+}
 function appendTranscriptRow(prefix, tailValue) {
   return Object.freeze({
     length: prefix.length + 1,
@@ -13397,7 +12527,7 @@ var notifyRenderFrame = (seq = ++renderAckSeq) => {
   pendingRenderAcks = [];
   for (const ack of acks) ack(seq);
 };
-var yieldToRenderer = ({ frames = 1 } = {}) => new Promise((resolve5) => {
+var yieldToRenderer = ({ frames = 1 } = {}) => new Promise((resolve4) => {
   const minSeq = renderAckSeq;
   let remainingFrames = Math.max(1, Math.floor(Number(frames) || 1));
   let settled = false;
@@ -13409,7 +12539,7 @@ var yieldToRenderer = ({ frames = 1 } = {}) => new Promise((resolve5) => {
     if (timer2) clearTimeout(timer2);
     const idx = pendingRenderAcks.indexOf(onFrame);
     if (idx !== -1) pendingRenderAcks.splice(idx, 1);
-    resolve5();
+    resolve4();
   };
   const onTimeout = () => {
     if (settled) return;
@@ -13470,7 +12600,7 @@ function useTranscriptScroll({
   const scrollAnimationRef = useRef8(null);
   const pendingReadbackRowsRef = useRef8(0);
   const selectionPaintRef = useRef8({ t: 0, rect: null, pending: null, timer: null });
-  const scrollCoalesceRef = useRef8({ pendingRows: 0, timer: null });
+  const scrollCoalesceRef = useRef8({ pendingRows: 0, direction: 0, timer: null });
   const selectionTextCaptureRef = useRef8(0);
   const stitchBufferRef = useRef8(/* @__PURE__ */ new Map());
   const stitchHarvestTimerRef = useRef8(null);
@@ -13761,6 +12891,7 @@ function useTranscriptScroll({
     if (coalesceState.timer) clearTimeout(coalesceState.timer);
     coalesceState.timer = null;
     coalesceState.pendingRows = 0;
+    coalesceState.direction = 0;
   }, []);
   const scrollTranscriptRows = useCallback3((deltaRows, options = {}) => {
     const maxTarget = Math.max(0, Number(maxScrollRowsRef.current) || 0);
@@ -13893,13 +13024,18 @@ function useTranscriptScroll({
   });
   const queueScrollCoalesced = useCallback3((deltaRows) => {
     const state = scrollCoalesceRef.current;
-    state.pendingRows += deltaRows;
+    const reversed = accumulateDirectionalScrollDelta(state, deltaRows);
+    if (reversed && state.timer) {
+      clearTimeout(state.timer);
+      state.timer = null;
+    }
     if (state.timer) return;
     const rows = state.pendingRows;
     state.pendingRows = 0;
     scrollTranscriptRows(rows);
     state.timer = setTimeout(() => {
       state.timer = null;
+      state.direction = 0;
       if (state.pendingRows !== 0) {
         const remaining = state.pendingRows;
         state.pendingRows = 0;
@@ -14121,17 +13257,18 @@ function usePromptHint() {
   const [promptHintTone, setPromptHintTone] = useState8("info");
   const promptHintTimerRef = useRef10(null);
   const promptHintActiveRef = useRef10(false);
-  const showPromptHint = useCallback5((text, tone = "info") => {
+  const showPromptHint = useCallback5((text, tone = "info", dismissMs = PROMPT_HINT_DISMISS_MS) => {
     if (promptHintTimerRef.current) clearTimeout(promptHintTimerRef.current);
     promptHintActiveRef.current = true;
     setPromptHint(String(text || ""));
     setPromptHintTone(tone);
+    const timeoutMs = Number(dismissMs) > 0 ? Number(dismissMs) : PROMPT_HINT_DISMISS_MS;
     promptHintTimerRef.current = setTimeout(() => {
       promptHintTimerRef.current = null;
       promptHintActiveRef.current = false;
       setPromptHint("");
       setPromptHintTone("info");
-    }, PROMPT_HINT_DISMISS_MS);
+    }, timeoutMs);
   }, []);
   const showSelectionCopyHint = useCallback5(
     (text, tone = "plain") => showPromptHint(text, tone),
@@ -14204,11 +13341,11 @@ function compactJson(value, max = 180) {
   if (!text) return "";
   return stringWidth8(text) > max ? `${text.slice(0, Math.max(1, max - 1))}\u2026` : text;
 }
-function toolApprovalDescription(request2 = {}) {
-  const surface = formatToolSurface(request2.name, request2.args);
-  const summary = surface?.summary ? `${surface.label || request2.name} (${surface.summary})` : surface?.label || request2.name || "tool";
-  const reason = clean(request2.reason) || "Hook requested approval.";
-  const args = compactJson(request2.args);
+function toolApprovalDescription(request = {}) {
+  const surface = formatToolSurface(request.name, request.args);
+  const summary = surface?.summary ? `${surface.label || request.name} (${surface.summary})` : surface?.label || request.name || "tool";
+  const reason = clean(request.reason) || "Hook requested approval.";
+  const args = compactJson(request.args);
   return [
     summary ? `Tool: ${summary}` : "",
     reason ? `Reason: ${reason}` : "",
@@ -14515,8 +13652,8 @@ function createUsageContextPanels({
     const context = contextStatusValue || {};
     const usage = context.usage || {};
     const messages = context.messages || {};
-    const request2 = context.request || {};
-    const schemaBreakdown = request2.toolSchemaBreakdown || {};
+    const request = context.request || {};
+    const schemaBreakdown = request.toolSchemaBreakdown || {};
     const schemaTokensFor = (buckets) => buckets.reduce(
       (sum, bucket) => sum + Number(schemaBreakdown?.[bucket]?.tokens || 0),
       0
@@ -14602,7 +13739,7 @@ function createUsageContextPanels({
       {
         value: "request",
         label: "Request overhead",
-        description: `${fmt(request2.requestOverheadTokens)} framing \xB7 ${fmt(request2.reserveTokens)} reserve incl. tools`,
+        description: `${fmt(request.requestOverheadTokens)} framing \xB7 ${fmt(request.reserveTokens)} reserve incl. tools`,
         _action: "request"
       },
       {
@@ -14678,9 +13815,9 @@ function createUsageContextPanels({
           results: messages.toolResultCount
         },
         request: {
-          toolSchemaBreakdown: request2.toolSchemaBreakdown,
-          overheadTokens: request2.requestOverheadTokens,
-          reserveTokens: request2.reserveTokens
+          toolSchemaBreakdown: request.toolSchemaBreakdown,
+          overheadTokens: request.requestOverheadTokens,
+          reserveTokens: request.reserveTokens
         },
         lastApi: {
           contextTokens: usage.lastContextTokens,
@@ -14746,6 +13883,13 @@ function createPromptSubmit({
   pastedImagesRef,
   pastedTextsRef
 }) {
+  const backendCall = (name, ...args) => {
+    const target = store?.[name];
+    if (typeof target !== "function") {
+      return Promise.reject(new TypeError(`project backend method ${name} is unavailable`));
+    }
+    return Promise.resolve(target.apply(store, args));
+  };
   const submitPrompt = (prompt, options) => {
     if (typeof store.submitAsync !== "function") return store.submit(prompt, options);
     void Promise.resolve(store.submitAsync(prompt, options)).then((accepted) => {
@@ -14919,9 +14063,14 @@ function createPromptSubmit({
             store.pushNotice("working directory path is required", "warn");
             return false;
           }
-          store.setCwd?.(commandText, { message: `Project set: ${projectNameFromPath(commandText)}` });
-          setSettingsPrompt(null);
-          void openSettingsPicker();
+          void backendCall("setCwd", commandText, {
+            message: `Project set: ${projectNameFromPath(commandText)}`
+          }).then(() => {
+            setSettingsPrompt(null);
+            void openSettingsPicker();
+          }).catch((error) => {
+            store.pushNotice(`project switch failed: ${error?.message || error}`, "error");
+          });
           return true;
         }
         if (settingsPrompt.kind === "project-new") {
@@ -14929,21 +14078,25 @@ function createPromptSubmit({
             store.pushNotice("project path is required", "warn");
             return false;
           }
-          const path3 = resolveProjectPath(commandText);
-          if (isDirectory(path3)) {
-            setSettingsPrompt(null);
-            registerProject(path3);
-            return true;
-          }
-          if (pathExists(path3)) {
-            store.pushNotice(`${path3} is not a directory`, "warn");
-            return false;
-          }
-          setSettingsPrompt({
-            kind: "project-create-confirm",
-            label: "New project \xB7 Create folder?",
-            hint: `${path3} does not exist. Type "y" to create it, or anything else to cancel.`,
-            pendingPath: path3
+          void backendCall("inspectProjectPath", commandText).then((result) => {
+            const path2 = String(result?.path || commandText);
+            if (result?.directory === true) {
+              setSettingsPrompt(null);
+              void registerProject(path2);
+              return;
+            }
+            if (result?.exists === true) {
+              store.pushNotice(`${path2} is not a directory`, "warn");
+              return;
+            }
+            setSettingsPrompt({
+              kind: "project-create-confirm",
+              label: "New project \xB7 Create folder?",
+              hint: `${path2} does not exist. Type "y" to create it, or anything else to cancel.`,
+              pendingPath: path2
+            });
+          }).catch((error) => {
+            store.pushNotice(`project path check failed: ${error?.message || error}`, "error");
           });
           return true;
         }
@@ -14951,14 +14104,13 @@ function createPromptSubmit({
           const pendingPath = String(settingsPrompt.pendingPath || "");
           const answer = String(commandText || "").trim().toLowerCase();
           if (answer === "y" || answer === "yes") {
-            const created = ensureDir(pendingPath);
-            if (!created) {
-              store.pushNotice(`could not create folder: ${pendingPath}`, "error");
+            void backendCall("ensureProjectDirectory", pendingPath).then((created) => {
               setSettingsPrompt(null);
-              return true;
-            }
-            setSettingsPrompt(null);
-            registerProject(pendingPath);
+              void registerProject(created || pendingPath);
+            }).catch((error) => {
+              store.pushNotice(`could not create folder: ${error?.message || error}`, "error");
+              setSettingsPrompt(null);
+            });
             return true;
           }
           setSettingsPrompt(null);
@@ -14967,16 +14119,15 @@ function createPromptSubmit({
         }
         if (settingsPrompt.kind === "project-rename") {
           const targetPath = String(settingsPrompt.projectPath || "");
-          try {
-            const updated = renameProject(targetPath, commandText);
+          void backendCall("renameProject", targetPath, commandText).then((updated) => {
             if (updated) {
               store.pushNotice(`project renamed to "${updated.name}"`, "info");
             }
-          } catch (e) {
-            store.pushNotice(`rename failed: ${e?.message || e}`, "error");
-          }
-          setSettingsPrompt(null);
-          openProjectPicker();
+            setSettingsPrompt(null);
+            void openProjectPicker();
+          }).catch((error) => {
+            store.pushNotice(`rename failed: ${error?.message || error}`, "error");
+          });
           return true;
         }
         if (settingsPrompt.kind === "system-shell") {
@@ -16960,7 +16111,7 @@ var Item = React19.memo(function Item2({ item, prevKind, columns, toolOutputExpa
 // src/tui/app/app-view.jsx
 import { Fragment as Fragment6, jsx as jsx20, jsxs as jsxs16 } from "react/jsx-runtime";
 function renderAppView(ctx) {
-  const { PANEL_MAX_VISIBLE, acceptSlashPalette, activeSlashQuery, activeTools, agentRevision, cancelChannelPrompt, cancelHookPrompt, cancelProviderPrompt, cancelSettingsPrompt, cancelSlashPalette, channelPrompt, clearPromptHint, completeSlashPalette, contextPanel, cycleWorkflowFromPrompt, exiting, expandedOptionPanel, floatingPanelRows, frameColumns, gridSelectionActiveRef, guardHintWidth, handlePromptEscape, handlePromptHistoryNavigate, handlePromptInterrupt, handlePromptPaste, hookPrompt, initialStatusLine, inputBoxHidden, inputHint, inputHintTone, liveSpinner, onPromptDraftChange, onSubmit, overlayHintAttachItemIndex, overlayHintBandRows, overlayHintFallbackRow, overlayHintOnLastItem, panelCloseMaskRows, panelInkMaskEpoch, panelTransitionClearRows, panelTransitionEpoch, picker, pickerOpenedFromEnterRef, pickerOpenedFromEnterTimerRef, pickerVisibleRows, promptBoxRectRef, promptBoxRows, promptDraft, promptDraftOverride, promptMetaVisible, promptMouseSelectionRef, promptSelectionRef, promptSpinnerColumns, promptValueRef, providerPrompt, queuedCompact, queuedVisible, renderedTranscriptItems, resizeEpoch, resizeState, restoreQueuedToPrompt, setPicker, setSlashIndex, setTextEntryLayoutRows, settingsPrompt, showWelcomeBanner, slashCommands, slashIndex, slashPaletteOpen, state, statuslineStats, store, toolApproval, toolOutputExpanded, transcriptContentHeight, transcriptGuardRows, transcriptMeasureRef, transcriptTailPinned, transcriptWindow, transientStatusWidth, tuiReady, usagePanel, viewportHeight, welcomePromptHintRows, welcomePromptHintText } = ctx;
+  const { PANEL_MAX_VISIBLE, acceptSlashPalette, activeSlashQuery, activeTools, agentRevision, cancelChannelPrompt, cancelHookPrompt, cancelProviderPrompt, cancelSettingsPrompt, cancelSlashPalette, channelPrompt, clearPromptHint, completeSlashPalette, contextPanel, cycleWorkflowFromPrompt, exiting, expandedOptionPanel, floatingPanelRows, frameColumns, gridSelectionActiveRef, guardHintWidth, handlePromptEscape, handlePromptHistoryNavigate, handlePromptInterrupt, handlePromptPaste, hasUserMessages, hookPrompt, initialStatusLine, inputBoxHidden, inputHint, inputHintTone, liveSpinner, onPromptDraftChange, onSubmit, overlayHintAttachItemIndex, overlayHintBandRows, overlayHintFallbackRow, overlayHintOnLastItem, panelCloseMaskRows, panelInkMaskEpoch, panelTransitionClearRows, panelTransitionEpoch, picker, pickerOpenedFromEnterRef, pickerOpenedFromEnterTimerRef, pickerVisibleRows, promptBoxRectRef, promptBoxRows, promptDraft, promptDraftOverride, promptMetaVisible, promptMouseSelectionRef, promptSelectionRef, promptSpinnerColumns, promptValueRef, providerPrompt, queuedCompact, queuedVisible, renderedTranscriptItems, resizeEpoch, resizeState, restoreQueuedToPrompt, setPicker, setSlashIndex, setTextEntryLayoutRows, settingsPrompt, showWelcomeBanner, slashCommands, slashIndex, slashPaletteOpen, state, statuslineStats, store, toolApproval, toolOutputExpanded, transcriptContentHeight, transcriptGuardRows, transcriptMeasureRef, transcriptTailPinned, transcriptWindow, transientStatusWidth, tuiReady, usagePanel, viewportHeight, welcomePromptHintRows, welcomePromptHintText } = ctx;
   const promptInputControl = /* @__PURE__ */ jsx20(
     PromptInput,
     {
@@ -16984,6 +16135,7 @@ function renderAppView(ctx) {
       onPasteText: handlePromptPaste,
       onHistoryNavigate: handlePromptHistoryNavigate,
       commandPaletteActive: slashPaletteOpen && slashCommands.length > 0,
+      commandPaletteOpen: slashPaletteOpen,
       onCommandPaletteNavigate: (direction) => {
         setSlashIndex((index) => {
           const total = slashCommands.length;
@@ -16998,7 +16150,9 @@ function renderAppView(ctx) {
       onCommandPaletteAccept: acceptSlashPalette,
       onCommandPaletteCancel: cancelSlashPalette,
       onCommandPaletteComplete: completeSlashPalette,
-      onRestoreQueued: (currentText) => restoreQueuedToPrompt({ restoreDraft: true, showHint: false, currentText })
+      onRestoreQueued: restoreQueuedToPrompt,
+      hasQueuedMessages: Array.isArray(state.queued) && state.queued.length > 0,
+      hasMessages: hasUserMessages
     }
   );
   return (
@@ -17448,10 +16602,8 @@ function usePromptDraftFlow({
     return token ? `/${token} ` : void 0;
   }, [slashCommands, slashIndex]);
   const cancelSlashPalette = useCallback8((value = "") => {
-    setSlashDismissedFor("");
-    setPromptDraft("");
-    setPromptDraftOverride({ id: Date.now(), value: "" });
-  }, []);
+    setSlashDismissedFor(String(value ?? ""));
+  }, [setSlashDismissedFor]);
   return {
     onPromptDraftChange,
     cancelProviderPrompt,
@@ -17694,10 +16846,10 @@ function createResumePicker({
   formatSessionUpdatedAt: formatSessionUpdatedAt2,
   formatSessionMessageCount: formatSessionMessageCount2
 }) {
-  const openResumePicker = () => {
+  const openResumePicker = async () => {
     let sessions;
     try {
-      sessions = store.listSessions({ refreshFromStorage: true });
+      sessions = await store.listSessions({ refreshFromStorage: true });
     } catch (e) {
       store.pushNotice(`could not list saved chats: ${e?.message || e}`, "error");
       return;
@@ -17762,16 +16914,16 @@ function createCoreMemoryPicker({
       onCancel: closeMemoryCorePicker
     });
     void store.memoryControl?.({ action: "core", op: "list", project_id: "*" }, { silent: true }).then(async (result) => {
-      const memory = await store.getMemorySettings?.() || { enabled: true };
-      const memoryOn = memory.enabled !== false;
+      const recap = await store.getRecapSettings?.() || { enabled: true };
+      const recapOn = recap.enabled !== false;
       const coreRows = parseMemoryCoreRows2(result);
       const rows = [
         {
-          value: "memory-toggle",
-          label: "Memory",
-          meta: memoryOn ? "On" : "Off",
-          description: memoryOn ? "Background memory cycles on" : "Background memory cycles off",
-          _action: "toggle-memory"
+          value: "recap-toggle",
+          label: "Recap",
+          meta: recapOn ? "On" : "Off",
+          description: recapOn ? "Background session recaps on" : "Background recaps off; core memory remains available",
+          _action: "toggle-recap"
         },
         { value: "core-add", label: "Add Memory", description: "store a new curated memory sentence", _action: "add-core" },
         {
@@ -17793,17 +16945,17 @@ function createCoreMemoryPicker({
         labelWidth: 12,
         footer: (item) => item && item._action === "core-entry" ? item._summary || item._element || "" : "",
         onSelect: (_value, item) => {
-          if (item?._action === "toggle-memory") toggleMemoryEnabled();
+          if (item?._action === "toggle-recap") toggleRecapEnabled();
           else if (item?._action === "add-core") beginAddCoreMemory();
           else if (item?._action === "core-list") openCoreMemoryListPicker(item._rows);
           else if (item?._line) store.pushNotice(item._line, "info");
         },
         // Toggle rows also respond to ←/→ (matches settings/channels UX).
         onLeft: (item) => {
-          if (item?._action === "toggle-memory") toggleMemoryEnabled();
+          if (item?._action === "toggle-recap") toggleRecapEnabled();
         },
         onRight: (item) => {
-          if (item?._action === "toggle-memory") toggleMemoryEnabled();
+          if (item?._action === "toggle-recap") toggleRecapEnabled();
         },
         onCancel: closeMemoryCorePicker
       });
@@ -17844,12 +16996,12 @@ function createCoreMemoryPicker({
       store.pushNotice(`core memory failed: ${e?.message || e}`, "error");
     });
   };
-  const toggleMemoryEnabled = async () => {
-    const memory = await store.getMemorySettings?.() || { enabled: true };
-    void Promise.resolve(store.setMemoryEnabled?.(!(memory.enabled !== false))).then((next) => {
-      if (!next) store.pushNotice("memory setting is busy", "warn");
-      else store.pushNotice(`Memory ${next.enabled ? "on" : "off"}`, "info");
-    }).catch((e) => store.pushNotice(`memory toggle failed: ${e?.message || e}`, "error")).finally(() => openMemoryCorePicker());
+  const toggleRecapEnabled = async () => {
+    const recap = await store.getRecapSettings?.() || { enabled: true };
+    void Promise.resolve(store.setRecapEnabled?.(!(recap.enabled !== false))).then((next) => {
+      if (!next) store.pushNotice("recap setting is busy", "warn");
+      else store.pushNotice(`Recap ${next.enabled ? "on" : "off"}`, "info");
+    }).catch((e) => store.pushNotice(`recap toggle failed: ${e?.message || e}`, "error")).finally(() => openMemoryCorePicker());
   };
   const openCoreEntryActionsPicker = (entryItem) => {
     setPicker({
@@ -19107,7 +18259,6 @@ function createOnboardingSteps({
     if (defaultRoute) {
       void store.completeOnboarding?.({
         defaultRoute,
-        defaultProvider: defaultRoute.provider,
         ...hasOverrides ? { agentRoutes: { ...overrides } } : {},
         ...searchRoute ? { searchRoute } : {}
       }).then(done).catch(failed);
@@ -19788,7 +18939,7 @@ function createProviderSetupPicker({
         }
       });
       try {
-        await new Promise((resolve5) => setTimeout(resolve5, 0));
+        await new Promise((resolve4) => setTimeout(resolve4, 0));
         setup = await store.getProviderSetup();
       } catch (e) {
         store.pushNotice(`providers failed: ${e?.message || e}`, "error");
@@ -20327,7 +19478,7 @@ function createModelPicker({
         items: [],
         onCancel: cancelModelPicker
       });
-      await new Promise((resolve5) => setTimeout(resolve5, 0));
+      await new Promise((resolve4) => setTimeout(resolve4, 0));
       try {
         if (options.refreshModels !== true && options.cacheRef !== "search") {
           refreshModelsPromise = Promise.resolve(loadModels({ force: false }));
@@ -20682,7 +19833,7 @@ function createRoutePickers({
     const items = agents.map((agent) => ({
       value: agent.id,
       label: agent.label,
-      metaParts: agentModelParts2(routeOverrides[agent.id] || agent.route),
+      metaParts: routeOverrides[agent.id] || agent.route ? agentModelParts2(routeOverrides[agent.id] || agent.route) : [{ text: "(follows main)", width: 17 }, { text: "", width: 6 }, { text: "", width: 4 }],
       description: agent.description || agent.definition?.description || "",
       _agent: agent
     }));
@@ -20909,7 +20060,7 @@ function createSettingsPicker({
     const snapshot = await store.getSettingsSnapshot?.({ heavy: !heavyCache }) || {};
     const autoClear = snapshot.autoClear || {};
     const compaction = snapshot.compaction || {};
-    const memory = snapshot.memory || { enabled: true };
+    const recap = snapshot.recap || { enabled: true };
     const channels = snapshot.channels || { enabled: true };
     const systemShell = snapshot.systemShell || { source: "auto", command: "", effective: "" };
     const outputStyle = snapshot.outputStyle || {};
@@ -20929,7 +20080,7 @@ function createSettingsPicker({
     const outputStyleLabel = outputStyle?.current?.label || outputStyle?.current?.id || outputStyle?.configured || "Default";
     const workflowLabel = workflowDisplayName2(workflow);
     const boolLabel = (enabled) => enabled ? "On" : "Off";
-    const compactTypeDescription = memory.enabled === false ? "Injects raw transcript lines (memory off: no LLM chunking)." : "Uses Memory recall to rebuild context faster on large histories.";
+    const compactTypeDescription = "Uses Memory recall to rebuild context faster on large histories.";
     const applyAutoClear = (patch = {}) => {
       void Promise.resolve(store.setAutoClear?.(patch)).then((next) => {
         if (!next) store.pushNotice("autoclear unavailable", "warn");
@@ -21130,8 +20281,8 @@ function createSettingsPicker({
       {
         value: "memory",
         label: "Memory",
-        meta: boolLabel(memory.enabled !== false),
-        description: memory.enabled === false ? "Memory off. Core memories stay editable." : "Session memory and core memories.",
+        meta: `Recap ${boolLabel(recap.enabled !== false)}`,
+        description: recap.enabled === false ? "Background recap off. Core memories and on-demand recall stay available." : "Background recap and core memories.",
         _action: "memory"
       },
       {
@@ -21898,6 +21049,13 @@ function createAppPickers({
 
 // src/tui/app/use-prompt-queue-history.mjs
 import { useCallback as useCallback9, useMemo as useMemo2 } from "react";
+
+// src/tui/components/prompt-input/restore-policy.mjs
+function mergeQueuedRestoreText(queuedText = "", currentText = "") {
+  return [String(queuedText ?? ""), String(currentText ?? "")].filter((text) => text.trim()).join("\n");
+}
+
+// src/tui/app/use-prompt-queue-history.mjs
 function usePromptQueueHistory({
   store,
   state,
@@ -21930,8 +21088,8 @@ function usePromptQueueHistory({
       let timer2 = null;
       Promise.race([
         Promise.resolve(store.dispose?.("cli-react-exit", { detach: true })),
-        new Promise((resolve5) => {
-          timer2 = setTimeout(resolve5, 350);
+        new Promise((resolve4) => {
+          timer2 = setTimeout(resolve4, 350);
         })
       ]).finally(() => {
         if (timer2) clearTimeout(timer2);
@@ -21951,8 +21109,12 @@ function usePromptQueueHistory({
       if (restoreDraft) {
         if (restored2.pastedImages) installPastedImages(restored2.pastedImages, { merge: true });
         if (restored2.pastedTexts) installPastedTexts(restored2.pastedTexts, { merge: true });
-        syncPromptLayoutRows(restored2.text);
-        setPromptDraftOverride({ id: Date.now(), value: restored2.text });
+        const restoredText = mergeQueuedRestoreText(
+          restored2.text,
+          promptValueRef.current ?? currentText
+        );
+        syncPromptLayoutRows(restoredText);
+        setPromptDraftOverride({ id: Date.now(), value: restoredText });
       }
       if (showHint) {
         showPromptHint(`restored ${restored2.count} queued message${restored2.count === 1 ? "" : "s"}`, "info");
@@ -21961,7 +21123,7 @@ function usePromptQueueHistory({
       }
       return true;
     };
-    const restored = store.restoreQueued?.(currentText);
+    const restored = store.restoreQueued?.("");
     if (restored && typeof restored.then === "function") {
       const queuedCount = Array.isArray(state?.queued) ? state.queued.length : 0;
       void Promise.resolve(restored).then(apply).catch(() => {
@@ -21993,6 +21155,88 @@ function usePromptQueueHistory({
   return { requestExit, restoreQueuedToPrompt, recentPromptHistory, resetPromptHistoryNav };
 }
 
+// src/tui/app/message-selector.mjs
+import { useCallback as useCallback10, useMemo as useMemo3 } from "react";
+var MAX_SELECTABLE_MESSAGES = 20;
+function selectableUserItems(items, limit = MAX_SELECTABLE_MESSAGES) {
+  const source = Array.isArray(items) ? items : [];
+  const rows = [];
+  for (let index = source.length - 1; index >= 0 && rows.length < limit; index -= 1) {
+    const item = source[index];
+    if (item?.kind !== "user") continue;
+    if (item?.id == null) continue;
+    const text = String(item.text || "").trim();
+    if (!text) continue;
+    rows.push({ id: String(item.id), text });
+  }
+  return rows.reverse();
+}
+function messageSelectorLabel(text, width = 56) {
+  const firstLine = String(text || "").split("\n").map((line) => line.trim()).find(Boolean) || "";
+  if (firstLine.length <= width) return firstLine;
+  return `${firstLine.slice(0, Math.max(1, width - 1))}\u2026`;
+}
+function useMessageSelector({
+  store,
+  state,
+  setPicker,
+  setPromptDraftOverride,
+  syncPromptLayoutRows,
+  showPromptHint,
+  clearPromptHint
+}) {
+  const hasUserMessages = useMemo3(
+    () => (Array.isArray(state.items) ? state.items : []).some(
+      (item) => item?.kind === "user" && String(item?.text || "").trim()
+    ),
+    [state.items]
+  );
+  const applyRewind = useCallback10((restored) => {
+    const text = String(restored?.text || "");
+    if (!text) {
+      showPromptHint("Could not restore that message.", "error");
+      return false;
+    }
+    clearPromptHint();
+    syncPromptLayoutRows(text);
+    setPromptDraftOverride({ id: Date.now(), value: text });
+    return true;
+  }, [clearPromptHint, syncPromptLayoutRows, setPromptDraftOverride, showPromptHint]);
+  const openMessageSelector = useCallback10(() => {
+    const items = store.getState?.().items ?? state.items;
+    const rows = selectableUserItems(items);
+    if (rows.length === 0) {
+      showPromptHint("No message to jump back to.", "info");
+      return false;
+    }
+    setPicker({
+      _kind: "message-selector",
+      title: "Jump back to a message",
+      description: "Rewind the conversation to a previous prompt and edit it.",
+      initialIndex: rows.length - 1,
+      items: rows.map((row) => ({ value: row.id, label: messageSelectorLabel(row.text) })),
+      onSelect: (value) => {
+        setPicker(null);
+        let restored;
+        try {
+          restored = store.rewindToItem?.(value);
+        } catch (error) {
+          showPromptHint(`rewind failed: ${error?.message || error}`, "error");
+          return;
+        }
+        if (restored && typeof restored.then === "function") {
+          void Promise.resolve(restored).then(applyRewind).catch((error) => showPromptHint(`rewind failed: ${error?.message || error}`, "error"));
+          return;
+        }
+        applyRewind(restored);
+      },
+      onCancel: () => setPicker(null)
+    });
+    return true;
+  }, [store, state.items, setPicker, applyRewind, showPromptHint]);
+  return { hasUserMessages, openMessageSelector };
+}
+
 // src/tui/app/use-terminal-chrome.mjs
 import { useEffect as useEffect11 } from "react";
 function useTerminalChrome({ stdout: stdout2, isRawModeSupported, setResizeState }) {
@@ -22042,7 +21286,7 @@ function useTerminalChrome({ stdout: stdout2, isRawModeSupported, setResizeState
 }
 
 // src/tui/app/use-transcript-window.mjs
-import { useCallback as useCallback10, useEffect as useEffect12, useLayoutEffect as useLayoutEffect4, useMemo as useMemo3, useRef as useRef12, useState as useState10 } from "react";
+import { useCallback as useCallback11, useEffect as useEffect12, useLayoutEffect as useLayoutEffect4, useMemo as useMemo4, useRef as useRef12, useState as useState10 } from "react";
 var HARVEST_BUMP_STREAK_LIMIT = 10;
 var TUI_DEBUG = /^(1|true|yes|on)$/i.test(String(process.env.MIXDOG_TUI_DEBUG || ""));
 var harvestBreakerLogged = false;
@@ -22133,7 +21377,7 @@ function useTranscriptWindow({
   useLayoutEffect4(() => {
     if (scrollOffset !== 0) setScrollOffset(0);
   }, [normalizedSessionKey, setScrollOffset]);
-  const transcriptMeasureRef = useCallback10((item) => {
+  const transcriptMeasureRef = useCallback11((item) => {
     if (!TRANSCRIPT_MEASURED_ROWS || !item || item.id == null) return void 0;
     if (shouldSuppressFullyFailedToolItem(item)) {
       transcriptMeasuredRowsCache.delete(item);
@@ -22157,8 +21401,6 @@ function useTranscriptWindow({
     return fn;
   }, []);
   const streamingTailItem = streamingTail?.kind === "assistant" && streamingTail.streaming ? streamingTail : null;
-  const scrolledUpRowsForPin = Math.max(0, Number(scrollTargetRef.current) || 0);
-  const transcriptPinnedForStreaming = followingRef.current || scrolledUpRowsForPin === 0;
   const tailRows = streamingTailItem ? estimateTranscriptItemRowsCached(streamingTailItem, frameColumns, toolOutputExpanded) : 0;
   const tailSig = streamingTailItem ? `${streamingTailItem.id}:${tailRows}` : "_";
   const revision = Math.max(0, Number(structureRevision) || 0);
@@ -22174,13 +21416,8 @@ function useTranscriptWindow({
     revision,
     streamingTailItem
   );
-  const transcriptStreamingActive = !!streamingTailItem;
-  const scrolledUpForStreamingMeasure = scrolledUpRowsForPin > 0;
-  const prevEstimateGeometry = transcriptGeomRef.current?.suppressMeasuredRowHeights === true;
-  const hasStreamingReadingAnchor = !!transcriptAnchorRef.current || transcriptAnchorDirtyRef.current;
-  const bottomPinnedForMeasure = transcriptPinnedForStreaming;
-  const suppressMeasuredRowHeights = bottomPinnedForMeasure || transcriptStreamingActive && (scrolledUpForStreamingMeasure && hasStreamingReadingAnchor || scrolledUpForStreamingMeasure && prevEstimateGeometry && !transcriptPinnedForStreaming);
-  const transcriptRowIndex = useMemo3(() => buildTranscriptRowIndexIncremental(transcriptItems, {
+  const suppressMeasuredRowHeights = false;
+  const transcriptRowIndex = useMemo4(() => buildTranscriptRowIndexIncremental(transcriptItems, {
     columns: frameColumns,
     toolOutputExpanded,
     suppressMeasuredRowHeights,
@@ -22279,7 +21516,7 @@ function useTranscriptWindow({
     contentHeight: lockViewRows,
     floatingPanelRows: Number(floatingPanelRows) || 0
   };
-  const transcriptWindow = useMemo3(() => transcriptRenderWindow(transcriptItems, {
+  const transcriptWindow = useMemo4(() => transcriptRenderWindow(transcriptItems, {
     scrollOffset: renderScrollOffset,
     viewportHeight: transcriptContentHeight,
     columns: frameColumns,
@@ -22461,7 +21698,7 @@ function useTranscriptWindow({
     const currentPosition = Math.max(0, Number(scrollPositionRef.current) || 0);
     const currentOffset = Math.max(0, Number(scrollOffset) || 0);
     const maxRows = Math.max(0, Number(transcriptWindow.maxScrollRows) || 0);
-    if (!followingRef.current && rowDelta > 0 && currentTarget === 0) {
+    if (!followingRef.current && rowDelta >= 0 && currentTarget === 0) {
       followingRef.current = true;
     }
     const nearBottom = followingRef.current;
@@ -22514,6 +21751,16 @@ function useTranscriptWindow({
       maxRows
     });
     if (desired == null) {
+      if (rowDelta < 0 || currentTarget > maxRows) {
+        stopSmoothScroll();
+        transcriptAnchorRef.current = null;
+        transcriptAnchorDirtyRef.current = false;
+        scrollTargetRef.current = 0;
+        scrollPositionRef.current = 0;
+        followingRef.current = true;
+        if (currentOffset !== 0) setScrollOffset(0);
+        return;
+      }
       transcriptAnchorDirtyRef.current = true;
       return;
     }
@@ -22560,6 +21807,11 @@ function useTranscriptWindow({
   }, [themeEpoch, withSelectionClip, paintSelectionRect]);
   useEffect12(() => {
     const maxRows = Math.max(0, Number(transcriptWindow.maxScrollRows) || 0);
+    if (maxRows === 0 && !followingRef.current) {
+      transcriptAnchorRef.current = null;
+      transcriptAnchorDirtyRef.current = false;
+      followingRef.current = true;
+    }
     if (scrollTargetRef.current <= maxRows && scrollPositionRef.current <= maxRows && scrollOffset <= maxRows) return;
     stopSmoothScroll();
     const next = Math.max(0, Math.min(maxRows, scrollTargetRef.current));
@@ -22589,42 +21841,49 @@ function createProjectPicker({
   setSettingsPrompt,
   setContextPanel,
   closeUsagePanel,
-  listProjects: listProjects2,
-  addProject: addProject2,
-  touchProjectSelected: touchProjectSelected2,
-  resolveProjectPath: resolveProjectPath2,
   projectNameFromPath: projectNameFromPath3,
   pickFolder: pickFolder2
 }) {
-  const buildProjectPickerState = ({ initialEntry = false } = {}) => {
-    let projects = [];
-    try {
-      projects = listProjects2() || [];
-    } catch {
-      projects = [];
+  const backendCall = (name, ...args) => {
+    const target = store?.[name];
+    if (typeof target !== "function") {
+      return Promise.reject(new TypeError(`project backend method ${name} is unavailable`));
     }
+    return Promise.resolve(target.apply(store, args));
+  };
+  const buildProjectPickerState = ({
+    initialEntry = false,
+    projects = [],
+    loading = false,
+    requestId = null
+  } = {}) => {
     const currentPath = String(state.cwd || process.cwd() || "");
     const items = [];
-    for (const project of projects) {
-      if (!project?.path) continue;
+    if (!loading) {
+      for (const project of projects) {
+        if (!project?.path) continue;
+        items.push({
+          value: project.path,
+          label: project.name || project.path,
+          meta: project.path,
+          _project: project
+        });
+      }
       items.push({
-        value: project.path,
-        label: project.name || project.path,
-        meta: project.path,
-        _project: project
+        value: "__use_current__",
+        label: "Current Path",
+        meta: currentPath,
+        _action: "current"
       });
     }
-    items.push({
-      value: "__use_current__",
-      label: "Current Path",
-      meta: currentPath,
-      _action: "current"
-    });
     return {
       kind: "project",
+      _kind: "project",
+      _projectRequestId: requestId,
+      _projectInitialPending: loading && initialEntry,
       title: "Project",
-      description: "Choose a project.",
-      help: initialEntry ? "\u2191/\u2193 Select \xB7 Enter Open \xB7 c Create \xB7 r Rename" : "\u2191/\u2193 Select \xB7 Enter Open \xB7 c Create \xB7 r Rename \xB7 Esc Back",
+      description: loading ? "Loading projects from the backend\u2026" : "Choose a project.",
+      help: loading ? "Waiting for the project backend\u2026" : initialEntry ? "\u2191/\u2193 Select \xB7 Enter Open \xB7 c Create \xB7 r Rename" : "\u2191/\u2193 Select \xB7 Enter Open \xB7 c Create \xB7 r Rename \xB7 Esc Back",
       indexMode: "always",
       labelWidth: 18,
       metaWidth: 40,
@@ -22635,20 +21894,11 @@ function createProjectPicker({
           return;
         }
         if (item?._action === "current") {
-          setPicker(null);
-          try {
-            store.setCwd?.(currentPath, {
-              notice: !initialEntry,
-              message: `Project set: ${projectNameFromPath3(currentPath)}`
-            });
-          } catch (e) {
-            store.pushNotice(`project switch failed: ${e?.message || e}`, "error");
-          }
+          void enterProject(currentPath, { notice: !initialEntry, register: false });
           return;
         }
-        setPicker(null);
         const project = item?._project;
-        if (project?.path) enterProject(project.path, { notice: !initialEntry });
+        if (project?.path) void enterProject(project.path, { notice: !initialEntry });
       },
       onKey: (input, _key, item) => {
         if (input === "c" || input === "C") {
@@ -22707,40 +21957,44 @@ function createProjectPicker({
         openProjectPicker();
         return;
       }
-      registerProject(result.path);
+      void registerProject(result.path);
     }).catch(() => {
       beginNewProjectManual();
     });
   };
-  const registerProject = (rawPath) => {
-    const path3 = resolveProjectPath2(rawPath);
-    if (!path3) {
+  const registerProject = async (rawPath) => {
+    const path2 = String(rawPath || "").trim();
+    if (!path2) {
       store.pushNotice("project path is required", "warn");
-      return;
+      return false;
     }
     try {
-      const project = addProject2(path3);
+      const project = await backendCall("addProject", path2);
       if (project?.name) store.pushNotice(`project added: ${project.name}`, "info");
-      openProjectPicker();
+      await openProjectPicker();
+      return true;
     } catch (e) {
       store.pushNotice(`project add failed: ${e?.message || e}`, "error");
+      return false;
     }
   };
-  const enterProject = (rawPath, options = {}) => {
-    const path3 = resolveProjectPath2(rawPath);
-    if (!path3) {
+  const enterProject = async (rawPath, options = {}) => {
+    const path2 = String(rawPath || "").trim();
+    if (!path2) {
       store.pushNotice("project path is required", "warn");
-      return;
+      return false;
     }
+    setPicker(null);
     try {
-      store.setCwd?.(path3, {
+      const resolved = await backendCall("setCwd", path2, {
         notice: options?.notice !== false,
-        message: `Project set: ${projectNameFromPath3(path3)}`
+        message: `Project set: ${projectNameFromPath3(path2)}`
       });
-      addProject2(path3);
-      touchProjectSelected2(path3);
+      if (options?.register !== false) await backendCall("addProject", resolved || path2);
+      return true;
     } catch (e) {
       store.pushNotice(`project switch failed: ${e?.message || e}`, "error");
+      return false;
     }
   };
   const beginRenameProject = (project) => {
@@ -22759,14 +22013,32 @@ function createProjectPicker({
       initialValue: project.name || ""
     });
   };
-  const openProjectPicker = () => {
+  const openProjectPicker = async ({ initialEntry = false } = {}) => {
     setProviderPrompt(null);
     setChannelPrompt(null);
     setHookPrompt(null);
     setSettingsPrompt(null);
     setContextPanel(null);
     closeUsagePanel();
-    setPicker(buildProjectPickerState());
+    const requestId = /* @__PURE__ */ Symbol("project-picker-request");
+    setPicker(buildProjectPickerState({
+      initialEntry,
+      loading: true,
+      requestId
+    }));
+    try {
+      const projects = await backendCall("listProjects");
+      setPicker((current) => current?._projectRequestId === requestId ? buildProjectPickerState({
+        initialEntry,
+        projects: Array.isArray(projects) ? projects : [],
+        requestId
+      }) : current);
+      return projects;
+    } catch (error) {
+      setPicker((current) => current?._projectRequestId === requestId ? buildProjectPickerState({ initialEntry, projects: [], requestId }) : current);
+      store.pushNotice(`project list failed: ${error?.message || error}`, "error");
+      return [];
+    }
   };
   return {
     buildProjectPickerState,
@@ -22782,20 +22054,20 @@ function createProjectPicker({
 // src/tui/app/use-prompt-handlers.mjs
 init_paste_attachments();
 init_paste_attachments();
-import { useCallback as useCallback11 } from "react";
+import { useCallback as useCallback12, useEffect as useEffect13, useRef as useRef13 } from "react";
 
 // src/tui/prompt-history-store.mjs
-import { chmodSync, existsSync as existsSync7, mkdirSync as mkdirSync6, readFileSync as readFileSync6, renameSync as renameSync3, writeFileSync as writeFileSync5 } from "node:fs";
+import { chmodSync, existsSync as existsSync6, mkdirSync as mkdirSync5, readFileSync as readFileSync5, renameSync as renameSync2, writeFileSync as writeFileSync4 } from "node:fs";
 init_plugin_paths();
-import { dirname as dirname7, join as join7, resolve as resolve4 } from "node:path";
+import { dirname as dirname6, join as join6, resolve as resolve3 } from "node:path";
 var PROMPT_HISTORY_LIMIT2 = 50;
 function promptHistoryKey2(value) {
   return String(value || "").trim().replace(/\s+/g, " ");
 }
 function readEntries(filePath) {
-  if (!filePath || !existsSync7(filePath)) return [];
+  if (!filePath || !existsSync6(filePath)) return [];
   try {
-    const parsed = JSON.parse(readFileSync6(filePath, "utf8"));
+    const parsed = JSON.parse(readFileSync5(filePath, "utf8"));
     const entries = Array.isArray(parsed?.entries) ? parsed.entries : [];
     return entries.map((entry) => String(entry || "").trim()).filter((entry) => promptHistoryKey2(entry));
   } catch {
@@ -22809,10 +22081,10 @@ function buildPayload(entries) {
 function writeEntriesSync(filePath, entries) {
   if (!filePath) return false;
   try {
-    mkdirSync6(dirname7(filePath), { recursive: true, mode: 448 });
+    mkdirSync5(dirname6(filePath), { recursive: true, mode: 448 });
     const tmp = `${filePath}.${process.pid}.tmp`;
-    writeFileSync5(tmp, buildPayload(entries), { encoding: "utf8", mode: 384 });
-    renameSync3(tmp, filePath);
+    writeFileSync4(tmp, buildPayload(entries), { encoding: "utf8", mode: 384 });
+    renameSync2(tmp, filePath);
     try {
       chmodSync(filePath, 384);
     } catch {
@@ -22849,6 +22121,13 @@ function flushPromptHistory() {
 }
 process.once("exit", flushPromptHistory);
 
+// src/tui/components/prompt-input/interrupt-policy.mjs
+function promptInterruptRestoreText(result, currentText = "") {
+  if (!result || result?.aborted === false) return "";
+  if (String(currentText ?? "") !== "") return "";
+  return String(result?.restoreText || "").trim();
+}
+
 // src/tui/app/use-prompt-handlers.mjs
 function usePromptHandlers({
   store,
@@ -22873,6 +22152,7 @@ function usePromptHandlers({
   recentPromptHistory,
   resetPromptHistoryNav,
   restoreQueuedToPrompt,
+  openMessageSelector,
   usagePanel,
   closeUsagePanel,
   contextPanel,
@@ -22884,7 +22164,9 @@ function usePromptHandlers({
   clearPastedTextsSnapshot,
   registerPastedText
 }) {
-  const handlePromptPaste = useCallback11((text, meta = {}) => {
+  const interruptGenerationRef = useRef13(0);
+  const pendingInterruptRestoreRef = useRef13(null);
+  const handlePromptPaste = useCallback12((text, meta = {}) => {
     const source = String(meta?.source || "paste");
     const value = String(text ?? "");
     const processText = (raw, returnRaw = false) => {
@@ -22946,7 +22228,7 @@ function usePromptHandlers({
     }
     return processText(value);
   }, [registerPastedImage, registerPastedText, showPromptHint, state.cwd]);
-  const handlePromptHistoryNavigate = useCallback11((direction, currentText = "", meta = {}) => {
+  const handlePromptHistoryNavigate = useCallback12((direction, currentText = "", meta = {}) => {
     const currentValue = String(currentText || "");
     const currentKey = promptHistoryKey2(currentValue);
     const nav = promptHistoryNavRef.current || { active: false, index: -1, seed: "", lastValue: "" };
@@ -22993,7 +22275,7 @@ function usePromptHandlers({
     promptHistoryDraftChangeRef.current = true;
     return nextValue;
   }, [recentPromptHistory, resetPromptHistoryNav, clearPromptHint]);
-  const handlePromptEscape = useCallback11((text = "", meta = {}) => {
+  const handlePromptEscape = useCallback12((text = "", meta = {}) => {
     if (usagePanel) {
       closeUsagePanel();
       return true;
@@ -23002,8 +22284,28 @@ function usePromptHandlers({
       setContextPanel(null);
       return true;
     }
+    if (meta.phase === "clear-arm") {
+      showPromptHint("Esc again to clear", "plain", PROMPT_ESCAPE_CLEAR_WINDOW_MS);
+      return true;
+    }
+    if (meta.phase === "select-arm") {
+      showPromptHint("Esc again to pick a message", "plain", PROMPT_ESCAPE_CLEAR_WINDOW_MS);
+      return true;
+    }
+    if (meta.phase === "select") {
+      clearPromptHint();
+      if (restoreQueuedToPrompt({ restoreDraft: true, showHint: false, currentText: text })) return true;
+      return openMessageSelector?.() === true;
+    }
     if (meta.phase === "clear") {
+      try {
+        const remembered = store.rememberPromptHistory?.(text);
+        if (remembered?.catch) void remembered.catch(() => {
+        });
+      } catch {
+      }
       clearPastedImagesSnapshot();
+      clearPastedTextsSnapshot();
       clearPromptHint();
       return false;
     }
@@ -23011,21 +22313,57 @@ function usePromptHandlers({
       return restoreQueuedToPrompt({ restoreDraft: true, showHint: false, currentText: text });
     }
     return false;
-  }, [contextPanel, usagePanel, closeUsagePanel, restoreQueuedToPrompt, clearPromptHint, clearPastedImagesSnapshot, store]);
-  const handlePromptInterrupt = useCallback11((currentText = "") => {
-    const result = store.abort?.();
-    if (result?.aborted === false) return void 0;
-    if (result?.pastedImages) installPastedImages(result.pastedImages, { merge: true });
-    if (result?.discardPastedImages) clearPastedImagesSnapshot(result.discardPastedImages);
-    if (result?.pastedTexts) installPastedTexts(result.pastedTexts, { merge: true });
-    if (result?.discardPastedTexts) clearPastedTextsSnapshot(result.discardPastedTexts);
-    const restoreText = String(result?.restoreText || "").trim();
-    if (!restoreText) return void 0;
-    const existingText = String(currentText || "").trim();
-    const nextText = [restoreText, existingText].filter(Boolean).join("\n");
+  }, [contextPanel, usagePanel, closeUsagePanel, restoreQueuedToPrompt, openMessageSelector, showPromptHint, clearPromptHint, clearPastedImagesSnapshot, clearPastedTextsSnapshot, store]);
+  const commitAsyncInterruptRestore = useCallback12((pending) => {
+    if (!pending || pending.generation !== interruptGenerationRef.current) return true;
+    if (store.getState?.().busy) return false;
+    const restoreText = promptInterruptRestoreText(pending.result, promptValueRef.current);
+    if (!restoreText) return true;
+    if (pending.result?.pastedImages) installPastedImages(pending.result.pastedImages, { merge: true });
+    if (pending.result?.pastedTexts) installPastedTexts(pending.result.pastedTexts, { merge: true });
     clearPromptHint();
-    return nextText;
-  }, [store, clearPromptHint, installPastedImages, clearPastedImagesSnapshot]);
+    syncPromptLayoutRows(restoreText);
+    setPromptDraftOverride({ id: Date.now(), value: restoreText });
+    return true;
+  }, [store, promptValueRef, installPastedImages, installPastedTexts, clearPromptHint, syncPromptLayoutRows, setPromptDraftOverride]);
+  useEffect13(() => {
+    const pending = pendingInterruptRestoreRef.current;
+    if (!pending) return;
+    if (commitAsyncInterruptRestore(pending)) pendingInterruptRestoreRef.current = null;
+  }, [state.busy, commitAsyncInterruptRestore]);
+  const handlePromptInterrupt = useCallback12((currentText = "") => {
+    const generation = ++interruptGenerationRef.current;
+    pendingInterruptRestoreRef.current = null;
+    const applyResult = (result2, draftText, asyncResult = false) => {
+      if (generation !== interruptGenerationRef.current || result2?.aborted === false) return void 0;
+      if (result2?.discardPastedImages) clearPastedImagesSnapshot(result2.discardPastedImages);
+      if (result2?.discardPastedTexts) clearPastedTextsSnapshot(result2.discardPastedTexts);
+      if (asyncResult) {
+        const pending = { generation, result: result2 };
+        if (!commitAsyncInterruptRestore(pending)) pendingInterruptRestoreRef.current = pending;
+        return void 0;
+      }
+      const restoreText = promptInterruptRestoreText(result2, draftText);
+      if (!restoreText) return void 0;
+      if (result2?.pastedImages) installPastedImages(result2.pastedImages, { merge: true });
+      if (result2?.pastedTexts) installPastedTexts(result2.pastedTexts, { merge: true });
+      clearPromptHint();
+      return restoreText;
+    };
+    let result;
+    try {
+      const options = { restorePrompt: String(currentText ?? "") === "" };
+      result = typeof store.abortAsync === "function" ? store.abortAsync(options) : store.abort?.(options);
+    } catch (error) {
+      store.pushNotice?.(`interrupt failed: ${error?.message || error}`, "error");
+      return void 0;
+    }
+    if (result && typeof result.then === "function") {
+      void Promise.resolve(result).then((resolved) => applyResult(resolved, promptValueRef.current, true)).catch((error) => store.pushNotice?.(`interrupt failed: ${error?.message || error}`, "error"));
+      return void 0;
+    }
+    return applyResult(result, currentText, false);
+  }, [store, commitAsyncInterruptRestore, clearPromptHint, installPastedImages, installPastedTexts, clearPastedImagesSnapshot, clearPastedTextsSnapshot]);
   return {
     handlePromptPaste,
     handlePromptHistoryNavigate,
@@ -23092,30 +22430,31 @@ function App({ store, initialStatusLine = "", forceOnboarding = false, onboardin
   const { stdout: stdout2 } = useStdout2();
   const [exiting, setExiting] = useState11(false);
   const [tuiReady, setTuiReady] = useState11(false);
-  const exitRequestedRef = useRef13(false);
+  const exitRequestedRef = useRef14(false);
   const [resizeState, setResizeState] = useState11(() => ({ ...terminalSize(stdout2), epoch: 0 }));
   const [panelTransitionEpoch, setPanelTransitionEpoch] = useState11(0);
   const [panelInkMaskEpoch, setPanelInkMaskEpoch] = useState11(0);
   const rightSafetyColumns = 1;
   const frameColumns = Math.max(1, resizeState.columns - rightSafetyColumns);
   const [scrollOffset, setScrollOffset] = useState11(0);
-  const scrollPositionRef = useRef13(0);
-  const scrollTargetRef = useRef13(0);
-  const maxScrollRowsRef = useRef13(0);
-  const transcriptBottomSlackRowsRef = useRef13(0);
-  const transcriptAnchorRef = useRef13(null);
-  const transcriptAnchorDirtyRef = useRef13(false);
-  const transcriptGeomRef = useRef13({ prefixRows: null, totalRows: 0, viewRows: 1 });
+  const scrollPositionRef = useRef14(0);
+  const scrollTargetRef = useRef14(0);
+  const maxScrollRowsRef = useRef14(0);
+  const transcriptBottomSlackRowsRef = useRef14(0);
+  const transcriptAnchorRef = useRef14(null);
+  const transcriptAnchorDirtyRef = useRef14(false);
+  const transcriptGeomRef = useRef14({ prefixRows: null, totalRows: 0, viewRows: 1 });
   const [measuredRowsVersion, setMeasuredRowsVersion] = useState11(0);
-  const followingRef = useRef13(false);
-  const lastItemsCountRef = useRef13(0);
-  const pickerOpenedFromEnterRef = useRef13(false);
-  const pickerOpenedFromEnterTimerRef = useRef13(null);
-  const projectPickerRef = useRef13(null);
+  const followingRef = useRef14(false);
+  const lastItemsCountRef = useRef14(0);
+  const lastFirstItemIdRef = useRef14(null);
+  const pickerOpenedFromEnterRef = useRef14(false);
+  const pickerOpenedFromEnterTimerRef = useRef14(null);
+  const projectPickerRef = useRef14(null);
   const buildProjectPickerState = (opts) => projectPickerRef.current.buildProjectPickerState(opts);
   const [picker, setPickerState] = useState11(null);
-  const livePickerRef = useRef13(null);
-  const setPicker = useCallback12((next) => {
+  const livePickerRef = useRef14(null);
+  const setPicker = useCallback13((next) => {
     livePickerRef.current = typeof next === "function" ? next(livePickerRef.current) : next;
     setPickerState((prev) => {
       const resolved = typeof next === "function" ? next(prev) : next;
@@ -23136,14 +22475,14 @@ function App({ store, initialStatusLine = "", forceOnboarding = false, onboardin
   livePickerRef.current = picker;
   const [contextPanel, setContextPanel] = useState11(null);
   const [usagePanel, setUsagePanel] = useState11(null);
-  const usageRequestRef = useRef13(0);
-  const settingsHeavyCacheRef = useRef13(null);
-  const closeUsagePanel = useCallback12(() => {
+  const usageRequestRef = useRef14(0);
+  const settingsHeavyCacheRef = useRef14(null);
+  const closeUsagePanel = useCallback13(() => {
     usageRequestRef.current += 1;
     setUsagePanel(null);
   }, []);
   const [providerPrompt, setProviderPrompt] = useState11(null);
-  const oauthSubmitRef = useRef13(false);
+  const oauthSubmitRef = useRef14(false);
   const [channelPrompt, setChannelPrompt] = useState11(null);
   const [hookPrompt, setHookPrompt] = useState11(null);
   const [settingsPrompt, setSettingsPrompt] = useState11(null);
@@ -23157,22 +22496,22 @@ function App({ store, initialStatusLine = "", forceOnboarding = false, onboardin
     setSettingsPrompt,
     setContextPanel,
     closeUsagePanel,
-    listProjects,
-    addProject,
-    touchProjectSelected,
-    resolveProjectPath,
     projectNameFromPath,
     pickFolder
   });
   projectPickerRef.current = projectPicker;
-  const initialPickerBuiltRef = useRef13(false);
+  const initialPickerBuiltRef = useRef14(false);
   if (!initialPickerBuiltRef.current) {
     initialPickerBuiltRef.current = true;
     const onboardingOwnsScreen = !resolveOnboardingCompleted(store, onboardingCompleted) || forceOnboarding;
     if (!onboardingOwnsScreen && state.items.length === 0) {
-      setPicker(projectPicker.buildProjectPickerState({ initialEntry: true }));
+      setPicker(projectPicker.buildProjectPickerState({ initialEntry: true, loading: true }));
     }
   }
+  useEffect14(() => {
+    if (livePickerRef.current?._projectInitialPending !== true) return;
+    void projectPickerRef.current?.openProjectPicker({ initialEntry: true });
+  }, [store]);
   const {
     beginNewProject,
     registerProject,
@@ -23181,7 +22520,7 @@ function App({ store, initialStatusLine = "", forceOnboarding = false, onboardin
     openProjectPicker
   } = projectPicker;
   const [disabledSkills, setDisabledSkillsInner] = useState11(() => /* @__PURE__ */ new Set());
-  useEffect13(() => {
+  useEffect14(() => {
     let alive = true;
     void Promise.resolve(store.getDisabledSkills?.()).then((result) => {
       if (!alive) return;
@@ -23193,7 +22532,7 @@ function App({ store, initialStatusLine = "", forceOnboarding = false, onboardin
       alive = false;
     };
   }, [store]);
-  const setDisabledSkills = useCallback12((next) => {
+  const setDisabledSkills = useCallback13((next) => {
     setDisabledSkillsInner((current) => {
       const base = current instanceof Set ? current : new Set(current);
       const set = typeof next === "function" ? next(base) : next instanceof Set ? next : new Set(next);
@@ -23208,7 +22547,7 @@ function App({ store, initialStatusLine = "", forceOnboarding = false, onboardin
   const toolApproval = state.toolApproval || null;
   const [promptDraft, setPromptDraft] = useState11("");
   const [promptDraftOverride, setPromptDraftOverride] = useState11(null);
-  const promptLayoutValueRef = useRef13("");
+  const promptLayoutValueRef = useRef14("");
   const [, setPromptLayoutRows] = useState11(1);
   const [textEntryLayoutRows, setTextEntryLayoutRows] = useState11(1);
   const {
@@ -23225,12 +22564,12 @@ function App({ store, initialStatusLine = "", forceOnboarding = false, onboardin
     clearPastedTextsSnapshot,
     registerPastedText
   } = usePastedBuffers();
-  const promptValueRef = useRef13("");
-  const promptSelectionRef = useRef13(null);
-  const promptBoxRectRef = useRef13(null);
-  const promptMouseSelectionRef = useRef13(null);
-  const promptHistoryNavRef = useRef13({ active: false, index: -1, seed: "", lastValue: "" });
-  const promptHistoryDraftChangeRef = useRef13(false);
+  const promptValueRef = useRef14("");
+  const promptSelectionRef = useRef14(null);
+  const promptBoxRectRef = useRef14(null);
+  const promptMouseSelectionRef = useRef14(null);
+  const promptHistoryNavRef = useRef14({ active: false, index: -1, seed: "", lastValue: "" });
+  const promptHistoryDraftChangeRef = useRef14(false);
   const {
     promptHint,
     promptHintTone,
@@ -23240,7 +22579,7 @@ function App({ store, initialStatusLine = "", forceOnboarding = false, onboardin
     showSelectionCopyHint,
     clearPromptHint
   } = usePromptHint();
-  const toastErrorSignature = useMemo4(() => (state.toasts || []).filter((toast) => toast?.tone === "error").map((toast) => `${toast.id || ""}:${toast.text || ""}`).join("|"), [state.toasts]);
+  const toastErrorSignature = useMemo5(() => (state.toasts || []).filter((toast) => toast?.tone === "error").map((toast) => `${toast.id || ""}:${toast.text || ""}`).join("|"), [state.toasts]);
   const {
     welcomePromptHintDismissed,
     conditionalWelcomePromptHint,
@@ -23250,16 +22589,16 @@ function App({ store, initialStatusLine = "", forceOnboarding = false, onboardin
   } = useWelcomePromptHint({ store, state, toastErrorSignature });
   const [slashIndex, setSlashIndex] = useState11(0);
   const [slashDismissedFor, setSlashDismissedFor] = useState11("");
-  const slashPaletteRef = useRef13({ open: false, count: 0 });
-  const workflowTabCycleRef = useRef13({ pending: false, lastAt: 0 });
-  const scrollFocusRef = useRef13({});
-  const onboardingStartedRef = useRef13(false);
-  const onboardingRef = useRef13({ defaultRoute: null, searchRoute: null, agentRoutes: {}, agents: [], providerModels: [] });
-  const providerModelsCacheRef = useRef13({ models: null, at: 0 });
-  const searchModelsCacheRef = useRef13({ models: null, at: 0 });
-  const modelPickerRequestRef = useRef13(0);
-  const onboardingPrefetchSeqRef = useRef13(0);
-  const clearModelCaches = useCallback12((scope = "all") => {
+  const slashPaletteRef = useRef14({ open: false, count: 0 });
+  const workflowTabCycleRef = useRef14({ pending: false, lastAt: 0 });
+  const scrollFocusRef = useRef14({});
+  const onboardingStartedRef = useRef14(false);
+  const onboardingRef = useRef14({ defaultRoute: null, searchRoute: null, agentRoutes: {}, agents: [], providerModels: [] });
+  const providerModelsCacheRef = useRef14({ models: null, at: 0 });
+  const searchModelsCacheRef = useRef14({ models: null, at: 0 });
+  const modelPickerRequestRef = useRef14(0);
+  const onboardingPrefetchSeqRef = useRef14(0);
+  const clearModelCaches = useCallback13((scope = "all") => {
     if (scope === "all" || scope === "provider") {
       providerModelsCacheRef.current = { models: null, at: 0 };
       onboardingRef.current.providerModels = [];
@@ -23269,7 +22608,7 @@ function App({ store, initialStatusLine = "", forceOnboarding = false, onboardin
       searchModelsCacheRef.current = { models: null, at: 0 };
     }
   }, []);
-  useEffect13(() => {
+  useEffect14(() => {
     let alive = true;
     const timer2 = setTimeout(async () => {
       const seq = onboardingPrefetchSeqRef.current;
@@ -23354,24 +22693,24 @@ function App({ store, initialStatusLine = "", forceOnboarding = false, onboardin
     openUsagePanel: (...a) => openUsagePanel(...a),
     openContextPicker: (...a) => openContextPicker(...a)
   });
-  const dragRef = useRef13({ anchor: null, anchorScroll: 0, last: null, active: false, rect: null, region: null, anchorSpan: null });
-  const transcriptViewportRef = useRef13({ top: 0, bottom: 0 });
-  const panelTransitionRef = useRef13({ signature: "", reserve: 0, clearRows: 0, guardRows: 0, epoch: 0 });
-  const panelCloseInkMaskRowsRef = useRef13(0);
-  const projectBootInputLatchRef = useRef13(false);
-  const frameRowsRef = useRef13(24);
+  const dragRef = useRef14({ anchor: null, anchorScroll: 0, last: null, active: false, rect: null, region: null, anchorSpan: null });
+  const transcriptViewportRef = useRef14({ top: 0, bottom: 0 });
+  const panelTransitionRef = useRef14({ signature: "", reserve: 0, clearRows: 0, guardRows: 0, epoch: 0 });
+  const panelCloseInkMaskRowsRef = useRef14(0);
+  const projectBootInputLatchRef = useRef14(false);
+  const frameRowsRef = useRef14(24);
   const STATUSLINE_BAND_ROWS = 3;
   const promptContentColumns = Math.max(1, frameColumns - 4);
-  const syncPromptLayoutRows = useCallback12((value) => {
+  const syncPromptLayoutRows = useCallback13((value) => {
     const text = String(value ?? "");
     promptLayoutValueRef.current = text;
     const nextRows = promptContentRows(text, promptContentColumns);
     setPromptLayoutRows((prev) => prev === nextRows ? prev : nextRows);
   }, [promptContentColumns]);
-  useEffect13(() => {
+  useEffect14(() => {
     syncPromptLayoutRows(promptLayoutValueRef.current);
   }, [syncPromptLayoutRows]);
-  useEffect13(() => {
+  useEffect14(() => {
     const kind = String(settingsPrompt?.kind || "");
     if (!CORE_MULTILINE_TEXT_ENTRY_KINDS.has(kind)) {
       setTextEntryLayoutRows(1);
@@ -23380,10 +22719,10 @@ function App({ store, initialStatusLine = "", forceOnboarding = false, onboardin
     const cols = Math.max(1, frameColumns - 4 - stringWidth11("Sentence > "));
     setTextEntryLayoutRows(textEntryReservedRows(settingsPrompt?.initialValue, cols, 8));
   }, [settingsPrompt?.kind, settingsPrompt?.initialValue, frameColumns]);
-  const selectionLayoutRef = useRef13(null);
-  const selectionTextRef = useRef13("");
-  const lastClickRef = useRef13({ x: -1, y: -1, t: 0, count: 0 });
-  useEffect13(() => {
+  const selectionLayoutRef = useRef14(null);
+  const selectionTextRef = useRef14("");
+  const lastClickRef = useRef14({ x: -1, y: -1, t: 0, count: 0 });
+  useEffect14(() => {
     const timer2 = setTimeout(() => setTuiReady(true), 0);
     return () => clearTimeout(timer2);
   }, []);
@@ -23429,7 +22768,7 @@ function App({ store, initialStatusLine = "", forceOnboarding = false, onboardin
     getStitchedSelectionText,
     showSelectionCopyHint
   });
-  useEffect13(() => () => {
+  useEffect14(() => () => {
     stopSmoothScroll();
   }, [stopSmoothScroll]);
   useMouseInput({
@@ -23463,12 +22802,15 @@ function App({ store, initialStatusLine = "", forceOnboarding = false, onboardin
     const count = state.items.length;
     const previousCount = lastItemsCountRef.current;
     lastItemsCountRef.current = count;
-    if (count < previousCount || previousCount === 0) {
+    const firstId = count > 0 ? state.items[0]?.id ?? null : null;
+    const previousFirstId = lastFirstItemIdRef.current;
+    lastFirstItemIdRef.current = firstId;
+    if (transcriptSwapReturnsToTail({ count, previousCount, firstId, previousFirstId })) {
       resetTranscriptScroll();
       return;
     }
     if (count === previousCount || dragRef.current.active) return;
-  }, [state.items.length, resetTranscriptScroll]);
+  }, [state.items, resetTranscriptScroll]);
   const {
     requestExit,
     restoreQueuedToPrompt,
@@ -23490,6 +22832,15 @@ function App({ store, initialStatusLine = "", forceOnboarding = false, onboardin
     setPromptDraftOverride,
     promptHistoryNavRef
   });
+  const { hasUserMessages, openMessageSelector } = useMessageSelector({
+    store,
+    state,
+    setPicker,
+    setPromptDraftOverride,
+    syncPromptLayoutRows,
+    showPromptHint,
+    clearPromptHint
+  });
   const {
     handlePromptPaste,
     handlePromptHistoryNavigate,
@@ -23515,6 +22866,7 @@ function App({ store, initialStatusLine = "", forceOnboarding = false, onboardin
     recentPromptHistory,
     resetPromptHistoryNav,
     restoreQueuedToPrompt,
+    openMessageSelector,
     usagePanel,
     closeUsagePanel,
     contextPanel,
@@ -23525,7 +22877,7 @@ function App({ store, initialStatusLine = "", forceOnboarding = false, onboardin
     clearPastedTextsSnapshot,
     registerPastedText
   });
-  const toggleExpand = useCallback12(() => {
+  const toggleExpand = useCallback13(() => {
     setToolOutputExpanded((expanded) => !expanded);
   }, []);
   useGlobalKeyInput({
@@ -23565,7 +22917,7 @@ function App({ store, initialStatusLine = "", forceOnboarding = false, onboardin
     setUsagePanel,
     closeUsagePanel
   });
-  useEffect13(() => {
+  useEffect14(() => {
     if (contextPanel?.kind === "context") {
       openContextPicker();
       return;
@@ -23586,7 +22938,7 @@ function App({ store, initialStatusLine = "", forceOnboarding = false, onboardin
     state.cwd,
     state.clientHostPid
   ]);
-  useEffect13(() => {
+  useEffect14(() => {
     if (onboardingStartedRef.current) return void 0;
     if (resolveOnboardingCompleted(store, onboardingCompleted) && !forceOnboarding) return void 0;
     let canceled = false;
@@ -23647,7 +22999,7 @@ function App({ store, initialStatusLine = "", forceOnboarding = false, onboardin
     hookPrompt: !!hookPrompt,
     settingsPrompt: !!settingsPrompt
   };
-  useEffect13(() => {
+  useEffect14(() => {
     setSlashIndex((index) => Math.min(index, Math.max(0, slashCommands.length - 1)));
   }, [slashCommands.length, activeSlashQuery]);
   const {
@@ -23750,7 +23102,7 @@ function App({ store, initialStatusLine = "", forceOnboarding = false, onboardin
     transcriptContentHeight,
     transcriptBottomSlackRows
   } = layout;
-  useEffect13(() => {
+  useEffect14(() => {
     const transition = panelTransitionRef.current;
     const pendingInkMask = panelCloseInkMaskRowsRef.current;
     const hadTransitionClearance = panelTransitionClearRows > 0 || panelTransitionGuardRows > 0;
@@ -23767,7 +23119,7 @@ function App({ store, initialStatusLine = "", forceOnboarding = false, onboardin
     const timer2 = setTimeout(() => setPanelTransitionEpoch((epoch) => epoch + 1), 0);
     return () => clearTimeout(timer2);
   }, [panelLayoutSignature, bottomClusterRows, panelTransitionClearRows, panelTransitionGuardRows]);
-  useEffect13(() => {
+  useEffect14(() => {
     panelTransitionRef.current.tailId = latestTranscriptItem?.id ?? null;
   });
   const {
@@ -23811,7 +23163,7 @@ function App({ store, initialStatusLine = "", forceOnboarding = false, onboardin
     measuredRowsVersion,
     setMeasuredRowsVersion
   });
-  const cycleWorkflowFromPrompt = useCallback12(() => {
+  const cycleWorkflowFromPrompt = useCallback13(() => {
     if (slashPaletteOpen || toolApproval || picker || settingsPrompt || providerPrompt || channelPrompt || hookPrompt || contextPanel || usagePanel) return true;
     const repeatGuardMs = 300;
     const cycleGuard = workflowTabCycleRef.current;
@@ -23871,6 +23223,7 @@ function App({ store, initialStatusLine = "", forceOnboarding = false, onboardin
     handlePromptHistoryNavigate,
     handlePromptInterrupt,
     handlePromptPaste,
+    hasUserMessages,
     hookPrompt,
     initialStatusLine,
     onPromptDraftChange,
@@ -23942,44 +23295,19 @@ var SYNTHETIC_SESSION_TEXT_PATTERNS = Object.freeze([
 init_plugin_paths();
 init_config();
 
-// src/runtime/agent/orchestrator/providers/openai-compat-presets.mjs
-var OPENAI_COMPAT_PRESETS = {
-  deepseek: {
-    baseURL: "https://api.deepseek.com",
-    defaultModel: "deepseek-v4-pro"
-  },
-  xai: {
-    baseURL: "https://api.x.ai/v1",
-    defaultModel: "grok-4.5"
-  },
-  // OpenCode Go - low-cost coding-model subscription gateway.
-  "opencode-go": {
-    baseURL: "https://opencode.ai/zen/go/v1",
-    defaultModel: "glm-5.2"
-  },
-  ollama: {
-    baseURL: "http://localhost:11434/v1",
-    defaultModel: "llama3.3:latest"
-  },
-  lmstudio: {
-    baseURL: "http://localhost:1234/v1",
-    defaultModel: "default"
-  }
-};
+// src/runtime/shared/agent-route-config.mjs
+var LEGACY_AGENT_ROUTE_SLOTS = Object.freeze({
+  explore: Object.freeze({ workflow: "explorer", maintenance: "explore" }),
+  maintainer: Object.freeze({ alias: "maintenance", workflow: "memory", maintenance: "memory" }),
+  worker: Object.freeze({ workflow: "agent" })
+});
 
 // src/runtime/agent/orchestrator/providers/oauth-credential-probes.mjs
 init_plugin_paths();
-import { join as join8 } from "node:path";
-var ANTHROPIC_DEFAULT_CREDENTIALS_PATH = join8(resolvePluginData(), "anthropic-oauth-credentials.json");
+import { join as join7 } from "node:path";
+var ANTHROPIC_DEFAULT_CREDENTIALS_PATH = join7(resolvePluginData(), "anthropic-oauth-credentials.json");
 
 // src/runtime/agent/orchestrator/config.mjs
-var CONFIG_PROVIDER_IDS = /* @__PURE__ */ new Set([
-  ...Object.keys(AGENT_PROVIDER_ENV),
-  ...Object.keys(OPENAI_COMPAT_PRESETS),
-  "openai-oauth",
-  "anthropic-oauth",
-  "grok-oauth"
-]);
 var MAINTENANCE_SLOTS = Object.freeze(["explore", "memory"]);
 var PROFILE_LANGUAGES = Object.freeze([
   { id: "system", label: "System (locale)", prompt: null },
@@ -24074,8 +23402,8 @@ var TRANSCRIPT_PROCESS_NONCE = randomUUID();
 
 // src/tui/engine.mjs
 async function createEngineSession(options = {}) {
-  const { createRemoteEngineSession: createRemoteEngineSession2 } = await Promise.resolve().then(() => (init_engine_daemon_client(), engine_daemon_client_exports));
-  return await createRemoteEngineSession2(options);
+  const { createRemoteEngineSession } = await import("../../standalone/engine-daemon-client.mjs");
+  return await createRemoteEngineSession(options);
 }
 
 // src/tui/index.jsx
@@ -24281,8 +23609,8 @@ function waitWithTimeout(promise, ms) {
   let timer2 = null;
   return Promise.race([
     Promise.resolve(promise).then(() => true),
-    new Promise((resolve5) => {
-      timer2 = setTimeout(() => resolve5(false), ms);
+    new Promise((resolve4) => {
+      timer2 = setTimeout(() => resolve4(false), ms);
     })
   ]).finally(() => {
     if (timer2) clearTimeout(timer2);
@@ -24301,7 +23629,7 @@ function scheduleHardExit(code = 0) {
   timer2.unref?.();
 }
 function resolveTuiStderrLogPath() {
-  return process.env.MIXDOG_TUI_STDERR_LOG || join9(process.env.MIXDOG_RUNTIME_ROOT || join9(tmpdir2(), "mixdog"), "mixdog-tui.stderr.log");
+  return process.env.MIXDOG_TUI_STDERR_LOG || join8(process.env.MIXDOG_RUNTIME_ROOT || join8(tmpdir2(), "mixdog"), "mixdog-tui.stderr.log");
 }
 function ansiFg(rgb) {
   const m = /rgb\((\d+),\s*(\d+),\s*(\d+)\)/.exec(String(rgb || ""));
@@ -24383,7 +23711,7 @@ function installTuiStderrGuard() {
   const originalWrite = process.stderr.write.bind(process.stderr);
   const logPath = resolveTuiStderrLogPath();
   try {
-    mkdirSync7(dirname8(logPath), { recursive: true });
+    mkdirSync6(dirname7(logPath), { recursive: true });
   } catch {
   }
   (0, import_mixdog_debug.rotateBoundedLog)(logPath, import_mixdog_debug.PLUGIN_LOG_MAX_BYTES, import_mixdog_debug.PLUGIN_LOG_KEEP_BYTES);
@@ -24491,7 +23819,7 @@ async function runTui({ provider, model, toolMode, remote, forceOnboarding } = {
     if (outcome.error) throw outcome.error;
     store = outcome.store;
     try {
-      touchProjectSelected(store.getState?.()?.cwd || process.cwd());
+      await store.touchProjectSelected(store.getState?.()?.cwd || process.cwd());
     } catch {
     }
     if (store.isRemoteEngine === true) {