agentlas 1.0.60 → 1.0.62

package/engine/commands/plugin.cjs

@@ -11,7 +11,11 @@ const {
   planPluginMcpInstall,
   installPluginMcpRows,
   listHubPlugins,
+  planPluginSkillInstall,
+  installPluginSkills,
+  listInstalledLocalPlugins,
 } = require("../hub/plugins.cjs");
+const { webBaseUrl } = require("../cloud/hub-client.cjs");
 const { terminalProjectCandidateCli, initializedAgentlasProjectPathCli } = require("../project/state.cjs");
 
 async function pluginAdd(ctx, slug) {
@@ -31,43 +35,80 @@ async function pluginAdd(ctx, slug) {
     return 1;
   }
   const { rows, refused } = planPluginMcpInstall(slug, manifest);
+  // 스킬 번들 절반 — 실콘텐츠(files[])가 실린 스킬은 ~/.agentlas/plugins/<slug>/ 에
+  // 파일로 착지한다(오너 결정 2026-08-20: 플러그인 = MCP와 별개의 능력 패키지).
+  const skillPlan = planPluginSkillInstall(slug, manifest);
   const docsLink = manifest.docs || manifest.source?.repo || manifest.source?.homepage || null;
-  if (!rows.length) {
-    const reasonLines = refused.map((item) => `  ✗ ${item.name}: ${item.reason}${item.source ? ` (${item.source})` : ""}`);
+  if (!rows.length && !skillPlan.skills.length) {
+    const reasonLines = [
+      ...refused.map((item) => `  ✗ ${item.name}: ${item.reason}${item.source ? ` (${item.source})` : ""}`),
+      ...skillPlan.refused.map((item) => `  ✗ skill ${item.name}: ${item.reason}`),
+      ...(skillPlan.declaredOnly.length
+        ? [`  ✗ skills declared without content payloads: ${skillPlan.declaredOnly.join(", ")}`]
+        : []),
+    ];
     ctx.err(
       [
-        `${slug} ships no machine-connectable MCP endpoint yet. Nothing was registered.`,
+        `${slug} ships no machine-connectable MCP endpoint and no installable skill payload. Nothing was installed.`,
         ...reasonLines,
         docsLink ? `  docs: ${docsLink} (upstream project page — not an MCP endpoint)` : null,
-        "  When the catalog gains verified connection info for this plugin, re-run: agentlas plugin add " + slug,
+        "  When the catalog gains verified connection info or skill payloads for this plugin, re-run: agentlas plugin add " + slug,
       ].filter(Boolean).join("\n"),
     );
     return 1;
   }
-  let installed, reused, needsApproval;
-  try {
-    ({ installed, reused, needsApproval } = installPluginMcpRows(ctx.db(), rows));
-  } catch (e) {
-    ctx.err(String((e && e.message) || e));
-    return 1;
+  let installed = 0, reused = 0, needsApproval = [];
+  if (rows.length) {
+    try {
+      ({ installed, reused, needsApproval } = installPluginMcpRows(ctx.db(), rows));
+    } catch (e) {
+      ctx.err(String((e && e.message) || e));
+      return 1;
+    }
+  }
+  let skillResult = null;
+  if (skillPlan.skills.length) {
+    skillResult = installPluginSkills(slug, skillPlan, {
+      manifestUrl: `${webBaseUrl()}/api/plugins/${encodeURIComponent(slug)}`,
+      meta: { name: manifest.name, family: manifest.family, version: manifest.version },
+    });
+    if (!skillResult.installed.length && !rows.length) {
+      // 스킬만 실린 매니페스트인데 하나도 못 썼다 — 조용한 성공 금지.
+      for (const item of skillResult.failed) ctx.err(`  ✗ skill ${item.name}: ${item.reason}`);
+      ctx.err(`${slug}: no skill could be installed.`);
+      return 1;
+    }
   }
   ctx.out(`${ctx.ui.green("✓")} Plugin installed ${ctx.ui.accent(manifest.slug)} — ${manifest.name}`);
   for (const item of refused) {
     ctx.out(`  ⚠ skipped ${item.name}: ${item.reason}${item.source ? ` (${item.source})` : ""}`);
   }
-  ctx.out(`  MCP servers: ${installed} added${reused ? `, ${reused} already present` : ""}`);
-  // 데스크탑 hub-plugin-bridge.ts:219-227 동형: stdio는 비활성 등록 + 승인 필요 표면화.
+  if (rows.length) {
+    ctx.out(`  MCP servers: ${installed} added${reused ? `, ${reused} already present` : ""}`);
+  }
+  // 데스크탑 hub-plugin-bridge.ts 동형: stdio는 비활성 등록 + 승인 필요 표면화.
   for (const name of needsApproval || []) {
     ctx.out(`  ⚠ needs-approval ${name}: local execution requires one-click approval in MCP settings`);
   }
+  if (skillResult) {
+    ctx.out(`  skills installed: ${skillResult.installed.join(", ")} → ${skillResult.dir}`);
+    if (!skillResult.verified) {
+      ctx.out(ctx.ui.dim("  (no content hash declared — manifest URL recorded as provenance)"));
+    }
+    for (const item of skillResult.failed) {
+      ctx.out(`  ⚠ skipped skill ${item.name}: ${item.reason}`);
+    }
+  }
+  if (skillPlan.declaredOnly.length) {
+    ctx.out(`  skills declared (no payload yet): ${skillPlan.declaredOnly.join(", ")}`);
+  }
   const authKind = manifest.auth?.kind;
   if (authKind && authKind !== "none") {
     ctx.out(`  ⚠ Requires ${authKind} — set credentials before use (agentlas creds).`);
   }
-  if (Array.isArray(manifest.skills) && manifest.skills.length) {
-    ctx.out(`  skills declared: ${manifest.skills.map((skill) => skill.name).filter(Boolean).join(", ")}`);
+  if (rows.length) {
+    ctx.out(ctx.ui.dim("  Only full-access turns wire active stdio servers into the runtime (agentlas mcp)."));
   }
-  ctx.out(ctx.ui.dim("  Only full-access turns wire active stdio servers into the runtime (agentlas mcp)."));
   return 0;
 }
 
@@ -83,8 +124,12 @@ async function pluginList(ctx) {
     ctx.out("No Hub plugins are available.");
     return 0;
   }
+  // 설치 여부는 ~/.agentlas/plugins/<slug>/plugin.json 마커(3채널 공유 규약)로 판정한다.
+  const installedSlugs = new Set(listInstalledLocalPlugins().map((entry) => entry.slug.toLowerCase()));
   for (const plugin of plugins.slice(0, 60)) {
-    ctx.out(`${ctx.ui.accent(String(plugin.slug || "").padEnd(32).slice(0, 32))} ${String(plugin.name || "").slice(0, 44)}`);
+    const slugText = String(plugin.slug || "");
+    const installedMark = installedSlugs.has(slugText.toLowerCase()) ? ctx.ui.green(" [installed]") : "";
+    ctx.out(`${ctx.ui.accent(slugText.padEnd(32).slice(0, 32))} ${String(plugin.name || "").slice(0, 44)}${installedMark}`);
   }
   ctx.out("");
   ctx.out(ctx.ui.dim("Install: agentlas plugin add <slug>"));

package/engine/commands/uninstall.cjs

@@ -9,6 +9,26 @@ const { findAgent } = require("../agents/registry.cjs");
 const { routesMap, saveRoutes } = require("../agents/routes.cjs");
 const { runWriteTransaction } = require("../agentlas-sqlite-policy.cjs");
 
+/**
+ * 이 DB 에서 에이전트를 지우면 그 대화도 함께 사라지는가.
+ *
+ * `chats.agent_id` 의 삭제 동작이 답이다. 좌석-세션 이전 스키마는 `CASCADE`(대화도 삭제),
+ * 이후는 `SET NULL`(자리만 비고 대화는 보존). 이 CLI 는 데스크탑과 같은 파일을 쓰고 그
+ * 파일의 사다리 위치는 기기마다 다르므로, 스키마 번호나 코드가 쓰인 시점이 아니라
+ * **열려 있는 파일**에 물어야 한다.
+ */
+function chatDeletionCascadesFromAgent(db) {
+  try {
+    const rows = db.prepare("SELECT \"table\" AS parent, \"from\" AS child, \"on_delete\" AS onDelete FROM pragma_foreign_key_list('chats')").all();
+    const link = rows.find((row) => row.child === "agent_id" && row.parent === "installed_agents");
+    // 관계가 없으면 지워도 대화가 따라가지 않는다 — 파괴를 예고하지 않는다.
+    return String(link && link.onDelete || "").toUpperCase() === "CASCADE";
+  } catch {
+    // 물어볼 수 없으면 보수적으로 파괴한다고 본다 — 동의를 한 번 더 묻는 쪽이 안전하다.
+    return true;
+  }
+}
+
 function run(ctx, args) {
   const ko = ctx.lang === "ko";
   // 동의 플래그를 슬러그보다 앞에 써도 되도록 첫 번째 비플래그 인자를 대상으로 본다.
@@ -47,17 +67,24 @@ function run(ctx, args) {
   }
 
   /*
-   * 대화 파괴 게이트 — bootstrap-schema.sql:50 chats.agent_id 는
-   * `ON DELETE CASCADE`, :61 chat_messages.chat_id 도 CASCADE 다. 즉
-   * installed_agents 행 하나를 지우면 그 에이전트의 모든 챗과 메시지가 같이
-   * 사라진다(데스크탑과 공유하는 SQLite라 데스크탑 쪽 이력도 함께 증발한다).
-   * 그런데 이 명령은 그 사실을 한 줄도 알리지 않고 `✓ 제거됨`만 찍었다 —
-   * 되돌릴 수 없는 삭제가 무고지·무확인으로 일어나던 자리다.
-   * 그래서 지우기 "전에" 파급 건수를 세고, 대화가 있으면 명시적 동의
-   * (--yes/-y/--force) 없이는 아무것도 지우지 않는다. 대화가 0건이면
-   * 파괴할 이력이 없으므로 종전대로 그냥 진행한다(불필요한 마찰 금지).
+   * 대화 파괴 게이트 — **파괴가 실제로 일어나는 스키마에서만.**
+   *
+   * 예전에는 `chats.agent_id` 가 `ON DELETE CASCADE` 였다. 그래서 에이전트 한 행을 지우면
+   * 그 대화와 메시지가 함께 사라졌고, 이 명령은 그 사실을 한 줄도 알리지 않고 `✓ 제거됨`만
+   * 찍었다 — 되돌릴 수 없는 삭제가 무고지로 일어나던 자리였고, 그래서 이 게이트가 생겼다.
+   *
+   * 좌석-세션 이후 그 제약은 `ON DELETE SET NULL` 로 내려갔다. 에이전트를 지우는 것은
+   * 이제 **자리를 비우는 일**이고 대화는 그대로 남는다(오너 정본: 봇 삭제 = 자리 비우기).
+   * 그런데 이 명령은 계속 "영구 삭제합니다" 라고 경고하고 "삭제됨" 이라고 보고했다 —
+   * 지켜지지 않는 약속의 반대, 즉 **일어나지 않은 파괴를 보고하는 거짓말**이다. 사용자는
+   * 남아 있는 이력을 잃었다고 믿고, 잃지 않아도 될 동의를 강요받는다.
+   *
+   * 그래서 문구를 새 스키마에 맞춰 바꿔 쓰지 않는다. 이 CLI 는 데스크탑과 **같은 파일**을
+   * 쓰고 그 파일의 스키마는 기기마다 다르다 — 아직 옛 사다리에 있는 기기에서는 파괴가
+   * 여전히 사실이다. 판단은 열려 있는 DB 의 외래키에서 읽는다.
    */
   const consented = args.some((a) => a === "--yes" || a === "-y" || a === "--force");
+  const cascades = ctx.tableExists(db, "chats") && chatDeletionCascadesFromAgent(db);
   let chatCount = 0;
   let messageCount = 0;
   if (ctx.tableExists(db, "chats")) {
@@ -68,7 +95,7 @@ function run(ctx, args) {
       ).get(agent.id).n;
     }
   }
-  if (chatCount && !consented) {
+  if (chatCount && cascades && !consented) {
     ctx.err(ko
       ? `"${agent.slug}" 제거는 대화 ${chatCount}개와 메시지 ${messageCount}개를 함께 영구 삭제합니다 (데스크탑 앱과 공유하는 DB이며 되돌릴 수 없습니다).\n계속하려면: agentlas uninstall ${agent.slug} --yes`
       : `Uninstalling "${agent.slug}" will also permanently delete ${chatCount} chat(s) and ${messageCount} message(s) (shared with the Desktop app; this cannot be undone).\nRe-run to confirm: agentlas uninstall ${agent.slug} --yes`);
@@ -89,9 +116,12 @@ function run(ctx, args) {
       }
     } catch { /* 라우트 정리는 best-effort */ }
     // 실제로 무엇이 사라졌는지 성공 줄에 남긴다 — 조용한 파괴 금지.
-    const cascade = chatCount
-      ? (ko ? ` (대화 ${chatCount}개 · 메시지 ${messageCount}개 삭제됨)` : ` (deleted ${chatCount} chat(s), ${messageCount} message(s))`)
-      : "";
+    // 실제로 무엇이 일어났는지만 적는다 — 지웠으면 지웠다고, 남겼으면 남겼다고.
+    const cascade = !chatCount
+      ? ""
+      : cascades
+        ? (ko ? ` (대화 ${chatCount}개 · 메시지 ${messageCount}개 삭제됨)` : ` (deleted ${chatCount} chat(s), ${messageCount} message(s))`)
+        : (ko ? ` (대화 ${chatCount}개 · 메시지 ${messageCount}개는 그대로 남습니다 — 자리만 비었습니다)` : ` (kept ${chatCount} chat(s) and ${messageCount} message(s) — the seat is now empty)`);
     ctx.out(`${ctx.ui.green("✓")} ${ko ? "제거됨" : "Uninstalled"}: ${agent.slug}${cascade}`);
     return 0;
   }

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,

package/engine/core/capability-grants.cjs

@@ -0,0 +1,204 @@
+"use strict";
+/*
+ * core/capability-grants — 데스크탑이 소유한 통합 능력 승인(capability_grants)을
+ * 터미널이 **읽고 쓴다**.
+ *
+ * 오너 결정(2026-08-20): 승인은 에이전트별·채널별이 아니라 **행동 기준**이고 공유된다.
+ * 데스크탑에서 "항상 허용"을 누른 행동은 터미널에서도 다시 묻지 않아야 하고, 데스크탑에서
+ * 영구 거부된 행동은 터미널의 어떤 권한 등급으로도 뚫려서는 안 된다. 표는 하나(공유
+ * agentlas.sqlite, v98)이므로 규칙도 하나다 — 터미널이 자기 사본을 들면 그 순간 갈라진다.
+ *
+ * 정본 구현: agentlas_desktop/electron/store/capability-grants.ts.
+ * 이 파일은 그 **판정 규칙을 그대로** 옮긴 것이다(키 후보 3종, 스코프 구체성 내림차순,
+ * 같은 스코프 안에서 deny > allow, 프리픽스 패턴). 규칙이 갈리면 같은 머신의 두 제품이
+ * 같은 행동에 다른 답을 준다 — 바꿀 때는 반드시 양쪽을 함께 바꿀 것.
+ *
+ * ★터미널은 마이그레이션 follower 다(core/db.cjs 참조). 표가 없으면 **만들지 않는다** —
+ *   조용히 기존 동작(터미널 자체 동의/권한 규칙)으로 폴백하고, 왜 폴백했는지 사유를
+ *   호출부에 돌려준다. 부재를 성공으로 위장하지 않는다.
+ */
+const { tableExists } = require("./db.cjs");
+
+const TABLE = "capability_grants";
+
+/** 표가 없는(구버전) 공유 DB 에서 호출부가 사용자에게 그대로 보여줄 수 있는 사유. */
+const UNAVAILABLE_REASON =
+  "shared database has no capability_grants table (older schema) — " +
+  "Terminal fell back to its own consent/permission rules. " +
+  "Launch the Agentlas Desktop app once to migrate the shared store.";
+
+/**
+ * 능력 클래스 — "항상 허용"이 영구 부여하는 단위.
+ * 정본: desktop electron/runtime/tool-approval.ts capabilityClassFor().
+ */
+function capabilityClassFor(kind, tool) {
+  if (kind === "execute" || tool === "bash") return "execute";
+  if (kind === "delete") return "delete";
+  if (kind === "edit") return "edit";
+  if (kind === "fetch" || kind === "network") return "network";
+  return "other";
+}
+
+/**
+ * "항상 허용"이 저장할 인자 패턴 — Claude Code 프리픽스 규칙과 같은 일반화.
+ * 정본: desktop tool-approval.ts generalizeDetailPattern().
+ */
+function generalizeDetailPattern(detail) {
+  if (!detail) return null;
+  const tokens = String(detail).trim().split(/\s+/);
+  if (tokens.length <= 2) return String(detail).trim();
+  return `${tokens[0]} ${tokens[1]} *`;
+}
+
+/** "git push *" 스타일 프리픽스 패턴. NULL/빈 패턴은 인자 무관 매치. */
+function patternMatches(pattern, detail) {
+  if (pattern === null || pattern === undefined || pattern === "") return true;
+  if (!detail) return false;
+  const text = String(pattern);
+  if (text.endsWith("*")) return String(detail).startsWith(text.slice(0, -1).trimEnd());
+  return String(detail) === text;
+}
+
+/** 구체성 내림차순 — 먼저 맞은 스코프가 이긴다(chat > agent > global). */
+function scopesFor(query) {
+  const scopes = [];
+  if (query && query.chatId) scopes.push(`chat:${query.chatId}`);
+  if (query && query.agentId) scopes.push(`agent:${query.agentId}`);
+  scopes.push("global");
+  return scopes;
+}
+
+/** 표가 실제로 있는가. 만들지 않는다 — 확인만 한다. */
+function capabilityGrantsAvailable(db) {
+  if (!db) return false;
+  return tableExists(db, TABLE);
+}
+
+/**
+ * 저장된 규칙으로 결정을 찾는다.
+ * @returns {{decision: "allow"|"deny"|null, available: boolean, reason: string|null}}
+ *   decision === null 은 "규칙 없음" — 호출부가 기존 동작(질문/권한 등급)으로 간다.
+ */
+function readCapabilityDecision(db, query) {
+  if (!capabilityGrantsAvailable(db)) {
+    return { decision: null, available: false, reason: UNAVAILABLE_REASON };
+  }
+  const capability = String((query && query.capability) || "other");
+  const keys = [capability];
+  if (query && query.tool) keys.push(`tool:${query.tool}`);
+  keys.push("*");
+  let rows;
+  try {
+    rows = db
+      .prepare(
+        `SELECT capability, pattern, decision, scope FROM ${TABLE} ` +
+        `WHERE capability IN (${keys.map(() => "?").join(",")})`,
+      )
+      .all(...keys);
+  } catch (error) {
+    // 표는 있는데 열 모양이 우리가 아는 것과 다르다 — 추측하지 않고 폴백한다.
+    return {
+      decision: null,
+      available: false,
+      reason: `capability_grants is present but unreadable (${(error && error.message) || error}) — Terminal fell back to its own rules.`,
+    };
+  }
+  if (!rows || rows.length === 0) return { decision: null, available: true, reason: null };
+  for (const scope of scopesFor(query)) {
+    const inScope = rows.filter(
+      (row) => row.scope === scope && patternMatches(row.pattern, query && query.detail),
+    );
+    if (inScope.length === 0) continue;
+    if (inScope.some((row) => row.decision === "deny")) return { decision: "deny", available: true, reason: null };
+    return { decision: "allow", available: true, reason: null };
+  }
+  return { decision: null, available: true, reason: null };
+}
+
+/**
+ * 규칙을 영속한다(같은 (capability, pattern, scope)는 마지막 결정으로 덮는다).
+ * 데스크탑의 recordCapabilityGrant 와 **같은 행**을 쓴다 — 터미널에서 고른
+ * "항상 허용"이 데스크탑에도 그대로 보인다.
+ *
+ * 표가 없으면 만들지 않고 정직하게 실패를 알린다(ok:false + reason).
+ */
+function recordCapabilityGrant(db, input) {
+  if (!capabilityGrantsAvailable(db)) {
+    return { ok: false, available: false, reason: UNAVAILABLE_REASON };
+  }
+  const decision = input && input.decision === "deny" ? "deny" : "allow";
+  try {
+    db.prepare(
+      `INSERT INTO ${TABLE} (capability, pattern, decision, scope, source, created_at)
+       VALUES (?, ?, ?, ?, ?, ?)
+       ON CONFLICT(capability, pattern, scope)
+       DO UPDATE SET decision = excluded.decision, source = excluded.source, created_at = excluded.created_at`,
+    ).run(
+      String((input && input.capability) || "other"),
+      input && input.pattern != null && input.pattern !== "" ? String(input.pattern) : null,
+      decision,
+      String((input && input.scope) || "global"),
+      String((input && input.source) || "terminal"),
+      new Date().toISOString(),
+    );
+    return { ok: true, available: true, reason: null };
+  } catch (error) {
+    return {
+      ok: false,
+      available: true,
+      reason: `capability_grants write failed: ${(error && error.message) || error}`,
+    };
+  }
+}
+
+/** 조회용(도구·게이트가 사람에게 보여줄 때). 표가 없으면 빈 배열 + available:false. */
+function listCapabilityGrants(db, scope) {
+  if (!capabilityGrantsAvailable(db)) return { rows: [], available: false, reason: UNAVAILABLE_REASON };
+  try {
+    const rows = scope
+      ? db.prepare(`SELECT * FROM ${TABLE} WHERE scope = ? ORDER BY id`).all(String(scope))
+      : db.prepare(`SELECT * FROM ${TABLE} ORDER BY id`).all();
+    return {
+      rows: (rows || []).map((row) => ({
+        id: Number(row.id),
+        capability: String(row.capability),
+        pattern: row.pattern == null ? null : String(row.pattern),
+        decision: row.decision === "deny" ? "deny" : "allow",
+        scope: String(row.scope),
+        source: String(row.source == null ? "chip" : row.source),
+        createdAt: String(row.created_at == null ? "" : row.created_at),
+      })),
+      available: true,
+      reason: null,
+    };
+  } catch (error) {
+    return { rows: [], available: false, reason: `capability_grants read failed: ${(error && error.message) || error}` };
+  }
+}
+
+/** 대화 전체 통과("항상 승인" 대화) — 데스크탑 isChatAlwaysApproved 와 같은 행. */
+function isChatAlwaysApproved(db, chatId) {
+  if (!capabilityGrantsAvailable(db) || !chatId) return false;
+  try {
+    const row = db
+      .prepare(`SELECT decision FROM ${TABLE} WHERE capability = '*' AND scope = ? ORDER BY id DESC LIMIT 1`)
+      .get(`chat:${chatId}`);
+    return !!row && row.decision === "allow";
+  } catch {
+    return false;
+  }
+}
+
+module.exports = {
+  TABLE,
+  UNAVAILABLE_REASON,
+  capabilityClassFor,
+  generalizeDetailPattern,
+  patternMatches,
+  scopesFor,
+  capabilityGrantsAvailable,
+  readCapabilityDecision,
+  recordCapabilityGrant,
+  listCapabilityGrants,
+  isChatAlwaysApproved,
+};

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/core/desktop-core.cjs

@@ -249,6 +249,28 @@ function loadDesktopCore(options = {}) {
       try { return require(path.join(root, "shared", "graph-execution-digest.js")).graphExecutionDigest; }
       catch { return null; }
     })(),
+    /*
+     * ★"이 노드가 바깥을 바꾸나" 는 판정이 **한 곳**에서만 나와야 한다. 벤더에는 이미
+     *   shared/graph-node-protocol.js 가 실려 있었는데 이 표면에 없어서, 터미널은
+     *   부를 수가 없었고 그래서 자기 사본을 들고 있었다(engine/graph/package.cjs,
+     *   engine/commands/graph.cjs). 사본은 게으름이 아니라 **정본에 못 닿아서** 생긴다.
+     *   옛 코어를 쓰는 동안에는 없을 수 있으므로 정직하게 null 로 둔다 — 부르는 쪽이
+     *   없으면 자기 판단을 쓰되, 그 사실이 보이게.
+     */
+    nodeEffectJudgments: (() => {
+      try {
+        const mod = require(path.join(root, "shared", "graph-node-protocol.js"));
+        return typeof mod.nodeCouldHaveActedOutside === "function" ? {
+          resolveNodeEffect: mod.resolveNodeEffect,
+          nodeDeclaresOutwardEffect: mod.nodeDeclaresOutwardEffect,
+          nodeCouldHaveActedOutside: mod.nodeCouldHaveActedOutside,
+        } : null;
+      } catch { return null; }
+    })(),
+    couldHaveChangedTheOutsideWorld: (() => {
+      try { return require(path.join(root, "shared", "tool-activity.js")).couldHaveChangedTheOutsideWorld; }
+      catch { return null; }
+    })(),
     graphFailureOf: kernel.graphFailureOf,
     planGraphLoops: kernel.planGraphLoops,
     /*