agentlas 1.0.60 → 1.0.62

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/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}};

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

@@ -27,9 +27,13 @@ const { runWriteTransaction } = require("../agentlas-sqlite-policy.cjs");
 const { callHubTool } = require("../cloud/hub-client.cjs");
 
 // ── 패키지 상한/식별 상수 (서버 package-contract와 동일) ──
-const CLOUD_MAX_TOTAL_BYTES = 3 * 1024 * 1024;
-const CLOUD_MAX_FILE_BYTES = 512 * 1024;
-const CLOUD_MAX_FILES = 400;
+// 상한은 정본 하나(upload-scan-catalog.json)에서 생성돼 내려온다. 여기서 다시
+// 적으면 서버·엔진·데스크탑과 어긋나고, 어긋난 쪽은 파일 이름도 없는 코드로 거절한다.
+const {
+  PACKAGE_MAX_TOTAL_BYTES: CLOUD_MAX_TOTAL_BYTES,
+  PACKAGE_MAX_FILE_BYTES: CLOUD_MAX_FILE_BYTES,
+  PACKAGE_MAX_FILES: CLOUD_MAX_FILES,
+} = require("../cloud-assets/upload-scan-catalog.generated.cjs");
 const CLOUD_PACKAGE_HASH_V1 = "path-sha256-v1";
 const CLOUD_PACKAGE_HASH_V2 = "path-sha256-executable-v2";
 const CLOUD_RESTORE_MARKER_PATH = ".agentlas-cloud-package.json";

package/engine/hub/plugins.cjs

@@ -15,6 +15,9 @@
  *    런타임이 통째로 죽는다(Runtime Doctor가 반복해서 잡던 사고 계열).
  */
 const crypto = require("node:crypto");
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
 const { callHubTool, fetchHub, parseHubJson, webBaseUrl } = require("../cloud/hub-client.cjs");
 
 // 레포/홈페이지 HTML 페이지는 문서지 MCP 연결이 아니다. 이 URL들을 transport:"http"로
@@ -193,6 +196,163 @@ function installPluginMcpRows(db, rows) {
   return { installed, reused, needsApproval };
 }
 
