agentlas 1.0.65 → 1.0.67

package/engine/sessions/sink.cjs

@@ -14,6 +14,53 @@
 const i18n = require("../agentlas-i18n.cjs");
 
 const NOOP_PALETTE = new Proxy({}, { get: () => (s) => String(s) });
+const STATUS_TEXT_MAX = 8 * 1024;
+const EVENT_TEXT_MAX = 64 * 1024;
+const TOOL_NAME_MAX = 256;
+const TOOL_SUMMARY_MAX = 16 * 1024;
+const TASK_TOOL_INPUTS = new Set(["todowrite", "write_todos", "taskcreate", "taskupdate"]);
+const TASK_TOOL_RESULTS = new Set(["taskcreate", "taskupdate", "tasklist"]);
+const TASK_RECORD_KEYS = new Set([
+  "id", "taskId", "content", "subject", "description", "text", "title", "activeForm", "status", "completed",
+]);
+
+function taskScalar(key, value) {
+  if (typeof value === "boolean" || typeof value === "number") return value;
+  if (typeof value !== "string") return undefined;
+  const max = key === "id" || key === "taskId" ? 256 : key === "status" ? 64 : 2_000;
+  return Array.from(value).slice(0, max).join("");
+}
+
+function taskRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const projected = {};
+  for (const [key, child] of Object.entries(value)) {
+    if (!TASK_RECORD_KEYS.has(key)) continue;
+    const safe = taskScalar(key, child);
+    if (safe !== undefined) projected[key] = safe;
+  }
+  return projected;
+}
+
+function taskPayload(value) {
+  if (Array.isArray(value)) return value.map(taskRecord).filter(Boolean).slice(0, 500);
+  const projected = taskRecord(value);
+  if (!projected) return null;
+  for (const key of ["todos", "items", "tasks"]) {
+    if (Array.isArray(value[key])) projected[key] = value[key].map(taskRecord).filter(Boolean).slice(0, 500);
+  }
+  if (value.task && typeof value.task === "object" && !Array.isArray(value.task)) {
+    projected.task = taskRecord(value.task);
+  }
+  return projected;
+}
+
+function boundedText(value, max, suffix = "… [truncated]") {
+  const text = String(value || "");
+  if (text.length <= max) return text;
+  const keep = Math.max(0, max - suffix.length);
+  return text.slice(0, keep) + suffix;
+}
 
 class EventSink {
   constructor({ lang = "en", onEvent, onPrivateEvidence } = {}) {
@@ -29,36 +76,55 @@ class EventSink {
     this._onEvent({ type, at: Date.now(), ...data });
   }
 
-  status(text) { this._emit("status", { text: String(text || "") }); }
-  warn(text) { this._emit("warn", { text: String(text || "") }); }
+  status(text) { this._emit("status", { text: boundedText(text, STATUS_TEXT_MAX) }); }
+  warn(text) { this._emit("warn", { text: boundedText(text, STATUS_TEXT_MAX) }); }
   // Runtime/provider failures are recovery evidence, never presentation copy.
   // Session owns the recovery loop and may give this evidence to the controller;
   // Renderer must never receive it first.
-  error(text) { this._onPrivateEvidence(String(text || "")); }
-  line(text) { this._emit("line", { text: String(text || "") }); }
-  tool(name, summary) { this._emit("tool", { name: String(name || "tool"), summary: String(summary || "") }); }
+  error(text) { this._onPrivateEvidence(boundedText(text, EVENT_TEXT_MAX)); }
+  line(text) { this._emit("line", { text: boundedText(text, EVENT_TEXT_MAX) }); }
+  tool(name, summary) {
+    this._emit("tool", {
+      name: boundedText(name || "tool", TOOL_NAME_MAX),
+      summary: boundedText(summary, TOOL_SUMMARY_MAX),
+    });
+  }
   toolResult(text, ok) {
     if (ok === false) {
-      this._onPrivateEvidence(String(text || ""));
+      this._onPrivateEvidence(boundedText(text, EVENT_TEXT_MAX));
       return;
     }
-    this._emit("tool-result", { text: String(text || ""), ok: true });
+    this._emit("tool-result", { text: boundedText(text, EVENT_TEXT_MAX), ok: true });
   }
   streamStart() {
     if (!this._streamOpen) { this._streamOpen = true; this._emit("stream-start", {}); }
   }
   streamDelta(text) {
     if (!this._streamOpen) this.streamStart();
-    this._emit("stream-delta", { text: String(text || "") });
+    const value = String(text || "");
+    if (!value) { this._emit("stream-delta", { text: "" }); return; }
+    // Preserve live output byte-for-byte while ensuring no single retained
+    // ring event can own an unbounded provider/MCP payload.
+    for (let offset = 0; offset < value.length; offset += EVENT_TEXT_MAX) {
+      this._emit("stream-delta", { text: value.slice(offset, offset + EVENT_TEXT_MAX) });
+    }
   }
   streamEnd() {
     if (this._streamOpen) { this._streamOpen = false; this._emit("stream-end", {}); }
   }
-  applyTaskTool(name, input, id) { this._emit("task-tool", { name, input, id }); }
-  applyTaskResult(name, result, id) { this._emit("task-result", { name, result, id }); }
-  info(text) { this._emit("line", { text: String(text || "") }); }
+  applyTaskTool(name, input, id) {
+    const tool = String(name || "").toLowerCase();
+    if (!TASK_TOOL_INPUTS.has(tool)) return;
+    this._emit("task-tool", { name: tool, input: taskPayload(input), id: taskScalar("id", String(id || "")) });
+  }
+  applyTaskResult(name, result, id) {
+    const tool = String(name || "").toLowerCase();
+    if (!TASK_TOOL_RESULTS.has(tool)) return;
+    this._emit("task-result", { name: tool, result: taskPayload(result), id: taskScalar("id", String(id || "")) });
+  }
+  info(text) { this._emit("line", { text: boundedText(text, EVENT_TEXT_MAX) }); }
   cost(usage) { this._emit("cost", { usage }); }
   stopSpinner() { /* 스피너는 렌더러 소관 — 이벤트 불필요 */ }
 }
 
-module.exports = { EventSink };
+module.exports = { EventSink, taskPayload, boundedText, EVENT_TEXT_MAX };

package/engine/sessions/store.cjs

@@ -84,24 +84,46 @@ function loadRuntimeSession(db, chatId, kind, fingerprint, agentId) {
   return {};
 }
 
-function saveRuntimeSession(db, chatId, kind, session, fingerprint, agentId) {
+function saveRuntimeSession(db, chatId, kind, session, fingerprint, agentId, expectedSessionId = null) {
   const sessionId = session && session.id ? String(session.id) : "";
   if (!sessionId) return false;
   const agent = normalizeRuntimeAgentId(agentId);
+  const expected = typeof expectedSessionId === "string" ? expectedSessionId : "";
   try {
-    runWriteTransaction(db, () => {
-      db.prepare(
-        "INSERT OR REPLACE INTO chat_runtime_sessions (chat_id, kind, agent_id, session_id, fingerprint, updated_at) VALUES (?,?,?,?,?,?)",
-      ).run(chatId, kind, agent, sessionId, fingerprint, nowIso());
+    const saved = runWriteTransaction(db, () => {
+      const current = db.prepare(
+        "SELECT session_id, fingerprint FROM chat_runtime_sessions WHERE chat_id=? AND kind=? AND agent_id=?",
+      ).get(chatId, kind, agent);
+      let changed = 0;
+      if (!current) {
+        const inserted = db.prepare(
+          "INSERT OR IGNORE INTO chat_runtime_sessions (chat_id, kind, agent_id, session_id, fingerprint, updated_at) VALUES (?,?,?,?,?,?)",
+        ).run(chatId, kind, agent, sessionId, fingerprint, nowIso());
+        changed = inserted.changes ?? inserted.rowsAffected ?? 0;
+      } else if (
+        (expected && current.session_id === expected && current.fingerprint === fingerprint) ||
+        (!expected && current.fingerprint !== fingerprint)
+      ) {
+        // Compare-and-swap: two sessions that began from the same provider id
+        // cannot finish out of order and overwrite the newer continuation.
+        const updated = db.prepare(
+          "UPDATE chat_runtime_sessions SET session_id=?, fingerprint=?, updated_at=? WHERE chat_id=? AND kind=? AND agent_id=? AND session_id=? AND fingerprint=?",
+        ).run(sessionId, fingerprint, nowIso(), chatId, kind, agent, current.session_id, current.fingerprint);
+        changed = updated.changes ?? updated.rowsAffected ?? 0;
+      } else if (current.session_id === sessionId && current.fingerprint === fingerprint) {
+        changed = 1; // idempotent retry of the already-persisted continuation
+      }
+      if (!changed) return false;
       // 레거시 행을 승계했다면 이제 새 키가 정본이다 — 같은 세션을 가리키는 '' 행을
       // 정리해 다음 점유자가 이 봇의 세션을 승계 후보로 오인하지 않게 한다.
       if (agent !== "") {
         db.prepare(
           "DELETE FROM chat_runtime_sessions WHERE chat_id=? AND kind=? AND agent_id='' AND session_id=?",
-        ).run(chatId, kind, sessionId);
+        ).run(chatId, kind, expected || sessionId);
       }
+      return true;
     });
-    return true;
+    return saved === true;
   } catch (error) {
     // 턴 자체는 유효하므로 던지지 않는다. 다만 조용히 지나가지도 않는다 — 이 자리의
     // 침묵이 resume 유실을 여러 판 동안 숨겼다.

package/engine/storm/storm.cjs

@@ -208,10 +208,33 @@ function create(deps) {
       cwd: executionContext.cwd || (typeof D.projectCwd === "function" ? D.projectCwd() : D.runCwd()),
       runtimeOverride,
     };
+    const seen = new Set();
+    let passthrough = false;
     for (let i = 0; i < args.length; i++) {
-      if (args[i] === "--research" || args[i] === "--research-evidence") ctx.research = true;
-      else if (args[i] === "--background") ctx.background = true;
-      else rest.push(args[i]);
+      const token = String(args[i]);
+      if (passthrough) { rest.push(token); continue; }
+      if (token === "--") { passthrough = true; continue; }
+      if (token === "--research" || token === "--research-evidence") {
+        if (seen.has("research")) {
+          const ui = executionContext.ui || newUi();
+          ui.error("duplicate option: --research", { reveal: true });
+          return { ok: false, error: "duplicate-option" };
+        }
+        seen.add("research");
+        ctx.research = true;
+      } else if (token === "--background") {
+        if (seen.has("background")) {
+          const ui = executionContext.ui || newUi();
+          ui.error("duplicate option: --background", { reveal: true });
+          return { ok: false, error: "duplicate-option" };
+        }
+        seen.add("background");
+        ctx.background = true;
+      } else if (token.startsWith("-")) {
+        const ui = executionContext.ui || newUi();
+        ui.error(`unknown option ${token} — storm accepts: --research | --background | --runtime <kind>`, { reveal: true });
+        return { ok: false, error: "unknown-option" };
+      } else rest.push(token);
     }
     const r = await stormRun(db, rest.join(" "), ctx);
     if (!r.ok) process.exitCode = 1;

package/engine/storm/swarm.cjs

@@ -429,16 +429,44 @@ function create(deps) {
   async function cmdSwarm(db, args, runtimeOverride, executionContext = {}) {
     const rest = [];
     let concurrency;
+    let parallelError = null;
+    let seenParallel = false;
+    let passthrough = false;
+    let strayFlag = null;
     for (let i = 0; i < args.length; i++) {
-      if (args[i] === "--parallel" || args[i] === "-n") concurrency = Number(args[++i]);
-      else rest.push(args[i]);
+      const token = String(args[i]);
+      if (passthrough) { rest.push(token); continue; }
+      if (token === "--") { passthrough = true; continue; }
+      if (token === "--parallel" || token === "-n" || token.startsWith("--parallel=")) {
+        if (seenParallel) {
+          parallelError = "duplicate option";
+          continue;
+        }
+        seenParallel = true;
+        const inline = token.startsWith("--parallel=");
+        const raw = inline ? token.slice(11) : args[++i];
+        const parsed = Number(raw);
+        if (raw === undefined || raw === "" || (!inline && String(raw).startsWith("--")) || !Number.isInteger(parsed) || parsed < 1) {
+          parallelError = raw === undefined ? "missing value" : String(raw);
+        } else {
+          concurrency = Math.min(8, parsed);
+        }
+      } else {
+        if (token.startsWith("-") && strayFlag === null) strayFlag = token;
+        rest.push(token);
+      }
+    }
+    if (parallelError !== null) {
+      const ui = executionContext.ui || newUi();
+      ui.error(`invalid --parallel value ${parallelError} — use a positive integer (maximum 8)`, { reveal: true });
+      process.exitCode = 1;
+      return { ok: false, error: "invalid-parallel" };
     }
     // storm.cjs stormRun 의 leading-dash 가드와 동일 계약. 여기서 안 막으면 미지원·
     // 오타 플래그(--permission, --model …)가 rest 에 남아 rest.join(" ") 로 목표가
     // 되어버린다: 유료 플래너가 플래그 텍스트를 목표로 실제 실행되고, 플래그가
     // 의도한 동작(예: 권한 상승)은 조용히 일어나지 않는다. 목표는 프롬프트까지
     // 오염된다. 그래서 소비되지 않은 대시 토큰은 실행 전에 fail-closed 로 거절한다.
-    const strayFlag = rest.find((token) => String(token).startsWith("-"));
     if (strayFlag) {
       const ui = executionContext.ui || newUi();
       ui.error(`unknown option ${strayFlag} — swarm accepts: --parallel N | -n N, --runtime <kind>`, { reveal: true });

package/engine/telegram/connect.cjs

@@ -20,16 +20,34 @@ const { userDataDir } = require("../core/paths.cjs");
 const { runWriteTransaction } = require("../agentlas-sqlite-policy.cjs");
 
 const TELEGRAM_REQUEST_TIMEOUT_MS = 20_000;
+const TELEGRAM_TOKEN_MAX_BYTES = 1024;
+const TELEGRAM_BINDING_ID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+
+function assertTelegramBindingId(id) {
+  const value = String(id || "");
+  if (!TELEGRAM_BINDING_ID_RE.test(value)) throw new Error("invalid Telegram binding id");
+  return value;
+}
 
 /** 순수 HTTPS. fetch 주입 가능(테스트). */
 async function telegramApi(token, method, payload, { fetchImpl } = {}) {
   const doFetch = fetchImpl || globalThis.fetch;
   if (typeof doFetch !== "function") throw new Error("this runtime has no fetch");
-  const longPoll = method === "getUpdates" && typeof payload.timeout === "number" ? Math.max(0, payload.timeout) : 0;
+  const safeToken = String(token || "");
+  const safeMethod = String(method || "");
+  if (!safeToken || Buffer.byteLength(safeToken, "utf8") > TELEGRAM_TOKEN_MAX_BYTES || !/^[A-Za-z0-9:_-]+$/.test(safeToken)) {
+    throw new Error("Telegram bot token has an unsafe format");
+  }
+  if (!/^[A-Za-z][A-Za-z0-9]{0,63}$/.test(safeMethod)) throw new Error("Telegram API method is invalid");
+  if (!payload || typeof payload !== "object" || Array.isArray(payload)) throw new Error("Telegram API payload must be an object");
+  const requestedLongPoll = safeMethod === "getUpdates" && Number.isFinite(Number(payload.timeout))
+    ? Number(payload.timeout)
+    : 0;
+  const longPoll = Math.max(0, Math.min(50, requestedLongPoll));
   const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(new Error(`Telegram ${method} timed out`)), TELEGRAM_REQUEST_TIMEOUT_MS + longPoll * 1000);
+  const timer = setTimeout(() => controller.abort(new Error(`Telegram ${safeMethod} timed out`)), TELEGRAM_REQUEST_TIMEOUT_MS + longPoll * 1000);
   try {
-    const res = await doFetch(`https://api.telegram.org/bot${token}/${method}`, {
+    const res = await doFetch(`https://api.telegram.org/bot${safeToken}/${safeMethod}`, {
       method: "POST",
       headers: { "content-type": "application/json" },
       body: JSON.stringify(payload),
@@ -37,7 +55,11 @@ async function telegramApi(token, method, payload, { fetchImpl } = {}) {
     });
     const json = await res.json().catch(() => null);
     if (!res.ok || !json || json.ok !== true) {
-      throw new Error((json && json.description) || `Telegram ${method} failed (${res.status})`);
+      const raw = (json && json.description) || `Telegram ${safeMethod} failed (${res.status})`;
+      const message = String(raw).replaceAll(safeToken, "[redacted]").replace(/[\u0000-\u001f\u007f]/g, " ").slice(0, 1000);
+      const error = new Error(message || `Telegram ${safeMethod} failed`);
+      error.telegramStatus = Number(res.status) || null;
+      throw error;
     }
     return json.result;
   } finally {
@@ -52,24 +74,124 @@ async function verifyBotToken(token, opts) {
 }
 
 // ── 토큰 비밀 저장 (0600 파일) ─────────────────────────────────────────────
-function tokenDir() {
+function tokenDir({ create = true } = {}) {
   const dir = path.join(userDataDir(), "telegram");
-  fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+  if (create) fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+  let stat;
+  try { stat = fs.lstatSync(dir); }
+  catch (error) {
+    if (error && error.code === "ENOENT" && !create) return dir;
+    throw error;
+  }
+  if (!stat.isDirectory() || stat.isSymbolicLink()) throw new Error("Telegram token directory must be a real directory");
   if (process.platform !== "win32") fs.chmodSync(dir, 0o700);
   return dir;
 }
-function tokenFile(id) { return path.join(tokenDir(), `${id}.token`); }
+function tokenFile(id, options) {
+  const bindingId = assertTelegramBindingId(id);
+  return path.join(tokenDir(options), `${bindingId}.token`);
+}
 function saveToken(id, token) {
   const file = tokenFile(id);
-  fs.writeFileSync(file, token, { encoding: "utf8", mode: 0o600 });
-  if (process.platform !== "win32") fs.chmodSync(file, 0o600);
+  const value = String(token || "");
+  if (!value || Buffer.byteLength(value, "utf8") > TELEGRAM_TOKEN_MAX_BYTES || !/^[A-Za-z0-9:_-]+$/.test(value)) {
+    throw new Error("Telegram bot token has an unsafe format");
+  }
+  let before = null;
+  try {
+    before = fs.lstatSync(file);
+    if (!before.isFile() || before.isSymbolicLink() || before.nlink !== 1) throw new Error("Telegram token target must be a regular private file");
+  } catch (error) {
+    if (!error || error.code !== "ENOENT") throw error;
+  }
+  const temp = path.join(path.dirname(file), `.${path.basename(file)}.${process.pid}.${crypto.randomUUID()}.tmp`);
+  try {
+    fs.writeFileSync(temp, value, { encoding: "utf8", mode: 0o600, flag: "wx" });
+    if (before) {
+      const current = fs.lstatSync(file);
+      if (
+        !current.isFile() || current.isSymbolicLink() || current.nlink !== 1 ||
+        current.dev !== before.dev || current.ino !== before.ino || current.size !== before.size || current.mtimeMs !== before.mtimeMs
+      ) throw new Error("Telegram token target changed before replacement");
+    } else {
+      try {
+        fs.lstatSync(file);
+        throw new Error("Telegram token target appeared before replacement");
+      } catch (error) {
+        if (!error || error.code !== "ENOENT") throw error;
+      }
+    }
+    try {
+      fs.renameSync(temp, file);
+    } catch (error) {
+      if (
+        process.platform !== "win32" || !before ||
+        !["EEXIST", "EPERM", "EACCES"].includes(error && error.code)
+      ) throw error;
+      const backup = `${file}.${process.pid}.${crypto.randomUUID()}.bak`;
+      fs.renameSync(file, backup);
+      try {
+        fs.renameSync(temp, file);
+      } catch (replaceError) {
+        try { if (!fs.existsSync(file)) fs.renameSync(backup, file); } catch { /* leave recoverable backup */ }
+        throw replaceError;
+      }
+      try { fs.rmSync(backup, { force: true }); } catch { /* committed target is authoritative */ }
+    }
+    if (process.platform !== "win32") fs.chmodSync(file, 0o600);
+  } finally {
+    try { fs.rmSync(temp, { force: true }); } catch { /* best-effort cleanup */ }
+  }
 }
 function readToken(id) {
-  try { return fs.readFileSync(tokenFile(id), "utf8").trim() || null; } catch { return null; }
+  const file = tokenFile(id, { create: false });
+  let fd;
+  try {
+    const before = fs.lstatSync(file);
+    if (
+      !before.isFile() || before.isSymbolicLink() || before.nlink !== 1 ||
+      before.size <= 0 || before.size > TELEGRAM_TOKEN_MAX_BYTES ||
+      (process.platform !== "win32" && (before.mode & 0o077) !== 0)
+    ) throw new Error("Telegram token file is unsafe");
+    fd = fs.openSync(file, fs.constants.O_RDONLY | (fs.constants.O_NOFOLLOW || 0));
+    const opened = fs.fstatSync(fd);
+    if (!opened.isFile() || opened.dev !== before.dev || opened.ino !== before.ino || opened.size !== before.size) {
+      throw new Error("Telegram token file changed while opening");
+    }
+    const token = fs.readFileSync(fd, "utf8").trim();
+    if (!token || !/^[A-Za-z0-9:_-]+$/.test(token)) throw new Error("Telegram token file has an unsafe format");
+    return token;
+  } catch (error) {
+    if (error && error.code === "ENOENT") return null;
+    throw error;
+  } finally {
+    if (fd !== undefined) fs.closeSync(fd);
+  }
+}
+function deleteToken(id) {
+  const file = tokenFile(id, { create: false });
+  try {
+    const stat = fs.lstatSync(file);
+    if (!stat.isFile() || stat.isSymbolicLink() || stat.nlink !== 1) throw new Error("Telegram token target is unsafe");
+    fs.unlinkSync(file);
+    return true;
+  } catch (error) {
+    if (error && error.code === "ENOENT") return false;
+    throw error;
+  }
 }
-function deleteToken(id) { try { fs.rmSync(tokenFile(id)); } catch { /* gone */ } }
 function tokenFingerprint(token) { return crypto.createHash("sha256").update(token).digest("hex").slice(0, 24); }
 
+function readBindingToken(row) {
+  if (!row) throw new Error("binding not found");
+  const token = readToken(row.id);
+  if (!token) throw new Error("no Terminal-owned token for this binding");
+  if (row.token_fingerprint && tokenFingerprint(token) !== row.token_fingerprint) {
+    throw new Error("stored Telegram token does not match the binding fingerprint");
+  }
+  return token;
+}
+
 // ── 바인딩 ─────────────────────────────────────────────────────────────────
 function listBindings(db) {
   try { return db.prepare("SELECT * FROM telegram_bindings ORDER BY rowid DESC").all(); } catch { return []; }
@@ -80,6 +202,10 @@ function getBinding(db, id) {
 
 /** 봇 토큰으로 바인딩을 만든다(방 미페어링). 반환: {id, botUsername}. */
 async function startConnection(db, targetKind, targetId, token, opts) {
+  if (!new Set(["agent", "firm", "one"]).has(String(targetKind))) throw new Error("invalid Telegram binding target kind");
+  if (typeof targetId !== "string" || !targetId.trim() || targetId.length > 512 || /[\u0000\r\n]/.test(targetId)) {
+    throw new Error("invalid Telegram binding target id");
+  }
   const me = await verifyBotToken(token, opts);
   const id = crypto.randomUUID();
   const now = new Date().toISOString();
@@ -95,7 +221,7 @@ async function startConnection(db, targetKind, targetId, token, opts) {
       db.prepare("UPDATE telegram_bindings SET token_saved=1, updated_at=? WHERE id=?").run(new Date().toISOString(), id);
     });
   } catch (error) {
-    deleteToken(id);
+    try { deleteToken(id); } catch { /* preserve the original storage failure */ }
     try {
       runWriteTransaction(db, () => db.prepare("DELETE FROM telegram_bindings WHERE id=?").run(id));
     } catch { /* preserve the original storage failure */ }
@@ -113,16 +239,26 @@ async function startConnection(db, targetKind, targetId, token, opts) {
  * 두 Terminal 프로세스가 같은 바인딩을 동시에 덮어쓰지 못하게 한다.
  */
 async function pairByPolling(db, id, { timeoutMs = 120_000, opts, onWait } = {}) {
-  const token = readToken(id);
-  if (!token) throw new Error("no stored token for this binding");
+  assertTelegramBindingId(id);
+  const initialRow = getBinding(db, id);
+  if (!initialRow) throw new Error("binding not found");
+  const token = readBindingToken(initialRow);
   const deadline = Date.now() + timeoutMs;
-  let offset = (getBinding(db, id) || {}).last_update_id || 0;
+  let offset = Number.isSafeInteger(Number(initialRow.last_update_id)) && Number(initialRow.last_update_id) >= 0
+    ? Number(initialRow.last_update_id)
+    : 0;
+  let lastApiError = null;
   while (Date.now() < deadline) {
     if (typeof onWait === "function") onWait();
     let updates;
     try {
       updates = await telegramApi(token, "getUpdates", { offset: offset + 1, timeout: 25, allowed_updates: ["message"] }, opts);
-    } catch { updates = []; }
+      if (!Array.isArray(updates)) throw new Error("Telegram getUpdates returned an invalid result");
+      lastApiError = null;
+    } catch (error) {
+      lastApiError = error;
+      updates = [];
+    }
     for (const update of updates || []) {
       if (typeof update.update_id === "number") offset = Math.max(offset, update.update_id);
       const message = update.message;
@@ -150,25 +286,52 @@ async function pairByPolling(db, id, { timeoutMs = 120_000, opts, onWait } = {})
       });
     }
   }
+  if (lastApiError) throw lastApiError;
   return null;
 }
 
 /** 페어링된 방에 확인 메시지를 보낸다. */
 async function sendTest(db, id, text, opts) {
+  assertTelegramBindingId(id);
   const row = getBinding(db, id);
   if (!row) throw new Error("binding not found");
   if (!row.telegram_chat_id) throw new Error("this binding is not paired to a chat yet");
-  const token = readToken(id);
-  if (!token) throw new Error("no stored token for this binding");
+  const token = readBindingToken(row);
   await telegramApi(token, "sendMessage", { chat_id: row.telegram_chat_id, text }, opts);
   return true;
 }
 
 function removeBinding(db, id) {
-  runWriteTransaction(db, () => {
-    db.prepare("DELETE FROM telegram_bindings WHERE id=?").run(id);
-  });
-  deleteToken(id);
+  const bindingId = assertTelegramBindingId(id);
+  const row = getBinding(db, bindingId);
+  if (!row) throw new Error("binding not found");
+  const file = tokenFile(bindingId, { create: false });
+  let tokenExists = false;
+  try {
+    const stat = fs.lstatSync(file);
+    if (!stat.isFile() || stat.isSymbolicLink() || stat.nlink !== 1) throw new Error("Telegram token target is unsafe");
+    tokenExists = true;
+  } catch (error) {
+    if (!error || error.code !== "ENOENT") throw error;
+  }
+  if (Number(row.token_saved) === 1 && !tokenExists) {
+    throw new Error("this binding secret is not Terminal-owned; remove it from Agentlas Desktop so its keychain secret is cleaned up");
+  }
+  const tombstone = `${file}.${process.pid}.${crypto.randomUUID()}.delete`;
+  if (tokenExists) fs.renameSync(file, tombstone);
+  try {
+    const removed = runWriteTransaction(db, () => {
+      return db.prepare("DELETE FROM telegram_bindings WHERE id=?").run(bindingId).changes === 1;
+    });
+    if (!removed) throw new Error("binding disappeared before removal");
+  } catch (error) {
+    if (tokenExists) {
+      try { if (!fs.existsSync(file)) fs.renameSync(tombstone, file); } catch { /* leave recoverable tombstone */ }
+    }
+    throw error;
+  }
+  if (tokenExists) fs.unlinkSync(tombstone);
+  return true;
 }
 
 /*

package/engine/ui/commands-catalog.cjs

@@ -118,7 +118,7 @@ const CATALOG = [
   { name: "telegram", group: "advanced", tier: "more", surfaces: BOTH, args: "[sub]", ko: "텔레그램 연결", en: "Telegram bindings" },
   { name: "connect", group: "advanced", tier: "more", surfaces: BOTH, aliases: ["hep-connect"], args: "<target>", argsKo: "<대상>", ko: "에이전트·팀 연결", en: "Connect an agent or team" },
   { name: "browser", group: "advanced", tier: "more", surfaces: BOTH, aliases: ["hep-browser"], args: "<url|status|sites|login>", ko: "브라우저 하드포인트", en: "Browser hardpoint" },
-  { name: "research", group: "advanced", tier: "more", surfaces: BOTH, args: "<sub>", ko: "리서치", en: "Research" },
+  { name: "research", group: "advanced", tier: "more", surfaces: BOTH, args: "<subcommand> [args]", argsKo: "<하위-명령> [인자]", ko: "Research Engine (전체 목록: research --help)", en: "Research Engine (full list: research --help)" },
   { name: "document", group: "advanced", tier: "more", surfaces: BOTH, args: "pdf <html|url>", ko: "문서 PDF 내보내기", en: "Export a document to PDF" },
   { name: "oberon", group: "advanced", tier: "more", surfaces: BOTH, aliases: ["film"], args: "<scaffold|render|list|open>", ko: "AI 필름 렌더", en: "AI film render" },
   { name: "variant", group: "advanced", tier: "more", surfaces: BOTH, args: "resolve --base-release", ko: "로컬 변형 선택", en: "Local variant selection" },

package/engine/ui/palette.cjs

@@ -34,11 +34,21 @@ const EFFORT_LEVELS = ["none", "minimal", "low", "medium", "high", "xhigh", "max
 const PERM_LEVELS = ["read", "write", "full"];
 // 세션 인자를 받는 명령 — 완성 후보를 살아있는 세션 키(s1, s2…)로 채운다.
 const SESSION_ARG_COMMANDS = new Set(["/s", "/switch", "/kill", "/rm"]);
+// DB-backed agent/firm/session lists must not freeze readline or allocate an
+// unbounded candidate array when a local store contains many rows.
+const MAX_COMPLETION_CANDIDATES = 100;
 
 function uniqStartsWith(list, prefix) {
   const p = String(prefix || "");
-  const hits = [...new Set(list)].filter((v) => v.startsWith(p));
-  return hits.length ? hits : [];
+  const hits = [];
+  const seen = new Set();
+  for (const value of Array.isArray(list) ? list : []) {
+    if (typeof value !== "string" || !value.startsWith(p) || seen.has(value)) continue;
+    seen.add(value);
+    hits.push(value);
+    if (hits.length >= MAX_COMPLETION_CANDIDATES) break;
+  }
+  return hits;
 }
 
 /**