agentlas 1.0.61 → 1.0.63

package/engine/commands/connect.cjs

@@ -13,6 +13,7 @@
  * 하위 명령:
  *   connect                           상태 표
  *   connect telegram <agent|firm>     이 대상에 봇을 연결(토큰 stdin) + 방 페어링
+ *   connect pair <id>                 타임아웃된 방 페어링을 다시 기다림
  *   connect test <id>                 연결된 방에 확인 메시지
  *   connect remove <id>               연결 제거(토큰 파일도 삭제)
  */
@@ -23,8 +24,8 @@ const readline = require("node:readline");
 
 function usage(ko) {
   return ko
-    ? "사용법: agentlas connect [ status | telegram <agent|firm> [--auto] | test <id> | remove <id> ]"
-    : "Usage: agentlas connect [ status | telegram <agent|firm> [--auto] | test <id> | remove <id> ]";
+    ? "사용법: agentlas connect [ status | telegram <agent|firm> [--auto] | pair <id> | test <id> | remove <id> ]"
+    : "Usage: agentlas connect [ status | telegram <agent|firm> [--auto] | pair <id> | test <id> | remove <id> ]";
 }
 
 function resolveTarget(db, token) {
@@ -111,8 +112,8 @@ async function connectTelegram(ctx, targetToken, { auto = false } = {}) {
   const botAt = started.botUsername ? "@" + started.botUsername : "(bot)";
   ctx.out(`${ctx.ui.green("✓")} ${ko ? "봇 확인됨" : "bot verified"}: ${botAt} → ${target.name}`);
   ctx.out(ko
-    ? `이제 텔레그램에서 ${botAt} 에게 아무 메시지나 보내세요 (예: /start). 방을 기다립니다…`
-    : `Now message ${botAt} on Telegram (e.g. /start). Waiting for the chat…`);
+    ? `이제 텔레그램에서 ${botAt} 에게 정확히 \`/start ${started.id}\` 를 보내세요. 방을 기다립니다…`
+    : `Now send exactly \`/start ${started.id}\` to ${botAt} on Telegram. Waiting for the chat…`);
 
   let paired;
   try {
@@ -127,8 +128,8 @@ async function connectTelegram(ctx, targetToken, { auto = false } = {}) {
 
   if (!paired) {
     ctx.out(ctx.ui.dim(ko
-      ? `방을 못 받았습니다(2분 초과). ${botAt} 에게 메시지를 보낸 뒤 다시: agentlas connect test ${started.id}`
-      : `No chat received (2 min). Message ${botAt}, then retry: agentlas connect test ${started.id}`));
+      ? `방을 못 받았습니다(2분 초과). ${botAt} 에게 \`/start ${started.id}\` 를 보낸 뒤 다시: agentlas connect pair ${started.id}`
+      : `No chat received (2 min). Send \`/start ${started.id}\` to ${botAt}, then retry: agentlas connect pair ${started.id}`));
     return 0;
   }
   ctx.out(`${ctx.ui.green("✓")} ${ko ? "방 연결됨" : "chat paired"}: ${paired.telegram_chat_title || paired.telegram_chat_id}`);
@@ -152,6 +153,33 @@ async function run(ctx, args) {
     if (!targetToken) { ctx.err(usage(ko)); return 1; }
     return connectTelegram(ctx, targetToken, { auto });
   }
+  if (sub === "pair") {
+    if (!args[1]) { ctx.err(ko ? "사용법: agentlas connect pair <id>" : "Usage: agentlas connect pair <id>"); return 1; }
+    const row = tg.getBinding(ctx.db(), args[1]);
+    if (!row) { ctx.err(ko ? "연결을 찾을 수 없습니다." : "connection not found."); return 1; }
+    if (row.telegram_chat_id) {
+      ctx.out(`${ctx.ui.green("✓")} ${ko ? "이미 방이 연결돼 있습니다" : "chat already paired"}: ${row.telegram_chat_title || row.telegram_chat_id}`);
+      return 0;
+    }
+    ctx.out(ko
+      ? `텔레그램에서 @${row.bot_username || "bot"} 에게 정확히 \`/start ${row.id}\` 를 보내세요.`
+      : `Send exactly \`/start ${row.id}\` to @${row.bot_username || "bot"} on Telegram.`);
+    try {
+      if (typeof ctx.ui.startSpinner === "function") ctx.ui.startSpinner(ko ? "방 연결 대기 중…" : "Waiting for the chat…");
+      const paired = await tg.pairByPolling(ctx.db(), row.id, { timeoutMs: 120_000 });
+      if (typeof ctx.ui.stopSpinner === "function") ctx.ui.stopSpinner();
+      if (!paired) {
+        ctx.err(ko ? "방을 못 받았습니다(2분 초과). 같은 명령으로 다시 기다릴 수 있습니다." : "No chat received (2 min). Run the same command to wait again.");
+        return 1;
+      }
+      ctx.out(`${ctx.ui.green("✓")} ${ko ? "방 연결됨" : "chat paired"}: ${paired.telegram_chat_title || paired.telegram_chat_id}`);
+      return 0;
+    } catch (e) {
+      if (typeof ctx.ui.stopSpinner === "function") ctx.ui.stopSpinner();
+      ctx.err(`${ctx.ui.red("✖")} ${String((e && e.message) || e)}`);
+      return 1;
+    }
+  }
   if (sub === "test") {
     if (!args[1]) { ctx.err(ko ? "사용법: agentlas connect test <id>" : "Usage: agentlas connect test <id>"); return 1; }
     try {

package/engine/commands/oberon.cjs

@@ -48,7 +48,7 @@ async function run(ctx, args, deps) {
       case "ls":
         return list(io);
       case "open":
-        return open(io, rest);
+        return open(io, rest, deps || {});
       case "help":
       case "--help":
       case "-h":

package/engine/commands/update.cjs

@@ -10,14 +10,35 @@
 const { compareSemVer } = require("../semver.cjs");
 const { readVersion } = require("../agentlas-banner.cjs");
 
-async function checkNpmLatest({ fetch: fetchImpl } = {}) {
+async function checkNpmLatest({ fetch: fetchImpl, timeoutMs = 8_000 } = {}) {
   const f = fetchImpl || globalThis.fetch;
   const currentVersion = readVersion();
   let latestVersion = null;
+  const controller = new AbortController();
+  const boundedTimeoutMs = Math.min(60_000, Math.max(10, Number(timeoutMs) || 8_000));
+  let timeout;
   try {
-    const resp = await f("https://registry.npmjs.org/agentlas/latest", { headers: { accept: "application/json" } });
-    if (resp.ok) latestVersion = String((await resp.json()).version || "");
-  } catch { /* offline 등 — 호출부에서 안내 */ }
+    // Bound both the connection and body parse. Some injected/custom fetch
+    // implementations ignore AbortSignal, so the explicit race is required to
+    // keep `agentlas update` from hanging the entire CLI indefinitely.
+    const request = Promise.resolve().then(async () => {
+      const resp = await f("https://registry.npmjs.org/agentlas/latest", {
+        headers: { accept: "application/json" },
+        signal: controller.signal,
+      });
+      return resp.ok ? String((await resp.json()).version || "") : null;
+    });
+    const expired = new Promise((_, reject) => {
+      timeout = setTimeout(() => {
+        const error = new Error(`npm update check timed out after ${boundedTimeoutMs}ms`);
+        error.code = "AGENTLAS_UPDATE_TIMEOUT";
+        try { controller.abort(error); } catch { controller.abort(); }
+        reject(error);
+      }, boundedTimeoutMs);
+    });
+    latestVersion = await Promise.race([request, expired]);
+  } catch { /* offline/timeout 등 — 호출부에서 안내 */ }
+  finally { if (timeout) clearTimeout(timeout); }
   const comparison = latestVersion ? compareSemVer(currentVersion, latestVersion) : null;
   return {
     currentVersion,
@@ -27,9 +48,9 @@ async function checkNpmLatest({ fetch: fetchImpl } = {}) {
   };
 }
 
-async function run(ctx, args) {
-  const json = args.includes("--json");
-  const status = await checkNpmLatest();
+async function run(ctx, args, deps = {}) {
+  const json = ctx.output?.format === "json" || args.includes("--json");
+  const status = await checkNpmLatest(deps);
   if (json) {
     ctx.out(JSON.stringify(status, null, 2));
     return 0;

package/engine/core/desktop-core-fetch.cjs

@@ -27,7 +27,17 @@ function readManifest() {
   try { return JSON.parse(fs.readFileSync(manifestPath(), "utf8")); } catch { return null; }
 }
 
-function cacheDir(version) { return path.join(userDataDir(), "desktop-core-cache", String(version)); }
+function cacheRoot() { return path.join(userDataDir(), "desktop-core-cache"); }
+function normalizedCacheVersion(version) {
+  const value = String(version ?? "").trim();
+  if (!value || value === "." || value === "..") return null;
+  return /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/.test(value) ? value : null;
+}
+function cacheDir(version) {
+  const normalized = normalizedCacheVersion(version);
+  if (!normalized) throw new TypeError("Desktop core manifest has an unsafe cache version");
+  return path.join(cacheRoot(), normalized);
+}
 function cacheDistDir(version) { return path.join(cacheDir(version), "dist"); }
 
 function sha256File(file) {
@@ -38,13 +48,48 @@ function sha256File(file) {
 
 /** 이미 캐시에 온전히 풀려 있으면 그 dist 경로, 아니면 null. */
 function cachedCoreRoot(manifest = readManifest()) {
-  if (!manifest) return null;
-  const dist = cacheDistDir(manifest.version);
-  const marker = path.join(cacheDir(manifest.version), ".complete");
-  if (fs.existsSync(marker) && fs.existsSync(path.join(dist, "electron", "workflow", "run-graph.js"))) return dist;
+  const version = normalizedCacheVersion(manifest?.version);
+  if (!version || !manifest?.sha256) return null;
+  const dist = cacheDistDir(version);
+  const marker = path.join(cacheDir(version), ".complete");
+  if (!fs.existsSync(path.join(dist, "electron", "workflow", "run-graph.js"))) return null;
+  try {
+    const completed = JSON.parse(fs.readFileSync(marker, "utf8"));
+    if (
+      completed?.schemaVersion === 2
+      && String(completed.version) === version
+      && completed.sha256 === manifest.sha256
+    ) return dist;
+  } catch {
+    // Timestamp-only and malformed markers predate the content-bound cache
+    // contract. They must be refreshed instead of trusted as executable code.
+  }
   return null;
 }
 
+/**
+ * Remove only cache entries that are recognizably old engine downloads.
+ * Unknown files under the dedicated root are preserved: cleanup must never
+ * widen from a versioned engine cache into arbitrary user data.
+ */
+function pruneStaleCaches(keepVersion) {
+  const root = cacheRoot();
+  let removed = 0;
+  let entries = [];
+  try { entries = fs.readdirSync(root, { withFileTypes: true }); } catch { return removed; }
+  for (const entry of entries) {
+    if (!entry.isDirectory() || entry.name === String(keepVersion) || entry.name.includes(".partial-")) continue;
+    const dir = path.join(root, entry.name);
+    const recognizable = fs.existsSync(path.join(dir, ".complete"))
+      || fs.existsSync(path.join(dir, "desktop-core.tar.gz"))
+      || fs.existsSync(path.join(dir, "dist", "electron", "workflow", "run-graph.js"));
+    if (!recognizable) continue;
+    fs.rmSync(dir, { recursive: true, force: true });
+    removed += 1;
+  }
+  return removed;
+}
+
 /**
  * 매니페스트가 가리키는 데스크탑 코어를 내려받아 캐시에 푼다.
  * onNotice(text): 사용자에게 보여줄 안내(무엇을·왜 받는지) — 조용히 받지 않는다.
@@ -52,47 +97,75 @@ function cachedCoreRoot(manifest = readManifest()) {
  */
 async function fetchDesktopCore({ onNotice } = {}) {
   const manifest = readManifest();
-  if (!manifest || !manifest.url || !manifest.sha256) return null;
+  const version = normalizedCacheVersion(manifest?.version);
+  if (!manifest || !version || !manifest.url || !manifest.sha256) return null;
 
-  const existing = cachedCoreRoot(manifest);
+  const existing = cachedCoreRoot({ ...manifest, version });
   if (existing) return existing;
 
   const say = (t) => { if (typeof onNotice === "function") onNotice(t); };
   say(`Downloading the graph-execution engine (${manifest.sizeBytes ? Math.round(manifest.sizeBytes / 1024 / 1024) + " MB" : "one-time"}) from ${manifest.url} …`);
 
-  const dir = cacheDir(manifest.version);
-  fs.rmSync(dir, { recursive: true, force: true });
-  fs.mkdirSync(dir, { recursive: true });
-  const tarPath = path.join(dir, "desktop-core.tar.gz");
+  const dir = cacheDir(version);
+  const partialDir = path.join(
+    cacheRoot(),
+    `${version}.partial-${process.pid}-${crypto.randomBytes(6).toString("hex")}`,
+  );
+  fs.mkdirSync(partialDir, { recursive: true });
+  const tarPath = path.join(partialDir, "desktop-core.tar.gz");
 
-  const res = await fetch(manifest.url);
-  if (!res.ok) { say(`Download failed: HTTP ${res.status}`); return null; }
+  let res;
+  try {
+    res = await fetch(manifest.url);
+  } catch (error) {
+    say(`Download failed: ${error?.message || error}`);
+    fs.rmSync(partialDir, { recursive: true, force: true });
+    return null;
+  }
+  if (!res.ok) {
+    say(`Download failed: HTTP ${res.status}`);
+    fs.rmSync(partialDir, { recursive: true, force: true });
+    return null;
+  }
   const buf = Buffer.from(await res.arrayBuffer());
   fs.writeFileSync(tarPath, buf);
 
   const digest = sha256File(tarPath);
   if (digest !== manifest.sha256) {
     say(`Checksum mismatch (expected ${manifest.sha256.slice(0, 12)}…, got ${digest.slice(0, 12)}…) — refusing to use it.`);
-    fs.rmSync(dir, { recursive: true, force: true });
+    fs.rmSync(partialDir, { recursive: true, force: true });
+    return null;
+  }
+  if (Number.isFinite(Number(manifest.sizeBytes)) && Number(manifest.sizeBytes) !== buf.length) {
+    say(`Size mismatch (expected ${manifest.sizeBytes} bytes, got ${buf.length}) — refusing to use it.`);
+    fs.rmSync(partialDir, { recursive: true, force: true });
     return null;
   }
 
-  const extract = spawnSync("tar", ["-xzf", tarPath, "-C", dir], { encoding: "utf8" });
+  const extract = spawnSync("tar", ["-xzf", tarPath, "-C", partialDir], { encoding: "utf8" });
   if (extract.status !== 0) {
     say(`Extraction failed: ${extract.stderr || extract.error || "unknown error"}`);
-    fs.rmSync(dir, { recursive: true, force: true });
+    fs.rmSync(partialDir, { recursive: true, force: true });
     return null;
   }
   fs.rmSync(tarPath);
 
-  if (!fs.existsSync(path.join(cacheDistDir(manifest.version), "electron", "workflow", "run-graph.js"))) {
+  if (!fs.existsSync(path.join(partialDir, "dist", "electron", "workflow", "run-graph.js"))) {
     say("Downloaded archive did not contain the expected engine files.");
-    fs.rmSync(dir, { recursive: true, force: true });
+    fs.rmSync(partialDir, { recursive: true, force: true });
     return null;
   }
-  fs.writeFileSync(path.join(dir, ".complete"), new Date().toISOString());
+  fs.writeFileSync(path.join(partialDir, ".complete"), JSON.stringify({
+    schemaVersion: 2,
+    version,
+    sha256: manifest.sha256,
+    completedAt: new Date().toISOString(),
+  }) + "\n");
+  fs.rmSync(dir, { recursive: true, force: true });
+  fs.renameSync(partialDir, dir);
+  pruneStaleCaches(version);
   say("Engine ready.");
-  return cacheDistDir(manifest.version);
+  return cacheDistDir(version);
 }
 
-module.exports = { readManifest, cachedCoreRoot, fetchDesktopCore, cacheDistDir };
+module.exports = { readManifest, cachedCoreRoot, fetchDesktopCore, cacheDistDir, pruneStaleCaches };

package/engine/hephaestus/local-core.cjs

@@ -30,7 +30,10 @@ function localCoreBin() {
   if (process.platform === "win32") return null;
   for (const candidate of candidates) {
     try {
-      if (candidate && fs.existsSync(candidate)) return candidate;
+      if (!candidate) continue;
+      const stat = fs.statSync(candidate);
+      fs.accessSync(candidate, fs.constants.X_OK);
+      if (stat.isFile()) return candidate;
     } catch { /* keep looking */ }
   }
   return null;
@@ -69,12 +72,25 @@ function createLocalCoreClient({ cwd, timeoutMs = 60_000 } = {}) {
   const pending = new Map();
   let exited = false;
 
-  child.on("exit", () => {
+  const failPending = (code, message) => {
+    if (exited) return;
     exited = true;
     for (const [, entry] of pending) {
-      entry.reject(coreError("local_core_exited", "the local core process exited before responding"));
+      entry.reject(coreError(code, message));
     }
     pending.clear();
+  };
+  child.once("error", (error) => {
+    failPending("local_core_spawn_failed", `the local core process could not start: ${(error && error.message) || error}`);
+  });
+  child.on("exit", () => {
+    failPending("local_core_exited", "the local core process exited before responding");
+  });
+  // Always drain stderr. Leaving the pipe unread lets a verbose Core fill the
+  // kernel buffer and deadlock an otherwise healthy tools/call.
+  child.stderr.on("data", () => {});
+  child.stdin.on("error", (error) => {
+    failPending("local_core_transport_error", `the local core input stream failed: ${(error && error.message) || error}`);
   });
   child.stdout.on("data", (chunk) => {
     buffer += chunk;
@@ -104,16 +120,35 @@ function createLocalCoreClient({ cwd, timeoutMs = 60_000 } = {}) {
       resolve: (message) => { clearTimeout(timer); resolve(message); },
       reject: (error) => { clearTimeout(timer); reject(error); },
     });
-    child.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", id, method, params })}\n`);
+    try {
+      child.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", id, method, params })}\n`, (error) => {
+        if (!error) return;
+        const entry = pending.get(id);
+        if (!entry) return;
+        pending.delete(id);
+        entry.reject(coreError("local_core_transport_error", `${method} could not be written to the local core: ${error.message}`));
+      });
+    } catch (error) {
+      const entry = pending.get(id);
+      pending.delete(id);
+      if (entry) entry.reject(coreError("local_core_transport_error", `${method} could not be written to the local core: ${error.message}`));
+    }
   });
 
   async function ensureInitialized() {
     if (!initialized) {
-      initialized = rpc("initialize", {
-        protocolVersion: "2024-11-05",
-        capabilities: {},
-        clientInfo: { name: "agentlas-terminal", version: "2" },
-      });
+      initialized = (async () => {
+        const response = await rpc("initialize", {
+          protocolVersion: "2024-11-05",
+          capabilities: {},
+          clientInfo: { name: "agentlas-terminal", version: "2" },
+        });
+        if (response.error) {
+          throw coreError("local_core_initialize_failed", `initialize: ${response.error.message || JSON.stringify(response.error)}`);
+        }
+        child.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", method: "notifications/initialized", params: {} })}\n`);
+        return response;
+      })();
     }
     return initialized;
   }

package/engine/memory-cli/curate.cjs

@@ -141,9 +141,12 @@ function curateCliReply(db, text, ctx) {
     if (scope === "discard" || scope === "session") { logCli(ctx.projectPath, { action: scope, kind, content, at: now }); continue; }
     if (scope === "project" && !ctx.projectPath) scope = "team_memory";
     const ppath = scope === "project" ? ctx.projectPath : null;
+    // Same ownership rule as agentlas-memory-governance: team is shared
+    // (NULL owner), while an agent_repo memory belongs to the exact agent.
+    const scopedAgentId = scope === "agent_repo" ? (ctx.agentId || null) : null;
     const requestContext = normalizeRequestContext(ev, ctx, ppath);
     try {
-      const dup = db.prepare("SELECT id,scope,kind,content,confidence,sensitivity,context_json FROM memory_entries WHERE scope=? AND kind=? AND lower(trim(content))=? AND superseded_at IS NULL AND (project_path IS ? OR project_path=?) LIMIT 1").get(scope, kind, content.toLowerCase(), ppath, ppath);
+      const dup = db.prepare("SELECT id,scope,kind,content,confidence,sensitivity,context_json FROM memory_entries WHERE scope=? AND kind=? AND lower(trim(content))=? AND superseded_at IS NULL AND (project_path IS ? OR project_path=?) AND (agent_id IS ? OR agent_id=?) LIMIT 1").get(scope, kind, content.toLowerCase(), ppath, ppath, scopedAgentId, scopedAgentId);
       if (dup) {
         rememberCurated({ ...dup, requestContext });
         continue;
@@ -151,7 +154,7 @@ function curateCliReply(db, text, ctx) {
       const memoryId = randomUUID();
       const confidence = ev.confidence || "medium";
       const sensitivity = ev.sensitivity || "internal";
-      db.prepare("INSERT INTO memory_entries (id,scope,kind,content,project_id,project_path,agent_id,chat_id,confidence,sensitivity,evidence_json,context_json,superseded_at,created_at) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,NULL,?)").run(memoryId, scope, kind, content, ctx.projectId || null, ppath, ctx.agentId || null, null, confidence, sensitivity, JSON.stringify(Array.isArray(ev.evidence_refs) ? ev.evidence_refs : []), JSON.stringify(requestContext), now);
+      db.prepare("INSERT INTO memory_entries (id,scope,kind,content,project_id,project_path,agent_id,chat_id,confidence,sensitivity,evidence_json,context_json,superseded_at,created_at) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,NULL,?)").run(memoryId, scope, kind, content, ctx.projectId || null, ppath, scopedAgentId, null, confidence, sensitivity, JSON.stringify(Array.isArray(ev.evidence_refs) ? ev.evidence_refs : []), JSON.stringify(requestContext), now);
       rememberCurated({ id: memoryId, scope, kind, content, confidence, sensitivity, requestContext });
       logCli(ctx.projectPath, { action: "written", scope, kind, content, request_context: requestContext, at: now });
     } catch { /* ignore */ }

package/engine/oberon/outputs.cjs

@@ -6,7 +6,7 @@
  */
 const fs = require("node:fs");
 const path = require("node:path");
-const { spawn } = require("node:child_process");
+const { spawnSync } = require("node:child_process");
 const { userDataDir } = require("../core/paths.cjs");
 const { fail } = require("./common.cjs");
 
@@ -58,11 +58,18 @@ function list(io) {
 }
 
 // `oberon open [path]` — 산출물 폴더를 OS 파일 매니저로 연다.
-function open(io, args) {
+function open(io, args, options = {}) {
   const target = args[0] ? path.resolve(args[0]) : oberonHome();
   if (!fs.existsSync(target)) fail(`Path not found: ${target}`);
   const opener = process.platform === "darwin" ? "open" : process.platform === "win32" ? "explorer" : "xdg-open";
-  spawn(opener, [target], { detached: true, stdio: "ignore" }).unref();
+  // `spawn(...).unref()` reported success before the OS opener had even spawned;
+  // a missing xdg-open/explorer then emitted an unhandled error and crashed the CLI
+  // after printing "Opening". The opener command is short-lived, so wait for its
+  // launch result and only claim success on exit 0.
+  const launch = options.spawnSyncImpl || spawnSync;
+  const result = launch(opener, [target], { stdio: "ignore", windowsHide: true });
+  if (result && result.error) fail(`Could not open ${target}: ${result.error.message}`);
+  if (!result || result.status !== 0) fail(`Could not open ${target} (opener exit ${result && result.status != null ? result.status : "unknown"})`);
   io.out(`Opening folder: ${target}`);
   return 0;
 }

package/engine/project/career-graph.cjs

@@ -209,8 +209,10 @@ async function runCareerGraphCli(args, opts) {
   }
   const paths = ensureCareerGraphCli(projectPath, opts.lang);
   if (sub === "open") {
-    if (!opts.noOpen) openLocalPathCli(paths.inboxPath, opts.notify);
-    return [`${ko ? "커리어 그래프 수신함을 열었습니다" : "Opened Career Graph inbox"}: ${paths.inboxPath}`];
+    const opened = opts.noOpen ? true : openLocalPathCli(paths.inboxPath, opts.notify);
+    return [`${opened
+      ? (ko ? "커리어 그래프 수신함을 열었습니다" : "Opened Career Graph inbox")
+      : (ko ? "커리어 그래프 수신함을 자동으로 열지 못했습니다. 직접 여세요" : "Could not open Career Graph inbox automatically; open it manually")}: ${paths.inboxPath}`];
   }
   if (sub === "add") {
     const flags = parseFlagsCli(normalizedArgs.slice(1));

package/engine/project/memory-context.cjs

@@ -185,19 +185,21 @@ function cliMemoryContext(db, projectPath, agentId = null, task = "") {
             WHERE superseded_at IS NULL AND (
               (scope='user_identity' AND project_path IS NULL)
               OR (scope='project' AND project_path=?)
-              OR (scope IN ('team_memory','agent_team','agent_repo') AND agent_id=? AND (project_path IS NULL OR project_path=?))
+              OR (scope IN ('team_memory','agent_team') AND (agent_id IS NULL OR agent_id=?) AND (project_path IS NULL OR project_path=?))
+              OR (scope='agent_repo' AND agent_id=? AND (project_path IS NULL OR project_path=?))
             )
             ORDER BY created_at DESC LIMIT 16
-          `).all(projectPath, agentId, projectPath)
+          `).all(projectPath, agentId, projectPath, agentId, projectPath)
         : db.prepare(`
             SELECT id,kind,content,confidence,context_json,created_at
             FROM memory_entries
             WHERE superseded_at IS NULL AND (
               (scope='user_identity' AND project_path IS NULL)
-              OR (scope IN ('team_memory','agent_team','agent_repo') AND agent_id=? AND project_path IS NULL)
+              OR (scope IN ('team_memory','agent_team') AND (agent_id IS NULL OR agent_id=?) AND project_path IS NULL)
+              OR (scope='agent_repo' AND agent_id=? AND project_path IS NULL)
             )
             ORDER BY created_at DESC LIMIT 16
-          `).all(agentId);
+          `).all(agentId, agentId);
       // R21 W2d — confidence was stored (governance normalizeConfidence) but
       // never reached retrieval: no ranking function existed and the render
       // dropped the column, so a one-off guess and a high-confidence procedure
@@ -268,9 +270,10 @@ function curateCliReply(db, text, ctx) {
     if (scope === "discard" || scope === "session") { logCli(ctx.projectPath, { action: scope, kind, content, at: now }); continue; }
     if (scope === "project" && !ctx.projectPath) scope = "team_memory";
     const ppath = scope === "project" ? ctx.projectPath : null;
+    const scopedAgentId = scope === "agent_repo" ? (ctx.agentId || null) : null;
     const requestContext = normalizeRequestContext(ev, ctx, ppath);
     try {
-      const dup = db.prepare("SELECT id,scope,kind,content,confidence,sensitivity,context_json FROM memory_entries WHERE scope=? AND kind=? AND lower(trim(content))=? AND superseded_at IS NULL AND (project_path IS ? OR project_path=?) LIMIT 1").get(scope, kind, content.toLowerCase(), ppath, ppath);
+      const dup = db.prepare("SELECT id,scope,kind,content,confidence,sensitivity,context_json FROM memory_entries WHERE scope=? AND kind=? AND lower(trim(content))=? AND superseded_at IS NULL AND (project_path IS ? OR project_path=?) AND (agent_id IS ? OR agent_id=?) LIMIT 1").get(scope, kind, content.toLowerCase(), ppath, ppath, scopedAgentId, scopedAgentId);
       if (dup) {
         rememberCurated({ ...dup, requestContext });
         continue;
@@ -278,7 +281,7 @@ function curateCliReply(db, text, ctx) {
       const memoryId = randomUUID();
       const confidence = ev.confidence || "medium";
       const sensitivity = ev.sensitivity || "internal";
-      db.prepare("INSERT INTO memory_entries (id,scope,kind,content,project_id,project_path,agent_id,chat_id,confidence,sensitivity,evidence_json,context_json,superseded_at,created_at) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,NULL,?)").run(memoryId, scope, kind, content, ctx.projectId || null, ppath, ctx.agentId || null, null, confidence, sensitivity, JSON.stringify(Array.isArray(ev.evidence_refs) ? ev.evidence_refs : []), JSON.stringify(requestContext), now);
+      db.prepare("INSERT INTO memory_entries (id,scope,kind,content,project_id,project_path,agent_id,chat_id,confidence,sensitivity,evidence_json,context_json,superseded_at,created_at) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,NULL,?)").run(memoryId, scope, kind, content, ctx.projectId || null, ppath, scopedAgentId, null, confidence, sensitivity, JSON.stringify(Array.isArray(ev.evidence_refs) ? ev.evidence_refs : []), JSON.stringify(requestContext), now);
       rememberCurated({ id: memoryId, scope, kind, content, confidence, sensitivity, requestContext });
       logCli(ctx.projectPath, { action: "written", scope, kind, content, request_context: requestContext, at: now });
     } catch { /* ignore */ }

package/engine/project/ontology.cjs

@@ -11,9 +11,10 @@
  *    manifest/inbox를 만든다 — 초기화되지 않았으면 던진다.
  */
 const fs = require("node:fs");
+const crypto = require("node:crypto");
 const os = require("node:os");
 const path = require("node:path");
-const { spawn } = require("node:child_process");
+const { spawnSync } = require("node:child_process");
 const { loadArch } = require("../core/db.cjs");
 const { initializedAgentlasProjectPathCli } = require("./state.cjs");
 
@@ -64,7 +65,7 @@ function readJsonSafeCli(filePath, fallback) {
 }
 
 function writeJsonSafeCli(filePath, value) {
-  fs.writeFileSync(filePath, JSON.stringify(value, null, 2) + "\n", "utf8");
+  return writeJsonPrivateAtomicCli(filePath, value);
 }
 
 // 원자적(temp+rename) + 소유자 전용(0600) JSON 쓰기. 세션 ID/경로 등 민감 상태 파일용:
@@ -72,8 +73,12 @@ function writeJsonSafeCli(filePath, value) {
 // (2) 기본 umask(0644)로 cli-sessions.json/agent-routes.json이 world-readable이던 정보 노출을 함께 막는다.
 function writeJsonPrivateAtomicCli(filePath, value) {
   const dir = path.dirname(filePath);
-  const tmp = path.join(dir, `.${path.basename(filePath)}.${process.pid}.tmp`);
-  fs.writeFileSync(tmp, JSON.stringify(value, null, 2) + "\n", { encoding: "utf8", mode: 0o600 });
+  const tmp = path.join(dir, `.${path.basename(filePath)}.${process.pid}.${crypto.randomUUID()}.tmp`);
+  fs.writeFileSync(tmp, JSON.stringify(value, null, 2) + "\n", {
+    encoding: "utf8",
+    mode: 0o600,
+    flag: "wx",
+  });
   try {
     fs.renameSync(tmp, filePath);
   } catch (e) {
@@ -415,9 +420,12 @@ function registerOntologySourceCli(paths, source, kind, scope, cwd, lang) {
 function openLocalPathCli(targetPath, notify) {
   const command = process.platform === "darwin" ? "open" : process.platform === "win32" ? "explorer.exe" : "xdg-open";
   try {
-    spawn(command, [targetPath], { detached: true, stdio: "ignore" }).unref();
+    const result = spawnSync(command, [targetPath], { stdio: "ignore", windowsHide: true });
+    if (result.error || result.status !== 0) throw result.error || new Error(`${command} exited ${result.status}`);
+    return true;
   } catch {
     if (typeof notify === "function") notify(`Open manually: ${targetPath}`);
+    return false;
   }
 }
 
@@ -450,8 +458,10 @@ async function runOntologyCli(args, opts) {
   }
   const paths = ensureOntologyCli(projectPath, opts.lang);
   if (sub === "open") {
-    if (!opts.noOpen) openLocalPathCli(paths.inboxPath, opts.notify);
-    return [`${ko ? "온톨로지 수신함을 열었습니다" : "Opened ontology inbox"}: ${paths.inboxPath}`];
+    const opened = opts.noOpen ? true : openLocalPathCli(paths.inboxPath, opts.notify);
+    return [`${opened
+      ? (ko ? "온톨로지 수신함을 열었습니다" : "Opened ontology inbox")
+      : (ko ? "온톨로지 수신함을 자동으로 열지 못했습니다. 직접 여세요" : "Could not open ontology inbox automatically; open it manually")}: ${paths.inboxPath}`];
   }
   if (sub === "add") {
     const flags = parseFlagsCli(normalizedArgs.slice(1));

package/engine/runtimes/acp-driver.cjs

@@ -10,6 +10,7 @@
  * 조용히 다른 런타임으로 넘어가지 않는다.
  */
 const { loadCoreAcpRuntime } = require("../core/desktop-core.cjs");
+const permissions = require("../agentlas-permissions.cjs");
 
 // 정본(runtimes/kinds.cjs)의 ACP 3종에서 파생 — resolve.cjs의 ACP_CLI_KINDS와 같은 원소.
 const ACP_KINDS = new Set(require("./kinds.cjs").ACP_CLI_KINDS);
@@ -47,6 +48,28 @@ async function runAcpTurn(req) {
     return { text: "", session: req.session || {}, error: `runtime '${kind}' is not an ACP agent in this core`, errorKind: "unsupported", errorSource: "marker" };
   }
   const runner = mod.createAcpRunner(spec);
+  let mcpConfigPath;
+  try {
+    // ACP runner consumes the same Claude-compatible MCP config shape as Desktop.
+    // Reuse native-host's content-addressed, credential-isolating materializer so
+    // Cursor/Grok/Kimi receive exactly the already-consented Terminal allowlist.
+    const nativeHost = require("../agentlas-native-host.cjs");
+    const allowedMcpServers = permissions.normalize(req.permission) === "full"
+      ? (req.mcpServers || [])
+      : [];
+    mcpConfigPath = nativeHost.cliMcpConfigPath(allowedMcpServers, {
+      exactAllowlist: req.mcpAllowlistMode === "exact",
+      env: req.env || process.env,
+    }).file;
+  } catch (error) {
+    return {
+      text: "",
+      session: req.session || {},
+      error: `ACP MCP configuration failed: ${error && error.message ? error.message : error}`,
+      errorKind: "configuration",
+      errorSource: "marker",
+    };
+  }
   const locale = req.locale === "ko" ? "ko" : "en";
   let streaming = false;
   let lastText = "";
@@ -69,7 +92,12 @@ async function runAcpTurn(req) {
   try {
     const result = await runner({
       systemPrompt: req.systemPrompt || "",
-      history: [],
+      history: Array.isArray(req.history)
+        ? req.history.map((entry) => ({
+          role: entry && entry.role === "assistant" ? "assistant" : "user",
+          text: String((entry && (entry.text ?? entry.content)) || ""),
+        }))
+        : [],
       userPrompt: req.prompt || "",
       backendLabel: spec.label,
       locale,
@@ -78,10 +106,20 @@ async function runAcpTurn(req) {
       cwd: req.cwd,
       env: req.env || process.env,
       signal: req.signal,
+      mcpConfigPath,
+      runtimeSessionId: (req.session && (req.session.id || req.session.acpSessionId)) || undefined,
+      chatId: req.chatId,
+      approvalChatId: req.chatId,
+      agentId: req.agentId,
+      sessionFingerprintSeed: req.sessionFingerprintSeed,
+      unattended: req.unattended === true,
       ...(req.model ? { model: req.model } : {}),
     }, events);
     if (streaming) ui.streamEnd();
-    const session = { ...(req.session || {}), ...(result.sessionId ? { acpSessionId: result.sessionId } : {}) };
+    const session = {
+      ...(req.session || {}),
+      ...(result.sessionId ? { id: result.sessionId, acpSessionId: result.sessionId } : {}),
+    };
     if (result.failure) {
       return { text: result.text || "", session, usage: null, error: result.failure.message, errorKind: result.failure.kind, errorSource: result.failure.source };
     }
@@ -89,7 +127,8 @@ async function runAcpTurn(req) {
   } catch (e) {
     if (streaming) ui.streamEnd();
     const message = e && e.message ? e.message : String(e);
-    return { text: "", session: req.session || {}, usage: null, error: message, errorKind: /abort/i.test(message) ? "cancelled" : "exit", errorSource: "marker" };
+    const detail = process.env.AGENTLAS_DEBUG && e && e.stack ? e.stack : message;
+    return { text: "", session: req.session || {}, usage: null, error: detail, errorKind: /abort/i.test(message) ? "cancelled" : "exit", errorSource: "marker" };
   }
 }