agentlas 1.0.28 → 1.0.29

package/engine/sessions/prompt.cjs

@@ -190,6 +190,22 @@ function augmentSystem(db, baseSystem, ctx, withEmitter, request = "") {
   if (connectionSkill) sys += "\n\n" + connectionSkill;
   const mem = cliMemoryContext(db, ctx && ctx.projectPath, ctx && ctx.agentId, request);
   if (mem) sys += "\n\n" + mem;
+  // 도구 접근 고지 — 터미널에는 이게 아예 없었다. 도구가 붙지 않은 턴에서 CLI는 아무
+  // 말도 하지 않았고, 에이전트는 "이 기계엔 도구가 없다"고 단정하거나 없는 도구를
+  // 불렀다. Desktop `shared/tool-access-notice.ts`와 같은 문장을 낸다(패리티 테스트로 고정).
+  //
+  // ★메모리 블록보다 **앞**에 둔다. 메모리 코어 예산은 `## Memory` 이후를 잘라서 재므로
+  // (test/memory-prompt-budget.cjs), 뒤에 붙이면 도구 고지가 메모리 예산으로 잘못 계산된다.
+  // 고지는 메모리 블록의 일부가 아니다.
+  try {
+    const { buildToolAccessNotice } = require("../tools/access-notice.cjs");
+    sys += "\n\n" + buildToolAccessNotice({
+      availableTools: (ctx && Array.isArray(ctx.availableTools)) ? ctx.availableTools : [],
+      // 터미널은 Hub 카탈로그를 hephaestus-network MCP로만 본다. 그 서버가 이번 턴에
+      // 붙지 않았으면 "찾아보라"고 말하면 안 된다 — 부를 수 없는 도구를 안내하는 셈이다.
+      hubCatalogAvailable: Boolean(ctx && ctx.hubCatalogAvailable),
+    });
+  } catch { /* 고지 실패가 턴을 막지 않는다 */ }
   if (withEmitter) {
     sys += "\n\n" + memoryEmitterPromptFor(request, arch, ctx && ctx.turnId, ctx && ctx.permission);
     const credentialReminder = credentialIndexReminderFor(request);

package/engine/sessions/session.cjs

@@ -205,12 +205,21 @@ class Session extends EventEmitter {
     try {
       const { augmentSystem } = require("./prompt.cjs");
       const projectPath = governedTurn ? governedTurn.projectPath : memoryTurn.initializedProjectPath(this.cwd);
+      // 이번 턴에 실제로 붙는 도구를 고지에 넘긴다. 권한이 낮아 목록을 읽지 않는 턴은
+      // 빈 배열이 되고, 고지는 "붙은 도구가 없다"고 정확히 말한다 — 침묵하지 않는다.
+      const consentedServers = this._consentedMcpServers();
+      const toolNames = consentedServers
+        .map((server) => String((server && (server.name || server.id)) || "").trim())
+        .filter(Boolean);
       systemPrompt = augmentSystem(this.db, systemPrompt, {
         lang: this.lang,
         projectPath,
         agentId: this.agent.id,
         turnId: governedTurn && governedTurn.memoryTurn.turnId,
         permission: this.permission,
+        availableTools: toolNames,
+        // Hub 카탈로그는 hephaestus-network MCP를 통해서만 보인다.
+        hubCatalogAvailable: toolNames.some((name) => /hephaestus[-_]?network|agentlas/i.test(name)),
       }, true, prompt);
     } catch { /* 프롬프트 증강 실패는 턴을 막지 않는다 — 원 프롬프트로 진행 */ }
 

package/engine/tools/access-notice.cjs

@@ -0,0 +1,86 @@
+// 도구 접근 고지 — Desktop `shared/tool-access-notice.ts`의 터미널 미러.
+//
+// 정본은 Desktop 쪽이고, 이 파일은 **같은 문장을 내야 한다**. 두 벌이 갈라지면 같은
+// 제품이 표면마다 다른 말을 하게 되고, 사용자는 어느 쪽이 맞는지 알 수 없다.
+// `test/tool-access-notice-parity.cjs`가 두 구현을 같은 입력으로 돌려 대조한다.
+//
+// 터미널에는 이 고지가 **아예 없었다**. 도구가 붙지 않은 실행에서 CLI는 아무 말도 하지
+// 않았고, 에이전트는 "이 기계엔 도구가 없다"고 단정하거나 없는 도구를 부르거나 그냥
+// 침묵했다. 도구가 없을 때가 안내가 가장 필요한 순간이다.
+
+"use strict";
+
+const DEFAULT_RESOLVE_TOOL = "agentlas_resolve_plugins";
+
+/**
+ * 모든 표면이 공유하는 도구 접근 고지.
+ * 절대 빈 문자열을 반환하지 않는다 — 붙은 도구가 없다는 사실 자체가 정보다.
+ *
+ * @param {{
+ *   availableTools: string[],
+ *   blockedTools?: string[],
+ *   pendingApprovalTools?: string[],
+ *   hubCatalogAvailable: boolean,
+ *   hubCatalogError?: string|null,
+ *   resolveToolName?: string,
+ * }} input
+ * @returns {string}
+ */
+function buildToolAccessNotice(input) {
+  const resolveTool = (input.resolveToolName || "").trim() || DEFAULT_RESOLVE_TOOL;
+  const clean = (list) => (Array.isArray(list) ? list : []).filter((name) => String(name || "").trim().length > 0);
+  const available = clean(input.availableTools);
+  const blocked = clean(input.blockedTools);
+  const pending = clean(input.pendingApprovalTools);
+  const lines = [];
+
+  lines.push(
+    available.length > 0
+      ? `Tools available in this run: ${available.join(", ")}.`
+      : "No tools are connected in this run.",
+  );
+
+  if (pending.length > 0) {
+    lines.push(
+      `Already attached but switched off, waiting for the user to approve local execution: ${pending.join(", ")}. ` +
+      "Ask the user to approve it instead of installing anything new.",
+    );
+  }
+
+  if (input.hubCatalogAvailable) {
+    lines.push(
+      `Before telling the user a capability is unavailable, call ${resolveTool} with the capability you need. ` +
+      "The Agentlas Hub catalog covers integrations that are not installed here yet.",
+    );
+  } else if (input.hubCatalogError) {
+    lines.push(
+      `The Agentlas Hub catalog could not be reached this run (${input.hubCatalogError}). ` +
+      "Say that the catalog is unreachable rather than that no such tool exists.",
+    );
+  } else {
+    lines.push(
+      "The Agentlas Hub catalog is not reachable from this surface. " +
+      "Say what you cannot do and why; do not claim a capability that is not connected.",
+    );
+  }
+
+  lines.push(
+    "Never install or enable a tool on your own. Show the slug, what it will be allowed to do, " +
+    "and whether it needs credentials, then let the user decide.",
+  );
+
+  if (blocked.length > 0) {
+    lines.push(
+      `Matched but unusable until credentials are set: ${blocked.join(", ")}. ` +
+      "Ask for those only if this task actually needs them.",
+    );
+  }
+
+  lines.push(
+    "If nothing covers the need, say so plainly. Do not describe a tool call you did not make.",
+  );
+
+  return lines.join("\n");
+}
+
+module.exports = { buildToolAccessNotice, DEFAULT_RESOLVE_TOOL };

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,7 @@ 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: "/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

@@ -585,8 +585,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 +599,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/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,14 +1,15 @@
 {
   "name": "agentlas",
-  "version": "1.0.28",
-  "description": "Agentlas project terminal — run project controllers and task-scoped agent teams from the terminal. Standalone: no desktop app process required.",
+  "version": "1.0.29",
+  "description": "Agentlas project terminal \u2014 run project controllers and task-scoped agent teams from the terminal. Standalone: no desktop app process required.",
   "bin": {
     "agentlas": "bin/agentlas.cjs"
   },
   "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",
+    "test:tool-access-notice-parity": "node test/tool-access-notice-parity.cjs"
   },
   "engines": {
     "node": ">=20"

package/engine/commands/legacy-network.cjs

@@ -1,29 +0,0 @@
-"use strict";
-/*
- * legacy-network — 호환 전용 Hephaestus 네트워크 경로 (명시적 탈출구).
- *
- * v1 디스패처 매핑 그대로:
- *   `agentlas legacy-network "<request>"` → cmdHep(["hep-network", ...rest])
- *
- * 오너 결정 배경: 기본 `network`/`workforce`는 host-LLM Agent Workforce
- * Ontology(fail-closed) 경로다. 구 Hephaestus hep-network 라우터는 이
- * "legacy-" 접두 명령으로만, 사용자가 이름으로 정확히 지목했을 때만 연다.
- * 절대 기본 경로의 폴백으로 쓰지 않는다.
- *
- * v1 가드 그대로: help 토큰 → usage 0, 무인자 → usage 실패 exit 1.
- */
-const { create, usageFor, isHelpToken } = require("../hephaestus/runtime.cjs");
-
-async function run(ctx, args) {
-  if (args.some(isHelpToken)) {
-    ctx.out(usageFor("legacy-network", ctx.lang));
-    return 0;
-  }
-  if (!args.length) {
-    ctx.err("✖ " + usageFor("legacy-network", ctx.lang));
-    return 1;
-  }
-  return create(ctx).cmdHep(["hep-network", ...args]);
-}
-
-module.exports = { run };