+// ── 스킬 번들 설치 (플러그인 = MCP와 별개의 능력 패키지, 오너 결정 2026-08-20) ──
+//
+// manifest.skills 행이 files[]에 실콘텐츠를 실으면 ~/.agentlas/plugins/<slug>/ 아래에
+// 파일로 착지시키고 plugin.json 마커(schema agentlas.local-plugin/v1)를 남긴다.
+// 이 규약은 데스크탑 electron/mcp-tools/hub-plugin-bridge.ts(installSkillBundle)와
+// Agentlas-OS agentlas_cloud/plugin_discovery.py 스캔이 공유한다 — mcp_servers 등록이
+// 아니라 파일시스템이 채널 간 공유 지점이다.
+
+const PLUGIN_SKILL_SLUG_RE = /^[a-z0-9][a-z0-9._-]{0,63}$/i;
+const PLUGIN_SKILL_FILE_MAX_BYTES = 512 * 1024;
+
+/** 세 채널이 공유하는 로컬 플러그인 저장소 루트. homeDir 주입은 테스트 격리용. */
+function agentlasPluginsDir({ homeDir } = {}) {
+  return path.join(homeDir || os.homedir(), ".agentlas", "plugins");
+}
+
+/** 스킬 파일 상대 경로 검증 — 절대경로·상위 탈출·널바이트·백슬래시 거부 (데스크탑 동형). */
+function pluginSkillSafeRelativePath(value) {
+  if (typeof value !== "string" || !value || value.length > 260) return false;
+  if (value.includes("\0") || value.includes("\\")) return false;
+  if (value.startsWith("/") || value.endsWith("/")) return false;
+  return value.split("/").every((part) => part.length > 0 && part !== "." && part !== ".." && !part.startsWith("~"));
+}
+
+/**
+ * manifest.skills 를 설치 계획으로 정규화: 실콘텐츠가 실린 스킬과 정직하게 거른 항목 분리.
+ * 이름뿐인 레거시 행({name}만)은 refused가 아니라 declaredOnly로 남긴다 — 결함이 아니라
+ * 과거 스키마의 정상 모양이다.
+ */
+function planPluginSkillInstall(slug, manifest) {
+  const entries = Array.isArray(manifest?.skills) ? manifest.skills : [];
+  const skills = [];
+  const declaredOnly = [];
+  const refused = [];
+  for (const entry of entries) {
+    const name = typeof entry?.name === "string" ? entry.name.trim() : "";
+    if (!name) continue;
+    const rawFiles = Array.isArray(entry?.files) ? entry.files : [];
+    if (rawFiles.length === 0) {
+      declaredOnly.push(name);
+      continue;
+    }
+    if (!PLUGIN_SKILL_SLUG_RE.test(name)) {
+      refused.push({ name, reason: "invalid skill name" });
+      continue;
+    }
+    const files = [];
+    let bad = null;
+    for (const file of rawFiles) {
+      const filePath = typeof file?.path === "string" ? file.path.trim() : "";
+      const content = typeof file?.content === "string" ? file.content : "";
+      if (!pluginSkillSafeRelativePath(filePath)) { bad = `unsafe file path "${filePath}"`; break; }
+      if (!content.trim()) { bad = `empty content for ${filePath}`; break; }
+      if (Buffer.byteLength(content, "utf8") > PLUGIN_SKILL_FILE_MAX_BYTES) { bad = `${filePath} exceeds the file size cap`; break; }
+      const sha256 = typeof file?.sha256 === "string" && /^[0-9a-f]{64}$/i.test(file.sha256)
+        ? file.sha256.toLowerCase()
+        : null;
+      files.push({ path: filePath, content, sha256 });
+    }
+    if (bad) { refused.push({ name, reason: bad }); continue; }
+    skills.push({ name, description: typeof entry?.description === "string" ? entry.description : null, files });
+  }
+  return { skills, declaredOnly, refused };
+}
+
+/**
+ * 계획된 스킬들을 ~/.agentlas/plugins/<slug>/skills/<name>/ 에 쓴다.
+ *
+ * 무결성: 행이 sha256을 선언하면 쓰기 전에 검증하고, 불일치 스킬은 설치하지 않는다.
+ * 해시와 콘텐츠가 같은 매니페스트 응답으로 오므로 이 검증은 전송 무결성이지 발행자
+ * 서명이 아니다 — 마커의 source.manifestUrl이 출처 기록이다(정직한 한계).
+ */
+function installPluginSkills(slug, plan, { homeDir, manifestUrl, meta } = {}) {
+  if (!PLUGIN_SKILL_SLUG_RE.test(String(slug || ""))) {
+    return { dir: "", installed: [], failed: [{ name: String(slug || ""), reason: "invalid plugin slug" }], verified: false };
+  }
+  const pluginDir = path.join(agentlasPluginsDir({ homeDir }), slug);
+  const installed = [];
+  const failed = [];
+  const markerSkills = [];
+  let allDeclared = true;
+  for (const skill of plan.skills || []) {
+    const written = [];
+    let mismatch = null;
+    for (const file of skill.files) {
+      const actual = crypto.createHash("sha256").update(file.content, "utf8").digest("hex");
+      if (file.sha256 && file.sha256 !== actual) { mismatch = `sha256 mismatch for ${file.path}`; break; }
+      if (!file.sha256) allDeclared = false;
+      written.push({ path: file.path, sha256: actual, verified: Boolean(file.sha256) });
+    }
+    if (mismatch) { failed.push({ name: skill.name, reason: mismatch }); continue; }
+    try {
+      const skillDir = path.join(pluginDir, "skills", skill.name);
+      for (const file of skill.files) {
+        const target = path.join(skillDir, file.path);
+        fs.mkdirSync(path.dirname(target), { recursive: true });
+        fs.writeFileSync(target, file.content, "utf8");
+      }
+      installed.push(skill.name);
+      markerSkills.push({ name: skill.name, files: written });
+    } catch (e) {
+      failed.push({ name: skill.name, reason: String((e && e.message) || e).slice(0, 160) });
+    }
+  }
+  const verified = installed.length > 0 && allDeclared;
+  if (installed.length > 0) {
+    // 마커는 마지막에 쓴다 — 마커가 있으면 스킬 파일도 있다는 뜻이어야 한다.
+    const marker = {
+      schema: "agentlas.local-plugin/v1",
+      slug,
+      name: (meta && meta.name) || slug,
+      family: (meta && meta.family) || null,
+      version: (meta && meta.version) || null,
+      installedAt: new Date().toISOString(),
+      installedBy: "agentlas-terminal",
+      source: { manifestUrl: manifestUrl || null, contentVerification: verified ? "manifest-sha256" : "none" },
+      skills: markerSkills,
+    };
+    try {
+      fs.mkdirSync(pluginDir, { recursive: true });
+      fs.writeFileSync(path.join(pluginDir, "plugin.json"), `${JSON.stringify(marker, null, 2)}\n`, "utf8");
+    } catch (e) {
+      failed.push({ name: "plugin.json", reason: String((e && e.message) || e).slice(0, 160) });
+    }
+  }
+  return { dir: pluginDir, installed, failed, verified };
+}
+
+/** ~/.agentlas/plugins/<slug>/plugin.json 마커들을 읽는다 — list의 설치 여부 표시용. */
+function listInstalledLocalPlugins({ homeDir } = {}) {
+  const root = agentlasPluginsDir({ homeDir });
+  let names;
+  try {
+    names = fs.readdirSync(root, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const name of names) {
+    if (name.startsWith(".")) continue;
+    try {
+      const marker = JSON.parse(fs.readFileSync(path.join(root, name, "plugin.json"), "utf8"));
+      out.push({
+        slug: String(marker.slug || name),
+        name: String(marker.name || name),
+        installedAt: marker.installedAt || null,
+        installedBy: marker.installedBy || null,
+        skills: Array.isArray(marker.skills) ? marker.skills.map((s) => String(s?.name || "")).filter(Boolean) : [],
+        dir: path.join(root, name),
+      });
+    } catch {
+      // 마커 없는 디렉터리는 다른 도구의 산출물일 수 있다 — 조용히 건너뛴다.
+    }
+  }
+  return out;
+}
+
 /** Hub 플러그인 카탈로그 목록 (marketplace.list_plugins). 실패는 그대로 throw — 폴백 카탈로그 금지. */
 async function listHubPlugins({ callTool } = {}) {
   const call = callTool || callHubTool;
@@ -210,4 +370,9 @@ module.exports = {
   planPluginMcpInstall,
   installPluginMcpRows,
   listHubPlugins,
+  agentlasPluginsDir,
+  pluginSkillSafeRelativePath,
+  planPluginSkillInstall,
+  installPluginSkills,
+  listInstalledLocalPlugins,
 };

package/engine/mcp/consent.cjs

@@ -36,6 +36,82 @@ const {
 const MCP_CONSENT_STATE_SCHEMA = "agentlas.terminal-mcp-consents.v1";
 const MCP_CONSENT_RECEIPT_SCHEMA = "agentlas.terminal-mcp-consent.v1";
 
+/*
+ * ── 통합 능력 승인(데스크탑 capability_grants)과의 합류 ───────────────────────
+ *
+ * 이 파일의 v1 계약(지문 일치 영수증)은 그대로다. 그 **위에** 공유 능력 규칙이 얹힌다:
+ *   · 규칙이 deny 면 영수증이 있어도 붙이지 않는다(영구 거부는 어디서도 뚫리지 않는다).
+ *   · 규칙이 allow 면 다시 묻지 않는다(데스크탑에서 누른 "항상 허용"이 여기서도 항상).
+ *   · 규칙이 없으면 종전대로 1회 동의 프롬프트가 돈다.
+ * 터미널에서 "항상"을 고르면 같은 표에 써서 데스크탑에도 반영된다.
+ *
+ * MCP 서버를 붙이는 것은 외부 프로세스를 띄우는 일이라 능력 클래스는 execute 다.
+ * 규칙 키는 `tool:mcp:<catalogId>` + 패턴 없음(그 서버 전체) — 데스크탑의 도구 규칙과
+ * 같은 표·같은 판정 함수를 쓴다.
+ */
+const MCP_CAPABILITY_CLASS = "execute";
+
+function mcpCapabilityQuery(catalogId) {
+  return { capability: MCP_CAPABILITY_CLASS, tool: `mcp:${String(catalogId)}`, detail: String(catalogId) };
+}
+
+function capabilityGrantsModule() {
+  return require("../core/capability-grants.cjs");
+}
+
+/**
+ * 계획의 후보들을 공유 능력 규칙으로 미리 가른다.
+ * @returns {{available:string[], preApproved:string[], denied:string[],
+ *            grantsAvailable:boolean, fallbackReason:string|null}}
+ *   grantsAvailable=false 는 표가 없는 구버전 공유 DB — 사유를 담아 돌려주고 기존 동작으로 간다.
+ */
+function partitionMcpConsentByCapabilityGrants(db, catalogIds) {
+  const ids = [...new Set((catalogIds || []).map((id) => String(id)).filter(Boolean))];
+  const grants = capabilityGrantsModule();
+  if (!db || !grants.capabilityGrantsAvailable(db)) {
+    return {
+      available: ids,
+      preApproved: [],
+      denied: [],
+      grantsAvailable: false,
+      fallbackReason: db ? grants.UNAVAILABLE_REASON : null,
+    };
+  }
+  const available = [];
+  const preApproved = [];
+  const denied = [];
+  let fallbackReason = null;
+  for (const id of ids) {
+    let ruling;
+    try {
+      ruling = grants.readCapabilityDecision(db, mcpCapabilityQuery(id));
+    } catch (error) {
+      fallbackReason = `capability_grants read failed: ${(error && error.message) || error}`;
+      available.push(id);
+      continue;
+    }
+    if (!ruling.available) {
+      fallbackReason = fallbackReason || ruling.reason;
+      available.push(id);
+    } else if (ruling.decision === "deny") denied.push(id);
+    else if (ruling.decision === "allow") preApproved.push(id);
+    else available.push(id);
+  }
+  return { available, preApproved, denied, grantsAvailable: true, fallbackReason };
+}
+
+/** 터미널에서 고른 "항상"을 데스크탑과 같은 표에 남긴다. 표가 없으면 정직한 실패. */
+function rememberMcpCapabilityGrant(db, catalogId, decision = "allow") {
+  const grants = capabilityGrantsModule();
+  return grants.recordCapabilityGrant(db, {
+    capability: `tool:mcp:${String(catalogId)}`,
+    pattern: null,
+    decision: decision === "deny" ? "deny" : "allow",
+    scope: "global",
+    source: "terminal-mcp-consent",
+  });
+}
+
 function mcpConsentStatePath(userDataDir) {
   return path.join(userDataDir, "terminal", "mcp-consents-v1.json");
 }
@@ -113,10 +189,16 @@ function readConsentedSystemMcpServers(db, options = {}) {
   let state;
   try { state = loadMcpConsentState(options.userDataDir); }
   catch { return []; }
+  // 영구 거부(deny)는 옛 동의 영수증을 이긴다 — 규칙이 영수증보다 위다.
+  const partition = partitionMcpConsentByCapabilityGrants(
+    db,
+    state.receipts.map((receipt) => receipt.catalogId),
+  );
+  const denied = new Set(partition.denied);
   const servers = [];
   const seen = new Set();
   for (const receipt of state.receipts) {
-    if (seen.has(receipt.catalogId)) continue;
+    if (seen.has(receipt.catalogId) || denied.has(receipt.catalogId)) continue;
     let row = null;
     try {
       row = db.prepare(
@@ -134,26 +216,66 @@ function readConsentedSystemMcpServers(db, options = {}) {
   return servers;
 }
 
-function normalizeConsentAnswer(answer, availableIds) {
+/**
+ * 답 한 줄을 해석한다. `always`/`a` 는 "전부 붙이고 **다시는 묻지 마라**" — 그 선택만
+ * 공유 능력 규칙(capability_grants)에 영구 기록된다. y/n/ids 는 종전 그대로 1회 한정이다.
+ */
+function parseConsentAnswer(answer, availableIds) {
   const text = String(answer || "").trim();
-  if (/^(?:y|yes|all|전체)$/i.test(text)) return [...availableIds];
-  if (!text || /^(?:n|no|none|없이|아니)$/i.test(text)) return [];
-  const requested = parseIdList(text);
+  if (/^(?:a|always|항상)$/i.test(text)) return { ids: [...availableIds], always: true };
+  if (/^(?:y|yes|all|전체)$/i.test(text)) return { ids: [...availableIds], always: false };
+  if (!text || /^(?:n|no|none|없이|아니)$/i.test(text)) return { ids: [], always: false };
+  const requested = parseIdList(text.replace(/^always\s+/i, ""));
   const allowed = new Set(availableIds);
-  return requested.filter((id) => allowed.has(id));
+  return { ids: requested.filter((id) => allowed.has(id)), always: /^always\s+/i.test(text) };
+}
+
+function normalizeConsentAnswer(answer, availableIds) {
+  return parseConsentAnswer(answer, availableIds).ids;
 }
 
 function askMcpConsentOnce(plan, options = {}) {
   const input = options.input || process.stdin;
   const output = options.output || process.stderr;
-  // TTY가 아니면(파이프/자동화) 묻지 않고 빈 승인 — 조용한 전체 승인 금지.
-  if (!input.isTTY || !output.isTTY || !plan.availableCatalogIds.length) return Promise.resolve([]);
+  /*
+   * 공유 능력 규칙을 먼저 본다(오너 결정 2026-08-20):
+   *   deny → 후보에서 제외하고 묻지 않는다.  allow → 묻지 않고 통과.
+   * 남은 후보만 사람에게 묻는다. 규칙이 없으면 목록이 그대로라 종전 동작과 동일하다.
+   */
+  const partition = partitionMcpConsentByCapabilityGrants(options.db, plan.availableCatalogIds || []);
+  const askable = partition.available;
+  const preApproved = partition.preApproved;
+  const notify = typeof options.onNotice === "function" ? options.onNotice : null;
+  if (notify) {
+    if (partition.denied.length) {
+      notify(`MCP blocked by a shared capability rule (Desktop/Terminal): ${partition.denied.join(", ")}`);
+    }
+    if (preApproved.length) {
+      notify(`MCP already allowed always (shared capability rule): ${preApproved.join(", ")}`);
+    }
+    if (partition.fallbackReason) notify(partition.fallbackReason);
+  }
+  // TTY가 아니면(파이프/자동화) 묻지 않는다 — 조용한 전체 승인 금지.
+  // 이미 "항상 허용"된 것만은 사람에게 물을 필요가 없으므로 그대로 통과시킨다.
+  if (!input.isTTY || !output.isTTY || !askable.length) return Promise.resolve([...preApproved]);
   const rl = readline.createInterface({ input, output, terminal: true });
   return new Promise((resolve) => {
-    rl.question("Attach the available MCP recommendations? [y=all / n=none / comma-separated ids] ", (answer) => {
-      rl.close();
-      resolve(normalizeConsentAnswer(answer, plan.availableCatalogIds));
-    });
+    rl.question(
+      "Attach the available MCP recommendations? [y=once / a=always / n=none / comma-separated ids] ",
+      (answer) => {
+        rl.close();
+        const parsed = parseConsentAnswer(answer, askable);
+        if (parsed.always && parsed.ids.length && options.db) {
+          for (const id of parsed.ids) {
+            const written = rememberMcpCapabilityGrant(options.db, id, "allow");
+            if (!written.ok && notify) notify(`"always" was not persisted for ${id}: ${written.reason}`);
+          }
+        } else if (parsed.always && parsed.ids.length && notify) {
+          notify("\"always\" was not persisted: no shared database handle was given to the consent prompt.");
+        }
+        resolve([...new Set([...preApproved, ...parsed.ids])]);
+      },
+    );
   });
 }
 
@@ -284,6 +406,12 @@ module.exports = {
   persistMcpConsentReceipts,
   readConsentedSystemMcpServers,
   normalizeConsentAnswer,
+  parseConsentAnswer,
   askMcpConsentOnce,
   resolveApprovedMcpRuntimeAllowlist,
+  // 공유 능력 승인(데스크탑 capability_grants) 합류 표면.
+  MCP_CAPABILITY_CLASS,
+  mcpCapabilityQuery,
+  partitionMcpConsentByCapabilityGrants,
+  rememberMcpCapabilityGrant,
 };

package/engine/mcp/index.cjs

@@ -27,6 +27,7 @@ module.exports = {
   probeSystemMcpServerConnection: probe.probeSystemMcpServerConnection,
   // plan — 요구사항 해소 + 빌드 플랜 + 빌더 지시문
   resolveMcpRequirement: plan.resolveMcpRequirement,
+  inferRequirements: plan.inferRequirements,
   buildMcpPlan: plan.buildMcpPlan,
   renderMcpPlan: plan.renderMcpPlan,
   fitApprovedMcpIds: plan.fitApprovedMcpIds,