agentlas 1.0.60 → 1.0.62

package/engine/sessions/orchestrator.cjs

@@ -7,21 +7,70 @@
  * 링버퍼에 쌓는다. 백그라운드 세션의 턴 종료는 'notice' 이벤트로 전면 세션에
  * 한 줄 알림된다.
  *
- * 동시 실행 상한: AGENTLAS_MAX_PARALLEL (기본 4). 상한 초과 스폰은 대기가 아니라
- * 정직한 거부 — 사용자가 세션을 정리하거나 상한을 올리게 안내한다.
+ * 동시 실행 상한: 공유 DB 의 agent_concurrency(데스크탑 슬라이더와 같은 값)가 기본이고,
+ * AGENTLAS_MAX_PARALLEL 은 **override**다(명시했을 때만 이긴다 — 예전엔 이 env 가
+ * 유일한 소스라 데스크탑과 터미널이 같은 머신에서 다른 예산을 들고 있었다).
+ * 상한 초과 스폰은 대기가 아니라 정직한 거부 — 사용자가 세션을 정리하거나 상한을 올리게 안내한다.
  */
+const os = require("node:os");
 const { EventEmitter } = require("node:events");
 const { Session } = require("./session.cjs");
 
+// 데스크탑 electron/store/concurrency.ts 와 같은 상수/공식 — 값이 갈리면 같은 머신의
+// 두 제품이 다른 예산을 말한다. 바꿀 때는 반드시 양쪽을 함께 바꿀 것.
+const AGENT_CONCURRENCY_HARD_MAX = 32;
+
+/** 사양 기반 추천 동시성(데스크탑 recommendedConcurrency 와 동일 공식). */
+function recommendedConcurrency() {
+  let cores = 4;
+  let totalMemGB = 8;
+  try { cores = Math.max(1, os.cpus().length); } catch { /* fall back */ }
+  try { totalMemGB = os.totalmem() / 1024 ** 3; } catch { /* fall back */ }
+  const coreBound = Math.max(1, cores - 2);
+  const memBound = Math.max(1, Math.floor((totalMemGB - 4) / 2));
+  return Math.max(1, Math.min(coreBound, memBound, AGENT_CONCURRENCY_HARD_MAX));
+}
+
+/*
+ * 공유 DB 핸들 — Orchestrator 생성 시 등록된다. maxParallel 이 배너 출력 등에서
+ * 오케스트레이터 없이도 불리므로(ui/shell.cjs), 핸들이 없을 때는 추천값으로 답한다.
+ */
+let _concurrencyDb = null;
+function setConcurrencyDb(db) {
+  _concurrencyDb = db || null;
+}
+
+function sharedDbConcurrency() {
+  if (!_concurrencyDb) return null;
+  try {
+    const row = _concurrencyDb.prepare("SELECT value FROM meta WHERE key='agent_concurrency'").get();
+    if (!row || row.value == null || row.value === "") return null;
+    const parsed = Number(row.value);
+    if (!Number.isFinite(parsed) || parsed <= 0) return null;
+    return Math.max(1, Math.min(Math.floor(parsed), AGENT_CONCURRENCY_HARD_MAX));
+  } catch {
+    // meta 테이블이 없는 옛/부분 DB — 추천값으로 폴백(조용한 실패가 아니라 설계된 폴백).
+    return null;
+  }
+}
+
 function maxParallel() {
+  // 1) env 는 명시적 override — 사람이 이번 셸에서 일부러 정한 값이 항상 이긴다.
   const n = Number(process.env.AGENTLAS_MAX_PARALLEL);
-  return Number.isInteger(n) && n > 0 ? Math.min(n, 16) : 4;
+  if (Number.isInteger(n) && n > 0) return Math.min(n, AGENT_CONCURRENCY_HARD_MAX);
+  // 2) 공유 DB 의 사용자 슬라이더 값(데스크탑과 동일 예산).
+  const shared = sharedDbConcurrency();
+  if (shared !== null) return shared;
+  // 3) 둘 다 없으면 사양 기반 추천값(데스크탑의 미설정 동작과 동일).
+  return recommendedConcurrency();
 }
 
 class Orchestrator extends EventEmitter {
   constructor({ db, lang }) {
     super();
     this.db = db;
+    // 공유 DB 를 동시성 기본값의 소스로 등록 — 데스크탑 슬라이더와 같은 예산을 쓴다.
+    if (db) setConcurrencyDb(db);
     this.lang = lang || "en";
     this.sessions = new Map(); // "s1" -> Session
     this._seq = 0;
@@ -189,4 +238,4 @@ class Orchestrator extends EventEmitter {
   }
 }
 
-module.exports = { Orchestrator, maxParallel };
+module.exports = { Orchestrator, maxParallel, setConcurrencyDb };

package/engine/sessions/session.cjs

@@ -76,7 +76,7 @@ class Session extends EventEmitter {
     this.fingerprint = crypto.createHash("sha256")
       .update(`${this.runtime.kind}\n${this.agent.id}\n${this.agent.systemPrompt || ""}`)
       .digest("hex");
-    this.runtimeSession = store.loadRuntimeSession(this.db, this.chatId, this.runtime.kind, this.fingerprint);
+    this.runtimeSession = store.loadRuntimeSession(this.db, this.chatId, this.runtime.kind, this.fingerprint, this.agent.id);
 
     this._sink = new EventSink({
       lang: this.lang,
@@ -183,6 +183,13 @@ class Session extends EventEmitter {
     this.lastError = null;
     this._privateRecoveryEvidence.length = 0;
     this._record({ type: "turn-start", at: Date.now(), prompt });
+    // ACP agents that cannot load a provider-side session need prior conversation
+    // reattached on a fresh session. Capture it before appending this turn so the
+    // current user prompt is not duplicated in both history and userPrompt.
+    const priorHistory = store.chatHistory(this.db, this.chatId).map((row) => ({
+      role: row.role,
+      text: row.text,
+    }));
     store.appendMessage(this.db, this.chatId, "user", prompt);
     let governedTurn = null;
     try {
@@ -242,6 +249,14 @@ class Session extends EventEmitter {
             cwd: this.cwd,
             permission: this.permission,
             env: process.env,
+            /*
+             * 공유 능력 규칙(capability_grants)을 도구 관문이 읽을 수 있게 한다 —
+             * 데스크탑에서 "항상 허용"/"영구 거부"한 행동이 여기서도 그대로 적용된다
+             * (agentlas-tools.runTool). 이 세 칸이 없으면 관문은 등급만 보고 판단한다.
+             */
+            db: this.db,
+            chatId: this.chatId,
+            agentId: this.agent && this.agent.id,
           },
           ui: this._sink,
           signal: ctrl.signal,
@@ -252,6 +267,9 @@ class Session extends EventEmitter {
         this._apiAbort = null;
       }
     } else {
+      const isAcpRuntime = require("../runtimes/acp-driver.cjs").ACP_KINDS.has(this.runtime.kind);
+      const turnAbort = isAcpRuntime ? new AbortController() : null;
+      if (turnAbort) this._apiAbort = turnAbort;
       const req = {
         kind: this.runtime.kind,
         bin: this.runtime.bin,
@@ -261,6 +279,11 @@ class Session extends EventEmitter {
         systemPrompt,
         permission: this.permission,
         session: { ...this.runtimeSession },
+        history: priorHistory,
+        chatId: this.chatId,
+        agentId: this.agent.id,
+        locale: this.lang,
+        sessionFingerprintSeed: this.fingerprint,
         model: this.runtime.model,
         effort: this.runtime.effort,
         // 사용자가 이미 동의한 MCP 서버를 턴에 싣는다.
@@ -278,6 +301,7 @@ class Session extends EventEmitter {
         mcpServers: this._consentedMcpServers(),
         onSpawn: (child) => { this._child = child; },
       };
+      if (turnAbort) req.signal = turnAbort.signal;
       if (this._spawnImpl) req.spawn = this._spawnImpl;
       if (this._timeoutConfig) req.timeoutConfig = this._timeoutConfig;
       try {
@@ -317,6 +341,8 @@ class Session extends EventEmitter {
         }
       } catch (e) {
         res = { text: "", session: req.session, error: (e && e.message) || String(e) };
+      } finally {
+        if (turnAbort && this._apiAbort === turnAbort) this._apiAbort = null;
       }
     }
     this._child = null;
@@ -370,7 +396,7 @@ class Session extends EventEmitter {
     if (persistText) store.appendMessage(this.db, this.chatId, "assistant", persistText);
     if (res && res.session && res.session.id) {
       this.runtimeSession = { id: res.session.id };
-      store.saveRuntimeSession(this.db, this.chatId, this.runtime.kind, this.runtimeSession, this.fingerprint);
+      store.saveRuntimeSession(this.db, this.chatId, this.runtime.kind, this.runtimeSession, this.fingerprint, this.agent.id);
     }
     if (res && res.usage) this.usage = res.usage;
 

package/engine/sessions/store.cjs

@@ -51,29 +51,65 @@ function chatHistory(db, chatId, limit = 40) {
 }
 
 /*
- * CLI resume 세션 ID 영속화 — 데스크탑 chat_runtime_sessions와 동일 스키마
- * (chat_id, kind, session_id, fingerprint). fingerprint가 다르면 resume하지
- * 않는다 — 시스템 프롬프트가 바뀐 세션을 이어붙이면 지시가 오염된다.
+ * CLI resume 세션 ID 영속화 — 데스크탑 `store/runtime-sessions.ts` 와 같은 키를 쓴다.
+ *
+ * ★키가 셋이다: (chat_id, kind, **agent_id**). 좌석-세션 전에는 둘이었고, 이 사본은
+ * 둘로 남아 있었다. 그래서 `ON CONFLICT(chat_id, kind)` 가 실제 기본키와 맞지 않아
+ * INSERT 가 예외를 냈고, 그 예외를 아래 catch 가 삼켰다 — **터미널의 resume 이 통째로
+ * 사라진 채 아무 표시도 나지 않았다.** 매 턴이 새 세션으로 시작하니 사용자에게는
+ * "말한 걸 자꾸 잊는다"로 보인다.
+ *
+ * 조용히 실패하는 catch 가 이 병을 몇 판이나 숨겼다. 이제 저장 성공 여부를 boolean 으로
+ * 돌려주고, 실패는 한 줄 남긴다 — 턴 자체는 유효하므로 던지지는 않는다.
+ *
+ * fingerprint 가 다르면 resume 하지 않는다 — 시스템 프롬프트가 바뀐 세션을 이어붙이면
+ * 지시가 오염된다.
  */
-function loadRuntimeSession(db, chatId, kind, fingerprint) {
+function normalizeRuntimeAgentId(agentId) {
+  return typeof agentId === "string" ? agentId.trim() : "";
+}
+
+function loadRuntimeSession(db, chatId, kind, fingerprint, agentId) {
+  const agent = normalizeRuntimeAgentId(agentId);
   try {
-    const row = db.prepare("SELECT session_id, fingerprint FROM chat_runtime_sessions WHERE chat_id=? AND kind=?").get(chatId, kind);
+    const select = db.prepare(
+      "SELECT session_id, fingerprint FROM chat_runtime_sessions WHERE chat_id=? AND kind=? AND agent_id=?",
+    );
+    let row = select.get(chatId, kind, agent);
+    // v103 이전 행은 agent_id='' 로 이관돼 있다. 정확한 키에 없으면 그 행을 승계 후보로
+    // 읽는다 — 다른 봇의 세션이면 바로 아래 지문 검증이 스스로 버린다(데스크탑과 동형).
+    if (!row && agent !== "") row = select.get(chatId, kind, "");
     if (row && row.session_id && row.fingerprint === fingerprint) return { id: row.session_id };
-  } catch { /* 테이블 부재 — resume 없이 진행 */ }
+  } catch { /* 테이블 부재(구형 DB) — resume 없이 진행 */ }
   return {};
 }
 
-function saveRuntimeSession(db, chatId, kind, session, fingerprint) {
+function saveRuntimeSession(db, chatId, kind, session, fingerprint, agentId) {
   const sessionId = session && session.id ? String(session.id) : "";
-  if (!sessionId) return;
+  if (!sessionId) return false;
+  const agent = normalizeRuntimeAgentId(agentId);
   try {
     runWriteTransaction(db, () => {
       db.prepare(
-        "INSERT INTO chat_runtime_sessions (chat_id, kind, session_id, fingerprint, updated_at) VALUES (?,?,?,?,?) " +
-        "ON CONFLICT(chat_id, kind) DO UPDATE SET session_id=excluded.session_id, fingerprint=excluded.fingerprint, updated_at=excluded.updated_at",
-      ).run(chatId, kind, sessionId, fingerprint, nowIso());
+        "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());
+      // 레거시 행을 승계했다면 이제 새 키가 정본이다 — 같은 세션을 가리키는 '' 행을
+      // 정리해 다음 점유자가 이 봇의 세션을 승계 후보로 오인하지 않게 한다.
+      if (agent !== "") {
+        db.prepare(
+          "DELETE FROM chat_runtime_sessions WHERE chat_id=? AND kind=? AND agent_id='' AND session_id=?",
+        ).run(chatId, kind, sessionId);
+      }
     });
-  } catch { /* 스키마가 다르면 resume만 포기 — 턴 자체는 유효 */ }
+    return true;
+  } catch (error) {
+    // 턴 자체는 유효하므로 던지지 않는다. 다만 조용히 지나가지도 않는다 — 이 자리의
+    // 침묵이 resume 유실을 여러 판 동안 숨겼다.
+    if (process.env.AGENTLAS_DEBUG) {
+      console.error(`[agentlas] resume session not persisted: ${error && error.message ? error.message : error}`);
+    }
+    return false;
+  }
 }
 
 module.exports = { createChat, appendMessage, retitleChat, chatHistory, loadRuntimeSession, saveRuntimeSession, newId };

package/engine/telegram/connect.cjs

@@ -55,10 +55,15 @@ async function verifyBotToken(token, opts) {
 function tokenDir() {
   const dir = path.join(userDataDir(), "telegram");
   fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+  if (process.platform !== "win32") fs.chmodSync(dir, 0o700);
   return dir;
 }
 function tokenFile(id) { return path.join(tokenDir(), `${id}.token`); }
-function saveToken(id, token) { fs.writeFileSync(tokenFile(id), token, { encoding: "utf8", mode: 0o600 }); }
+function saveToken(id, token) {
+  const file = tokenFile(id);
+  fs.writeFileSync(file, token, { encoding: "utf8", mode: 0o600 });
+  if (process.platform !== "win32") fs.chmodSync(file, 0o600);
+}
 function readToken(id) {
   try { return fs.readFileSync(tokenFile(id), "utf8").trim() || null; } catch { return null; }
 }
@@ -81,19 +86,31 @@ async function startConnection(db, targetKind, targetId, token, opts) {
   runWriteTransaction(db, () => {
     db.prepare(
       "INSERT INTO telegram_bindings (id, target_kind, target_id, bot_user_id, bot_username, bot_display_name, status, enabled, token_saved, token_fingerprint, created_at, updated_at) " +
-      "VALUES (?,?,?,?,?,?,'waiting_for_chat',1,1,?,?,?)",
+      "VALUES (?,?,?,?,?,?,'waiting_for_chat',1,0,?,?,?)",
     ).run(id, targetKind, targetId, me.id, me.username || null, me.first_name || null, tokenFingerprint(token), now, now);
   });
-  saveToken(id, token);
+  try {
+    saveToken(id, token);
+    runWriteTransaction(db, () => {
+      db.prepare("UPDATE telegram_bindings SET token_saved=1, updated_at=? WHERE id=?").run(new Date().toISOString(), id);
+    });
+  } catch (error) {
+    deleteToken(id);
+    try {
+      runWriteTransaction(db, () => db.prepare("DELETE FROM telegram_bindings WHERE id=?").run(id));
+    } catch { /* preserve the original storage failure */ }
+    throw error;
+  }
   // 남은 웹훅이 있으면 getUpdates가 막히므로 제거(있어도 무해).
   await telegramApi(token, "deleteWebhook", { drop_pending_updates: false }, opts).catch(() => null);
   return { id, botUsername: me.username || null };
 }
 
 /**
- * getUpdates 폴링으로 첫 private 메시지의 chat을 이 바인딩에 귀속한다.
- * 보안: 데스크탑과 같은 규칙 — 미페어링·enabled·waiting_for_chat 인 신선 바인딩
- * (30분 이내)에만, private 채팅만. 반환: 페어링된 바인딩 또는 null(시간초과).
+ * getUpdates 폴링으로 `/start <bindingId>`를 보낸 private chat을 이 바인딩에 귀속한다.
+ * 보안: 봇 이름을 발견한 제3자의 첫 메시지가 로컬 에이전트를 탈취하지 못하도록 정확한
+ * 페어링 토큰을 요구한다. 최종 UPDATE도 미페어링·enabled·waiting 상태를 조건으로 삼아
+ * 두 Terminal 프로세스가 같은 바인딩을 동시에 덮어쓰지 못하게 한다.
  */
 async function pairByPolling(db, id, { timeoutMs = 120_000, opts, onWait } = {}) {
   const token = readToken(id);
@@ -110,6 +127,8 @@ async function pairByPolling(db, id, { timeoutMs = 120_000, opts, onWait } = {})
       if (typeof update.update_id === "number") offset = Math.max(offset, update.update_id);
       const message = update.message;
       if (!message || !message.chat || message.chat.type !== "private") continue;
+      const pairingToken = String(message.text || "").match(/^\/start(?:@\w+)?\s+(\S+)/i)?.[1] || "";
+      if (pairingToken !== id) continue;
       // 신선 미페어링 바인딩인지 재확인(경합 방지) 후 귀속.
       const row = getBinding(db, id);
       if (!row || row.telegram_chat_id || row.status !== "waiting_for_chat") continue;
@@ -117,11 +136,13 @@ async function pairByPolling(db, id, { timeoutMs = 120_000, opts, onWait } = {})
       if (!Number.isFinite(createdAt) || Date.now() - createdAt > 30 * 60 * 1000) throw new Error("pairing window expired (30 min) — reconnect");
       const now = new Date().toISOString();
       const title = message.chat.title || [message.chat.first_name, message.chat.last_name].filter(Boolean).join(" ") || message.chat.username || String(message.chat.id);
-      runWriteTransaction(db, () => {
-        db.prepare("UPDATE telegram_bindings SET telegram_chat_id=?, telegram_chat_title=?, status='chat_paired', last_update_id=?, updated_at=? WHERE id=?")
-          .run(String(message.chat.id), title, offset, now, id);
+      const claimed = runWriteTransaction(db, () => {
+        return db.prepare(
+          "UPDATE telegram_bindings SET telegram_chat_id=?, telegram_chat_title=?, status='chat_paired', last_update_id=?, updated_at=? " +
+          "WHERE id=? AND telegram_chat_id IS NULL AND enabled=1 AND status='waiting_for_chat'",
+        ).run(String(message.chat.id), title, offset, now, id).changes === 1;
       });
-      return getBinding(db, id);
+      if (claimed) return getBinding(db, id);
     }
     if (offset) {
       runWriteTransaction(db, () => {

package/engine/ui/commands-catalog.cjs

@@ -47,6 +47,7 @@ const CATALOG = [
   { name: "help", group: "start", tier: "core", surfaces: BOTH, args: "[all|<command>]", argsKo: "[all|<명령>]", ko: "명령 보기 (all = 전체 목록)", en: "Show commands (all = the full list)" },
 
   // ── 2 work ────────────────────────────────────────────────────────────────
+  { name: "one", group: "work", tier: "core", surfaces: CLI, args: '["<prompt>"] [--list|--new]', argsKo: '["<프롬프트>"] [--list|--new]', ko: "개인 에이전트 One — 같은 One 대화를 이어감", en: "Your personal agent One — continues the same One conversation" },
   { name: "run", group: "work", tier: "core", surfaces: CLI, args: '[agent] "<task>"', argsKo: '[에이전트] "<작업>"', ko: "이 프로젝트 컨트롤러로 1회 실행", en: "Run once with this project's controller" },
   { name: "project", group: "work", tier: "core", surfaces: BOTH, args: "[status|use <agent>]", argsKo: "[status|use <에이전트>]", ko: "이 폴더를 프로젝트로 연결", en: "Connect this folder to a project" },
   { name: "storm", group: "work", tier: "core", surfaces: BOTH, args: '"<goal>"', argsKo: '"<목표>"', ko: "목표 하나를 계획→실행→검증까지", en: "Drive one goal: plan, execute, verify" },

package/engine/ui/repl.cjs

@@ -792,7 +792,9 @@ function handleSlash(ctx, cmdline, api) {
        */
       // help/agents/list/mcp/doctor 등은 위 케이스에서 이미 처리된다.
       // acp: stdout becomes the protocol wire — meaningless (and destructive) inside the REPL.
-      const REPL_EXCLUDED = new Set(["firm", "setup", "run", "acp"]);
+      // `one` 도 자기 readline 루프를 여는 대화형 명령이라 셸 안에서 중첩하지 않는다
+      // (run/firm/setup/acp 와 같은 이유). 셸에서는 `agentlas one` 을 밖에서 연다.
+      const REPL_EXCLUDED = new Set(["firm", "setup", "run", "acp", "one"]);
       if (!REPL_EXCLUDED.has(cmd) && commands.COMMANDS[cmd]) {
         const result = commands.COMMANDS[cmd]().run(ctx, rest);
         if (result && typeof result.then === "function") {

package/engine/ui/screens.cjs

@@ -11,6 +11,8 @@
  *  - 모든 화면은 ctx.out 이 아니라 ui 를 직접 받아 pi 프레임 안에 그린다.
  */
 
+const path = require("node:path");
+
 function table(ui, rows, opts = {}) {
   // rows: [[col, col, …]] — 첫 행이 헤더. 폭은 CJK 셀 폭으로 계산한다.
   const { visWidth, truncateWidth } = require("./width.cjs");
@@ -52,6 +54,28 @@ function rows(db, sql, args = []) {
 }
 const shortTs = (v) => (v ? String(v).replace("T", " ").slice(0, 16) : "");
 
+const ATTENTION_RUN_WHERE = `
+  r.id = (
+    SELECT r2.id FROM automation_runs r2
+     WHERE r2.automation_id IS r.automation_id
+     ORDER BY COALESCE(r2.started_at,'') DESC, r2.rowid DESC LIMIT 1
+  )
+  AND (
+    r.status IN ('error','partial','blocked','needs_input')
+    OR r.outcome IN ('needs_input','blocked','rejected')
+    OR (r.status = 'running' AND julianday(r.last_activity_at) < julianday('now','-15 minutes'))
+  )`;
+
+function pathContains(root, candidate) {
+  if (!root) return false;
+  try {
+    const relative = path.relative(path.resolve(String(root)), path.resolve(String(candidate)));
+    return relative === "" || (!relative.startsWith(`..${path.sep}`) && relative !== ".." && !path.isAbsolute(relative));
+  } catch {
+    return false;
+  }
+}
+
 /* ── /dashboard — 데스크탑 dashboard 의 관제 패널 집합 ── */
 function dashboard(ui, db, en) {
   const chip = (paint, s) => paint(` ${s} `);
@@ -66,11 +90,12 @@ function dashboard(ui, db, en) {
   ui.line(`  ${chip(ui.c.inverse, `${en ? "agents" : "에이전트"} ${local}`)} ${chip(ui.c.dim, `builtin ${builtin}`)} ${chip(ui.c.inverse, `${en ? "firms" : "회사"} ${firms}`)} ${chip(ui.c.dim, `${en ? "bookmarks" : "북마크"} ${marks}`)} ${chip(ui.c.dim, `${en ? "borrowed" : "대여"} ${borrowed}`)}`);
 
   // ── 확인 필요 (D1 숨은 계약 2: 없으면 실행이 조용히 멈춘 채 정상처럼 보인다) ──
-  const pending = count(db, "SELECT COUNT(*) n FROM automation_node_approvals WHERE decision NOT IN ('approved','rejected')");
+  const pending = count(db, `SELECT COUNT(*) n FROM automation_runs r WHERE ${ATTENTION_RUN_WHERE}`);
   const stalled = rows(db,
     `SELECT r.id, a.name, r.status, r.last_activity_at
        FROM automation_runs r LEFT JOIN automations a ON a.id = r.automation_id
-      WHERE r.status NOT IN ('ok','error','cancelled') ORDER BY COALESCE(r.last_activity_at,'') DESC LIMIT 5`);
+      WHERE ${ATTENTION_RUN_WHERE}
+      ORDER BY COALESCE(r.last_activity_at,'') DESC LIMIT 5`);
   ui.line("");
   ui.line(ui.c.bold(en ? "Needs attention" : "확인 필요"));
   if (!pending && !stalled.length) {
@@ -242,10 +267,10 @@ function projects(ui, db, en) {
   if (list.length) {
     table(ui, [[en ? "project" : "프로젝트", en ? "source" : "소스", en ? "chats" : "채팅", en ? "tasks" : "작업", en ? "updated" : "수정"],
       ...list.map((p) => [
-        (p.folder_path && cwd.startsWith(p.folder_path) ? "▸ " : "  ") + (p.name || p.id),
+        (pathContains(p.folder_path, cwd) ? "▸ " : "  ") + (p.name || p.id),
         p.source_type || "local", String(p.chats), String(p.tasks), shortTs(p.updated_at)])],
       { cap: [30, 10, 6, 6, 16] });
-    const here = list.find((p) => p.folder_path && cwd.startsWith(p.folder_path));
+    const here = list.find((p) => pathContains(p.folder_path, cwd));
     ui.line("");
     ui.line(here
       ? ui.c.dim(en ? `▸ this folder is connected to "${here.name}"` : `▸ 이 폴더는 "${here.name}"에 연결돼 있습니다`)
@@ -350,5 +375,4 @@ function firms(ui, db, en, ctx, arg) {
   void ctx;
 }
 
-module.exports = { dashboard, library, marketplace, settings, projects, automations, firms, table };
-
+module.exports = { dashboard, library, marketplace, settings, projects, automations, firms, table, pathContains, ATTENTION_RUN_WHERE };

package/engine/vendor/desktop-core.manifest.json

@@ -1,7 +1,7 @@
 {
-  "version": "12",
-  "url": "https://github.com/agentlas-ai/agentlas-terminal/releases/download/desktop-core-v12/desktop-core.tar.gz",
-  "sha256": "cc2ad07bd7695a9dcee4e61f7eb1f65ea86454caf79a6e449e5afb10d3ff8150",
-  "sizeBytes": 12563495,
-  "writtenAt": "2026-08-19T23:39:35.152Z"
+  "version": "15",
+  "url": "https://github.com/agentlas-ai/agentlas-terminal/releases/download/desktop-core-v15/desktop-core.tar.gz",
+  "sha256": "df39404b55ea4e6a3571e416167f64e75bcde92fdb86f19bd26e54746156f87b",
+  "sizeBytes": 18167726,
+  "writtenAt": "2026-08-29T08:38:53.468Z"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentlas",
-  "version": "1.0.60",
+  "version": "1.0.62",
   "description": "Agentlas project terminal — run project controllers and task-scoped agent teams from the terminal. Standalone: no desktop app process required.",
   "bin": {
     "agentlas": "bin/agentlas.cjs"
@@ -13,8 +13,9 @@
     "vendor:core": "node scripts/vendor-desktop-core.cjs",
     "test:tool-access-notice-parity": "node test/tool-access-notice-parity.cjs",
     "verify:engine-reachable": "node scripts/verify-engine-reachable.cjs",
-    "prepublishOnly": "npm run verify:engine-reachable && npm run verify:way-out",
-    "verify:way-out": "node scripts/verify-raised-errors-have-a-way-out.cjs"
+    "prepublishOnly": "npm run vendor:core && npm run verify:engine-reachable && npm run verify:way-out",
+    "verify:way-out": "node scripts/verify-raised-errors-have-a-way-out.cjs",
+    "verify:node-effect-parity": "node scripts/verify-node-effect-parity.cjs"
   },
   "engines": {
     "node": ">=20.19"
@@ -26,6 +27,8 @@
   "files": [
     "bin/",
     "engine/",
+    "!engine/vendor/desktop-core/",
+    "!engine/vendor/desktop-core.tar.gz",
     "install.sh",
     "install.ps1",
     "CHANGELOG.md",