agentlas 1.0.59 → 1.0.61

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

@@ -231,12 +231,46 @@ function loadDesktopCore(options = {}) {
     initStore: req("store/db").initStore,
     getDb: req("store/db").getDb,
     runGraph: kernel.runGraph,
+    /*
+     * 저장 전 확인 — 빌더가 만든 스크립트를 **저장하기 전에** 돌려 보고, 안 되면 한 번
+     * 고친다. 옛 코어에는 없으므로 정직하게 null 로 둔다(부르는 쪽이 없으면 건너뛴다).
+     */
+    verifyBeforeSave: (() => {
+      try {
+        const mod = req("workflow/verify-before-save");
+        return typeof mod.verifyGraphBeforeSaveWithKernel === "function"
+          ? { run: mod.verifyGraphBeforeSaveWithKernel, render: mod.renderPreSaveVerification }
+          : null;
+      } catch { return null; }
+    })(),
     getAutomation: req("store/automations").getAutomation,
     // shared/ 는 electron/ 밖이라 req 로 못 닿는다 — 직접 해석한다.
     graphExecutionDigest: (() => {
       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,
     /*

package/engine/experience/build.cjs

@@ -114,9 +114,17 @@ async function cmdBuild(options) {
   const emit = options.out || console.log;
   const inventory = mcp.collectSystemMcpInventory(options.db, { userDataDir: options.userDataDir, env: options.env || process.env });
   const policy = mcp.loadProjectMcpPolicy(options.cwd || process.cwd());
+  // 명시적 요구(정책/플래그)가 하나도 없을 때만 추론 — 판정기(연결 모델) 경유이며,
+  // 판정 불가면 빈 목록(중립)이다. 휴리스틱 정규식은 판정 힌트로만 실린다.
+  const explicitRequirementCount =
+    ((policy && policy.requirements) || []).length + parsed.requiredIds.length + parsed.recommendedIds.length;
+  const inferredRequirements = explicitRequirementCount === 0
+    ? await mcp.inferRequirements(parsed.request, inventory)
+    : [];
   const plan = mcp.buildMcpPlan({
     inventory, policy, request: parsed.request,
     requiredIds: parsed.requiredIds, recommendedIds: parsed.recommendedIds,
+    inferredRequirements,
   });
   emit(parsed.json ? JSON.stringify(plan, null, 2) : mcp.renderMcpPlan(plan));
   if (parsed.planOnly) return { plan, approvedIds: [], invoked: false };

package/engine/graph/ask-model.cjs

@@ -50,6 +50,23 @@ function quietSink() {
  * @returns {Promise<{ok:true,text:string,runtime:string,fellBackFrom?:string}
  *                  |{ok:false,reason:string,nextAction:string}>}
  */
+/**
+ * 이 컴퓨터에서 **이미 동의된** MCP 서버들. 빌더도 실행기와 같은 재료를 본다.
+ *
+ * 새 동의를 받지 않는다 — 만드는 중에 승인 창을 띄우면 사람이 흐름에서 튕긴다.
+ * 못 읽으면 빈 배열: 예전 동작과 같아질 뿐 나빠지지 않는다(조용한 실패가 아니라
+ * "없는 것"이 사실이다).
+ */
+function consentedMcpServersFor(ctx) {
+  try {
+    const mcp = require("../mcp/index.cjs");
+    if (typeof mcp.readConsentedSystemMcpServers !== "function") return [];
+    return mcp.readConsentedSystemMcpServers(ctx.db(), { env: process.env }) || [];
+  } catch {
+    return [];
+  }
+}
+
 async function askModel(ctx, prompt, opts = {}) {
   const db = ctx.db();
   let primary = null;
@@ -103,12 +120,27 @@ async function askModel(ctx, prompt, opts = {}) {
         ui: quietSink(),
         cwd: opts.cwd || process.cwd(),
         prompt,
-        // 읽기 권한 — 인터뷰는 사람에게 묻고 형식을 만드는 일이라 파일을 바꿀 이유가 없다.
+        /*
+         * 읽기 권한 — 만드는 동안 바깥을 바꾸지 않는다. 메일이 나가거나 글이 올라가면 안 된다.
+         * ★런타임의 "read"는 **쓰기 금지가 아니라 도구 금지에 가깝다**(이 저장소 실측:
+         *   조회 그래프가 조회조차 못 했던 사고). 조회 도구는 남으므로 확인은 할 수 있다.
+         */
         permission: "read",
         session: {},
         model: runtime.model,
         effort: runtime.effort,
-        mcpServers: [],
+        /*
+         * ★사용자가 **이미 동의한** MCP 를 빌더에게도 준다.
+         *
+         *   실측 2026-08-20: 여기가 빈 배열이었다. 그래서 빌더는 이 컴퓨터에 무엇이
+         *   연결돼 있는지 모른 채 그래프를 지었고, 자기가 쓴 스크립트가 도는지도 볼 수
+         *   없었다. 도구는 제품에 다 있는데(브라우저·MCP·크리덴셜) **만드는 자리에만
+         *   안 닿아 있었다.**
+         *
+         *   새로 동의를 받지 않는다 — 이미 받아 둔 것만 그대로 쓴다(consent 영수증 기준).
+         *   못 읽으면 빈 배열로 간다: 예전과 같아질 뿐 나빠지지 않는다.
+         */
+        mcpServers: consentedMcpServersFor(ctx),
         mcpAllowlistMode: "exact",
       });
     } catch (err) {

package/engine/graph/node-effect.cjs

@@ -0,0 +1,56 @@
+"use strict";
+/*
+ * "이 노드가 바깥을 바꾸나" — 터미널 쪽 **거울 하나**.
+ *
+ * 정본은 데스크탑의 `shared/graph-node-protocol.ts` 다. 터미널이 그걸 직접 부르지
+ * 못하는 이유는 하나뿐이다: 그 판정은 `.filter()` 안에서 **동기로** 필요한데, 엔진을
+ * 얻는 길(`acquireCore`)은 비동기다(새 설치는 아직 내려받지 않았을 수 있다).
+ * 동기 로더로 우회하면 새로 설치한 사람에게만 조용히 다른 답이 나온다 —
+ * `verify-engine-reachable` 게이트가 정확히 그걸 막는다.
+ *
+ * 그래서 규칙을 여기 한 번 편다. 대신 **같은 답을 내는지 게이트가 증명한다**
+ * (`scripts/verify-node-effect-parity.cjs`). 거울이 허용되는 조건은 그 증명뿐이다.
+ *
+ * 왜 이 판정이 중요한가 (실측 2026-08-20):
+ *   `config.effect === "mutation"` 만 보면 emitter 가 만든 출력 노드(effect 칸이
+ *   아예 없음)가 "바깥에 안 나감"으로 읽힌다. 그 노드의 기본값은 나가는 것이다.
+ *   데스크탑에서 같은 구멍이 다섯 곳에 있었다 — 도구 모드·패키지 경고·권한 유도·
+ *   발행 심사·패치 승인. 터미널도 세 곳에 있었다.
+ */
+
+/** 안 적힌 효과의 기본값. 출력 블록은 "바깥으로 내보내기"다(레지스트리 선언). */
+function defaultNodeEffect(nodeType) {
+  return nodeType === "output" ? "mutation" : "read";
+}
+
+/** 이 노드의 효과. 선언된 것이 있으면 그것을 믿고, 없으면 종류의 기본값이다. */
+function resolveNodeEffect(node) {
+  const declared = typeof node?.config?.effect === "string" ? node.config.effect.trim() : "";
+  if (declared === "mutation" || declared === "read" || declared === "pure") return declared;
+  return defaultNodeEffect(String(node?.type ?? ""));
+}
+
+/**
+ * ① 바깥으로 나간다고 **선언돼 있는가** — 사람에게 "이 단계는 발행한다"고 말할 근거.
+ *    패키지 경고·발행 고지가 쓴다.
+ */
+function nodeDeclaresOutwardEffect(node) {
+  return resolveNodeEffect(node) === "mutation";
+}
+
+/**
+ * ② 바깥에 뭔가 **했을 수 있는가** — 재개가 묻는 다른 질문. ①의 상위집합이다.
+ *    모델을 부르는 단계는 선언이 read 여도 도구를 부를 수 있다.
+ *    (정본이 이 둘을 갈라 놓은 이유는 shared/graph-node-protocol.ts 주석에 있다.)
+ */
+function nodeCouldHaveActedOutside(node) {
+  if (nodeDeclaresOutwardEffect(node)) return true;
+  return node?.type === "agent" || node?.type === "action" || node?.type === "output";
+}
+
+module.exports = {
+  defaultNodeEffect,
+  resolveNodeEffect,
+  nodeDeclaresOutwardEffect,
+  nodeCouldHaveActedOutside,
+};

package/engine/graph/package.cjs

@@ -1,4 +1,6 @@
 "use strict";
+
+const { nodeDeclaresOutwardEffect: reachesOutside } = require("./node-effect.cjs");
 /*
  * .agentgraph 패키징 — 그래프를 남에게 줄 수 있는 형태로 만든다.
  *
@@ -31,6 +33,8 @@ const SECRET_KEY_RE = /(token|secret|password|passwd|apikey|api_key|credential|p
 /** 로컬 사용자 경로 — 남의 기계에서 의미가 없고, 계정명이 그대로 드러난다. */
 const PERSONAL_PATH_RE = /(\/Users\/[^/\s"']+|\/home\/[^/\s"']+|C:\\Users\\[^\\\s"']+)/g;
 
+
+
 function vaultKeyFor(nodeId, key) {
   return `${String(key).replace(/[^A-Za-z0-9]+/g, "_").toUpperCase()}`;
 }
@@ -113,6 +117,7 @@ function buildPackage(input) {
     // 에이전트 참조는 핀으로 남긴다 — 받는 사람이 무엇을 빌려야 하는지 알아야 한다.
     // 노드가 ref를 선언하지 않으면 자동화의 대상 에이전트를 상속한다(제품의 실제 동작).
     // 그 경우를 빼면 패키지가 "채울 것 없음"이라고 거짓말한다.
+    // judgment-exempt: 이건 "바깥을 바꾸나"가 아니라 "이 단계가 에이전트를 굴리나"다.
     const isAgentish = node.type === "agent" || node.type === "action" || node.type === "output";
     const ref = typeof node.config?.ref === "string" && node.config.ref ? node.config.ref : null;
     const inheritedSlug = automation.target_id || null;
@@ -139,7 +144,7 @@ function buildPackage(input) {
   }
 
   const mutationNodes = nodes
-    .filter((n) => n.config?.effect === "mutation")
+    .filter((n) => reachesOutside(n))
     .map((n) => ({ nodeId: n.id, label: n.label || n.id }));
 
   const scrubbedGraph = { version: graph.version ?? 1, nodes, edges: graph.edges || [] };

package/engine/graph/vocabulary.generated.cjs

@@ -7,7 +7,7 @@
 "use strict";
 
 const GRAPH_WIRE = "graph/1";
-const GRAPH_ERROR_CODES = ["APPROVAL_REQUIRED","APPROVAL_TIMED_OUT","ARCHITECT_NO_CHANGE","ARCHITECT_NO_REQUEST","ARCHITECT_OUTPUT_MALFORMED","ARCHITECT_OUTPUT_TOO_LARGE","ARCHITECT_OUTPUT_UNREADABLE","ARCHITECT_UNAVAILABLE","AUTOMATION_NOT_CONNECTED","BUDGET_EXHAUSTED","CODE_DEPENDENCY_MISSING","CODE_NODE_EMPTY","CODE_PRODUCED_NOTHING","CODE_STEP_FAILED","CREATE_INPUT_INVALID","EDGE_CONDITION_UNRESOLVED","EVAL_FAILED","EVAL_INCOMPLETE","EVAL_STUCK","EVAL_UNAVAILABLE","INTERVIEW_MODEL_UNAVAILABLE","INTERVIEW_OUTPUT_UNREADABLE","INTERVIEW_REPEATED_QUESTIONS","INTERVIEW_SELF_CORRECTION_EXHAUSTED","INTERVIEW_STATE_INVALID","LOOP_BOUND_INVALID","LOOP_BOUND_UNDECLARED","LOOP_LIMIT_REACHED","LOOP_WITHOUT_EXIT","MUTATION_UNVERIFIED","NODE_CLAIMED_WITHOUT_TOOLS","NODE_FAILED","NODE_INPUT_MISSING","NODE_NEVER_REACHED","NODE_NO_RESULT","NODE_TIMEOUT","NODE_TYPE_UNSUPPORTED","NO_MATCHING_EDGE","OUTPUT_NODE_EMPTY","PATCH_CODE_EMPTY","PATCH_EDGE_CONFLICT","PATCH_EDGE_DANGLING","PATCH_EDGE_HANDLE_MISSING","PATCH_EDGE_MISSING","PATCH_EMPTY","PATCH_LOOP_BOUND_MISSING","PATCH_NODE_CONFLICT","PATCH_NODE_MISSING","PATCH_NO_GRAPH","PATCH_OP_UNKNOWN","REDUCER_MERGE_CONFLICT","REDUCER_WRITE_CONFLICT","RESUME_CONFLICT","RUN_REQUEST_DISABLED","RUN_REQUEST_INPUT_REQUIRED","RUN_REQUEST_NOT_FOUND","RUN_REQUEST_QUEUE_UNAVAILABLE","RUN_REQUEST_REF_AMBIGUOUS","RUN_REQUEST_REF_MISSING","SUBGRAPH_DEPTH_EXCEEDED","SUBGRAPH_FAILED","SUBGRAPH_NOT_FOUND","SUBGRAPH_NO_RESULT","SUBGRAPH_SELF_CALL","SWAP_CAPABILITY_MISMATCH","SWAP_HUB_RELEASE_UNPINNED","SWAP_NODE_NOT_FOUND","SWAP_NOT_AGENT_NODE","SWAP_NO_MATCH","SWAP_UNKNOWN_PROVIDER","TOOL_BROKER_CALL_UNREADABLE","TOOL_BROKER_MUTATION_IN_SIMULATION","TOOL_BROKER_PLAN_UNREADABLE","TOOL_BROKER_TOOL_NOT_DECLARED","TOOL_NODE_UNATTACHED","TOOL_NODE_UNCONFIGURED","TRANSFORM_MODE_UNKNOWN","TRANSFORM_NODE_UNCONFIGURED"];
+const GRAPH_ERROR_CODES = ["APPROVAL_REQUIRED","APPROVAL_TIMED_OUT","ARCHITECT_NO_CHANGE","ARCHITECT_NO_REQUEST","ARCHITECT_OUTPUT_MALFORMED","ARCHITECT_OUTPUT_TOO_LARGE","ARCHITECT_OUTPUT_UNREADABLE","ARCHITECT_UNAVAILABLE","AUTOMATION_NOT_CONNECTED","BUDGET_EXHAUSTED","CODE_DEPENDENCY_MISSING","CODE_NODE_EMPTY","CODE_PRODUCED_NOTHING","CODE_STEP_FAILED","CREATE_INPUT_INVALID","EDGE_CONDITION_UNRESOLVED","EVAL_CONTRADICTS_BRANCH","EVAL_FAILED","EVAL_INCOMPLETE","EVAL_STUCK","EVAL_UNAVAILABLE","INTERVIEW_MODEL_UNAVAILABLE","INTERVIEW_OUTPUT_UNREADABLE","INTERVIEW_REPEATED_QUESTIONS","INTERVIEW_SELF_CORRECTION_EXHAUSTED","INTERVIEW_STATE_INVALID","LOOP_BOUND_INVALID","LOOP_BOUND_UNDECLARED","LOOP_LIMIT_REACHED","LOOP_WITHOUT_EXIT","MUTATION_UNVERIFIED","NODE_CLAIMED_WITHOUT_TOOLS","NODE_FAILED","NODE_INPUT_MISSING","NODE_NEVER_REACHED","NODE_NO_RESULT","NODE_TIMEOUT","NODE_TYPE_UNSUPPORTED","NO_MATCHING_EDGE","OUTPUT_NODE_EMPTY","PATCH_CODE_EMPTY","PATCH_EDGE_CONFLICT","PATCH_EDGE_DANGLING","PATCH_EDGE_HANDLE_MISSING","PATCH_EDGE_MISSING","PATCH_EMPTY","PATCH_LOOP_BOUND_MISSING","PATCH_NODE_CONFLICT","PATCH_NODE_MISSING","PATCH_NO_GRAPH","PATCH_OP_UNKNOWN","REDUCER_MERGE_CONFLICT","REDUCER_WRITE_CONFLICT","RESUME_CONFLICT","RUN_REQUEST_DISABLED","RUN_REQUEST_INPUT_REQUIRED","RUN_REQUEST_NOT_FOUND","RUN_REQUEST_QUEUE_UNAVAILABLE","RUN_REQUEST_REF_AMBIGUOUS","RUN_REQUEST_REF_MISSING","SUBGRAPH_DEPTH_EXCEEDED","SUBGRAPH_FAILED","SUBGRAPH_NOT_FOUND","SUBGRAPH_NO_RESULT","SUBGRAPH_SELF_CALL","SWAP_CAPABILITY_MISMATCH","SWAP_HUB_RELEASE_UNPINNED","SWAP_NODE_NOT_FOUND","SWAP_NOT_AGENT_NODE","SWAP_NO_MATCH","SWAP_UNKNOWN_PROVIDER","TOOL_BROKER_CALL_UNREADABLE","TOOL_BROKER_MUTATION_IN_SIMULATION","TOOL_BROKER_PLAN_UNREADABLE","TOOL_BROKER_TOOL_NOT_DECLARED","TOOL_NODE_UNATTACHED","TOOL_NODE_UNCONFIGURED","TRANSFORM_MODE_UNKNOWN","TRANSFORM_NODE_UNCONFIGURED"];
 const GRAPH_JOURNAL_KINDS = ["blob_externalized","node_failed","node_intent","node_reserved","node_retry","node_routed","node_settled","resumed","run_completed","run_created","run_failed","run_validated","suspended"];
 const GRAPH_NODE_KINDS = ["action","agent","code","condition","eval","output","subgraph","tool","transform","trigger"];
 const GRAPH_BLOCK_UI = {"trigger":{"section":"none","placeable":false,"placeReason":"그래프마다 하나뿐이고 처음 만들 때 함께 지어진다"},"agent":{"section":"inventory","placeable":true},"eval":{"section":"flow","placeable":true},"condition":{"section":"flow","placeable":true},"transform":{"section":"flow","placeable":true},"code":{"section":"flow","placeable":true},"tool":{"section":"inventory","placeable":true},"action":{"section":"actions","placeable":true},"output":{"section":"flow","placeable":true},"loop":{"section":"none","placeable":false,"placeReason":"노드가 아니라 되돌아가는 연결의 성질이다 — 엣지를 이어서 만든다"},"subgraph":{"section":"flow","placeable":true}};