agentlas 1.0.28 → 1.0.35

package/engine/ui/palette.cjs

@@ -21,6 +21,7 @@ const SLASH_COMMANDS = [
   { command: "/rm", args: "<n>", ko: "세션 제거", en: "Remove a session" },
   { command: "/agents", args: "", ko: "설치 에이전트 목록", en: "List installed agents" },
   { command: "/list", args: "", ko: "설치 에이전트 목록", en: "List installed agents" },
+  { command: "/graph", args: "[run <이름>]", ko: "저장된 자동화 그래프", en: "Saved automation graphs" },
   { command: "/mcp", args: "", ko: "MCP 서버 목록", en: "MCP servers" },
   { command: "/doctor", args: "", ko: "런타임·데이터 점검", en: "Health check" },
   { command: "/runtime", args: "<kind>", ko: "새 세션 런타임 지정", en: "Set runtime for new sessions" },
@@ -39,9 +40,10 @@ const SLASH_COMMANDS = [
   { command: "/network", args: "<request>", ko: "Workforce 라우트", en: "Workforce route" },
   { command: "/workforce", args: "<request>", ko: "Workforce 라우트", en: "Workforce route" },
   { command: "/taskforce", args: "<request>", ko: "임시 태스크포스 편성", en: "Assemble a task force" },
-  // 소스 스코프가 이름에 붙은 스태핑 3종. 스코프를 문장에 적는다 — 예전에는
-  // 별칭이 스코프를 버려 /hep-cloud 가 자산 보관함으로, /hep-hub 가 검색으로
-  // 갔다(2026-07-28 수리). 팔레트 문구가 곧 사용자에게 하는 약속이다.
+  // 소스 스코프 편성 4종 — 2026-08-05 같은 날 삭제 후 네이티브 배선으로 복원.
+  // 이전에는 외부 CLI 스텁(exit 3)이라 죽은 메뉴였다. 지금은 이 터미널의 편성
+  // 루프가 직접 돌고 로컬 Agentlas-OS Core가 선언된 스코프의 메뉴를 연합한다.
+  // 팔레트 문구가 곧 사용자에게 하는 약속이다 — 스코프를 문장에 적는다.
   { command: "/hep-network", args: "\"<request>\"", ko: "로컬+오너 클라우드+공개 Hub 연합 편성", en: "Staff across Local + owner Cloud + public Hub" },
   { command: "/hep-local", args: "\"<request>\"", ko: "등록된 로컬 에이전트만으로 편성", en: "Staff from registered Local agents only" },
   { command: "/hep-cloud", args: "\"<request>\"", ko: "오너 Agent Cloud만으로 편성", en: "Staff from owner Agent Cloud only" },
@@ -75,6 +77,8 @@ const SLASH_COMMANDS = [
   { command: "/creds", args: "<sub>", ko: "자격증명", en: "Credentials" },
   { command: "/env", args: "", ko: "공유 환경 키", en: "Shared env keys" },
   { command: "/multimodal", args: "", ko: "이미지·영상·음성 설정", en: "Image/video/audio providers" },
+  { command: "/document", args: "pdf <html|url>", ko: "문서 PDF 내보내기", en: "Export a document to PDF" },
+  { command: "/roles", args: "[set <role> <runtime>]", ko: "오케스트레이터·워커 모델 역할 조회/설정", en: "Show or set orchestrator/worker model roles" },
   { command: "/telegram", args: "[sub]", ko: "텔레그램 연결", en: "Telegram bindings" },
   { command: "/oberon", args: "[sub]", ko: "AI 필름", en: "AI film" },
   { command: "/film", args: "<sub>", ko: "필름 렌더", en: "Film render" },

package/engine/ui/repl.cjs

@@ -132,6 +132,36 @@ async function startRepl(ctx, opts = {}) {
   let effortOverride = opts.effort || null;
 
   const recoverPresentation = (operation, error) => {
+    /*
+     * 정직 정지(honestStop)는 복구 대상이 아니다 (2026-08-06 실사용 실측).
+     * 실제 REPL에 자연어 지시를 하면 "이 프로젝트에 팀이 없다"는 정직한 안내가
+     * "One이 복구 중" 한 줄로 삼켜졌다 — 사용자는 무엇이 왜 안 되는지, 무엇을
+     * 하면 되는지 전혀 못 봤다(빈 답보다 나쁜 침묵). 정직 정지는 그 사유를
+     * 그대로 보여주고, 어떻게 실행하는지까지 덧붙인다. One 복구는 예상 못 한
+     * 실패에만 쓴다. (사람용 문장과 기계 판단은 다른 필드 — 스케줄러와 같은 원칙.)
+     */
+    if (error && (error.honestStop || error.code)) {
+      // 공유 controller 모듈은 lang을 모른다 — 기계 code로 여기서 현지화한다.
+      const KO_REASON = {
+        project_team_empty: "이 프로젝트에 에이전트 팀이 없습니다. Agentlas Desktop의 Work에서 에이전트를 넣고 다시 시도하세요.",
+        project_not_connected: "이 폴더는 Agentlas 프로젝트에 연결돼 있지 않습니다. Desktop Work에서 연결하거나, 특정 에이전트를 지정해 바로 실행하세요.",
+        project_ambiguous: "이 폴더에 Agentlas 프로젝트가 둘 이상 연결돼 있습니다. 소스 연결을 하나만 남기고 다시 시도하세요.",
+        project_team_unreadable: "이 프로젝트의 에이전트 팀을 읽을 수 없습니다. Agentlas Desktop에서 프로젝트를 열어 팀을 다시 저장하세요.",
+        project_teams_unsupported: "이 Agentlas 데이터 저장소는 아직 프로젝트 팀을 지원하지 않습니다. 최신 Agentlas Desktop을 한 번 실행한 뒤 다시 시도하세요.",
+      };
+      const reason = (!en && error.code && KO_REASON[error.code]) || String(error.message || error);
+      ui.line(ui.c.amber("✖ ") + reason);
+      // 데스크탑을 강제하지 않는다 — 터미널에서 바로 프로젝트를 연결한다(오너 원칙).
+      const connectHint = (error.code === "project_not_connected" || error.code === "project_team_empty");
+      ui.line(ui.c.dim(en
+        ? (connectHint
+          ? "Connect this folder standalone: agentlas project use <agent>  ·  list agents: /list  ·  or run one directly: agentlas run <agent> \"<task>\"."
+          : "Run a specific agent directly: agentlas run <agent> \"<task>\"  ·  list agents: /list.")
+        : (connectHint
+          ? "이 폴더를 바로 연결: agentlas project use <에이전트>  ·  에이전트 목록: /list  ·  또는 하나만 바로 실행: agentlas run <에이전트> \"<할 일>\"."
+          : "특정 에이전트로 바로 실행: agentlas run <에이전트> \"<할 일>\"  ·  에이전트 목록: /list.")));
+      return;
+    }
     const active = orch.active();
     const evidence = String((error && error.message) || error || "").slice(0, 8000);
     if (active && !active.isBusy()) {
@@ -252,10 +282,37 @@ async function startRepl(ctx, opts = {}) {
       },
     });
     const PROMPT = "› ";
+    /*
+     * 빈 입력 고스트 힌트 (2026-08-06, 레퍼런스 REPL 대조에서 나온 유도 격차).
+     * claude-code류 REPL은 빈 입력줄에 무엇을 칠 수 있는지 흐리게 보여준다 —
+     * 우리는 `› ` 뿐이라 첫 사용자가 / 팔레트·@ 멘션·? 도움의 존재를 알 길이
+     * 없었다. 커서 "뒤"에 dim 힌트를 쓰고 커서를 되돌린다. 어떤 키든 처음
+     * 눌리는 순간 커서-뒤 지우기(CSI K)로 걷어내므로 readline 의 echo·팔레트
+     * 오버레이와 겹치지 않는다. 비TTY·바쁜 세션에서는 그리지 않는다.
+     */
+    const { visWidth } = require("../agentlas-composer.cjs");
+    const GHOST_HINT = en
+      ? "type a task · / commands · @ files · ? shortcuts"
+      : "할 일을 문장으로 · / 명령 · @ 파일 · ? 단축키";
+    let ghostVisible = false;
+    const drawGhost = () => {
+      if (!process.stdout.isTTY || rl.line) return;
+      const width = visWidth(GHOST_HINT);
+      const room = (process.stdout.columns || 80) - visWidth(PROMPT) - 2;
+      if (width > room) return; // 좁은 터미널에서는 유도보다 입력이 우선이다
+      ui.write(ui.c.faint(GHOST_HINT) + `\x1b[${width}D`);
+      ghostVisible = true;
+    };
+    const clearGhost = () => {
+      if (!ghostVisible) return;
+      ghostVisible = false;
+      if (process.stdout.isTTY) ui.write("\x1b[K");
+    };
     const prompt = () => {
       if (!renderer.session || !renderer.session.isBusy()) {
         rl.setPrompt(PROMPT);
         rl.prompt();
+        drawGhost();
       }
     };
 
@@ -289,6 +346,8 @@ async function startRepl(ctx, opts = {}) {
       },
     });
     const onShortcutKey = (str, key) => {
+      // 고스트 힌트는 어떤 키가 와도 readline 이 echo 하기 전에 걷어낸다.
+      clearGhost();
       if (!permissionShortcut.handleKey(str, key)) return;
       swallowCompletion = true;
       setImmediate(() => { swallowCompletion = false; });
@@ -329,10 +388,62 @@ async function startRepl(ctx, opts = {}) {
       }
     };
 
+    let emptyEnters = 0;
     rl.on("line", (line) => {
       sigints = 0;
       const input = line.trim();
-      if (!input) { prompt(); return; }
+      if (!input) {
+        /*
+         * 빈 Enter 유도 (2026-08-06 레퍼런스 대조): 1회는 조용히 — 실수로 친
+         * Enter 마다 잔소리하면 소음이다. 연달아 두 번이면 길을 잃은 것이므로
+         * 다음 행선지를 한 줄로 보여준다.
+         */
+        emptyEnters += 1;
+        if (emptyEnters >= 2) {
+          emptyEnters = 0;
+          ui.line(ui.c.dim(en
+            ? "Type a task in plain words, / for commands, ? for shortcuts."
+            : "할 일을 그냥 문장으로 치세요. / 는 명령, ? 는 단축키입니다."));
+        }
+        prompt();
+        return;
+      }
+      emptyEnters = 0;
+
+      /*
+       * `?` 단축키 도움 (2026-08-06): 첫 화면 어디에도 키 조작법이 없었다 —
+       * Shift-Tab 권한 순환·조종 큐·@멘션은 아는 사람만 썼다. 한 글자로 요약을
+       * 준다(claude-code 의 ? 관례).
+       */
+      if (input === "?") {
+        const rowsHelp = en ? [
+          ["/", "command palette (type to filter, ↑↓ pick, Tab complete, Esc close)"],
+          ["Tab", "complete commands, agent names, @file paths, session keys"],
+          ["@path", "mention a file anywhere in your sentence"],
+          ["↑ / ↓", "input history (kept across sessions)"],
+          ["Shift-Tab", "cycle permission read → write (twice for full)"],
+          ["Ctrl-C", "interrupt the running turn · press twice to quit"],
+          ["typing while running", "queues steering for the current turn"],
+          ["/sessions · /s <n>", "list · switch parallel sessions"],
+        ] : [
+          ["/", "명령 팔레트 (입력=검색, ↑↓ 선택, Tab 완성, Esc 닫기)"],
+          ["Tab", "명령·에이전트 이름·@파일 경로·세션 키 완성"],
+          ["@경로", "문장 어디서든 파일 멘션"],
+          ["↑ / ↓", "입력 히스토리 (세션 넘어 유지)"],
+          ["Shift-Tab", "권한 순환 read → write (두 번이면 full)"],
+          ["Ctrl-C", "실행 중 턴 중단 · 두 번이면 종료"],
+          ["실행 중 타이핑", "현재 턴에 조종 지시로 쌓임"],
+          ["/sessions · /s <n>", "병렬 세션 목록 · 전환"],
+        ];
+        // 한글 키 라벨은 전각 폭 — padEnd(코드포인트 수)로 맞추면 열이 어긋난다.
+        const keyWidth = Math.max(...rowsHelp.map(([k]) => visWidth(k)));
+        ui.line(ui.c.bold(en ? "Shortcuts" : "단축키"));
+        for (const [k, desc] of rowsHelp) {
+          ui.line("  " + ui.c.blue(k) + " ".repeat(keyWidth - visWidth(k)) + "  " + ui.c.dim(desc));
+        }
+        prompt();
+        return;
+      }
 
       if (input.startsWith("/")) {
         try {
@@ -585,8 +696,12 @@ function handleSlash(ctx, cmdline, api) {
 
     case "runtime": {
       if (!rest[0]) throw new Error("Usage: /runtime claude-code|codex|gemini");
+      // 세션 오버라이드는 저장되지 않는다 — 고지 없이는 사용자가 영구 설정으로
+      // 믿는다(2026-08-05 감사 결함 C). 영구 경로를 같은 줄에서 알려준다.
       api.setRuntime(rest[0]);
-      ctx.out(ui.c.dim(`runtime: ${rest[0]} (${en ? "applies to new sessions" : "새 세션부터 적용"})`));
+      ctx.out(ui.c.dim(`runtime: ${rest[0]} (${en
+        ? "new sessions in this REPL only — persist with: agentlas roles set orchestrator " + rest[0]
+        : "이 REPL의 새 세션 한정 — 영구 설정: agentlas roles set orchestrator " + rest[0]})`));
       return;
     }
     case "model": {
@@ -595,7 +710,9 @@ function handleSlash(ctx, cmdline, api) {
       const next = ["default", "inherit"].includes(model.toLowerCase()) ? null : model;
       api.setModel(next);
       ctx.out(ui.c.dim(
-        `model: ${next || "default"} (${en ? "applies to new sessions" : "새 세션부터 적용"})`,
+        `model: ${next || "default"} (${en
+          ? "new sessions in this REPL only — persist with: agentlas roles set"
+          : "이 REPL의 새 세션 한정 — 영구 설정: agentlas roles set"})`,
       ));
       return;
     }

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

@@ -0,0 +1,7 @@
+{
+  "version": "2",
+  "url": "https://github.com/agentlas-ai/agentlas-terminal/releases/download/desktop-core-v2/desktop-core.tar.gz",
+  "sha256": "782760c34af1d06b9efd212d48ba032fe46907bdc8bc836025c44fc658968d6f",
+  "sizeBytes": 12295321,
+  "writtenAt": "2026-08-09T21:43:34.707Z"
+}

package/engine/workforce/capture.cjs

@@ -18,6 +18,7 @@
  *    프로젝트 .env가 보호 키(타임아웃/캡처 상한 포함)를 덮지 못한다
  */
 const fs = require("node:fs");
+const { detectRuntimeRefusal } = require("../runtime-refusal.cjs");
 const os = require("node:os");
 const path = require("node:path");
 const { spawn } = require("node:child_process");
@@ -309,6 +310,48 @@ function capturedRuntimeUsage(kind, raw) {
   return null;
 }
 
+
+/**
+ * ★캡처된 스트림에서 **실패 표식**을 걷는다 — 종료코드만 보면 exit 0 거절이 산출물이 된다.
+ *
+ * 실측(2026-08-06): claude 한도는 rate_limit_event(status:rejected)·result(is_error:true)를
+ * 보내고, codex 한도는 표식 없이 거절문을 agent_message로 싣고 turn.completed로 끝난다.
+ * 이 파일은 이벤트 종류 목록에 rate_limit_event를 적어 두고도 한 번도 읽지 않았다 —
+ * 거절문이 그대로 워커 핸드오프가 되어 종합(synthesis)에 섞였다.
+ */
+function capturedRuntimeFailure(kind, raw, text) {
+  const events = raw.split(/\r?\n/).map((line) => {
+    try { return JSON.parse(line); } catch { return null; }
+  }).filter(Boolean);
+  for (const event of events) {
+    if (!event || typeof event !== "object") continue;
+    if (kind === "claude-code") {
+      if (event.type === "result" && event.is_error) {
+        return { message: typeof event.result === "string" ? event.result : "claude error", source: "marker" };
+      }
+      if (event.type === "rate_limit_event" && event.rate_limit_info && event.rate_limit_info.status === "rejected") {
+        return { message: "claude rate limit rejected", source: "marker" };
+      }
+    }
+    if (kind === "codex" && (event.type === "turn.failed" || event.type === "error")) {
+      const msg = (event.error && (event.error.message || event.error)) || "codex error";
+      return { message: String(msg), source: "marker" };
+    }
+    if (kind === "gemini") {
+      if (event.type === "error") {
+        const msg = (event.error && (event.error.message || event.error)) || "gemini error";
+        return { message: String(msg), source: "marker" };
+      }
+      if (event.type === "result" && event.status && event.status !== "success") {
+        return { message: `gemini ${event.status}`, source: "marker" };
+      }
+    }
+  }
+  // 표식이 전혀 없는 케이스(codex 한도) — 휴리스틱 최후 그물, 출처 표기.
+  const refusal = detectRuntimeRefusal(text);
+  return refusal ? { message: refusal.message, source: "heuristic" } : null;
+}
+
 function capturedRuntimeAgentText(kind, raw) {
   const text = String(raw || "");
   const events = [];
@@ -377,7 +420,8 @@ function captureRuntime(kind, systemPrompt, prompt, opts) {
     ? captureOutputLimit(opts.env || process.env)
     : directCaptureOutputLimit(opts.outputLimitBytes);
   return new Promise((resolve, reject) => {
-    const bin = which(RUNTIME_BIN[kind]) || RUNTIME_BIN[kind];
+    // 계약 테스트용 실행 파일 주입(가짜 CLI가 픽스처를 cat) — 프로덕션 경로에선 없음.
+    const bin = opts.binOverride || which(RUNTIME_BIN[kind]) || RUNTIME_BIN[kind];
     let child;
     try {
       const spawnImpl = opts.spawn || spawn;
@@ -523,6 +567,12 @@ function captureRuntime(kind, systemPrompt, prompt, opts) {
       } else {
         text = raw;
       }
+      // ★거절 고지문은 산출물이 아니다 — 성공으로 돌려주면 워커 핸드오프가 오염된다.
+      const failure = capturedRuntimeFailure(kind, raw, text);
+      if (failure) {
+        finishReject(new Error(`${kind} runtime refused (${failure.source}): ${failure.message}`));
+        return;
+      }
       finishResolve(opts.envelope
         ? { text, usage: capturedRuntimeUsage(kind, raw) }
         : text);

package/engine/workforce/deps.cjs

@@ -579,9 +579,22 @@ function workforceRuntime(ctx = {}) {
   return _workforce;
 }
 
+/*
+ * 로컬 Core 전송을 실은 1회용 런타임 (2026-08-05, hep-* 네이티브 배선).
+ * 싱글턴을 쓰지 않는 이유: D.callHubTool은 명령 수명의 stdio 프로세스와 validate
+ * 계보 상태를 붙잡는다 — 공유하면 다음 편성이 앞 편성의 계보를 이어받는다.
+ * 원격 기본 경로(workforceRuntime)는 여기서 아무것도 바뀌지 않는다.
+ */
+function createLocalCoreWorkforceRuntime(ctx, transport) {
+  const deps = buildWorkforceDeps(ctx);
+  deps.callHubTool = transport.callHubTool;
+  return require("../agentlas-workforce.cjs").create(deps);
+}
+
 module.exports = {
   buildWorkforceDeps,
   workforceRuntime,
+  createLocalCoreWorkforceRuntime,
   resolveWorkforceRuntime,
   receiptFile,
   appendReceipt,

package/engine/workforce/local-core-transport.cjs

@@ -0,0 +1,298 @@
+"use strict";
+/*
+ * workforce/local-core-transport — 편성 루프(agentlas-workforce.cjs)를 로컬
+ * Agentlas Core(연합 소유자)에 잇는 어댑터.
+ *
+ * 전선 계약 — 전부 2026-08-05 실측(모델 호출 0회 프로브)으로 확정:
+ *   search_candidates  요청 {workOrder, sourceScope}
+ *                      응답 agentlas.workforce-federation-result.v1 봉투
+ *                      → 루프에는 봉투를 벗긴 candidateSet만 준다.
+ *   validate_selection 요청 {workOrder, selection, candidateSet}
+ *                      (federationResult를 실으면 invalid_federation_result —
+ *                       Core는 자기 선택 세션에서 연합을 이미 안다)
+ *                      응답 안의 selectionValidation이 정확히
+ *                      agentlas.workforce-selection-validation.v1 — 루프 검증기와
+ *                      동일 계약이라 그대로 돌려준다. 원본 응답은 여기 상태로
+ *                      붙잡아 둔다(prepare가 요구).
+ *   prepare_execution  요청 {workOrder, selection, candidateSet,
+ *                       federatedSelection: <validate 원본 응답>,
+ *                       validationReceipt: <동일>, projectDir}
+ *                      응답 안의 executionPlan이 정확히
+ *                      agentlas.workforce-execution-plan.v5 (roster에
+ *                      directiveBundle·permissionPolicy 동봉) — 그대로 돌려준다.
+ *
+ * 원격(agentlas.cloud) 경로는 건드리지 않는다: 이 어댑터는 D.callHubTool로
+ * 주입될 때만 산다. Core 거절 코드는 원문 그대로 전파된다(local-core.cjs 계약).
+ */
+const crypto = require("node:crypto");
+const { createLocalCoreClient } = require("../hephaestus/local-core.cjs");
+
+const SOURCE_SCOPES = new Set(["network", "local", "cloud", "hub"]);
+
+/*
+ * ── id 정규화 (실측 2026-08-05 라이브 런 실패의 수리) ──
+ *
+ * 리더 LLM은 사람이 읽는 id를 짓는다(work-order:korean-summary-…-20260805,
+ * slotId "korean-doc-writer"). 원격 서버는 받아주지만 로컬 Core 경계는 finite id
+ * 정책으로 거절한다 — 실측 issues: work_order_id_not_public_finite,
+ * slot_id_not_public_finite. novel id 의 유효 형식은 <ns>:opaque-<64hex> 다.
+ *
+ * 그래서 Core 로 나가는 모든 workOrderId·slotId 를 결정론적 opaque 로 정규화하고
+ * (sha256(원본) — 같은 원본은 항상 같은 opaque, 재검색·재개에도 안정), Core 에서
+ * 들어오는 응답의 그 값들을 원본으로 역치환한다. 루프·리더 프롬프트·영수증은
+ * 사람이 읽는 원본만 본다. 치환은 "문자열 값의 정확 일치"로만 한다 — 부분 문자열
+ * 치환은 다이제스트·서술문을 오염시킨다.
+ */
+const sha256hex = (value) => crypto.createHash("sha256").update(String(value)).digest("hex");
+const OPAQUE_RE = /^[a-z][a-z-]*:(?:opaque-[0-9a-f]{64}|ordinal-\d+)$/;
+
+function opaqueId(namespace, id) {
+  return OPAQUE_RE.test(id) ? id : `${namespace}:opaque-${sha256hex(id)}`;
+}
+
+/** workOrder에서 forward(원본→opaque)/reverse(opaque→원본) 값 지도를 만든다. */
+function buildIdMaps(workOrder) {
+  const forward = new Map();
+  const reverse = new Map();
+  const add = (namespace, id) => {
+    if (typeof id !== "string" || !id) return;
+    const mapped = opaqueId(namespace, id);
+    if (mapped === id) return;
+    forward.set(id, mapped);
+    reverse.set(mapped, id);
+  };
+  add("work-order", workOrder.workOrderId);
+  for (const slot of workOrder.roleSlots || []) add("slot", slot.slotId);
+  return { forward, reverse };
+}
+
+/*
+ * 경계 거절 issues 의 path("edges[0].artifactKinds[0]")에서 실제 값을 찾는다.
+ * 선제 정규화(workOrderId·slotId)가 못 덮는 finite 어휘가 있다 — 실측:
+ * artifactKinds 는 finite 카탈로그다(artifact_concept_not_public_finite). 카탈로그를
+ * 하드코딩하면 Core 업데이트마다 어긋나므로, 거절이 지목한 값만 opaque 화해
+ * 1회 재시도한다. role/skill/community 는 open-world 라 여기 올 일이 없다.
+ */
+function valueAtPath(root, issuePath) {
+  const segments = String(issuePath || "").match(/[A-Za-z_][A-Za-z0-9_]*|\[\d+\]/g) || [];
+  let current = root;
+  for (const segment of segments) {
+    if (current == null) return undefined;
+    current = segment.startsWith("[") ? current[Number(segment.slice(1, -1))] : current[segment];
+  }
+  return current;
+}
+
+function boundaryIssues(error) {
+  const issues = error?.detail?.boundary?.issues;
+  return Array.isArray(issues) ? issues : null;
+}
+
+/** 깊은 순회로 문자열 값을 정확 일치 치환한 사본을 만든다. */
+function mapDeep(value, map) {
+  if (map.size === 0) return value;
+  if (typeof value === "string") return map.get(value) || value;
+  if (Array.isArray(value)) return value.map((item) => mapDeep(item, map));
+  if (value && typeof value === "object") {
+    const out = {};
+    for (const [key, item] of Object.entries(value)) out[key] = mapDeep(item, map);
+    return out;
+  }
+  return value;
+}
+
+function createLocalCoreHubTool({ sourceScope, projectDir, cwd, client } = {}) {
+  if (!SOURCE_SCOPES.has(sourceScope)) {
+    const error = new Error(`sourceScope must be network|local|cloud|hub, got: ${String(sourceScope)}`);
+    error.code = "source_scope_invalid";
+    throw error;
+  }
+  if (!projectDir || typeof projectDir !== "string") {
+    const error = new Error("projectDir is required — local Core prepare_execution binds the preparation to a project");
+    error.code = "project_dir_required";
+    throw error;
+  }
+  const core = client || createLocalCoreClient({ cwd: cwd || projectDir });
+  // 편성 계보 상태 — 전부 "Core 어휘"(opaque id) 원본이다:
+  //   maps: 마지막 search 의 id 지도. 재검색(refinement)마다 재구성된다.
+  //   coreCandidateSet: Core 가 준 원본 CandidateSet (validate/prepare 로 무수정 반송).
+  //   lastValidationEnvelope: validate 원본 응답. prepare 의 federatedSelection 은
+  //     이것이어야 한다 — 루프가 들고 있는 것은 벗겨낸 selectionValidation 뿐이다.
+  let maps = { forward: new Map(), reverse: new Map() };
+  let coreCandidateSet = null;
+  let lastValidationEnvelope = null;
+  // validate 가 실제로 수락한 Core 어휘 selection. prepare 는 정확히 이 본을
+  // 반송해야 한다 — 반응형 reasonCode 수리가 있었으면 루프의 selection 을 다시
+  // 변환한 것과 다르다(exact binding).
+  let lastCoreSelection = null;
+
+  const invalid = (message) => {
+    const error = new Error(message);
+    error.code = "local_core_invalid_response";
+    return error;
+  };
+
+  async function callHubTool(name, args) {
+    if (name === "workforce.search_candidates") {
+      maps = buildIdMaps(args.workOrder);
+      coreCandidateSet = null;
+      lastValidationEnvelope = null;
+      // fullDossier: 터미널 루프의 후보 검증기는 legacy full-echo 계약이다
+      // (qualificationEvidence·packageHash·contentDigest 필수 — 실측: 기본
+      // reference-first 메뉴는 candidate_set_invalid 로 거절된다).
+      let envelope;
+      try {
+        envelope = await core.call(name, { workOrder: mapDeep(args.workOrder, maps.forward), sourceScope, fullDossier: true });
+      } catch (error) {
+        // 반응형 정규화(1회): 경계가 지목한 finite 값만 opaque 로 바꿔 재시도.
+        const issues = error.code === "work_order_hub_boundary_rejected" ? boundaryIssues(error) : null;
+        if (!issues || !issues.length) throw error;
+        const sentWorkOrder = mapDeep(args.workOrder, maps.forward);
+        let repaired = 0;
+        for (const issue of issues) {
+          const value = valueAtPath(sentWorkOrder, issue.path);
+          if (typeof value !== "string" || !value) continue;
+          const namespace = value.includes(":") ? value.slice(0, value.indexOf(":")) : "id";
+          const original = maps.reverse.get(value) || value;
+          const mapped = opaqueId(namespace, value);
+          if (mapped === value) continue;
+          maps.forward.set(original, mapped);
+          maps.reverse.set(mapped, original);
+          repaired += 1;
+        }
+        if (!repaired) throw error;
+        envelope = await core.call(name, { workOrder: mapDeep(args.workOrder, maps.forward), sourceScope, fullDossier: true });
+      }
+      const candidateSet = envelope && envelope.candidateSet;
+      if (!candidateSet || typeof candidateSet !== "object") throw invalid("local Core federation returned no candidateSet");
+      coreCandidateSet = candidateSet;
+      return mapDeep(candidateSet, maps.reverse);
+    }
+    if (name === "workforce.validate_selection") {
+      if (!coreCandidateSet) {
+        const error = new Error("validate_selection called before search_candidates — the federated lineage is missing");
+        error.code = "local_core_lineage_missing";
+        throw error;
+      }
+      // 루프의 candidateSet(역치환본)과 보관본의 계보 일치를 다이제스트로 확인한다.
+      if (args.candidateSet?.candidateSetDigest !== coreCandidateSet.candidateSetDigest) {
+        throw invalid("candidateSet lineage mismatch between the loop and the local Core session");
+      }
+      let envelope;
+      let coreSelection = mapDeep(args.selection, maps.forward);
+      try {
+        envelope = await core.call(name, {
+          workOrder: mapDeep(args.workOrder, maps.forward),
+          selection: coreSelection,
+          candidateSet: coreCandidateSet,
+        });
+      } catch (error) {
+        /*
+         * 반응형 정규화(1회): 리더의 자유 reasonCodes 는 finite 정책에 걸린다
+         * (실측: selection_reason_code_not_public_finite). 선택 경계의 finite id
+         * 정책은 "public finite reason codes" — opaque 형식 허용 문구가 없어
+         * 카탈로그 값으로만 대체한다. reason:host-semantic-judgment 는 관측된
+         * 카탈로그 값이며 사실 그 자체다(호스트 LLM 의 의미 판단). 사람이 읽을
+         * 원문 사유는 루프의 영수증(selection.assignments 원본)에 이미 남아 있다.
+         */
+        const issues = error.code === "selection_hub_boundary_rejected" ? boundaryIssues(error) : null;
+        const reasonIssues = issues ? issues.filter((issue) => issue.code === "selection_reason_code_not_public_finite") : [];
+        if (!reasonIssues.length) throw error;
+        const repairedSelection = mapDeep(args.selection, maps.forward);
+        for (const assignment of repairedSelection.assignments || []) {
+          assignment.reasonCodes = ["reason:host-semantic-judgment"];
+        }
+        envelope = await core.call(name, {
+          workOrder: mapDeep(args.workOrder, maps.forward),
+          selection: repairedSelection,
+          candidateSet: coreCandidateSet,
+        });
+        coreSelection = repairedSelection;
+      }
+      if (!envelope || typeof envelope.selectionValidation !== "object") throw invalid("local Core validation returned no selectionValidation receipt");
+      lastValidationEnvelope = envelope;
+      lastCoreSelection = coreSelection;
+      return mapDeep(envelope.selectionValidation, maps.reverse);
+    }
+    if (name === "workforce.prepare_execution") {
+      if (!lastValidationEnvelope) {
+        const error = new Error("prepare_execution called before validate_selection — the federated lineage is missing");
+        error.code = "local_core_lineage_missing";
+        throw error;
+      }
+      const envelope = await core.call(name, {
+        workOrder: mapDeep(args.workOrder, maps.forward),
+        // validate 가 수락한 정확한 본 — 반응형 reasonCode 수리를 반영한다.
+        selection: lastCoreSelection || mapDeep(args.selection, maps.forward),
+        candidateSet: coreCandidateSet,
+        federatedSelection: lastValidationEnvelope,
+        validationReceipt: lastValidationEnvelope,
+        projectDir,
+      });
+      if (!envelope || typeof envelope.executionPlan !== "object") throw invalid("local Core preparation returned no executionPlan");
+      const plan = mapDeep(envelope.executionPlan, maps.reverse);
+      /*
+       * 어휘 왕복의 마지막 두 조각 (실측: 루프의 execution_context_mismatch):
+       *  1) Core 는 워크오더의 미선언 slot 필드를 스키마 기본값 [] 로 정규화해
+       *     돌려준다. 루프의 expectedContext 는 원본 워크오더에서 유도하므로
+       *     undefined ↔ [] 가 불일치가 된다. 원본에 없던 필드가 빈 값으로 돌아온
+       *     경우만 제거한다 — 값이 실제로 다르면 그대로 두어 루프가 잡게 한다.
+       *  2) 반응형 reasonCode 수리가 있었으면 Core 어휘의 assignments 에는
+       *     카탈로그 값이 들어 있다. 사람이 읽는 원문 사유(루프의 selection)를
+       *     자리(slotId+agentReleaseId) 기준으로 복원한다.
+       */
+      const context = plan.executionContext;
+      if (context && Array.isArray(context.slots)) {
+        const originalSlots = new Map((args.workOrder.roleSlots || []).map((slot) => [slot.slotId, slot]));
+        for (const slot of context.slots) {
+          const original = originalSlots.get(slot.slotId);
+          if (!original) continue;
+          for (const [key, value] of Object.entries(slot)) {
+            const emptyDefault = Array.isArray(value) && value.length === 0;
+            if (emptyDefault && original[key] === undefined && !["allowedEntityKinds"].includes(key)) {
+              delete slot[key];
+            }
+          }
+        }
+      }
+      if (context && Array.isArray(context.assignments)) {
+        const originalAssignments = new Map((args.selection.assignments || []).map(
+          (assignment) => [`${assignment.slotId}${assignment.agentReleaseId}`, assignment],
+        ));
+        for (const assignment of context.assignments) {
+          const original = originalAssignments.get(`${assignment.slotId}${assignment.agentReleaseId}`);
+          if (original) assignment.reasonCodes = original.reasonCodes;
+        }
+      }
+      /*
+       * 다이제스트 재서명: Core 의 executionContextDigest 는 Core 어휘(opaque id·
+       * 카탈로그 reason·[] 기본값) 위에서 계산됐다. 위의 어휘 왕복으로 루프 어휘
+       * 컨텍스트가 됐으므로 루프와 같은 함수로 재계산한다 — 게이트웨이에서의
+       * 재서명이지 위조가 아니다: 원본 무결성은 Core 세션과 영수증이 지킨다.
+       */
+      if (context) {
+        const { _test } = require("../agentlas-workforce.cjs");
+        plan.executionContextDigest = _test.executionContextDigest(context);
+        // roster 행도 같은 이유로 재서명한다 — 역치환이 행 내용(slot 어휘)을
+        // 루프 어휘로 바꿨으므로 bundleDigest/executionGraphDigest 를 루프와 같은
+        // 함수로 재계산한다.
+        for (const row of plan.executionRoster || []) {
+          if (row && row.executionGraph && typeof row.executionGraphDigest === "string") {
+            row.executionGraphDigest = _test.executionGraphDigest(_test.validateExecutionGraph(row.executionGraph));
+          }
+          if (row && typeof row.bundleDigest === "string") {
+            row.bundleDigest = _test.workforceRuntimeBundleDigest(row);
+          }
+        }
+      }
+      return plan;
+    }
+    const error = new Error(`unsupported local-core workforce tool: ${name}`);
+    error.code = "local_core_unsupported_tool";
+    throw error;
+  }
+
+  return { callHubTool, close: () => core.close() };
+}
+
+module.exports = { createLocalCoreHubTool, SOURCE_SCOPES };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentlas",
-  "version": "1.0.28",
+  "version": "1.0.35",
   "description": "Agentlas project terminal — run project controllers and task-scoped agent teams from the terminal. Standalone: no desktop app process required.",
   "bin": {
     "agentlas": "bin/agentlas.cjs"
@@ -8,7 +8,9 @@
   "scripts": {
     "smoke": "sh test/smoke.sh",
     "test:release-contracts": "npm run smoke",
-    "sync:architecture": "node scripts/sync-architecture-from-desktop.cjs"
+    "sync:architecture": "node scripts/sync-architecture-from-desktop.cjs",
+    "vendor:core": "node scripts/vendor-desktop-core.cjs",
+    "test:tool-access-notice-parity": "node test/tool-access-notice-parity.cjs"
   },
   "engines": {
     "node": ">=20"