agentlas 0.6.0 → 0.9.1

package/engine/agentlas.cjs

@@ -29,6 +29,13 @@ const fs = require("node:fs");
 const { spawn } = require("node:child_process");
 const crypto = require("node:crypto");
 const { compareSemVer, normalizeSemVer, parseSemVer } = require("./semver.cjs");
+const terminalAssets = require("./agentlas-experience-mcp.cjs");
+const terminalExperienceExchange = require("./agentlas-experience-exchange.cjs");
+const desktopOntologyLoadout = require("./agentlas-desktop-loadout.cjs");
+const workloadRouting = require("./agentlas-workload-routing.cjs");
+const terminalExperienceIntake = require("./agentlas-experience-intake.cjs");
+const terminalMemoryGovernance = require("./agentlas-memory-governance.cjs");
+const { captureCoreJsonSync, resolveCoreRuntimeRoot } = require("./agentlas-core-harness.cjs");
 
 // ── 앱과 동일한 userData 경로 (electron app.getPath('userData')와 일치) ──
 function userDataDir() {
@@ -93,6 +100,19 @@ function openNodeSqliteDb(p) {
         run: (...args) => stmt.run(...args),
       };
     },
+    // better-sqlite3 API 패리티 — 폴백 경로에서도 db.exec/db.pragma가 있어야 한다.
+    // 누락 시 ensureMemoryContextColumn 등 ALTER TABLE(exec)이 TypeError로 조용히 죽어
+    // (try/catch 삼킴) context_json 컬럼 마이그레이션이 되지 않고 memory 조회가 깨진다.
+    exec: (sql) => db.exec(sql),
+    pragma: (source) => {
+      const rows = db.prepare(`PRAGMA ${source}`).all();
+      // better-sqlite3 pragma()의 단일값 반환 관례를 근사(단일 컬럼·단일 행 → 스칼라).
+      if (rows.length === 1) {
+        const keys = Object.keys(rows[0]);
+        if (keys.length === 1) return rows[0][keys[0]];
+      }
+      return rows;
+    },
     transaction(fn) {
       return (...args) => {
         db.exec("BEGIN");
@@ -241,7 +261,7 @@ function saveMultimodalSettingsCli(db, patch) {
     db.prepare("INSERT INTO meta(key,value) VALUES(?,?) ON CONFLICT(key) DO UPDATE SET value=excluded.value")
       .run(MULTIMODAL_META_KEY, JSON.stringify(next));
   } catch (e) {
-    fail("multimodal settings 저장 실패: " + e.message);
+    fail("Failed to save multimodal settings: " + e.message);
   }
   return next;
 }
@@ -280,7 +300,17 @@ const AGENT_BUILD_TERMS = [
 const BUILD_ENTITY_RE = /(에이전트|agent|팀|team|회사|company)/i;
 const BUILD_VERB_RE = /(만들|만든|생성|구축|구성해|꾸려|세팅|패키징|scaffold|build|create|\bmake\b|set\s?up|spin\s?up)/i;
 function isAgentBuildIntent(prompt) {
-  const p = routeNormalize(prompt);
+  // 경로/파일 참조는 빌드 의도의 증거가 아니다 — "/Users/x/agent-tools/notes.md 요약본
+  // 만들어줘"의 디렉터리명이나 "agent-notes.md" 같은 파일명이 BUILD_ENTITY_RE를 때려
+  // 메타빌더(score 1000)로 직행하던 우회로 차단. 빌드 의도는 산문에서만 읽는다.
+  // ⚠️ 남은 슬래시는 통째로 지우지 않고 공백으로만 벌린다 — "에이전트/팀 만들어줘"의
+  // 슬래시-엔티티("에이전트/팀")를 삭제하면 BUILD_ENTITY_RE가 못 맞아 빌드 의도를 놓친다.
+  // 진짜 경로는 이미 routeStripPaths(마지막 세그먼트만)+확장자 제거가 처리했다.
+  const p = routeNormalize(
+    routeStripPaths(prompt)
+      .replace(/\S+\.[A-Za-z0-9]{1,6}(?=\s|$)/g, " ")
+      .replace(/[\\/]+/g, " "),
+  );
   if (!p.trim() || isTrivialRoutePrompt(p)) return false;
   if (AGENT_BUILD_TERMS.some((term) => p.includes(routeNormalize(term)))) return true;
   // 예: "단일 에이전트 하나만 만들어줘", "팀 좀 꾸려줘", "make me an agent"
@@ -302,7 +332,9 @@ function resolveMetaBuilder(db) {
 }
 // "ai"/"llm" 같은 초범용 토큰은 모든 에이전트 프롬프트에 나오므로 판별력이 0이다 —
 // 이런 단어 하나로 전문 에이전트가 선택되던 오라우팅(예: 일반 맥 질문 → Pitch Deck Architect)을 막는다.
-const ROUTE_STOP_WORDS = new Set(["the", "and", "for", "with", "this", "that", "from", "into", "make", "build", "create", "agent", "agents", "please", "ai", "llm", "인공지능", "에이아이", "좀", "해주세요", "해줘", "만들어", "붙여", "연결", "작업", "요청"]);
+// "local"/"imported"/"team"은 임포터 보일러플레이트("Imported local team")와 slug 접두/접미에
+// 편재해 판별력이 없다 — 'team' 한 단어가 아무 임포트 팀의 slug 부분문자열(+6 strong)을 때리던 구멍.
+const ROUTE_STOP_WORDS = new Set(["the", "and", "for", "with", "this", "that", "from", "into", "make", "build", "create", "agent", "agents", "team", "please", "ai", "llm", "local", "imported", "인공지능", "에이아이", "좀", "해주세요", "해줘", "만들어", "붙여", "연결", "작업", "요청"]);
 const ROUTE_HINTS = [
   {
     slug: "agentlas-app-builder",
@@ -360,24 +392,46 @@ const ROUTE_HINTS = [
 function routeNormalize(value) {
   return String(value || "").toLowerCase().replace(/[_/]+/g, "-");
 }
+// 경로 디렉터리 성분은 라우팅 의도가 아니다 — 마지막 세그먼트(파일/폴더명)만 남긴다.
+// 사고(2026-07-12): "/Users/example/Projects/…/Appbridge_Template.이 …" 프롬프트의 경로 토큰
+// ("users","example","projects","users-example-projects-")이 임포트 에이전트 system_prompt 속
+// 절대경로와 맞아떨어져 +2씩 쌓이고 라우팅 근거에까지 노출됐다. 프롬프트/헤이스택 양쪽에
+// 대칭 적용해 경로↔경로 우연 일치를 차단한다. 파일/폴더명은 실제 의도라서 보존한다.
+// 규칙: 공백/인용부호/괄호 뒤(또는 문자열 시작)에서 시작하고, "세그먼트+구분자"가 2회 이상
+// 이어지는 절대·홈·드라이브·UNC 경로만 경로로 본다 — "and/or", "서울/부산", 날짜(2026/07/12),
+// "https://…"(콜론 뒤 //는 시작 조건 불충족)는 건드리지 않는다. 세그먼트 안의 단일 공백은
+// 뒤가 대문자로 시작할 때만 허용해 "Mobile Documents"/"Application Support"는 접되,
+// "/tmp/out 기획/디자인 …" 같은 한글 프로즈를 경로로 삼켜버리지 않는다. 상대경로는
+// 확장자 있는 파일 참조("docs/plan/roadmap.md")만 접는다 — 디렉터리명("plan")이 힌트/이름
+// strong 채널을 때리는 것을 막으면서 "서울/부산/대구" 같은 나열은 보존한다.
+const ROUTE_PATH_RE = /(^|[\s"'`(<\[{])((?:~|[A-Za-z]:)?[\\/]{1,2}(?:[^\s\\/]+(?: [A-Z][^\s\\/]*)?[\\/]+){2,}[^\s\\/]*|(?:[^\s\\/]+[\\/]+){2,}[^\s\\/]+\.[A-Za-z0-9]{1,6})/g;
+function routeStripPaths(value) {
+  return String(value || "").replace(ROUTE_PATH_RE, (whole, pre, p) => {
+    const segs = p.split(/[\\/]+/).filter(Boolean);
+    return pre + (segs.length ? segs[segs.length - 1] : "");
+  });
+}
 function routeTokenize(value) {
-  const matches = routeNormalize(value).match(/[a-z0-9][a-z0-9-]{1,}|[가-힣]{2,}/g) || [];
+  // 매치가 영숫자로 끝나도록 강제해 "users-mason-documents-" 같은 후행 하이픈 토큰을 원천 차단.
+  const matches = routeNormalize(routeStripPaths(value)).match(/[a-z0-9][a-z0-9-]*[a-z0-9]|[가-힣]{2,}/g) || [];
   const expanded = matches.flatMap((term) => term.split("-").filter(Boolean).concat(term));
   return [...new Set(expanded.filter((term) => term.length >= 2 && !ROUTE_STOP_WORDS.has(term)))];
 }
 // 정체성 존(slug/이름/태그라인) — 여기 적중은 강한 라우팅 신호. system_prompt 본문 적중은 약한 신호.
+// 임포터 보일러플레이트 태그라인("Imported local team/agent")의 세 단어는 전부 스톱워드라
+// 프롬프트 토큰이 될 수 없다 — 별도 필터 불필요.
 function routeIdentityHaystack(agent) {
-  return routeNormalize([agent.slug, agent.name, agent.name_en, agent.tagline, agent.tagline_en].join("\n"));
+  return routeNormalize(routeStripPaths([agent.slug, agent.name, agent.name_en, agent.tagline, agent.tagline_en].join("\n")));
 }
 function routeHaystack(agent) {
-  return routeNormalize([
+  return routeNormalize(routeStripPaths([
     agent.slug,
     agent.name,
     agent.name_en,
     agent.tagline,
     agent.tagline_en,
     String(agent.system_prompt || "").slice(0, 3500),
-  ].join("\n"));
+  ].join("\n")));
 }
 const APP_BUILDER_EXPLICIT_TERMS = [
   "apps generate", "app builder", "make an app", "build an app", "create an app",
@@ -420,7 +474,7 @@ function isTrivialRoutePrompt(promptText) {
   return words.length <= 3 && TRIVIAL_ROUTE_PROMPTS.has(stripped);
 }
 function isAppBuilderWorthyRoutePrompt(prompt) {
-  const promptText = routeNormalize(prompt);
+  const promptText = routeNormalize(routeStripPaths(prompt));
   if (!promptText.trim() || isTrivialRoutePrompt(promptText)) return false;
   const explicit = routeMatchedTerms(promptText, APP_BUILDER_EXPLICIT_TERMS);
   if (explicit.length) return true;
@@ -442,8 +496,10 @@ function routeHint(promptText, agent, lang) {
   if (!terms.length) return { score: 0, terms: [], reason: "" };
   return { score: 12 + terms.length * 3, terms, reason: lang === "ko" ? hint.reasonKo : hint.reasonEn };
 }
-function scoreRouteAgent(prompt, promptTerms, agent, lang) {
-  const promptText = routeNormalize(prompt);
+function scoreRouteAgent(prompt, promptTerms, agent, lang, pre) {
+  // 대칭 스트리핑 필수: promptText는 이름(+20)·힌트(+12↑) strong 채널의 입력이라, 여기서
+  // 경로를 안 벗기면 "/Users/x/project-plan/…"의 디렉터리명이 strong 게이트를 그대로 뚫는다.
+  const promptText = routeNormalize(routeStripPaths(prompt));
   if (agent.slug === "agentlas-app-builder" && !isAppBuilderWorthyRoutePrompt(promptText)) {
     return {
       agent,
@@ -452,24 +508,33 @@ function scoreRouteAgent(prompt, promptTerms, agent, lang) {
         ? "전용 App을 만들 만큼 반복·상태·편집·자동화가 뚜렷하지 않아 App Builder 라우트를 보류했습니다"
         : "the request does not clearly need a dedicated App with durable workflow, state, editing, or automation",
       terms: [],
+      strong: false,
     };
   }
-  const identityHay = routeIdentityHaystack(agent);
-  const haystack = routeHaystack(agent);
+  // 헤이스택은 설치/임포트 시에만 변하므로 autoRouteAgent가 미리 계산해 넘긴다(중복 계산 제거).
+  const identityHay = (pre && pre.identityHay) || routeIdentityHaystack(agent);
+  const haystack = (pre && pre.haystack) || routeHaystack(agent);
   let score = 0;
+  let strong = false; // 이름 언급/정체성 적중/큐레이션 힌트 — 데스크탑처럼 "이름/힌트급 증거"가 있어야 위임한다
   const terms = [];
+  const seenNames = new Set();
   for (const name of [agent.slug, agent.name, agent.name_en].filter(Boolean)) {
     const n = routeNormalize(name);
     // 4자 미만 일반 단어("team","agent" 등)가 프롬프트에 우연히 들어가 +20을 독식하지 않도록 가드.
-    if (n && n.length >= 4 && promptText.includes(n)) {
+    // name === name_en 인 임포트 에이전트(appbridge 등)가 +20을 두 번 받지 않도록 정규화 기준 dedupe.
+    if (!n || n.length < 4 || seenNames.has(n)) continue;
+    seenNames.add(n);
+    if (promptText.includes(n)) {
       score += 20;
       terms.push(name);
+      strong = true;
     }
   }
   for (const term of promptTerms) {
     if (identityHay.includes(term)) {
       score += 6; // 이름/태그라인 적중 = 그 에이전트의 정체성 자체를 부른 것
       terms.push(term);
+      strong = true;
     } else if (haystack.includes(term)) {
       score += term.length >= 5 ? 3 : 2;
       terms.push(term);
@@ -477,6 +542,7 @@ function scoreRouteAgent(prompt, promptTerms, agent, lang) {
   }
   const hint = routeHint(promptText, agent, lang);
   score += hint.score;
+  if (hint.score) strong = true;
   terms.push(...hint.terms);
   const unique = [...new Set(terms)].slice(0, 6);
   const reason = hint.reason || (lang === "ko"
@@ -486,13 +552,14 @@ function scoreRouteAgent(prompt, promptTerms, agent, lang) {
     : unique.length
       ? `request terms ${unique.map((term) => `"${term}"`).join(", ")} best match this agent's role/triggers`
       : "no specialist matched clearly, so the default project coordinator is safest");
-  return { agent, score, reason, terms: unique };
-}
-// 라우팅 확신 임계값. 이름/태그라인 적중(+6), 라우트 힌트(+12↑), 이름 포함(+20)만 전문 라우트로 인정하고,
-// system_prompt 본문의 약한 단어 적중(+2~3) 한두 개로는 에이전트를 절대 선택하지 않는다.
-// 임계값 미만이면 "직답"(에이전트·능력 라우팅 없음) — 일반 질문이 Pitch Deck Architect 같은
-// 무관 페르소나 + gemini 이미지 런타임으로 끌려가던 사고의 근본 수리.
-const MIN_ROUTE_SCORE = 6;
+  return { agent, score, reason, terms: unique, strong };
+}
+// 라우팅 확신 임계값 — 데스크탑 auto-router의 MIN_SPECIALIST_SCORE(10)와 동일 기준.
+// 위임에는 점수뿐 아니라 strong 신호(이름 포함 +20 / 정체성 적중 +6 / 큐레이션 힌트 +12↑)가
+// 반드시 있어야 한다. system_prompt 본문의 약한 단어 적중(+2~3)이 몇 개 쌓여도, strong 신호가
+// 없으면 절대 위임하지 않는다. 미달이면 "직답"(에이전트·능력 라우팅 없음) — 일반 질문이
+// Pitch Deck Architect 같은 무관 페르소나 + gemini 이미지 런타임으로 끌려가던 사고의 근본 수리.
+const MIN_ROUTE_SCORE = 10;
 function directRouteChoice(lang) {
   const resolvedLang = lang || prefsLang();
   return {
@@ -500,6 +567,7 @@ function directRouteChoice(lang) {
     agent: null,
     score: 0,
     terms: [],
+    strong: false,
     reason: resolvedLang === "ko"
       ? "특정 전문 에이전트가 필요 없는 일반 요청입니다"
       : "this is a general request that needs no specialist agent",
@@ -521,6 +589,7 @@ function autoRouteAgent(db, prompt, lang) {
       return {
         agent: meta,
         score: 1000,
+        strong: true,
         reason:
           resolvedLang === "ko"
             ? "새 에이전트/팀/회사를 만드는 요청이라 메타에이전트(빌더)로 라우팅했습니다"
@@ -532,13 +601,19 @@ function autoRouteAgent(db, prompt, lang) {
   const agents = listRoutableAgents(db).filter((agent) => !NON_GENERIC_ROUTE_SLUGS.has(agent.slug));
   if (!agents.length) return directRouteChoice(resolvedLang);
   let terms = routeTokenize(prompt);
+  // 헤이스택은 한 번만 계산해 IDF와 스코어링 양쪽에서 재사용한다.
+  const hays = agents.map((agent) => ({ identityHay: routeIdentityHaystack(agent), haystack: routeHaystack(agent) }));
   // IDF 근사 — 설치 에이전트 절반 이상의 haystack에 나오는 단어("ai","도구" 등)는 판별력이 없어 제외.
   if (agents.length >= 3) {
-    const hays = agents.map((agent) => routeHaystack(agent));
-    terms = terms.filter((term) => hays.filter((hay) => hay.includes(term)).length * 2 <= agents.length);
-  }
-  const ranked = agents.map((agent) => scoreRouteAgent(prompt, terms, agent, resolvedLang)).sort((a, b) => b.score - a.score);
-  if (ranked[0] && ranked[0].score >= MIN_ROUTE_SCORE) return ranked[0];
+    terms = terms.filter((term) => hays.filter((h) => h.haystack.includes(term)).length * 2 <= agents.length);
+  }
+  const ranked = agents
+    .map((agent, i) => scoreRouteAgent(prompt, terms, agent, resolvedLang, hays[i]))
+    .sort((a, b) => b.score - a.score);
+  // 1위가 아니라 "임계값+strong을 모두 만족하는 최고 순위"를 뽑는다 — 장황한 프롬프트의
+  // 약한 단어 적중이 점수 1위를 먹어도, 자격 있는 전문 에이전트가 직답으로 밀려나지 않는다.
+  const pick = ranked.find((r) => r.score >= MIN_ROUTE_SCORE && r.strong);
+  if (pick) return pick;
   return directRouteChoice(resolvedLang);
 }
 function autoRouteNote(choice, lang) {
@@ -597,6 +672,40 @@ function agentFolder(agent) {
   if (exists(path.join(cloudRoot, CLOUD_RESTORE_MARKER_PATH))) return cloudRoot;
   return path.join(userDataDir(), "agents", agent.slug);
 }
+function exactAgentBaseForExecution(db, agent, runtimeExperience = null) {
+  if (!agent || agent.builtin) return null;
+  const portableId = /^[A-Za-z0-9][A-Za-z0-9._:/@-]{2,255}$/;
+  let binding = null;
+  try {
+    if (tableExists(db, "installed_agent_hub_bindings")) {
+      binding = db.prepare(
+        "SELECT agent_definition_id,agent_release_id FROM installed_agent_hub_bindings WHERE installed_agent_id=?",
+      ).get(agent.id) || null;
+    }
+  } catch { binding = null; }
+  const route = routesMap()[agent.id] || {};
+  const markerResult = terminalExperienceExchange.readExactLocalBaseMarker(agentFolder(agent), agent.slug);
+  const marker = markerResult.marker;
+  const rawHash = String(marker?.packageHash || route.packageHash || route.definitionHash || "").replace(/^sha256:/i, "").toLowerCase();
+  const packageHash = /^[a-f0-9]{64}$/.test(rawHash) ? `sha256:${rawHash}` : null;
+  const explicitDefinition = String(runtimeExperience?.agentDefinitionId || "");
+  const explicitRelease = String(runtimeExperience?.baseAgentReleaseId || "");
+  if (portableId.test(explicitDefinition) && portableId.test(explicitRelease)) {
+    return { agentDefinitionId: explicitDefinition, agentReleaseId: explicitRelease, packageHash, authority: "explicit-runtime-binding" };
+  }
+  if (binding && portableId.test(String(binding.agent_definition_id)) && portableId.test(String(binding.agent_release_id))) {
+    return { agentDefinitionId: binding.agent_definition_id, agentReleaseId: binding.agent_release_id, packageHash, authority: "installed-hub-binding" };
+  }
+  if (!packageHash) return null;
+  const definitionDigest = sha(`terminal-local-definition\0${agent.id}\0${agent.slug}`);
+  const releaseDigest = sha(`terminal-local-release\0${definitionDigest}\0${packageHash}`);
+  return {
+    agentDefinitionId: `local-agent-definition:${definitionDigest.slice(0, 32)}`,
+    agentReleaseId: `local-agent-release:${releaseDigest.slice(0, 32)}`,
+    packageHash,
+    authority: "exact-local-package-hash",
+  };
+}
 function agentSystemPromptCli(agent) {
   return agent && agent.system_prompt ? agent.system_prompt : `You are ${agent?.name || "an Agentlas agent"}.`;
 }
@@ -704,7 +813,7 @@ function buildImportSystemPrompt(dir, name, kind) {
 }
 function importLocalFolderCli(db, absPath) {
   const dir = path.resolve(absPath);
-  if (!isDir(dir)) fail(`폴더가 아닙니다: ${absPath}`);
+  if (!isDir(dir)) fail(`Not a directory: ${absPath}`);
   const labels = detectRuntimeLabels(dir);
   const runtime = labels[0];
   const kind = detectKind(dir);
@@ -754,9 +863,14 @@ function importLocalFolderCli(db, absPath) {
       ).run(id, slug, name, name, tagline, tagline, systemPrompt, envReqsJson, now, tone);
     }
   }
+  // detectKind 결과를 DB에도 기록 — needsImage의 팀 body-veto 등 능력 판정이
+  // 데스크탑이 써준 entity_kind에 무임승차하지 않고 터미널 단독 임포트에서도 성립한다.
+  if (columnExists(db, "installed_agents", "entity_kind")) {
+    db.prepare("UPDATE installed_agents SET entity_kind=? WHERE id=?").run(kind, id);
+  }
   // 라우트 저장
   routes[id] = { agentId: id, path: dir, runtime, labels, kind, importedAt: now };
-  fs.writeFileSync(path.join(userDataDir(), "agent-routes.json"), JSON.stringify(routes, null, 2), "utf8");
+  writeJsonPrivateAtomicCli(path.join(userDataDir(), "agent-routes.json"), routes);
 
   // 팀이면 회사(firm)로도 등록 → 앱 FIRMS 목록 + `agentlas firm <slug>` 사용 가능. slug 기준 멱등.
   let firm = null;
@@ -804,15 +918,15 @@ function upsertLocalTeamFirmCli(db, dir, ceoAgentId, agentSlug, name, tagline) {
   return { id, slug: firmSlug };
 }
 function cmdImport(db, absPath) {
-  if (!absPath) fail("사용법: agentlas import <폴더경로>");
+  if (!absPath) fail("Usage: agentlas import <folder-path>");
   const r = importLocalFolderCli(db, absPath);
-  out(`${r.updated ? "갱신" : "임포트"} 완료: ${r.name}  (${r.kind})`);
+  out(`${r.updated ? "Updated" : "Imported"}: ${r.name}  (${r.kind})`);
   out(`  slug:    ${r.slug}`);
   out(`  runtime: ${r.runtime}  [${r.labels.join(", ")}]`);
   out(`  path:    ${r.path}`);
-  if (r.firmSlug) out(`  firm:    ${r.firmSlug}  (FIRMS 등록됨 — 앱 사이드바 + 'agentlas firm ${r.firmSlug}')`);
+  if (r.firmSlug) out(`  firm:    ${r.firmSlug}  (registered in Firms — Desktop sidebar + 'agentlas firm ${r.firmSlug}')`);
   out("");
-  out(`실행: agentlas ${r.slug} "..."   ·   agentlas run ${r.slug} "..."   (대상 프로젝트 폴더에서 실행)`);
+  out(`Run: agentlas ${r.slug} "..."   ·   agentlas run ${r.slug} "..."   (run from the target project folder)`);
 }
 
 // ── Agentlas Cloud packaging / marketplace ────────────────────────────────
@@ -831,6 +945,7 @@ const CLOUD_AGENT_FILES = new Set(["AGENT.md", "AGENTS.md", "CLAUDE.md", "GEMINI
 const CLOUD_SKIP_DIRS = new Set([".git", ".next", ".studio-runtime", ".turbo", "build", "coverage", "dist", "node_modules", "out", "release"]);
 const CLOUD_BLOCKED_FILE_RE = [/^\.env(?:\..*)?$/i, /^id_rsa(?:\.pub)?$/i, /^credentials(?:\..*)?$/i, /^secrets?(?:\..*)?$/i, /^cloud-asset-state\.v1\.json$/i, /(?:^|[._-])service-account(?:[._-]|$)/i, /\.(?:key|pem|p12|pfx|mobileprovision)$/i];
 const CLOUD_ROUTING_CARD_PATH = ".agentlas/routing-card.json";
+const CLOUD_LOCAL_EXPERIENCE_LINEAGE_PATH = ".agentlas/experience-relations.jsonl";
 const CLOUD_ROUTING_CARD_CAPABILITY_RE = /^[a-z][a-z0-9]*(_[a-z0-9]+)+$/;
 const CLOUD_ROUTING_CARD_STATUSES = new Set(["draft", "searchable", "candidate", "routing_ready", "trusted"]);
 const CLOUD_SECRET_RE = [
@@ -887,7 +1002,7 @@ function hubTimeoutError(kind, ms) {
 /** Hub/Cloud fetch + body reader. Headers 전 connect, chunk 사이 idle, 전 구간 total timeout. */
 async function fetchHubCli(url, init = {}, options = {}) {
   const fetchImpl = options.fetch || globalThis.fetch;
-  if (typeof fetchImpl !== "function") throw new Error("이 런타임에 fetch가 없습니다.");
+  if (typeof fetchImpl !== "function") throw new Error("fetch is unavailable in this runtime.");
   const timeout = options.timeoutConfig ? directHubTimeoutConfig(options.timeoutConfig) : hubTimeoutConfig(options.env || process.env);
   const controller = new AbortController();
   const upstreamSignal = init.signal;
@@ -951,7 +1066,7 @@ async function fetchHubCli(url, init = {}, options = {}) {
     } else {
       const raw = Buffer.from(await Promise.race([response.arrayBuffer(), terminal]));
       bytes = raw.length;
-      if (bytes > HUB_RESPONSE_MAX_BYTES) throw new Error(`Hub 응답이 허용 크기(${HUB_RESPONSE_MAX_BYTES} bytes)를 초과했습니다.`);
+      if (bytes > HUB_RESPONSE_MAX_BYTES) throw new Error(`Hub response exceeds the allowed size (${HUB_RESPONSE_MAX_BYTES} bytes).`);
       chunks.push(raw);
     }
     if (idleTimer) clearTimeout(idleTimer);
@@ -976,7 +1091,7 @@ function parseHubJsonCli(response, label) {
   try {
     return JSON.parse(response.text || "null");
   } catch {
-    throw new Error(`${label} 응답 JSON 형식이 올바르지 않습니다.`);
+    throw new Error(`${label} returned invalid JSON.`);
   }
 }
 
@@ -1050,6 +1165,7 @@ async function cmdCloud(db, args, runtimeOverride) {
       "  list [--json]                       list packages in your private Agent Cloud",
       "  restore <slug> [--json]             restore an owned Cloud package on this machine",
       "  install <slug>                      compatibility alias: install from the public Hub",
+      "  plugin add <slug>                   install a Hub plugin (MCP servers)",
       "  delete <slug> [--scope owner-private|hub-public] [--json]",
       "                                      conditionally delete one exact observed Cloud revision",
       "  search \"<what you need>\" [--limit 10]",
@@ -1068,7 +1184,7 @@ async function cmdCloud(db, args, runtimeOverride) {
     const result = await listOwnedCloudAgentsCli(Number(flags.limit || 100));
     if (flags.json) return out(JSON.stringify(result, null, 2));
     const agents = Array.isArray(result.results) ? result.results : [];
-    if (!agents.length) return out("Private Agent Cloud에 저장된 에이전트가 없습니다.");
+    if (!agents.length) return out("No agents are stored in Private Agent Cloud.");
     for (const agent of agents) out(`${agent.slug}\t${agent.name || agent.nameEn || agent.slug}\t${agent.entityKind || "agent"}`);
     return;
   }
@@ -1164,8 +1280,8 @@ async function cmdCloud(db, args, runtimeOverride) {
 async function packageCloudAgentCli(db, root, opts) {
   const requestedRoot = path.resolve(root);
   let st;
-  try { st = fs.lstatSync(requestedRoot); } catch { throw new Error(`폴더를 찾을 수 없습니다: ${root}`); }
-  if (!st.isDirectory() || st.isSymbolicLink()) throw new Error(`실제 폴더가 아닙니다: ${root}`);
+  try { st = fs.lstatSync(requestedRoot); } catch { throw new Error(`Folder not found: ${root}`); }
+  if (!st.isDirectory() || st.isSymbolicLink()) throw new Error(`Not a real directory: ${root}`);
   const rootPath = fs.realpathSync.native(requestedRoot);
   const visibility = opts.visibility || "private-link";
   const isPublicHubPublish = visibility === "marketplace";
@@ -1620,6 +1736,12 @@ function scanCloudFolderCli(rootPath) {
       if (entry.name.startsWith("._")) continue;
       const abs = path.join(dir, entry.name);
       const rel = path.relative(rootPath, abs).split(path.sep).join("/");
+      if (cloudIsLocalExperienceLineagePath(rel)) {
+        let bytes = 0;
+        try { bytes = Number(fs.lstatSync(abs).size) || 0; } catch { /* excluded local state */ }
+        files.push({ path: rel, bytes, sha256: "", kind: "text", included: false, reason: "experience-lineage-separate-asset" });
+        continue;
+      }
       if (cloudPortablePathKey(rel) === cloudPortablePathKey(CLOUD_RESTORE_MARKER_PATH)) {
         // Local restore/CAS metadata is runtime state, never portable asset
         // data, but it must be captured with the same no-follow stability gate.
@@ -1858,19 +1980,19 @@ function cloudCasResponseErrorCli(response, label) {
   let body = null;
   try { body = JSON.parse(response.text || "null"); } catch { /* generic below */ }
   const code = body && typeof body.code === "string" ? body.code : "cloud_request_failed";
-  let message = `${label} 실패 ${response.status}`;
+  let message = `${label} failed with HTTP ${response.status}`;
   if (response.status === 412 && code === "cloud_agent_revision_conflict") {
     const current = body && body.current ? body.current : body && body.conflict && body.conflict.current;
     message = current
       ? `다른 PC에서 이 Agent Cloud 자산이 변경되었습니다. 자동 덮어쓰기는 중단했습니다. \`agentlas cloud list\`로 최신 revision을 확인하고 \`agentlas cloud restore ${current.slug || "<slug>"}\`로 복원한 뒤 변경 사항을 병합하세요.`
       : "이 Agent Cloud 자산은 다른 PC에서 삭제되었거나 다른 식별자로 다시 생성되었습니다. 자동 재생성은 중단했습니다. `agentlas cloud list`로 현재 상태를 확인하세요.";
   } else if (response.status === 428 && code === "client_upgrade_required") {
-    message = "기존 Cloud 자산을 안전하게 갱신할 base revision이 없습니다. 서버 revision을 자동 복사하지 않습니다. `agentlas cloud list`로 확인하고 `agentlas cloud restore <slug>`로 복원한 뒤 다시 저장하세요.";
+    message = "No base revision is available to safely update the existing Cloud asset. The server revision will not be copied automatically. Check `agentlas cloud list`, restore with `agentlas cloud restore <slug>`, then save again.";
   } else if (response.status === 503 && code === "cloud_mutations_maintenance") {
     const retryAfter = response.headers && typeof response.headers.get === "function" ? response.headers.get("retry-after") : null;
-    message = `Agent Cloud 저장/삭제가 잠시 점검 중입니다${retryAfter ? ` (약 ${retryAfter}초 후 재시도)` : ""}. 읽기·목록·복원은 계속 사용할 수 있습니다.`;
+    message = `Agent Cloud save/delete is temporarily under maintenance${retryAfter ? ` (retry in about ${retryAfter} seconds)` : ""}. Read, list, and restore remain available.`;
   } else if (body && typeof body.error === "string") {
-    message = `${label} 실패 ${response.status}: ${body.error.slice(0, 300)}`;
+    message = `${label} failed with HTTP ${response.status}: ${body.error.slice(0, 300)}`;
   }
   const error = new Error(message);
   error.code = code;
@@ -1882,8 +2004,8 @@ function cloudCasResponseErrorCli(response, label) {
 
 async function registerCloudAgentCli(manifest, bundlePath, review, visibility, options = {}) {
   const cookie = await cloudSessionCookieCli();
-  if (!cookie) fail("agentlas.cloud 로그인이 필요합니다. 데스크톱 앱에서 로그인하거나 AGENTLAS_SESSION을 설정하세요.");
-  if (typeof fetch !== "function") fail("이 런타임에 fetch가 없습니다(앱 런타임으로 실행 필요).");
+  if (!cookie) fail("Agent Cloud sign-in is required. Sign in through Desktop or set AGENTLAS_SESSION.");
+  if (typeof fetch !== "function") fail("fetch is unavailable in this runtime (run through the app runtime).");
   const base = (process.env.AGENTLAS_WEB_BASE_URL || "https://agentlas.cloud").replace(/\/$/, "");
   const bundle = JSON.parse(fs.readFileSync(bundlePath, "utf8"));
   const expectedScope = cloudScopeForVisibility(visibility);
@@ -1956,8 +2078,8 @@ async function deleteCloudAgentCli(slug, options = {}) {
   const safeSlug = String(slug || "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 64);
   if (!safeSlug) fail("usage: agentlas cloud delete <slug> [--json]");
   const cookie = await cloudSessionCookieCli();
-  if (!cookie) fail("agentlas.cloud 로그인이 필요합니다. 데스크톱 앱에서 로그인하거나 AGENTLAS_SESSION을 설정하세요.");
-  if (typeof fetch !== "function") fail("이 런타임에 fetch가 없습니다(앱 런타임으로 실행 필요).");
+  if (!cookie) fail("Agent Cloud sign-in is required. Sign in through Desktop or set AGENTLAS_SESSION.");
+  if (typeof fetch !== "function") fail("fetch is unavailable in this runtime (run through the app runtime).");
   const scope = options.scope == null ? null : normalizeCloudScopeFlagCli(options.scope);
   if (options.scope != null && !scope) throw new Error("--scope must be owner-private or hub-public");
   const localEntry = findCloudAssetDescriptorCli(safeSlug, scope);
@@ -2060,28 +2182,121 @@ async function cloudSessionCookieCli() {
 async function cmdCloudInstall(db, slug) {
   if (!slug) fail("usage: agentlas cloud install <slug>");
   const listing = await fetchCloudManifestCli(slug);
-  if (!listing) fail(`Hub agent를 찾을 수 없습니다: ${slug}`);
+  if (!listing) fail(`Hub agent not found: ${slug}`);
   if (listing.delivery && listing.delivery.mode === "call_only") {
-    fail(`이 Hub 에이전트는 소스 설치가 허용되지 않은 call-only 자산입니다. 실행: agentlas call ${slug}`);
+    fail(`This Hub agent is call-only and cannot be installed from source. Run: agentlas call ${slug}`);
   }
   const agent = persistCloudListingCli(db, listing);
   out(`✓ Hub installed ${agent.slug} — ${agent.name}`);
   if (agent.localPath) out(`  files: ${agent.localPath}`);
 }
 
+// ── Hub 플러그인 설치 ────────────────────────────────────────────────────────
+// 서버는 처음부터 준비돼 있었다: /api/plugins/<slug>가 agentlas.plugin/v1 매니페스트를 주고,
+// 그 라우트 주석이 이 CLI(`agentlas plugin add <slug>`)를 소비자로 지목한다. 그런데 이 명령이
+// 구현된 적이 없어서, 카탈로그 146개가 전부 "존재하지 않는 설치 명령"을 광고하고 있었다.
+// (`agentlas install`은 marketplace.get_manifest{kind:"agent"} 고정이라 플러그인엔 안 먹는다.)
+async function fetchPluginManifestCli(slug) {
+  const base = (process.env.AGENTLAS_WEB_BASE_URL || "https://agentlas.cloud").replace(/\/$/, "");
+  const resp = await fetchHubCli(`${base}/api/plugins/${encodeURIComponent(slug)}`, {
+    headers: { accept: "application/json" },
+  });
+  if (resp.status === 404) return null;
+  if (!resp.ok) fail(`plugin lookup failed with HTTP ${resp.status}`);
+  const manifest = parseHubJsonCli(resp, "plugin manifest");
+  if (!manifest || manifest.schema !== "agentlas.plugin/v1") {
+    fail(`Unexpected plugin manifest schema for ${slug}.`);
+  }
+  return manifest;
+}
+
+/** 매니페스트의 mcp[] 항목을 mcp_servers 행으로 정규화. stdio(command)와 remote(url)를 구분한다. */
+function pluginMcpRowCli(slug, entry, index) {
+  const source = typeof entry?.source === "string" ? entry.source.trim() : "";
+  const name = (typeof entry?.name === "string" && entry.name.trim()) || `${slug}-${index + 1}`;
+  const remote = /^https?:\/\//i.test(source);
+  // 원격은 URL, stdio는 실행 커맨드다. 둘을 섞으면 codex config.toml 스키마 위반으로
+  // 런타임이 통째로 죽는다(Runtime Doctor가 반복해서 잡던 사고 계열).
+  if (!remote && !source) return null;
+  const argv = remote ? [] : source.split(/\s+/).filter(Boolean);
+  return {
+    id: require("node:crypto").randomUUID(),
+    catalogId: `hub:${slug}:${name}`,
+    name,
+    transport: remote ? "http" : "stdio",
+    command: remote ? null : (argv[0] ?? null),
+    argsJson: JSON.stringify(remote ? [] : argv.slice(1)),
+    url: remote ? source : null,
+    envKeysJson: JSON.stringify(
+      Array.isArray(entry?.envKeys) ? entry.envKeys.filter((key) => typeof key === "string") : [],
+    ),
+  };
+}
+
+async function cmdPluginAdd(db, slug) {
+  if (!slug) fail('usage: agentlas plugin add <slug>   (run agentlas plugin list first)');
+  const manifest = await fetchPluginManifestCli(slug);
+  if (!manifest) fail(`Hub plugin not found: ${slug}`);
+  const entries = Array.isArray(manifest.mcp) ? manifest.mcp : [];
+  const rows = entries.map((entry, index) => pluginMcpRowCli(slug, entry, index)).filter(Boolean);
+  if (!rows.length) {
+    // 설치할 MCP 서버가 없으면 조용히 성공했다고 하지 않는다 — 사용자는 이 플러그인이
+    // 붙었다고 믿고 도구를 기대하게 된다.
+    fail(
+      `${slug} ships no MCP server to install (skills-only or source-link plugin). ` +
+        `Nothing was registered. See: ${manifest.source?.repo || manifest.source?.homepage || "the plugin page"}`,
+    );
+  }
+  let installed = 0;
+  let reused = 0;
+  for (const row of rows) {
+    const existing = db.prepare("SELECT id FROM mcp_servers WHERE catalog_id = ? LIMIT 1").get(row.catalogId);
+    if (existing) { reused += 1; continue; } // 멱등: 재설치가 중복 행을 만들지 않는다
+    db.prepare(
+      `INSERT INTO mcp_servers (id, catalog_id, name, name_en, transport, command, args_json, url, env_keys_json, enabled, installed_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 1, ?)`,
+    ).run(
+      row.id, row.catalogId, row.name, row.name, row.transport,
+      row.command, row.argsJson, row.url, row.envKeysJson, new Date().toISOString(),
+    );
+    installed += 1;
+  }
+  out(`✓ Plugin installed ${manifest.slug} — ${manifest.name}`);
+  out(`  MCP servers: ${installed} added${reused ? `, ${reused} already present` : ""}`);
+  const authKind = manifest.auth?.kind;
+  if (authKind && authKind !== "none") {
+    out(`  ⚠ Requires ${authKind} — set credentials before use (agentlas creds).`);
+  }
+  if (Array.isArray(manifest.skills) && manifest.skills.length) {
+    out(`  skills declared: ${manifest.skills.map((skill) => skill.name).filter(Boolean).join(", ")}`);
+  }
+  out("  Only full-access turns wire active stdio servers into the runtime (agentlas mcp).");
+}
+
+async function cmdPluginList() {
+  const result = await callAgentlasMcpToolCli("marketplace.list_plugins", {});
+  const plugins = (result && (result.plugins || result.results)) || [];
+  if (!plugins.length) return out("No Hub plugins are available.");
+  for (const plugin of plugins.slice(0, 60)) {
+    out(`${String(plugin.slug || "").padEnd(32).slice(0, 32)} ${String(plugin.name || "").slice(0, 44)}`);
+  }
+  out("");
+  out("Install: agentlas plugin add <slug>");
+}
+
 async function callAgentlasMcpToolCli(name, args, { requireSession = false } = {}) {
-  if (typeof fetch !== "function") fail("이 런타임에 fetch가 없습니다(앱 런타임으로 실행 필요).");
+  if (typeof fetch !== "function") fail("fetch is unavailable in this runtime (run through the app runtime).");
   const base = process.env.AGENTLAS_MCP_BASE_URL || "https://agentlas.cloud/api/mcp/v1";
   const headers = { "content-type": "application/json" };
   const cookie = await cloudSessionCookieCli();
-  if (requireSession && !cookie) fail("Agent Cloud에는 로그인이 필요합니다. 먼저 `agentlas login`을 실행하세요.");
+  if (requireSession && !cookie) fail("Agent Cloud sign-in is required. Run `agentlas login` first.");
   if (cookie) headers.cookie = cookie;
   const resp = await fetchHubCli(`${base.replace(/\/$/, "")}/tools/call`, {
     method: "POST",
     headers,
     body: JSON.stringify({ method: name, params: { name, arguments: args || {} } }),
   });
-  if (!resp.ok) fail(`${name} 실패 ${resp.status}`);
+  if (!resp.ok) fail(`${name} failed with HTTP ${resp.status}`);
   const json = parseHubJsonCli(resp, name);
   if (json.error) fail(`${name}: ${json.error.message || "unknown error"}`);
   return json.result || null;
@@ -2364,6 +2579,17 @@ function persistCloudListingCli(db, listing) {
     throw error;
   }
   const localPath = restore?.path || null;
+  // entity_kind 기록 — needsImage의 팀 body-veto가 로컬 폴더 임포트(detectKind)뿐 아니라
+  // 클라우드/Hub 소스 설치 팀에도 걸리게 한다. 안 하면 팀 CEO 두뇌의 부서 키워드
+  // ("Design HQ" 등)로 needsImage가 참이 되어 세션 런타임이 통째로 gemini로 하이재킹된다.
+  // Hub가 준 entityKind를 우선하고, 없으면 materialize된 팩 폴더 구조로 판정한다.
+  if (columnExists(db, "installed_agents", "entity_kind")) {
+    let kind = String(listing.entityKind || "").toLowerCase();
+    if (kind !== "team" && kind !== "agent") {
+      kind = localPath && fs.existsSync(localPath) ? detectKind(localPath) : "agent";
+    }
+    db.prepare("UPDATE installed_agents SET entity_kind=? WHERE id=?").run(kind, id);
+  }
   return existing
     ? { ...existing, slug, name: dbExpected.name, ...(localPath ? { localPath } : {}) }
     : { id, slug, name: dbExpected.name, ...(localPath ? { localPath } : {}) };
@@ -2709,6 +2935,13 @@ function printCloudPackageResult(result) {
 function cloudPackageSnapshot(files) {
   return new Map(files.map((file) => [file.path, file]));
 }
+function cloudIsLocalExperienceLineagePath(value) {
+  const normalized = cloudPortablePathKey(String(value || "").replace(/\\/g, "/"));
+  const canonical = cloudPortablePathKey(CLOUD_LOCAL_EXPERIENCE_LINEAGE_PATH);
+  return normalized === canonical
+    || normalized.startsWith(`${canonical}.`)
+    || normalized.startsWith(cloudPortablePathKey(".agentlas/.experience-relations.jsonl."));
+}
 function cloudReadPublicCareerCard(snapshot, findings) {
   const relativePath = ".agentlas/public-career-card.json";
   const file = snapshot.get(relativePath);
@@ -2901,7 +3134,7 @@ function cloudHashPackage(files, version = CLOUD_PACKAGE_HASH_V1) {
   // 서버 package-contract.ts와 바이트 동일해야 한다: 경로 코드포인트 순 정렬.
   // 정렬 없이 스캔 순서로 해시하면 대소문자 혼합 경로 패키지(AGENTS.md + agents/…)가
   // 전부 package_hash_mismatch로 거절된다(2026-07-02 근본 수정).
-  for (const file of [...files].sort(cloudCodePointPathOrder)) {
+  for (const file of [...files].filter((file) => !cloudIsLocalExperienceLineagePath(file.path)).sort(cloudCodePointPathOrder)) {
     h.update(file.path);
     h.update("\0");
     h.update(file.sha256);
@@ -6986,6 +7219,21 @@ function readJsonSafeCli(filePath, fallback) {
 function writeJsonSafeCli(filePath, value) {
   fs.writeFileSync(filePath, JSON.stringify(value, null, 2) + "\n", "utf8");
 }
+// 원자적(temp+rename) + 소유자 전용(0600) JSON 쓰기. 세션 ID/경로 등 민감 상태 파일용:
+// (1) 크래시 중간 쓰기로 JSON이 깨져 routesMap()이 {}를 돌려주며 임포트 매핑을 통째로 잃던 사고,
+// (2) 기본 umask(0644)로 cli-sessions.json/agent-routes.json이 world-readable이던 정보 노출을 함께 막는다.
+function writeJsonPrivateAtomicCli(filePath, value) {
+  const dir = path.dirname(filePath);
+  const tmp = path.join(dir, `.${path.basename(filePath)}.${process.pid}.tmp`);
+  fs.writeFileSync(tmp, JSON.stringify(value, null, 2) + "\n", { encoding: "utf8", mode: 0o600 });
+  try {
+    fs.renameSync(tmp, filePath);
+  } catch (e) {
+    try { fs.unlinkSync(tmp); } catch { /* ignore */ }
+    throw e;
+  }
+  try { fs.chmodSync(filePath, 0o600); } catch { /* 일부 FS는 chmod 미지원 — best-effort */ }
+}
 
 function ontologySourceManifestSkeletonCli(root) {
   return {
@@ -7528,38 +7776,320 @@ function contextLine(json) {
     return "";
   }
 }
-// 작업 폴더 반복 방문 → 활성화(.agentlas 생성). 앱의 activation.ts와 동일한 정책(2회).
-function recordCliFolderVisit(db, projectPath) {
-  if (!tableExists(db, "folder_activity")) return { activated: false };
-  const now = new Date().toISOString();
+const AGENTLAS_PROJECT_STATE_IGNORE_START = "# >>> agentlas local project state >>>";
+const AGENTLAS_PROJECT_STATE_IGNORE_END = "# <<< agentlas local project state <<<";
+const AGENTLAS_GITIGNORE_MAX_BYTES = 1024 * 1024;
+const projectBootstrapStates = new Map();
+
+function terminalProjectCandidateCli(projectPath) {
   try {
-    const row = db.prepare("SELECT visits, activated_at FROM folder_activity WHERE path=?").get(projectPath);
-    let visits, activatedAt;
-    if (row) {
-      visits = row.visits + 1; activatedAt = row.activated_at;
-      db.prepare("UPDATE folder_activity SET visits=?, last_seen=? WHERE path=?").run(visits, now, projectPath);
-    } else {
-      visits = 1; activatedAt = null;
-      db.prepare("INSERT INTO folder_activity (path, visits, activated_at, first_seen, last_seen) VALUES (?,?,NULL,?,?)").run(projectPath, visits, now, now);
+    const root = path.resolve(projectPath || process.cwd());
+    const unsafe = new Set([
+      path.resolve(os.homedir()),
+      path.parse(root).root,
+      path.resolve(userDataDir()),
+      path.resolve(runCwd()),
+    ]);
+    if (unsafe.has(root)) return null;
+    const stat = fs.statSync(root);
+    if (!stat.isDirectory()) return null;
+    return root;
+  } catch {
+    return null;
+  }
+}
+
+function assertNoSymlinkInAgentlasStateCli(stateDir) {
+  const pending = [stateDir];
+  let visited = 0;
+  while (pending.length && visited < 4096) {
+    const current = pending.pop();
+    visited += 1;
+    let stat;
+    try { stat = fs.lstatSync(current); } catch (error) {
+      if (error && error.code === "ENOENT") continue;
+      throw error;
     }
-    if (!activatedAt && visits >= 2) {
-      db.prepare("UPDATE folder_activity SET activated_at=? WHERE path=?").run(now, projectPath);
-      ensureProjectMemoryCli(projectPath);
-      activatedAt = now;
+    if (stat.isSymbolicLink()) throw new Error(".agentlas local state must not contain symbolic links");
+    if (stat.isDirectory()) {
+      for (const entry of fs.readdirSync(current)) pending.push(path.join(current, entry));
     }
-    return { activated: !!activatedAt };
-  } catch { return { activated: false }; }
+  }
+  if (pending.length) throw new Error(".agentlas local state exceeds the safe bootstrap inspection limit");
 }
-// `agentlas run` 등이 호출된 작업 디렉터리 → 활성 프로젝트 경로(또는 null).
-function activeProjectPath(db) {
+
+function readRegularUtf8FileNoFollowCli(filePath, maxBytes = AGENTLAS_GITIGNORE_MAX_BYTES) {
+  let before;
+  try { before = fs.lstatSync(filePath); } catch (error) {
+    if (error && error.code === "ENOENT") return { exists: false, content: "", mode: 0o644, stat: null };
+    throw error;
+  }
+  if (before.isSymbolicLink() || !before.isFile()) throw new Error(".gitignore must be a regular non-symbolic-link file");
+  if (before.size > maxBytes) throw new Error(`.gitignore exceeds the ${maxBytes}-byte safe bootstrap limit`);
+
+  const noFollow = fs.constants.O_NOFOLLOW || 0;
+  let fd;
   try {
-    const cwd = process.cwd();
-    if (cwd === os.homedir() || cwd === userDataDir() || cwd === runCwd()) return null;
-    const v = recordCliFolderVisit(db, cwd);
-    return v.activated ? cwd : null;
-  } catch { return null; }
+    fd = fs.openSync(filePath, fs.constants.O_RDONLY | noFollow);
+  } catch (error) {
+    if (process.platform !== "win32" || !noFollow || !["EINVAL", "ENOTSUP"].includes(error && error.code)) throw error;
+    fd = fs.openSync(filePath, fs.constants.O_RDONLY);
+  }
+  try {
+    const opened = fs.fstatSync(fd);
+    if (!opened.isFile()) throw new Error(".gitignore changed type during bootstrap");
+    if (opened.size > maxBytes) throw new Error(`.gitignore exceeds the ${maxBytes}-byte safe bootstrap limit`);
+    if (
+      Number.isFinite(before.dev) && Number.isFinite(before.ino) &&
+      (before.dev !== opened.dev || before.ino !== opened.ino)
+    ) {
+      throw new Error(".gitignore changed during bootstrap");
+    }
+    const chunks = [];
+    let total = 0;
+    while (total <= maxBytes) {
+      const buffer = Buffer.allocUnsafe(Math.min(64 * 1024, maxBytes + 1 - total));
+      const count = fs.readSync(fd, buffer, 0, buffer.length, null);
+      if (!count) break;
+      chunks.push(buffer.subarray(0, count));
+      total += count;
+    }
+    if (total > maxBytes) throw new Error(`.gitignore exceeds the ${maxBytes}-byte safe bootstrap limit`);
+    const after = fs.fstatSync(fd);
+    if (after.size !== opened.size || after.mtimeMs !== opened.mtimeMs) throw new Error(".gitignore changed while it was being read");
+    let content;
+    try { content = new TextDecoder("utf-8", { fatal: true }).decode(Buffer.concat(chunks, total)); } catch {
+      throw new Error(".gitignore must contain valid UTF-8 text");
+    }
+    return { exists: true, content, mode: before.mode & 0o777, stat: before };
+  } finally {
+    fs.closeSync(fd);
+  }
+}
+
+function assertFileSnapshotUnchangedCli(filePath, snapshot) {
+  if (!snapshot.exists) {
+    try {
+      fs.lstatSync(filePath);
+      throw new Error(".gitignore appeared during bootstrap");
+    } catch (error) {
+      if (error && error.code === "ENOENT") return;
+      throw error;
+    }
+  }
+  const current = fs.lstatSync(filePath);
+  if (current.isSymbolicLink() || !current.isFile()) throw new Error(".gitignore changed type during bootstrap");
+  const original = snapshot.stat;
+  if (
+    !original || current.dev !== original.dev || current.ino !== original.ino ||
+    current.size !== original.size || current.mtimeMs !== original.mtimeMs
+  ) {
+    throw new Error(".gitignore changed during bootstrap");
+  }
+}
+
+function replaceRegularFileCli(tempPath, destinationPath, snapshot) {
+  try {
+    fs.renameSync(tempPath, destinationPath);
+    return;
+  } catch (error) {
+    if (process.platform !== "win32" || !snapshot.exists || !["EEXIST", "EPERM", "EACCES"].includes(error && error.code)) {
+      throw error;
+    }
+  }
+
+  // Windows can reject replacement of an existing file. Keep a same-directory
+  // rollback copy so an interrupted replacement never silently loses user rules.
+  assertFileSnapshotUnchangedCli(destinationPath, snapshot);
+  const backup = `${destinationPath}.agentlas-${process.pid}-${crypto.randomUUID()}.bak`;
+  fs.renameSync(destinationPath, backup);
+  try {
+    fs.renameSync(tempPath, destinationPath);
+  } catch (error) {
+    try {
+      if (!fs.existsSync(destinationPath)) fs.renameSync(backup, destinationPath);
+    } catch { /* preserve the original error and leave the backup recoverable */ }
+    throw error;
+  }
+  try { fs.unlinkSync(backup); } catch { /* a harmless rollback copy may remain on locked Windows hosts */ }
+}
+
+function ensureAgentlasProjectStateIgnoreCli(projectPath) {
+  const root = terminalProjectCandidateCli(projectPath);
+  if (!root) throw new Error("refusing to initialize an unsafe Agentlas project root");
+  const stateDir = path.join(root, ".agentlas");
+  let stateExists = false;
+  try {
+    const state = fs.lstatSync(stateDir);
+    stateExists = true;
+    if (state.isSymbolicLink() || !state.isDirectory()) throw new Error(".agentlas must be a real directory");
+    assertNoSymlinkInAgentlasStateCli(stateDir);
+  } catch (error) {
+    if (error && error.code !== "ENOENT") throw error;
+  }
+
+  const gitignorePath = path.join(root, ".gitignore");
+  const snapshot = readRegularUtf8FileNoFollowCli(gitignorePath);
+  const existing = snapshot.content;
+  const mode = snapshot.mode || 0o644;
+
+  let next = existing;
+  const start = existing.indexOf(AGENTLAS_PROJECT_STATE_IGNORE_START);
+  const end = start >= 0 ? existing.indexOf(AGENTLAS_PROJECT_STATE_IGNORE_END, start) : -1;
+  if (start >= 0 && end >= 0) {
+    const blockEnd = end + AGENTLAS_PROJECT_STATE_IGNORE_END.length;
+    const block = existing.slice(start, blockEnd);
+    if (!/^\.agentlas\/$/m.test(block)) {
+      next = `${existing.slice(0, start)}${block.replace(AGENTLAS_PROJECT_STATE_IGNORE_START, `${AGENTLAS_PROJECT_STATE_IGNORE_START}\n.agentlas/`)}${existing.slice(blockEnd)}`;
+    }
+  } else {
+    const block = `${AGENTLAS_PROJECT_STATE_IGNORE_START}\n.agentlas/\n${AGENTLAS_PROJECT_STATE_IGNORE_END}\n`;
+    next = existing.trimEnd() ? `${existing.trimEnd()}\n\n${block}` : block;
+  }
+  if (next !== existing) {
+    const temp = path.join(root, `.gitignore.agentlas-${process.pid}-${crypto.randomUUID()}.tmp`);
+    fs.writeFileSync(temp, next.endsWith("\n") ? next : `${next}\n`, { encoding: "utf8", mode, flag: "wx" });
+    try {
+      assertFileSnapshotUnchangedCli(gitignorePath, snapshot);
+      replaceRegularFileCli(temp, gitignorePath, snapshot);
+    } catch (error) {
+      try { fs.unlinkSync(temp); } catch { /* ignore */ }
+      throw error;
+    }
+  }
+  if (!stateExists) fs.mkdirSync(stateDir, { recursive: false, mode: 0o700 });
+  assertNoSymlinkInAgentlasStateCli(stateDir);
+  try { fs.chmodSync(stateDir, 0o700); } catch { /* Windows/best effort */ }
+}
+
+function hardenAgentlasProjectStateCli(projectPath) {
+  const root = terminalProjectCandidateCli(projectPath);
+  if (!root) return;
+  const stateDir = path.join(root, ".agentlas");
+  const pending = [stateDir];
+  let visited = 0;
+  while (pending.length && visited < 4096) {
+    const current = pending.pop();
+    visited += 1;
+    try {
+      const stat = fs.lstatSync(current);
+      if (stat.isSymbolicLink()) continue;
+      if (stat.isDirectory()) {
+        try { fs.chmodSync(current, 0o700); } catch { /* Windows/best effort */ }
+        for (const entry of fs.readdirSync(current)) pending.push(path.join(current, entry));
+      } else if (stat.isFile()) {
+        try { fs.chmodSync(current, 0o600); } catch { /* Windows/best effort */ }
+      }
+    } catch { /* disappearing files and ACL-only hosts are best effort */ }
+  }
+}
+
+function ensureCoreProjectCli(projectPath, options = {}) {
+  const root = terminalProjectCandidateCli(projectPath);
+  if (!root) throw new Error("Agentlas project bootstrap requires a real project directory");
+  fs.accessSync(root, fs.constants.R_OK | fs.constants.W_OK);
+  ensureAgentlasProjectStateIgnoreCli(root);
+  const cached = projectBootstrapStates.get(root);
+  if (cached && fs.existsSync(path.join(root, ".agentlas", "project-soul-memory.md"))) {
+    return cached === "core";
+  }
+  projectBootstrapStates.delete(root);
+  const coreRoot = resolveCoreRuntimeRoot(options.coreRoot);
+  const hasCanonicalBootstrap = Boolean(
+    coreRoot && fs.existsSync(path.join(coreRoot, "agentlas_cloud", "project_bootstrap.py")),
+  );
+  if (hasCanonicalBootstrap) {
+    const result = captureCoreJsonSync(
+      "agentlas_cloud",
+      ["project", "ensure", "--project", root, "--reason", options.reason || "terminal-first-contact"],
+      { cwd: root },
+      coreRoot,
+    );
+    const canonical = Boolean(
+      result
+      && result.schemaVersion === "agentlas.project-bootstrap.v1"
+      && ["active", "privacy_warning"].includes(result.status)
+      && result.mergeOnly === true
+      && result.privacyBlockInstalled === true
+      && result.privateModeCompliant === true
+      && Array.isArray(result.missing)
+      && result.missing.length === 0
+      && Array.isArray(result.overwritten)
+      && result.overwritten.length === 0
+      && Array.isArray(result.permissionIssues)
+      && result.permissionIssues.length === 0
+    );
+    if (canonical) {
+      // Core owns the canonical seed. Terminal adds one intentionally broader
+      // guard so future local memory files are private without a release update.
+      ensureAgentlasProjectStateIgnoreCli(root);
+      hardenAgentlasProjectStateCli(root);
+      projectBootstrapStates.set(root, "core");
+      return true;
+    }
+    throw new Error("Agentlas Core returned an incomplete project bootstrap contract");
+  }
+  // A just-updated Terminal can briefly see the previous Core. The legacy
+  // merge-only seed remains local-only and Core is retried next process.
+  ensureProjectMemoryCli(root);
+  if (!fs.existsSync(path.join(root, ".agentlas"))) {
+    throw new Error("Agentlas project bootstrap could not create private local state");
+  }
+  ensureAgentlasProjectStateIgnoreCli(root);
+  hardenAgentlasProjectStateCli(root);
+  projectBootstrapStates.set(root, "fallback");
+  return false;
 }
-function cliMemoryContext(db, projectPath) {
+
+// Passive checks never increment visits or touch the project. Activation is
+// reserved for an actual write/full Terminal execution or an explicit ensure.
+function recordCliFolderVisit(db, projectPath, options = {}) {
+  const root = terminalProjectCandidateCli(projectPath);
+  if (!root) return { activated: false };
+  const activate = options.activate === true;
+  try {
+    if (!activate) {
+      const row = tableExists(db, "folder_activity")
+        ? db.prepare("SELECT activated_at FROM folder_activity WHERE path=?").get(root)
+        : null;
+      return { activated: Boolean(row && row.activated_at) || fs.existsSync(path.join(root, ".agentlas")) };
+    }
+
+    ensureCoreProjectCli(root, { reason: options.reason || "terminal-first-contact", coreRoot: options.coreRoot });
+    if (!tableExists(db, "folder_activity")) return { activated: true };
+    const now = new Date().toISOString();
+    const row = db.prepare("SELECT visits FROM folder_activity WHERE path=?").get(root);
+    if (row) {
+      db.prepare("UPDATE folder_activity SET visits=?, activated_at=COALESCE(activated_at,?), last_seen=? WHERE path=?")
+        .run(Number(row.visits || 0) + 1, now, now, root);
+    } else {
+      db.prepare("INSERT INTO folder_activity (path, visits, activated_at, first_seen, last_seen) VALUES (?,?,?,?,?)")
+        .run(root, 1, now, now, now);
+    }
+    return { activated: true };
+  } catch (error) {
+    // An activation failure can mean that the project-local privacy boundary
+    // could not be established (for example, a symlinked or oversized
+    // .gitignore). Never continue a write/full execution in that state.
+    if (activate) throw error;
+    return { activated: false };
+  }
+}
+
+function activeProjectPath(db, options = {}) {
+  const root = terminalProjectCandidateCli(options.projectPath || process.cwd());
+  if (!root) return null;
+  const result = recordCliFolderVisit(db, root, options);
+  return result.activated ? root : null;
+}
+
+function ensureTerminalProjectForExecutionCli(db, projectPath, permission = PERMISSION, reason = "terminal-first-contact") {
+  const root = terminalProjectCandidateCli(projectPath);
+  if (!root) return null;
+  if (permission === "read") return activeProjectPath(db, { projectPath: root });
+  return activeProjectPath(db, { projectPath: root, activate: true, reason });
+}
+function cliMemoryContext(db, projectPath, agentId = null) {
   const sections = [];
   const arch = loadArch();
   ensureMemoryContextColumn(db);
@@ -7575,14 +8105,49 @@ function cliMemoryContext(db, projectPath) {
   }
   if (tableExists(db, "memory_entries")) {
     try {
-      const rows = projectPath
-        ? db.prepare("SELECT kind, content, context_json FROM memory_entries WHERE superseded_at IS NULL AND scope!='session' AND (project_path=? OR (project_path IS NULL AND scope IN ('user_identity','team_memory','agent_team'))) ORDER BY created_at DESC LIMIT 12").all(projectPath)
-        : db.prepare("SELECT kind, content, context_json FROM memory_entries WHERE project_path IS NULL AND scope!='session' AND superseded_at IS NULL ORDER BY created_at DESC LIMIT 12").all();
-      if (rows.length) sections.push((projectPath ? "### Recent curated memory\n" : "### Curated memory (global)\n") + rows.map((r) => `- [${r.kind}] ${r.content}${contextLine(r.context_json)}`).join("\n"));
+      // New writes are read through a scoped global<->project timeline. The
+      // project key is a digest, and team/agent lanes additionally require the
+      // current owner id, so project B cannot recall project A's local memory.
+      const governed = terminalMemoryGovernance.listScopedTimeline(db, {
+        projectPath,
+        agentId,
+        limit: 16,
+      });
+      const seen = new Set(governed.map((row) => row.id));
+      // Legacy rows predate the timeline. Keep only intentional user-global
+      // rows, this exact project, and this exact agent/team owner. In
+      // particular, do not revive the old global team-memory leakage query.
+      const legacy = projectPath
+        ? db.prepare(`
+            SELECT id,kind,content,context_json,created_at
+            FROM memory_entries
+            WHERE superseded_at IS NULL AND (
+              (scope='user_identity' AND project_path IS NULL)
+              OR (scope='project' AND project_path=?)
+              OR (scope IN ('team_memory','agent_team','agent_repo') AND agent_id=? AND (project_path IS NULL OR project_path=?))
+            )
+            ORDER BY created_at DESC LIMIT 16
+          `).all(projectPath, agentId, projectPath)
+        : db.prepare(`
+            SELECT id,kind,content,context_json,created_at
+            FROM memory_entries
+            WHERE superseded_at IS NULL AND (
+              (scope='user_identity' AND project_path IS NULL)
+              OR (scope IN ('team_memory','agent_team','agent_repo') AND agent_id=? AND project_path IS NULL)
+            )
+            ORDER BY created_at DESC LIMIT 16
+          `).all(agentId);
+      const rows = [...governed, ...legacy.filter((row) => !seen.has(row.id))].slice(0, 16);
+      if (rows.length) {
+        sections.push(
+          (projectPath ? "### Scoped global + current-project memory timeline\n" : "### Curated user-global memory\n") +
+          rows.map((r) => `- [${r.kind}] ${r.content}${contextLine(r.context_json)}`).join("\n"),
+        );
+      }
     } catch { /* ignore */ }
   }
   if (!sections.length) return "";
-  return "## Agentlas memory (read before answering; five-scope + request_context recall)\n\n" + sections.join("\n\n");
+  return "## Agentlas memory (read before answering; governed scope recall)\n\n" + sections.join("\n\n");
 }
 function parseMemoryEventsCli(text) {
   const heading = loadArch().eventsHeading;
@@ -7600,11 +8165,16 @@ function parseMemoryEventsCli(text) {
 function curateCliReply(db, text, ctx) {
   const { events, cleaned } = parseMemoryEventsCli(text);
   const style = require("./agentlas-style.cjs");
+  if (ctx && ctx.permission === "read") return style.sanitizeAssistantText(cleaned);
   if (!events.length || !tableExists(db, "memory_entries")) return style.sanitizeAssistantText(cleaned);
   ensureMemoryContextColumn(db);
   const arch = loadArch();
   const { randomUUID } = require("node:crypto");
   const now = new Date().toISOString();
+  const rememberCurated = (memory) => {
+    if (!ctx || !Array.isArray(ctx.curatedMemories) || !memory) return;
+    if (!ctx.curatedMemories.some((item) => item.id === memory.id)) ctx.curatedMemories.push(memory);
+  };
   for (const ev of events) {
     const content = ev && typeof ev.content === "string" ? ev.content.trim() : "";
     if (!content) continue;
@@ -7620,9 +8190,16 @@ function curateCliReply(db, text, ctx) {
     const ppath = scope === "project" ? ctx.projectPath : null;
     const requestContext = normalizeRequestContext(ev, ctx, ppath);
     try {
-      const dup = db.prepare("SELECT 1 FROM memory_entries WHERE scope=? AND kind=? AND lower(trim(content))=? AND superseded_at IS NULL AND (project_path IS ? OR project_path=?) LIMIT 1").get(scope, kind, content.toLowerCase(), ppath, ppath);
-      if (dup) continue;
-      db.prepare("INSERT INTO memory_entries (id,scope,kind,content,project_id,project_path,agent_id,chat_id,confidence,sensitivity,evidence_json,context_json,superseded_at,created_at) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,NULL,?)").run(randomUUID(), scope, kind, content, ctx.projectId || null, ppath, ctx.agentId || null, null, ev.confidence || "medium", ev.sensitivity || "internal", JSON.stringify(Array.isArray(ev.evidence_refs) ? ev.evidence_refs : []), JSON.stringify(requestContext), now);
+      const dup = db.prepare("SELECT id,scope,kind,content,confidence,sensitivity,context_json FROM memory_entries WHERE scope=? AND kind=? AND lower(trim(content))=? AND superseded_at IS NULL AND (project_path IS ? OR project_path=?) LIMIT 1").get(scope, kind, content.toLowerCase(), ppath, ppath);
+      if (dup) {
+        rememberCurated({ ...dup, requestContext });
+        continue;
+      }
+      const memoryId = randomUUID();
+      const confidence = ev.confidence || "medium";
+      const sensitivity = ev.sensitivity || "internal";
+      db.prepare("INSERT INTO memory_entries (id,scope,kind,content,project_id,project_path,agent_id,chat_id,confidence,sensitivity,evidence_json,context_json,superseded_at,created_at) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,NULL,?)").run(memoryId, scope, kind, content, ctx.projectId || null, ppath, ctx.agentId || null, null, confidence, sensitivity, JSON.stringify(Array.isArray(ev.evidence_refs) ? ev.evidence_refs : []), JSON.stringify(requestContext), now);
+      rememberCurated({ id: memoryId, scope, kind, content, confidence, sensitivity, requestContext });
       logCli(ctx.projectPath, { action: "written", scope, kind, content, request_context: requestContext, at: now });
     } catch { /* ignore */ }
   }
@@ -7641,7 +8218,50 @@ function prefsLang() {
   }
 }
 
-function augmentSystem(db, baseSystem, ctx, withEmitter) {
+const TERMINAL_MEMORY_CORE_MAX_TOKENS = 150;
+const TERMINAL_MEMORY_CORE = [
+  "## Memory governance",
+  "End every completed reply with hidden `## Memory Events` plus fenced JSON:",
+  '{"turn_id":"<stable-id>","observation":{"outcome":"completed","summary":"safe short outcome"},"candidates":[]}',
+  "Candidates 0..N: memory_kind,content,suggested_scope,confidence.",
+  "Scopes: user_global|team|agent|project|session|discard.",
+  "No raw prompts/transcripts, secrets, logs, or absolute paths. Curator suggests; deterministic gates decide writes.",
+].join("\n");
+const MEMORY_DETAIL_RE = /\b(?:remember|memory|save this|record this|memory event)\b|기억|메모리|저장해|기록해|남겨/i;
+const CREDENTIAL_INDEX_RE = /\b(?:deploy|release|billing|auth|oauth|credential|api key|secret key|cloud)\b|배포|릴리스|출시|결제|인증|자격 증명|API\s*키|시크릿|클라우드/i;
+
+function approximatePromptTokens(text) {
+  return Math.ceil(Buffer.byteLength(String(text || ""), "utf8") / 3);
+}
+if (approximatePromptTokens(TERMINAL_MEMORY_CORE) > TERMINAL_MEMORY_CORE_MAX_TOKENS) {
+  throw new Error("Terminal always-on memory core exceeds 150 tokens");
+}
+
+function memoryEmitterPromptFor(request, arch = loadArch(), turnId = null, permission = "write") {
+  const stableId = String(turnId || "").replace(/[^A-Za-z0-9:._-]/g, "").slice(0, 160);
+  let prompt = TERMINAL_MEMORY_CORE;
+  if (stableId) prompt += `\nUse turn_id=${stableId}. permission=${permission === "read" ? "receipt-only" : "curated-write"}.`;
+  if (!MEMORY_DETAIL_RE.test(String(request || ""))) return prompt;
+  const kinds = Array.isArray(arch?.kinds) && arch.kinds.length ? arch.kinds.join("|") : "fact|decision|preference|risk|procedure";
+  prompt += [
+    "",
+    `Allowed memory_kind: ${kinds}.`,
+    "Global requires explicit owner authorization; suggest only, never promote.",
+    "Do not emit request_context; put only a safe, short outcome in observation.",
+  ].join("\n");
+  return prompt;
+}
+
+function credentialIndexReminderFor(request) {
+  if (!CREDENTIAL_INDEX_RE.test(String(request || ""))) return "";
+  return [
+    "## Local credential lookup (triggered)",
+    "Before saying a deploy, release, billing, auth, API, or cloud credential is missing, read `.agentlas/local-credentials.map.json` and the Local Credential Index in `.agentlas/project-soul-memory.md`.",
+    "Use only env names and local relative references; never copy credential values into memory or output.",
+  ].join("\n");
+}
+
+function augmentSystem(db, baseSystem, ctx, withEmitter, request = "") {
   const arch = loadArch();
   let sys = baseSystem || "";
   // 언어/말투 지시를 맨 앞에 둔다. imported/cloud/company agents도 같은 전역 계약을 따른다.
@@ -7649,12 +8269,133 @@ function augmentSystem(db, baseSystem, ctx, withEmitter) {
   sys = langDirective(lang) + (sys ? "\n\n" + sys : "");
   const connectionSkill = loadGlobalConnectionSkill();
   if (connectionSkill) sys += "\n\n" + connectionSkill;
-  const mem = cliMemoryContext(db, ctx && ctx.projectPath);
+  const mem = cliMemoryContext(db, ctx && ctx.projectPath, ctx && ctx.agentId);
   if (mem) sys += "\n\n" + mem;
-  if (withEmitter && arch.emitterBlock) sys += "\n\n" + arch.emitterBlock;
+  if (withEmitter) {
+    sys += "\n\n" + memoryEmitterPromptFor(request, arch, ctx && ctx.turnId, ctx && ctx.permission);
+    const credentialReminder = credentialIndexReminderFor(request);
+    if (credentialReminder) sys += "\n\n" + credentialReminder;
+  }
   return sys;
 }
 
+function curatorRuntimeDirCli() {
+  const root = path.join(userDataDir(), "memory-governance", "curator-runtime");
+  fs.mkdirSync(root, { recursive: true, mode: 0o700 });
+  try { fs.chmodSync(path.dirname(root), 0o700); } catch { /* Windows/ACL-only host */ }
+  try { fs.chmodSync(root, 0o700); } catch { /* Windows/ACL-only host */ }
+  return root;
+}
+
+function curatorRuntimeEnvCli(source = process.env) {
+  // The semantic Curator has no tools and receives only pre-gated candidates.
+  // Keep its process environment equally narrow: subscription CLIs can locate
+  // their normal file-backed auth, but project/provider secret env is absent.
+  const allowed = new Set([
+    "PATH", "HOME", "USER", "LOGNAME", "SHELL", "TMPDIR", "TMP", "TEMP",
+    "LANG", "LC_ALL", "LC_CTYPE", "TERM", "COLORTERM", "NO_COLOR",
+    "CODEX_HOME", "CLAUDE_CONFIG_DIR", "XDG_CONFIG_HOME", "USERPROFILE",
+    "APPDATA", "LOCALAPPDATA", "SYSTEMROOT", "SystemRoot", "COMSPEC", "ComSpec", "PATHEXT",
+  ]);
+  const env = {};
+  for (const [key, value] of Object.entries(source || {})) {
+    if (allowed.has(key) || key.startsWith("LC_")) env[key] = value;
+  }
+  env.AGENTLAS_MEMORY_CURATOR = "1";
+  return env;
+}
+
+function ensureGeminiNoToolsPolicyCli() {
+  const dir = curatorRuntimeDirCli();
+  const file = path.join(dir, "gemini-no-tools-policy.toml");
+  const content = [
+    "# Managed by Agentlas Terminal for the semantic Memory Curator.",
+    "[[rule]]",
+    'toolName = "*"',
+    'decision = "deny"',
+    "priority = 999",
+    "",
+  ].join("\n");
+  let current = null;
+  try { current = fs.readFileSync(file, "utf8"); } catch { /* first write */ }
+  if (current !== content) {
+    const temp = path.join(dir, `.gemini-no-tools-policy.${process.pid}.${crypto.randomUUID()}.tmp`);
+    fs.writeFileSync(temp, content, { encoding: "utf8", mode: 0o600, flag: "wx" });
+    fs.renameSync(temp, file);
+  }
+  try { fs.chmodSync(file, 0o600); } catch { /* Windows/ACL-only host */ }
+  return file;
+}
+
+async function invokeMemoryCuratorCli(db, runtime, model, payload, systemPrompt) {
+  const serialized = JSON.stringify(payload);
+  if (
+    terminalMemoryGovernance.hasSecret(serialized) ||
+    terminalMemoryGovernance.hasAbsolutePath(serialized) ||
+    terminalMemoryGovernance.hasTranscriptBody(serialized)
+  ) {
+    throw new Error("Memory Curator payload failed the pre-invocation privacy gate");
+  }
+  if (runtime.mode === "cli") {
+    return captureRuntime(runtime.kind, systemPrompt, serialized, {
+      cwd: curatorRuntimeDirCli(),
+      env: curatorRuntimeEnvCli(),
+      permission: "read",
+      model: model || runtime.model || null,
+      effort: "low",
+      authorityMode: "no-authority",
+      noToolsPolicyPath: runtime.kind === "gemini" ? ensureGeminiNoToolsPolicyCli() : null,
+      outputLimitBytes: 64 * 1024,
+      timeoutConfig: { idleMs: 60_000, totalMs: 120_000, killGraceMs: 2_000 },
+    });
+  }
+  return runApi(runtime.backend, model || runtime.model, systemPrompt, serialized);
+}
+
+function beginMemoryTurnCli(db, prompt, ctx = {}) {
+  return terminalMemoryGovernance.beginTurn(db, {
+    prompt,
+    projectPath: ctx.projectPath,
+    agentId: ctx.agentId,
+    permission: ctx.permission,
+    surface: ctx.surface || "terminal-normal-turn",
+    conversationRef: ctx.conversationRef,
+    priorContextDigest: ctx.priorContextDigest,
+    stableTurnId: ctx.stableTurnId || process.env.AGENTLAS_TURN_ID,
+  });
+}
+
+async function completeMemoryTurnCli(db, text, ctx, runtime, options = {}) {
+  const turnId = ctx?.memoryTurn?.turnId || ctx?.turnId;
+  const arch = loadArch();
+  const runtimeInfo = runtime || {};
+  const completion = {
+    turnId,
+    mainOutput: text,
+    requestText: options.requestText,
+    permission: ctx && ctx.permission,
+    projectPath: ctx && ctx.projectPath,
+    agentId: ctx && ctx.agentId,
+    eventsHeading: arch.eventsHeading,
+    outcome: options.outcome || "completed",
+    coreFiles: {
+      memoryDir: arch.memoryDir || ".agentlas",
+      ticketFile: arch.memoryTicketsFile || "memory-tickets.jsonl",
+      decisionFile: arch.curatorDecisionsFile || "curator-decisions.jsonl",
+    },
+  };
+  if (options.invokeCurator !== false) {
+    completion.invokeCurator = (payload, systemPrompt) => invokeMemoryCuratorCli(
+      db,
+      runtimeInfo,
+      options.model || runtimeInfo.model || null,
+      payload,
+      systemPrompt,
+    );
+  }
+  return terminalMemoryGovernance.completeTurn(db, completion);
+}
+
 function loadGlobalConnectionSkill() {
   try {
     return require("../dist/electron/runtime/global-skill.js").GLOBAL_CONNECTION_SKILL || "";
@@ -7676,19 +8417,78 @@ const RUNTIME_BIN = {
 
 // 활성 런타임 → 실행 방식 결정. CLI(claude/codex/gemini) 또는 API(BYOK/Ollama).
 function resolveRuntime(db, override) {
+  const ar = activeRuntime(db);
+  const activeCli = ar && RUNTIME_BIN[ar.kind]
+    ? {
+        mode: "cli",
+        kind: ar.kind,
+        model: ar.model || null,
+        capabilities: ["code", "tools", ...(ar.long_context ? ["long-context"] : [])],
+        efforts: [],
+      }
+    : null;
   if (override) {
-    if (!RUNTIME_BIN[override]) fail(`알 수 없는 런타임: ${override} (claude-code|codex|gemini)`);
-    return { mode: "cli", kind: override };
+    if (!RUNTIME_BIN[override]) fail(`Unknown runtime: ${override} (claude-code|codex|gemini)`);
+    return activeCli && activeCli.kind === override ? activeCli : { mode: "cli", kind: override };
   }
-  const ar = activeRuntime(db);
-  if (ar && RUNTIME_BIN[ar.kind]) return { mode: "cli", kind: ar.kind };
+  if (activeCli) return activeCli;
   if (ar && ar.kind === "byok" && ar.backend) return { mode: "api", backend: ar.backend, model: ar.model };
   if (ar && ar.kind === "ollama") return { mode: "api", backend: "ollama", model: ar.model };
   // 폴백: 설치된 CLI 탐지
   for (const kind of Object.keys(RUNTIME_BIN)) {
     if (which(RUNTIME_BIN[kind])) return { mode: "cli", kind };
   }
-  fail("사용할 런타임이 없습니다. CLI(claude/codex/gemini)를 설치하거나 앱에서 API 키/Ollama를 설정하세요.");
+  fail("No runtime is available. Install a CLI (claude/codex/gemini) or configure an API key/Ollama in the app.");
+}
+
+// Build the executable runtime inventory for the parent allocator.  It is
+// intentionally local to this host: a Terminal/Codex/Claude plugin never
+// pretends it can schedule a runtime that is not installed and connected here.
+function listAvailableRuntimes(db, fallbackRuntime = null) {
+  const routing = require("./agentlas-workload-routing.cjs");
+  const active = fallbackRuntime || resolveRuntime(db);
+  const candidates = [];
+  const add = (runtime) => {
+    if (!runtime) return;
+    const key = runtime.mode === "cli" ? `cli:${runtime.kind}` : `api:${runtime.backend}:${runtime.model || ""}`;
+    if (candidates.some((item) => item.key === key)) return;
+    const discovered = routing.defaultAvailableModels(runtime);
+    const availableModels = [...discovered];
+    if (runtime.model && !availableModels.some((model) => model.id === runtime.model)) {
+      availableModels.push({
+        id: runtime.model,
+        tier: runtime.modelTier || runtime.tier || null,
+        capabilities: runtime.capabilities || [],
+        contextWindow: runtime.contextWindow || null,
+        efforts: runtime.efforts || [],
+        description: runtime.modelDescription || "host-selected current model",
+      });
+    }
+    candidates.push({ ...runtime, key, availableModels });
+  };
+  add(active);
+  for (const kind of Object.keys(RUNTIME_BIN)) {
+    if (!which(RUNTIME_BIN[kind])) continue;
+    add({ mode: "cli", kind });
+  }
+  return candidates
+    .filter((runtime) => runtime.availableModels.length)
+    .map(({ key, ...runtime }, index) => ({ ...runtime, runtimeId: `runtime-${index + 1}` }));
+}
+
+function currentRuntimeInventoryCli(db, runtime) {
+  const candidates = listAvailableRuntimes(db, runtime);
+  const current = candidates.find((candidate) =>
+    candidate.mode === runtime.mode &&
+    (runtime.mode === "cli"
+      ? candidate.kind === runtime.kind
+      : candidate.backend === runtime.backend && candidate.model === runtime.model));
+  if (current) return current;
+  return {
+    ...runtime,
+    runtimeId: "runtime-current",
+    availableModels: workloadRouting.defaultAvailableModels(runtime),
+  };
 }
 
 // ── API 러너 (BYOK / Ollama) — 비스트리밍, 최종 텍스트 반환 ──
@@ -7728,14 +8528,14 @@ function normalizeCustomApiBaseUrl(raw) {
   try {
     parsed = new URL(value);
   } catch {
-    throw new Error("Custom API base URL이 올바르지 않습니다.");
+    throw new Error("Custom API base URL is invalid.");
   }
   const host = parsed.hostname.toLowerCase();
   const isLoopback = host === "localhost" || host === "127.0.0.1" || host === "::1" || host === "[::1]";
   const isPrivateLan =
     /^10\./.test(host) || /^192\.168\./.test(host) || /^172\.(1[6-9]|2\d|3[01])\./.test(host);
   if (parsed.protocol !== "https:" && !(parsed.protocol === "http:" && (isLoopback || isPrivateLan))) {
-    throw new Error("Custom API base URL은 HTTPS 또는 localhost/LAN의 HTTP여야 합니다.");
+    throw new Error("Custom API base URL must use HTTPS or HTTP on localhost/LAN.");
   }
   return value.replace(/\/+$/, "");
 }
@@ -7761,7 +8561,7 @@ function readCustomApiBaseUrl() {
       raw = "";
     }
   } catch (e) {
-    throw new Error(`Custom API base URL을 공유 DB에서 읽지 못했습니다: ${(e && e.message) || e}`);
+    throw new Error(`Could not read the Custom API base URL from the shared database: ${(e && e.message) || e}`);
   } finally {
     try { if (db && typeof db.close === "function") db.close(); } catch { /* ignore close failure */ }
   }
@@ -7777,22 +8577,22 @@ async function runApi(backend, model, system, prompt, options) {
   options = options || {};
   model = model || DEFAULT_API_MODEL[backend];
   const fetchImpl = options.fetch || globalThis.fetch;
-  if (typeof fetchImpl !== "function") throw new Error("이 런타임에 fetch가 없습니다(앱 런타임으로 실행 필요).");
+  if (typeof fetchImpl !== "function") throw new Error("fetch is unavailable in this runtime (run through the app runtime).");
   if (backend === "ollama") {
     const resp = await fetchImpl("http://127.0.0.1:11434/api/chat", {
       method: "POST",
       headers: { "content-type": "application/json" },
       body: JSON.stringify({ model, stream: false, messages: [{ role: "system", content: system }, { role: "user", content: prompt }] }),
     });
-    if (!resp.ok) throw new Error(`Ollama ${resp.status} — 'ollama serve' 실행/모델 확인`);
+    if (!resp.ok) throw new Error(`Ollama ${resp.status} — run 'ollama serve' and check the model`);
     const j = await resp.json();
     return (j.message && j.message.content) || "";
   }
   const supported = backend === "anthropic" || backend === "openai" || backend === "google" ||
     backend === "upstage" || backend === "custom" || !!ANTHROPIC_COMPAT_API[backend];
-  if (!supported) throw new Error("지원하지 않는 backend: " + backend);
+  if (!supported) throw new Error("Unsupported backend: " + backend);
   const key = Object.prototype.hasOwnProperty.call(options, "apiKey") ? options.apiKey : await apiKey(backend);
-  if (!key) throw new Error(`${backend} API 키가 없습니다. 앱 설정 → BYOK에서 키를 등록하세요.`);
+  if (!key) throw new Error(`${backend} API key is missing. Register it in App settings → BYOK.`);
 
   const anthropicCompat = ANTHROPIC_COMPAT_API[backend];
   if (backend === "anthropic" || anthropicCompat) {
@@ -7840,18 +8640,129 @@ async function runApi(backend, model, system, prompt, options) {
     const c = j.candidates && j.candidates[0];
     return (c && c.content && c.content.parts && c.content.parts[0] && c.content.parts[0].text) || "";
   }
-  throw new Error("지원하지 않는 backend: " + backend);
+  throw new Error("Unsupported backend: " + backend);
 }
 
 // 1회 실행 — CLI면 spawn(스트리밍 stdout), API면 호출 후 텍스트 출력. 종료코드 반환.
 // ctx = { projectPath, agentId } — 메모리 주입/큐레이션에 사용.
+function finalizeExperienceExecutionCli(db, input) {
+  if (input.permission === "read") return null;
+  if (!input.agentId) return null;
+  let agent;
+  try { agent = db.prepare("SELECT * FROM installed_agents WHERE id=?").get(input.agentId); }
+  catch { return null; }
+  if (!agent) return null;
+  const exactBase = exactAgentBaseForExecution(db, agent, input.runtimeExperience);
+  if (!exactBase) return null;
+  const runtime = input.runtime || {};
+  const provider = runtime.mode === "cli" ? runtime.kind : runtime.backend;
+  const modelId = input.model || runtime.model || provider;
+  const usage = input.usage || {};
+  try {
+    return terminalExperienceIntake.finalizeAgentExecution({
+      db,
+      userDataDir: userDataDir(),
+      cwd: input.cwd || input.projectPath || projectCwd(),
+      agent,
+      exactBase,
+      environment: { runtime: provider || "terminal", os: process.platform, arch: process.arch },
+      model: { provider: provider || "terminal-runtime", modelId: modelId || "terminal-runtime" },
+      mcp: (input.mcpServers || []).flatMap((server) => {
+        const catalogId = server.catalog_id || server.catalogId;
+        // A reviewed runtime allowlist proves approval, not that this turn's
+        // child completed an MCP initialize/tool call. Do not inflate it into
+        // connected evidence without an exact runtime signal.
+        return catalogId ? [{ catalogId, status: "approved" }] : [];
+      }),
+      outcome: input.outcome,
+      metrics: {
+        promptTokens: usage.input_tokens || usage.prompt_tokens || 0,
+        completionTokens: usage.output_tokens || usage.completion_tokens || 0,
+        totalTokens: usage.total_tokens || 0,
+        durationMs: input.durationMs || usage.duration_ms || 0,
+        retryCount: 0,
+      },
+      curatedMemories: input.curatedMemories || [],
+      taskHint: input.taskHint,
+      taskSignatures: input.runtimeExperience?.taskSignatures || [],
+      experiencePackReleaseId: input.runtimeExperience?.experiencePackReleaseIds?.[0] || null,
+      locale: input.lang || prefsLang(),
+      runId: input.runId,
+      createdAt: input.createdAt,
+    });
+  } catch (error) {
+    process.stderr.write(`▸ local Experience intake skipped · ${String((error && error.message) || error).slice(0, 180)}\n`);
+    return null;
+  }
+}
+
 async function executeOnce(db, system, prompt, override, ctx) {
   ctx = ctx || { projectPath: null, agentId: null };
+  const runStartedAt = Date.now();
+  const memoryTurn = beginMemoryTurnCli(db, prompt, {
+    ...ctx,
+    surface: ctx.surface || "terminal-one-shot",
+    stableTurnId: ctx.turnId,
+  });
+  ctx.memoryTurn = memoryTurn;
+  ctx.turnId = memoryTurn.turnId;
+  const experienceRunId = `terminal-run:${memoryTurn.turnId}`;
+  const curatedMemories = [];
+  ctx.curatedMemories = curatedMemories;
   if (!ctx.cwdAtRequest) ctx.cwdAtRequest = projectCwd();
+  let memoryRuntime = null;
+  let memorySettled = false;
+  try {
+  let runtimeSystem = system;
+  let localExperienceContext = null;
+  if (ctx.runtimeExperience?.disabled === true && ctx.runtimeExperience.observableReason) {
+    process.stderr.write(`▸ local Experience skipped · ${ctx.runtimeExperience.observableReason}\n`);
+  } else if (ctx.runtimeExperience && ctx.runtimeExperience.disabled !== true) {
+    const runtimeExperience = ctx.runtimeExperience;
+    const augmented = terminalExperienceExchange.augmentRuntimeSystemWithLocalExperience(system, {
+      userDataDir: userDataDir(),
+      cwd: ctx.projectPath || ctx.cwdAtRequest,
+      baseAgentReleaseId: runtimeExperience.baseAgentReleaseId,
+      agentDefinitionId: runtimeExperience.agentDefinitionId,
+      experiencePackReleaseIds: runtimeExperience.experiencePackReleaseIds || [],
+      taskSignatures: runtimeExperience.taskSignatures || [],
+      environmentTags: Array.isArray(runtimeExperience.environmentTags) && runtimeExperience.environmentTags.length
+        ? runtimeExperience.environmentTags
+        : terminalExperienceExchange.defaultEnvironmentTags(),
+      reservedTokens: ctx.runtimeExperience?.tasteRuntimeOverlay?.estimatedTokens ?? 0,
+    });
+    runtimeSystem = augmented.systemPrompt;
+    localExperienceContext = augmented.experienceContext;
+    if (localExperienceContext.itemIds.length) {
+      const source = runtimeExperience.loadoutAuthority === "desktop-terminal-exact-loadout"
+        ? "Desktop-approved exact Experience"
+        : "local Experience advisory";
+      process.stderr.write(`▸ ${source} · ${localExperienceContext.itemIds.length} item(s) · ~${localExperienceContext.estimatedTokens} tokens · no server rental receipt\n`);
+    }
+  }
+  const tasteTaskResolution = terminalExperienceExchange.deriveCanonicalTaskClasses(prompt);
+  if (
+    ctx.runtimeExperience?.tasteRuntimeOverlay &&
+    desktopOntologyLoadout.tasteRuntimeOverlayMatchesTask(
+      ctx.runtimeExperience.tasteRuntimeOverlay,
+      tasteTaskResolution.taskIds,
+      prompt,
+    )
+  ) {
+    const tasteDirective = desktopOntologyLoadout.renderTasteRuntimeDirective(
+      ctx.runtimeExperience.tasteRuntimeOverlay,
+    );
+    runtimeSystem = `${runtimeSystem}\n\n${tasteDirective}`;
+    process.stderr.write(
+      `▸ Desktop-approved exact Taste · ${ctx.runtimeExperience.tasteRuntimeOverlay.releaseId} · ~${ctx.runtimeExperience.tasteRuntimeOverlay.estimatedTokens} tokens · session snapshot\n`,
+    );
+  }
   const rt = resolveRuntime(db, override);
+  memoryRuntime = rt;
   if (rt.mode === "cli") {
-    // 네이티브 CLI는 자체 세션을 가지므로 emitter는 넣지 않고(노이즈 방지) 메모리 컨텍스트만 주입.
-    const sys = augmentSystem(db, system, ctx, false);
+    // 네이티브 CLI에도 같은 Memory emitter를 주입하되 guard가 화면의 JSON 블록을 숨긴다.
+    // 큐레이터가 만든 구조화 Memory만 성공 RunReceipt 이후 Experience intake로 전달된다.
+    const sys = augmentSystem(db, runtimeSystem, ctx, true, prompt);
     const cwd = ctx.projectPath || projectCwd();
     const permission = ctx.permission || "write";
     const env = await buildChildEnvCli(db, { ...ctx, cwd });
@@ -7859,40 +8770,300 @@ async function executeOnce(db, system, prompt, override, ctx) {
     // one-shot(`agentlas "작업"`)도 REPL과 동일한 리치 렌더(⏺ 툴 / └ 결과 / 토큰)로 출력한다.
     const { runNativeTurn } = require("./agentlas-native-host.cjs");
     const { Ui } = require("./agentlas-ui.cjs");
+    const { makeMemoryGuard } = require("./agentlas-repl.cjs");
     const ui = new Ui({ lang: prefsLang() });
     let mcpServers = [];
     if (permission === "full") {
-      try {
-        mcpServers = db.prepare("SELECT id, name, transport, command, args_json, enabled FROM mcp_servers WHERE enabled=1 AND transport='stdio'").all();
-      } catch { /* ignore */ }
+      if (Array.isArray(ctx.mcpServers)) {
+        // Build's reviewed host allowlist is authoritative, including the valid
+        // empty list. Never fall back to every enabled registry row.
+        mcpServers = ctx.mcpServers;
+      } else {
+        try {
+          mcpServers = terminalAssets.readConsentedSystemMcpServers(db, { userDataDir: userDataDir() });
+        } catch { /* ignore */ }
+      }
     }
     ui.beginTurn();
-    const res = await runNativeTurn({
-      kind: rt.kind,
-      bin: which(RUNTIME_BIN[rt.kind]) || RUNTIME_BIN[rt.kind],
-      prompt,
-      systemPrompt: sys,
+    const memoryGuard = makeMemoryGuard(ui, loadArch().eventsHeading);
+    let res;
+    try {
+      res = await runNativeTurn({
+        kind: rt.kind,
+        bin: which(RUNTIME_BIN[rt.kind]) || RUNTIME_BIN[rt.kind],
+        prompt,
+        systemPrompt: sys,
+        cwd,
+        permission,
+        session: {},
+        model: ctx.model || null,
+        effort: ctx.effort || null,
+        mcpServers,
+        mcpAllowlistMode: ctx.mcpAllowlistMode,
+        env,
+        ui: memoryGuard,
+      });
+    } finally {
+      ui.endTurn();
+    }
+    const nativeText = String(res.text || "");
+    const memoryResult = await completeMemoryTurnCli(db, nativeText, ctx, rt, {
+      model: ctx.model || rt.model,
+      outcome: res.error ? "failed" : "succeeded",
+      requestText: prompt,
+      // Every failed runtime needs a deterministic receipt, but must not
+      // recursively call the runtime that just failed.
+      invokeCurator: !res.error,
+    });
+    memorySettled = true;
+    for (const memory of memoryResult.curatedMemories || []) {
+      if (memory && !curatedMemories.some((item) => item.id === memory.id)) curatedMemories.push(memory);
+    }
+    finalizeExperienceExecutionCli(db, {
+      agentId: ctx.agentId,
+      projectPath: ctx.projectPath,
       cwd,
-      permission,
-      session: {},
-      model: null,
-      effort: null,
+      runtime: rt,
+      permission: ctx.permission,
+      model: ctx.model || rt.model,
+      runtimeExperience: ctx.runtimeExperience,
       mcpServers,
-      env,
-      ui,
+      curatedMemories,
+      taskHint: prompt,
+      outcome: { status: res.error ? "failed" : "succeeded", failureCode: res.error ? "runtime-error" : null },
+      usage: res.usage,
+      durationMs: Date.now() - runStartedAt,
+      runId: experienceRunId,
+      lang: ctx.lang,
     });
-    ui.endTurn();
     return res.error ? 1 : 0;
   }
   // API 경로 — emitter 동봉 → 답변에서 메모리 이벤트를 파싱·큐레이션하고 블록은 제거.
-  const sys = augmentSystem(db, system, ctx, true);
+  const sys = augmentSystem(db, runtimeSystem, ctx, true, prompt);
   const env = await buildChildEnvCli(db, { ...ctx, cwd: ctx.cwd || projectCwd() });
   Object.assign(process.env, env);
-  process.stderr.write(`▸ ${rt.backend}${rt.model ? " · " + rt.model : ""}\n`);
-  const text = await runApi(rt.backend, rt.model, sys, prompt);
-  const cleaned = curateCliReply(db, text || "", ctx);
+  const selectedModel = ctx.model || rt.model;
+  process.stderr.write(`▸ ${rt.backend}${selectedModel ? " · " + selectedModel : ""}\n`);
+  let text;
+  try {
+    text = await runApi(rt.backend, selectedModel, sys, prompt);
+  } catch (error) {
+    finalizeExperienceExecutionCli(db, {
+      agentId: ctx.agentId,
+      projectPath: ctx.projectPath,
+      cwd: ctx.cwd || projectCwd(),
+      runtime: rt,
+      permission: ctx.permission,
+      model: selectedModel,
+      runtimeExperience: ctx.runtimeExperience,
+      curatedMemories,
+      taskHint: prompt,
+      outcome: { status: "failed", failureCode: "runtime-error" },
+      durationMs: Date.now() - runStartedAt,
+      runId: experienceRunId,
+      lang: ctx.lang,
+    });
+    throw error;
+  }
+  const memoryResult = await completeMemoryTurnCli(db, text || "", ctx, rt, {
+    model: selectedModel,
+    outcome: "succeeded",
+    requestText: prompt,
+  });
+  memorySettled = true;
+  for (const memory of memoryResult.curatedMemories || []) {
+    if (memory && !curatedMemories.some((item) => item.id === memory.id)) curatedMemories.push(memory);
+  }
+  const cleaned = require("./agentlas-style.cjs").sanitizeAssistantText(memoryResult.cleaned || "");
+  finalizeExperienceExecutionCli(db, {
+    agentId: ctx.agentId,
+    projectPath: ctx.projectPath,
+    cwd: ctx.cwd || projectCwd(),
+    runtime: rt,
+    permission: ctx.permission,
+    model: selectedModel,
+    runtimeExperience: ctx.runtimeExperience,
+    curatedMemories,
+    taskHint: prompt,
+    outcome: { status: "succeeded", failureCode: null },
+    durationMs: Date.now() - runStartedAt,
+    runId: experienceRunId,
+    lang: ctx.lang,
+  });
   process.stdout.write((cleaned || "").trim() + "\n");
   return 0;
+  } catch (error) {
+    if (!memorySettled) {
+      try {
+        await completeMemoryTurnCli(db, "", ctx, memoryRuntime, {
+          model: ctx.model || memoryRuntime?.model || null,
+          outcome: "failed",
+          requestText: prompt,
+          invokeCurator: false,
+        });
+        memorySettled = true;
+      } catch {
+        // A missing/locked DB is the only remaining case where a receipt may
+        // be impossible. Preserve the original runtime error for the caller.
+      }
+    }
+    throw error;
+  }
+}
+
+async function runTerminalBuilder(db, request, metadata = {}, runtimeOverride = null, cwd = projectCwd()) {
+  const builder = resolveMetaBuilder(db);
+  if (!builder) throw new Error("Agentlas Core Engine Meta-Agent is unavailable; Build did not start.");
+  const runtime = resolveRuntime(db, runtimeOverride);
+  const routingOptions = metadata.workloadRouting && typeof metadata.workloadRouting === "object"
+    ? metadata.workloadRouting
+    : {};
+  let allocation = null;
+  try {
+    const currentInventory = currentRuntimeInventoryCli(db, runtime);
+    const plannerSystem = workloadRouting.plannerSystemPrompt({
+      language: prefsLang() === "ko" ? "Korean" : "English",
+      maxTasks: 1,
+      mode: "builder",
+      liveRuntimeInventory: workloadRouting.runtimeInventory([currentInventory]),
+    });
+    let plannerText;
+    if (runtime.mode === "cli") {
+      const env = await buildChildEnvCli(db, { projectPath: cwd, agentId: builder.id, permission: "read", cwd });
+      plannerText = await captureRuntime(runtime.kind, plannerSystem, request, {
+        cwd,
+        env,
+        permission: "read",
+        model: routingOptions.modelPin || runtime.model || null,
+        effort: routingOptions.effortPin === undefined ? null : routingOptions.effortPin,
+      });
+    } else {
+      plannerText = await runApi(runtime.backend, routingOptions.modelPin || runtime.model, plannerSystem, request);
+    }
+    const plan = workloadRouting.normalizePlan(plannerText, { maxTasks: 1 });
+    allocation = plan && plan.tasks[0] && plan.tasks[0].allocation;
+  } catch (error) {
+    process.stderr.write(`▸ builder model planner fallback · ${String((error && error.message) || error).slice(0, 160)}\n`);
+  }
+  const currentInventory = currentRuntimeInventoryCli(db, runtime);
+  const resolution = workloadRouting.resolveAllocation({
+    runtime: currentInventory,
+    decision: allocation,
+    modelPin: routingOptions.modelPin,
+    effortPin: routingOptions.effortPin,
+    availableModels: currentInventory.availableModels,
+    maxTier: routingOptions.maxTier || process.env.AGENTLAS_MODEL_MAX_TIER,
+  });
+  const receipt = workloadRouting.createDecisionReceipt({
+    taskId: "builder-execution",
+    stage: "builder",
+    decision: allocation,
+    resolution,
+  });
+  try {
+    workloadRouting.appendDecisionReceipt(receipt, path.join(userDataDir(), "model-routing-receipts.jsonl"));
+  } catch (error) {
+    process.stderr.write(`▸ builder model routing receipt failed · ${String((error && error.message) || error).slice(0, 120)}\n`);
+  }
+  if (!resolution.ok) {
+    throw new Error(`Agentlas builder model allocation failed closed: ${resolution.fallbackReason || "no compliant live model"}`);
+  }
+  process.stderr.write(
+    `▸ builder model route · ${resolution.source} · ${resolution.model || runtime.kind || runtime.backend}` +
+      `${resolution.effort ? ` · ${resolution.effort}` : ""}` +
+      `${resolution.fallbackReason ? ` · ${resolution.fallbackReason}` : ""}\n`,
+  );
+  const code = await executeOnce(db, agentSystemPromptCli(builder), request, runtimeOverride, {
+    projectPath: cwd,
+    agentId: builder.id,
+    permission: "full",
+    // This is an exact private host object created after consent. An empty array
+    // deliberately overrides all global/project/default MCP configuration.
+    mcpServers: Array.isArray(metadata.mcpServers) ? metadata.mcpServers : [],
+    mcpAllowlistMode: "exact",
+    model: resolution.model,
+    effort: resolution.effort,
+  });
+  if (code !== 0) throw new Error(`Agentlas builder runtime exited ${code}`);
+  return code;
+}
+
+async function allocateSingleWorkloadCli(db, request, options = {}) {
+  const runtime = options.runtime || resolveRuntime(db, options.runtimeOverride);
+  const cwd = options.cwd || projectCwd();
+  let allocation = null;
+  try {
+    const currentInventory = currentRuntimeInventoryCli(db, runtime);
+    const plannerSystem = workloadRouting.plannerSystemPrompt({
+      language: options.lang === "ko" ? "Korean" : "English",
+      maxTasks: 1,
+      mode: options.mode || "team",
+      liveRuntimeInventory: workloadRouting.runtimeInventory([currentInventory]),
+    });
+    let plannerText;
+    if (runtime.mode === "cli") {
+      const env = await buildChildEnvCli(db, {
+        projectPath: options.projectPath || null,
+        agentId: options.agentId || null,
+        permission: "read",
+        cwd,
+      });
+      plannerText = await captureRuntime(runtime.kind, plannerSystem, request, {
+        cwd,
+        env,
+        permission: "read",
+        model: options.modelPin || runtime.model || null,
+        effort: options.effortPin === undefined ? null : options.effortPin,
+      });
+    } else {
+      plannerText = await runApi(runtime.backend, options.modelPin || runtime.model, plannerSystem, request);
+    }
+    const plan = workloadRouting.normalizePlan(plannerText, { maxTasks: 1 });
+    allocation = plan && plan.tasks[0] && plan.tasks[0].allocation;
+  } catch (error) {
+    if (options.onWarning) options.onWarning(`model planner fallback: ${String((error && error.message) || error).slice(0, 160)}`);
+  }
+  const currentInventory = currentRuntimeInventoryCli(db, runtime);
+  const resolution = workloadRouting.resolveAllocation({
+    runtime: currentInventory,
+    decision: allocation,
+    modelPin: options.modelPin,
+    effortPin: options.effortPin,
+    availableModels: options.availableModels || currentInventory.availableModels,
+    maxTier: options.maxTier || process.env.AGENTLAS_MODEL_MAX_TIER,
+  });
+  const receipt = workloadRouting.createDecisionReceipt({
+    taskId: options.taskId || `${options.mode || "team"}-execution`,
+    stage: options.mode || "team",
+    decision: allocation,
+    resolution,
+  });
+  try {
+    workloadRouting.appendDecisionReceipt(receipt, options.receiptFile || path.join(userDataDir(), "model-routing-receipts.jsonl"));
+  } catch (error) {
+    if (options.onWarning) options.onWarning(`model routing receipt failed: ${String((error && error.message) || error).slice(0, 120)}`);
+  }
+  if (!resolution.ok) {
+    throw new Error(`Agentlas model allocation failed closed: ${resolution.fallbackReason || "no compliant live model"}`);
+  }
+  return { allocation, resolution, receipt };
+}
+
+async function probeApprovedTerminalMcp(db, server, runtimeOverride, cwd, probeOptions = {}) {
+  const runtime = resolveRuntime(db, runtimeOverride);
+  if (runtime.mode !== "cli") return { connected: false, reason: "runtime_incompatible" };
+  const env = await buildChildEnvCli(db, { cwd, permission: "full" });
+  if (runtime.kind === "gemini") {
+    const readiness = require("./agentlas-native-host.cjs").geminiMcpIsolationReadiness(env);
+    if (!readiness.ready) return { connected: false, reason: "runtime_isolation_unavailable" };
+  }
+  return terminalAssets.probeSystemMcpServerConnection(server, {
+    cwd,
+    env,
+    userDataDir: userDataDir(),
+    timeoutMs: probeOptions.timeoutMs,
+    signal: probeOptions.signal,
+  });
 }
 
 // API 백엔드용 간이 대화형 REPL (네이티브 인터랙티브가 없는 BYOK/Ollama).
@@ -7901,7 +9072,7 @@ function apiRepl(db, backend, model, system, label, ctx) {
   ctx = ctx || { projectPath: null, agentId: null };
   if (!ctx.cwdAtRequest) ctx.cwdAtRequest = ctx.cwd || projectCwd();
   const readline = require("node:readline");
-  process.stderr.write(`▸ ${label} (${backend}${model ? " · " + model : ""}) — 종료: /exit\n`);
+  process.stderr.write(`▸ ${label} (${backend}${model ? " · " + model : ""}) — type /exit to stop\n`);
   const rl = readline.createInterface({ input: process.stdin, output: process.stderr });
   const ask = () =>
     rl.question("\nyou › ", async (line) => {
@@ -7909,7 +9080,7 @@ function apiRepl(db, backend, model, system, label, ctx) {
       if (tt === "/exit" || tt === "/quit") return rl.close();
       if (!tt) return ask();
       try {
-        const sys = augmentSystem(db, system, ctx, true);
+        const sys = augmentSystem(db, system, ctx, true, tt);
         const text = await runApi(backend, model, sys, tt);
         const cleaned = curateCliReply(db, text || "", ctx);
         process.stdout.write("\n" + (cleaned || "").trim() + "\n");
@@ -7955,12 +9126,6 @@ function runCwd() {
   }
 }
 
-function cliMcpConfigPath() {
-  return require("./agentlas-native-host.cjs").cliMcpConfigPath([]).file;
-}
-
-const CODEX_PLAYWRIGHT_MCP_ARGS = require("./agentlas-native-host.cjs").codexMcpArgs([]);
-
 // 에이전트가 실제로 실행될 작업 폴더 = 사용자가 명령을 친 현재 디렉터리(= 대상 프로젝트).
 // 단, home/userData/agent-cwd 같은 "프로젝트 아님" 위치면 안전한 전용 폴더로 폴백한다.
 function projectCwd() {
@@ -8055,13 +9220,28 @@ const PROTECTED_CHILD_ENV_KEYS_CLI = new Set([
   "AGENTLAS_NATIVE_IDLE_TIMEOUT_MS", "AGENTLAS_NATIVE_TOTAL_TIMEOUT_MS", "AGENTLAS_NATIVE_KILL_GRACE_MS",
   "AGENTLAS_CAPTURE_MAX_OUTPUT_BYTES",
 ]);
-function isProtectedChildEnvKeyCli(key) {
-  return PROTECTED_CHILD_ENV_KEYS_CLI.has(String(key || "").trim().toUpperCase());
+// 네트워크 무결성 키 — TLS 검증·프록시·CA·엔드포인트·세션. 프로젝트/에이전트 dotenv(신뢰 불가:
+// 클론한 레포에 딸려올 수 있음)로 주입되면 MITM/SSRF/세션 하이재킹이 된다. 단, 사용자 본인의
+// 전역 credentials.env와 호스트 셸 env는 신뢰하므로 그대로 허용한다. 사고 방지: 원샷 API 경로는
+// buildChildEnvCli 결과를 process.env에 병합(Object.assign)하므로, 프로젝트 .env가 부모 프로세스의
+// 클라우드 호출(세션 쿠키 동반)까지 오염시킬 수 있었다.
+const UNTRUSTED_PROTECTED_ENV_KEYS_CLI = new Set([
+  "NODE_TLS_REJECT_UNAUTHORIZED", "NODE_EXTRA_CA_CERTS", "SSL_CERT_FILE", "SSL_CERT_DIR",
+  "OPENSSL_CONF", "REQUESTS_CA_BUNDLE", "CURL_CA_BUNDLE",
+  "HTTP_PROXY", "HTTPS_PROXY", "ALL_PROXY", "NO_PROXY", "GRPC_PROXY", "NPM_CONFIG_PROXY",
+  "AGENTLAS_SESSION", "AGENTLAS_MCP_BASE_URL", "AGENTLAS_WEB_BASE_URL", "AGENTLAS_API_BASE_URL",
+  "AGENTLAS_HUB_BASE_URL", "AGENTLAS_CLOUD_BASE_URL", "OLLAMA_HOST",
+]);
+function isProtectedChildEnvKeyCli(key, trusted) {
+  const k = String(key || "").trim().toUpperCase();
+  if (PROTECTED_CHILD_ENV_KEYS_CLI.has(k)) return true; // 호스트 신원/플러그인 루트 — 모든 출처 차단
+  if (!trusted && UNTRUSTED_PROTECTED_ENV_KEYS_CLI.has(k)) return true; // 네트워크 무결성 — 비신뢰 출처만 차단
+  return false;
 }
-function mergeChildEnvValuesCli(target, values, overwrite) {
+function mergeChildEnvValuesCli(target, values, overwrite, trusted) {
   const injected = [];
   for (const [key, value] of Object.entries(values || {})) {
-    if (!value || isProtectedChildEnvKeyCli(key)) continue;
+    if (!value || isProtectedChildEnvKeyCli(key, trusted)) continue;
     if (!overwrite && target[key]) continue;
     target[key] = value;
     injected.push(key);
@@ -8070,19 +9250,20 @@ function mergeChildEnvValuesCli(target, values, overwrite) {
 }
 async function buildChildEnvCli(db, ctx) {
   const env = { ...process.env };
-  const apply = (values, overwrite) => {
-    mergeChildEnvValuesCli(env, values, overwrite);
+  // trusted=true: 사용자 본인의 전역 자격/볼트. trusted=false: 프로젝트·에이전트 폴더 dotenv.
+  const apply = (values, overwrite, trusted) => {
+    mergeChildEnvValuesCli(env, values, overwrite, trusted);
   };
   const globalCredentials = {
     ...readDotEnvFileCli(path.join(userDataDir(), "credentials.env")),
     ...readDotEnvFileCli(path.join(os.homedir(), ".agentlas", "credentials.env")),
   };
-  apply(globalCredentials, false);
-  if (ctx && ctx.projectPath) apply(projectScopedEnvValuesCli(globalCredentials, ctx.projectPath), true);
-  if (ctx && ctx.cwd) apply(readDotEnvDirCli(ctx.cwd), true);
-  if (ctx && ctx.projectPath) apply(readDotEnvDirCli(ctx.projectPath), true);
+  apply(globalCredentials, false, true);
+  if (ctx && ctx.projectPath) apply(projectScopedEnvValuesCli(globalCredentials, ctx.projectPath), true, true);
+  if (ctx && ctx.cwd) apply(readDotEnvDirCli(ctx.cwd), true, false);
+  if (ctx && ctx.projectPath) apply(readDotEnvDirCli(ctx.projectPath), true, false);
   const agentDir = agentEnvDirCli(ctx && ctx.agentId);
-  if (agentDir) apply(readDotEnvDirCli(agentDir), true);
+  if (agentDir) apply(readDotEnvDirCli(agentDir), true, false);
 
   const mm = loadMultimodalCatalog();
   const settings = getMultimodalSettingsCli(db);
@@ -8091,7 +9272,7 @@ async function buildChildEnvCli(db, ctx) {
     if (req && req.key) keys.add(req.key);
   }
   const vaultValues = await readVaultEnvValuesCli([...keys].filter((key) => !env[key]), ctx && ctx.projectPath);
-  apply(vaultValues, false);
+  apply(vaultValues, false, true); // 볼트는 사용자 본인 저장소 — 신뢰
   env.AGENTLAS_MULTIMODAL_IMAGE_PROVIDER = settings.imageProvider;
   env.AGENTLAS_MULTIMODAL_VIDEO_PROVIDER = settings.videoProvider;
   env.AGENTLAS_MULTIMODAL_AUDIO_PROVIDER = settings.audioProvider;
@@ -8100,29 +9281,89 @@ async function buildChildEnvCli(db, ctx) {
 
 // One-shot/background capture uses the same permission truth as the interactive host.
 // Keep its plain-output argument shape, but never duplicate the security mapping here.
-function buildArgs(kind, systemPrompt, prompt, permission) {
+function buildArgs(kind, systemPrompt, prompt, permission, runtimeOptions = {}) {
   const native = require("./agentlas-native-host.cjs");
   const level = require("./agentlas-permissions.cjs").normalize(permission);
+  const model = runtimeOptions.model ? String(runtimeOptions.model) : null;
+  const effort = runtimeOptions.effort ? String(runtimeOptions.effort) : null;
+  const noAuthority = runtimeOptions.authorityMode === "no-authority";
   if (kind === "claude-code") {
-    const perm = native.claudePermissionArgs(level);
-    const mcp = level === "full"
-      ? ["--strict-mcp-config", "--mcp-config", cliMcpConfigPath(), "--allowedTools", "mcp__playwright"]
-      : native.claudeMcpIsolationArgs();
-    return ["-p", prompt, "--append-system-prompt", systemPrompt, ...perm, ...mcp];
+    const perm = native.claudePermissionArgs(noAuthority ? "read" : level);
+    // Background/capture has no one-pass reviewed server list. Full permission
+    // changes tool authority, not MCP consent, so this path remains exact-empty.
+    const mcp = native.claudeMcpIsolationArgs();
+    const thinking = effort === "max" || effort === "xhigh" ? "Ultrathink. " : effort === "high" ? "Think hard. " : effort === "medium" ? "Think. " : "";
+    const claudeEffort = effort === "minimal" ? "low" : effort === "xhigh" ? "max" : effort;
+    const effortArgs = claudeEffort && claudeEffort !== "none" ? ["--effort", claudeEffort] : [];
+    return [
+      "-p", thinking + prompt,
+      "--append-system-prompt", systemPrompt,
+      ...(model ? ["--model", model] : []),
+      ...effortArgs,
+      ...perm,
+      ...(noAuthority ? ["--tools", ""] : []),
+      ...mcp,
+    ];
   }
   if (kind === "codex") {
-    const perm = native.codexPermissionArgs(level);
-    const mcp = level === "full" ? CODEX_PLAYWRIGHT_MCP_ARGS : [];
-    return ["exec", "--skip-git-repo-check", ...perm, ...mcp, `[SYSTEM]\n${systemPrompt}\n\n${prompt}`];
+    const perm = native.codexPermissionArgs(noAuthority ? "read" : level);
+    const mcp = [];
+    const modelArgs = model ? ["-m", model] : [];
+    const effortArgs = effort ? ["-c", `model_reasoning_effort="${effort}"`] : [];
+    const noAuthorityArgs = noAuthority ? [
+      "--ephemeral",
+      "--ignore-user-config",
+      "--ignore-rules",
+      "--disable", "shell_tool",
+      "--disable", "unified_exec",
+      "--disable", "apps",
+      "--disable", "browser_use",
+      "--disable", "computer_use",
+      "--disable", "image_generation",
+      "--disable", "workspace_dependencies",
+      "--disable", "goals",
+      "--disable", "memories",
+      "--disable", "plugins",
+      "--disable", "hooks",
+      "--disable", "multi_agent",
+      "--disable", "tool_suggest",
+      "--json",
+    ] : [];
+    return ["exec", "--skip-git-repo-check", ...noAuthorityArgs, ...modelArgs, ...effortArgs, ...perm, ...mcp, `[SYSTEM]\n${systemPrompt}\n\n${prompt}`];
   }
   if (kind === "gemini") {
-    const perm = native.geminiPermissionArgs(level);
-    const mcp = level === "full" ? [] : native.geminiMcpIsolationArgs();
-    return ["--prompt", `[SYSTEM]\n${systemPrompt}\n\n${prompt}`, ...perm, ...mcp];
+    const perm = native.geminiPermissionArgs(noAuthority ? "read" : level);
+    if (noAuthority && !runtimeOptions.noToolsPolicyPath) {
+      throw new Error("Gemini no-authority capture requires an explicit deny-all policy");
+    }
+    const noAuthorityArgs = noAuthority
+      ? ["--admin-policy", String(runtimeOptions.noToolsPolicyPath)]
+      : [];
+    // Legacy/background capture has no structured reviewed server list. Even
+    // at full permission it must stay exact-empty instead of inheriting the
+    // user's global Gemini MCP definitions with the provider credential env.
+    const mcp = native.geminiMcpIsolationArgs();
+    return ["--prompt", `[SYSTEM]\n${systemPrompt}\n\n${prompt}`, ...(model ? ["-m", model] : []), ...perm, ...noAuthorityArgs, ...mcp];
   }
   return [prompt];
 }
 
+function codexCaptureAgentText(jsonl) {
+  const completed = [];
+  const latest = new Map();
+  for (const line of String(jsonl || "").split(/\r?\n/)) {
+    if (!line.trim()) continue;
+    let event;
+    try { event = JSON.parse(line); } catch { continue; }
+    const item = event?.item;
+    if (!item || item.type !== "agent_message" || typeof item.text !== "string") continue;
+    if (event.type === "item.completed") completed.push(item.text);
+    else if (event.type === "item.started" || event.type === "item.updated") latest.set(String(item.id || latest.size), item.text);
+  }
+  if (completed.length) return completed.join("");
+  return [...latest.values()].join("");
+}
+
 // `claude` 치면 바로 대화형 세션 뜨듯이 — 에이전트 폴더(CLAUDE.md/AGENTS.md/GEMINI.md 보유)에서
 // 네이티브 CLI를 인자 없이(대화형) 실행. 에이전트 페르소나는 그 폴더의 프로젝트 지시로 자동 로드. (A+B 결합)
 // 보스턴테리어 터미널(대화형 TUI)로 진입. agentlas 가 항상 "호스트"다 —
@@ -8145,14 +9386,23 @@ function buildHelpers(db) {
   return {
     which,
     RUNTIME_BIN,
-    augmentSystem: (db_, base, ctx, emit) => augmentSystem(db_, base, ctx, emit),
-    curateCliReply: (db_, text, ctx) => curateCliReply(db_, text, ctx),
+    augmentSystem: (db_, base, ctx, emit, request) => augmentSystem(db_, base, ctx, emit, request),
+    memoryEmitterPrompt: (request, ctx) => memoryEmitterPromptFor(
+      request,
+      loadArch(),
+      ctx && ctx.turnId,
+      ctx && ctx.permission,
+    ),
+    beginMemoryTurn: (db_, prompt, ctx) => beginMemoryTurnCli(db_, prompt, ctx),
+    completeMemoryTurn: (db_, text, ctx, runtime, options) => completeMemoryTurnCli(db_, text, ctx, runtime, options),
     detectResponseLanguage: (prompt, fallback) => require("./agentlas-style.cjs").detectResponseLanguage(prompt, fallback),
     sanitizeAssistantText: (text) => require("./agentlas-style.cjs").sanitizeAssistantText(text),
     apiKey: (backend) => apiKey(backend),
     eventsHeading: () => loadArch().eventsHeading,
     defaultApiModel: (backend) => DEFAULT_API_MODEL[backend],
     buildChildEnv: (db_, ctx) => buildChildEnvCli(db_, ctx),
+    allocateWorkload: (db_, request, ctx) => allocateSingleWorkloadCli(db_, request, ctx),
+    finalizeExperienceRun: (db_, input) => finalizeExperienceExecutionCli(db_, input),
     multimodalStatus: (db_) => multimodalStatusCli(db_),
     setMultimodal: (db_, modality, providerId) => setMultimodalCli(db_, modality, providerId),
     resolveAgent,
@@ -8164,11 +9414,11 @@ function buildHelpers(db) {
     autoRouteNote: (choice, lang) => autoRouteNote(choice, lang),
     autoRoutePreamble: (choice, lang) => autoRoutePreamble(choice, lang),
     directSystemPrompt: (lang) => directSystemPrompt(lang),
-    cliMemoryContext: (db_, pp) => cliMemoryContext(db_, pp),
+    cliMemoryContext: (db_, pp, agentId) => cliMemoryContext(db_, pp, agentId),
     importLocal: (db_, p) => importLocalFolderCli(db_, p),
     // REPL-safe public Hub install: fail()(process.exit) 대신 Error를 throw 해 REPL이 직접 렌더하게 한다.
     cloudInstall: async (db_, slug) => {
-      if (typeof fetch !== "function") throw new Error("이 런타임에 fetch가 없습니다(앱 런타임 필요).");
+      if (typeof fetch !== "function") throw new Error("fetch is unavailable in this runtime (app runtime required).");
       const base = process.env.AGENTLAS_MCP_BASE_URL || "https://agentlas.cloud/api/mcp/v1";
       const headers = { "content-type": "application/json" };
       const cookie = await cloudSessionCookieCli();
@@ -8181,18 +9431,18 @@ function buildHelpers(db) {
           body: JSON.stringify({ method: "marketplace.get_manifest", params: { name: "marketplace.get_manifest", arguments: { kind: "agent", slug } } }),
         });
       } catch (e) {
-        throw new Error(`Hub 연결 실패: ${(e && e.message) || e}`);
+        throw new Error(`Hub connection failed: ${(e && e.message) || e}`);
       }
       if (!resp.ok) {
         const authHint = resp.status === 401 || resp.status === 403 ? " — 로그인이 필요합니다 (앱에서 로그인 또는 AGENTLAS_SESSION 설정)" : "";
-        throw new Error(`Hub 응답 ${resp.status}${authHint}`);
+        throw new Error(`Hub returned HTTP ${resp.status}${authHint}`);
       }
       const json = parseHubJsonCli(resp, "marketplace.get_manifest");
       if (json.error) throw new Error(json.error.message || "Hub error");
       const listing = json.result;
-      if (!listing) throw new Error(`Hub에서 찾을 수 없음: ${slug}`);
+      if (!listing) throw new Error(`Not found in Hub: ${slug}`);
       if (listing.delivery && listing.delivery.mode === "call_only") {
-        throw new Error(`이 Hub 에이전트는 call-only 자산입니다. 실행: agentlas call ${slug}`);
+        throw new Error(`This Hub agent is call-only. Run: agentlas call ${slug}`);
       }
       return persistCloudListingCli(db_, listing);
     },
@@ -8201,7 +9451,22 @@ function buildHelpers(db) {
     },
     mcpServers: (db_) => {
       try {
-        return db_.prepare("SELECT id, name, name_en, transport, command, args_json, url, env_keys_json, enabled FROM mcp_servers ORDER BY installed_at ASC").all();
+        const consentedIds = new Set(
+          terminalAssets.readConsentedSystemMcpServers(db_, { userDataDir: userDataDir(), createRuntimeHome: false })
+            .map((server) => server.id),
+        );
+        return db_.prepare("SELECT id, catalog_id, name, name_en, transport, command, args_json, url, env_keys_json, enabled FROM mcp_servers ORDER BY installed_at ASC")
+          .all()
+          .map((row) => {
+            const runtime = terminalAssets.materializeTrustedSystemMcpServer(row, { userDataDir: userDataDir(), createRuntimeHome: false });
+            Object.defineProperty(row, "runtimeEligible", { value: Boolean(runtime), enumerable: false });
+            Object.defineProperty(row, "runtimeConsented", { value: Boolean(runtime && consentedIds.has(String(row.id))), enumerable: false });
+            if (runtime) {
+              Object.defineProperty(row, "credentialKeyNames", { value: runtime.credentialKeyNames, enumerable: false });
+              if (runtime.mcpRuntimeHome) Object.defineProperty(row, "mcpRuntimeHome", { value: runtime.mcpRuntimeHome, enumerable: false });
+            }
+            return row;
+          });
       } catch {
         return [];
       }
@@ -8211,11 +9476,30 @@ function buildHelpers(db) {
       try { return JSON.parse(fs.readFileSync(path.join(userDataDir(), "cli-sessions.json"), "utf8")) || []; } catch { return []; }
     },
     sessionsSave: (list) => {
-      try { fs.writeFileSync(path.join(userDataDir(), "cli-sessions.json"), JSON.stringify((list || []).slice(0, 30), null, 2), "utf8"); } catch { /* ignore */ }
+      try { writeJsonPrivateAtomicCli(path.join(userDataDir(), "cli-sessions.json"), (list || []).slice(0, 30)); } catch { /* ignore */ }
     },
     // 패리티: REPL의 /storm·/swarm·/build·/route·/research 가 그대로 호출한다.
     stormRun: (db_, goal, ctx) => parity().stormRun(db_, goal, ctx),
     swarmRun: (db_, goal, ctx) => parity().swarmRun(db_, goal, ctx),
+    workforceRun: (db_, goal, ctx) => workforce().workforceRun(db_, goal, ctx),
+    terminalBuild: (db_, args, ctx = {}) => terminalAssets.cmdBuild({
+      db: db_,
+      args: Array.isArray(args) ? args : terminalAssets.tokenizeBuildCommandLine(String(args || "")),
+      userDataDir: userDataDir(),
+      cwd: ctx.cwd || projectCwd(),
+      input: ctx.input || process.stdin,
+      promptOutput: ctx.promptOutput || process.stderr,
+      out: ctx.out || out,
+      probeMcpServer: (server, probeOptions) => probeApprovedTerminalMcp(db_, server, null, ctx.cwd || projectCwd(), probeOptions),
+      invokeBuild: (request, metadata) => runTerminalBuilder(db_, request, {
+        ...metadata,
+        workloadRouting: {
+          modelPin: ctx.modelPin || null,
+          effortPin: ctx.effortPin,
+          maxTier: ctx.maxTier,
+        },
+      }, null, ctx.cwd || projectCwd()),
+    }),
     hepRun: (args, opts) => parity().runHephaestusInteractive(args, opts),
     cloudSearch: (db_, args) => parity().cloudSearch(db_, args),
     careerGraphCommand: (text, ctx) => runCareerGraphNaturalCli(text, {
@@ -8236,12 +9520,14 @@ function buildHelpers(db) {
         return null;
       }
     },
+    ensureProjectForExecution: (db_, dir, permission, reason) =>
+      ensureTerminalProjectForExecutionCli(db_, dir, permission, reason || "terminal-interactive-turn"),
     doctor: async (db_, ui) => {
       ui.line("");
       ui.info("userData: " + userDataDir());
-      ui.info("db: " + (fs.existsSync(dbPath()) ? "OK" : "없음"));
+      ui.info("db: " + (fs.existsSync(dbPath()) ? "OK" : "missing"));
       const ar = activeRuntime(db_);
-      ui.info("활성 런타임: " + (ar ? ar.kind : "(없음)"));
+      ui.info("Active runtime: " + (ar ? ar.kind : "(none)"));
       // CLI 런타임: 설치 + 로그인(인증 파일) 휴리스틱
       const home = os.homedir();
       const authFiles = {
@@ -8253,17 +9539,17 @@ function buildHelpers(db) {
       for (const [kind, bin] of Object.entries(RUNTIME_BIN)) {
         const installed = !!which(bin);
         const authed = (authFiles[kind] || []).some(has);
-        ui.info(`  ${kind.padEnd(12)} ${!installed ? "미설치" : authed ? "설치됨 · 로그인" : "설치됨 · 로그인 미확인"}`);
+        ui.info(`  ${kind.padEnd(12)} ${!installed ? "not installed" : authed ? "installed · signed in" : "installed · sign-in unverified"}`);
       }
       // BYOK 키 (keytar) + 클라우드 세션
       const byok = [];
       for (const b of ["anthropic", "openai", "google", "upstage"]) {
         try { if (await apiKey(b)) byok.push(b); } catch { /* keytar 미사용 */ }
       }
-      ui.info("BYOK 키: " + (byok.length ? byok.join(", ") : "(없음 — 앱 설정 → BYOK)"));
+      ui.info("BYOK keys: " + (byok.length ? byok.join(", ") : "(none — App settings → BYOK)"));
       let cloud = false;
       try { cloud = !!(await cloudSessionCookieCli()); } catch { /* ignore */ }
-      ui.info("클라우드 세션: " + (cloud ? "로그인됨" : "로그아웃"));
+      ui.info("Cloud session: " + (cloud ? "signed in" : "signed out"));
     },
   };
 }
@@ -8304,14 +9590,18 @@ function spawnRuntime(kind, systemPrompt, prompt, opts) {
   const cwd = opts.cwd || runCwd();
   return new Promise((resolve) => {
     const bin = which(RUNTIME_BIN[kind]) || RUNTIME_BIN[kind];
-    const env = require("./agentlas-native-host.cjs").runtimeEnvForKind(kind, opts.env || process.env);
+    const env = require("./agentlas-native-host.cjs").runtimeEnvForKind(kind, opts.env || process.env, {
+      permission: opts.permission,
+      mcpServers: [],
+      mcpAllowlistMode: kind === "gemini" ? "exact" : undefined,
+    });
     const child = spawn(bin, buildArgs(kind, systemPrompt, prompt, opts.permission), {
       cwd,
       stdio: ["ignore", "inherit", "inherit"],
       env,
     });
     child.on("error", (err) => {
-      process.stderr.write(`\n실행 실패(${kind}): ${err.message}\n`);
+      process.stderr.write(`\nExecution failed (${kind}): ${err.message}\n`);
       resolve(1);
     });
     child.on("close", (code) => resolve(code ?? 0));
@@ -8341,8 +9631,17 @@ function captureRuntime(kind, systemPrompt, prompt, opts) {
     let child;
     try {
       const spawnImpl = opts.spawn || spawn;
-      const env = require("./agentlas-native-host.cjs").runtimeEnvForKind(kind, opts.env || process.env);
-      child = spawnImpl(bin, buildArgs(kind, systemPrompt, prompt, opts.permission), {
+      const env = require("./agentlas-native-host.cjs").runtimeEnvForKind(kind, opts.env || process.env, {
+        permission: opts.permission,
+        mcpServers: [],
+        mcpAllowlistMode: kind === "gemini" ? "exact" : undefined,
+      });
+      child = spawnImpl(bin, buildArgs(kind, systemPrompt, prompt, opts.permission, {
+        model: opts.model,
+        effort: opts.effort,
+        authorityMode: opts.authorityMode,
+        noToolsPolicyPath: opts.noToolsPolicyPath,
+      }), {
         cwd,
         stdio: ["ignore", "pipe", "pipe"],
         env,
@@ -8453,7 +9752,11 @@ function captureRuntime(kind, systemPrompt, prompt, opts) {
         finishReject(new Error(`${kind} exited ${code}: ${stderr.slice(-500)}`));
         return;
       }
-      finishResolve(stdout.trim() || stderr.trim());
+      const raw = stdout.trim() || stderr.trim();
+      const captured = kind === "codex" && opts.authorityMode === "no-authority"
+        ? codexCaptureAgentText(raw)
+        : "";
+      finishResolve(captured || raw);
     };
     onAbort = () => {
       const reason = opts.signal && opts.signal.reason;
@@ -8483,10 +9786,12 @@ function parity() {
       captureRuntime,
       runApi,
       resolveRuntime,
+      listAvailableRuntimes,
       buildChildEnvCli,
       projectCwd,
       runCwd,
       userDataDir,
+      modelRoutingReceiptPath: () => path.join(userDataDir(), "model-routing-receipts.jsonl"),
       resolveAgent,
       resolveFirm,
       listAgents,
@@ -8505,6 +9810,99 @@ function parity() {
   return parity._i;
 }
 
+// Agent Workforce Ontology is a separate, fail-closed route. Unlike the
+// compatibility router it gives final staffing authority to the active host
+// LLM and uses Hub MCP only for retrieval, validation, and pinned preparation.
+async function listWorkforceToolsCli({ db, roster, runtimeId, cwd, env, timeoutMs, signal }) {
+  const mcp = require("./agentlas-experience-mcp.cjs");
+  const servers = mcp.readConsentedSystemMcpServers(db, {
+    userDataDir: userDataDir(),
+    createRuntimeHome: false,
+  }).slice(0, 8);
+  if (!servers.length) return [];
+  const deadline = Date.now() + Math.max(50, Math.min(12_000, Number(timeoutMs) || 12_000));
+  const outcomes = new Array(servers.length);
+  let cursor = 0;
+  const worker = async () => {
+    while (true) {
+      const index = cursor++;
+      if (index >= servers.length) return;
+      const remaining = deadline - Date.now();
+      if (remaining <= 0 || signal?.aborted) return;
+      outcomes[index] = await mcp.probeSystemMcpServerConnection(servers[index], {
+        cwd,
+        env,
+        userDataDir: userDataDir(),
+        timeoutMs: Math.min(4_000, remaining),
+        signal,
+      });
+    }
+  };
+  await Promise.all(Array.from({ length: Math.min(3, servers.length) }, () => worker()));
+
+  const safeId = /^[A-Za-z0-9][A-Za-z0-9_.$:/@+~-]{0,127}$/;
+  const rows = [];
+  for (let index = 0; index < servers.length; index += 1) {
+    const server = servers[index];
+    const listed = outcomes[index];
+    if (!listed?.connected || !Array.isArray(listed.tools)) continue;
+    for (const tool of listed.tools.slice(0, 256)) {
+      if (!tool || typeof tool !== "object" || Array.isArray(tool)) continue;
+      const declared = tool._meta?.agentlas || {};
+      const toolId = typeof declared.toolId === "string" ? declared.toolId : String(tool.name || "");
+      const capabilityIds = Array.isArray(declared.capabilityIds)
+        ? [...new Set(declared.capabilityIds.filter((id) => /^[A-Za-z0-9][A-Za-z0-9._:/@-]{1,255}$/.test(String(id))))]
+        : [];
+      if (!safeId.test(toolId) || !capabilityIds.length) continue;
+      const schemaJson = JSON.stringify(tool.inputSchema || {}, Object.keys(tool.inputSchema || {}).sort());
+      for (const pinned of roster || []) {
+        if (pinned?.permissionPolicy?.mcp?.mode !== "allowlist" || !pinned.permissionPolicy.mcp.allowedTools.includes(toolId)) continue;
+        rows.push({
+          slotId: pinned.slotId,
+          agentReleaseId: pinned.agentReleaseId,
+          permissionPolicyDigest: pinned.permissionPolicyDigest,
+          provider: "mcp",
+          toolId,
+          serverId: server.id,
+          description: "Ready consented host MCP tool",
+          inputSchemaDigest: `sha256:${crypto.createHash("sha256").update(schemaJson).digest("hex")}`,
+          // Terminal's one-shot native/API runners do not yet expose a proven
+          // exact per-tool attachment boundary. Preserve the real tools/list
+          // observation, but advertise no executable runtime instead of
+          // manufacturing authority. collectToolInventory filters this row and
+          // fails closed before the planner for a required capability.
+          runtimeIds: [],
+          selectiveEnforcement: "unavailable",
+          capabilityIds,
+          status: "observed-not-executable",
+        });
+      }
+    }
+  }
+  return rows;
+}
+
+function workforce() {
+  if (!workforce._i) {
+    workforce._i = require("./agentlas-workforce.cjs").create({
+      captureRuntime,
+      runApi,
+      resolveRuntime,
+      buildChildEnv: buildChildEnvCli,
+      projectCwd,
+      userDataDir,
+      receiptFile: () => path.join(userDataDir(), "workforce-execution-receipts.jsonl"),
+      cloudSessionCookie: cloudSessionCookieCli,
+      fetchHub: (url, init) => fetchHubCli(url, init),
+      listWorkforceTools: listWorkforceToolsCli,
+      supportsWorkforceToolAuthority: async () => false,
+      prefsLang,
+      out,
+    });
+  }
+  return workforce._i;
+}
+
 // ── 명령 구현 ──────────────────────────────────────────────
 function cmdList(db) {
   const agents = listAgents(db);
@@ -8556,52 +9954,162 @@ function writeIfMissing(file, content) {
 
 function cmdCd(db, query) {
   const agent = resolveAgent(db, query);
-  if (!agent) fail(`에이전트를 찾을 수 없습니다: ${query}`);
+  if (!agent) fail(`Agent not found: ${query}`);
   const folder = agentFolder(agent);
   ensureNativeFiles(agent, folder);
   // 경로만 stdout으로 (cd "$(agentlas cd seo)") — 안내는 stderr로.
-  process.stderr.write(`# ${agent.name} — 네이티브 CLI 컨텍스트(CLAUDE.md/AGENTS.md/GEMINI.md) 준비됨\n`);
+  process.stderr.write(`# ${agent.name} — native CLI context ready (CLAUDE.md/AGENTS.md/GEMINI.md)\n`);
   process.stdout.write(folder + "\n");
 }
 
-async function cmdRun(db, query, prompt, runtimeOverride) {
+function parseRunExperienceArgs(args) {
+  const prompt = [];
+  const experience = { taskSignatures: [], declaredTaskClasses: [], environmentTags: [], experiencePackReleaseIds: [] };
+  let passthrough = false;
+  const addList = (target, value) => {
+    for (const item of String(value || "").split(",").map((entry) => entry.trim()).filter(Boolean)) {
+      if (!target.includes(item)) target.push(item);
+    }
+  };
+  for (let index = 0; index < args.length; index += 1) {
+    const token = String(args[index]);
+    if (passthrough) { prompt.push(token); continue; }
+    if (token === "--") { passthrough = true; continue; }
+    const take = () => index + 1 < args.length ? String(args[++index]) : "";
+    if (token === "--experience-base-release") experience.baseAgentReleaseId = take();
+    else if (token.startsWith("--experience-base-release=")) experience.baseAgentReleaseId = token.slice(26);
+    else if (token === "--experience-pack-release") addList(experience.experiencePackReleaseIds, take());
+    else if (token.startsWith("--experience-pack-release=")) addList(experience.experiencePackReleaseIds, token.slice(26));
+    else if (token === "--experience-agent-definition") experience.agentDefinitionId = take();
+    else if (token.startsWith("--experience-agent-definition=")) experience.agentDefinitionId = token.slice(30);
+    else if (token === "--experience-task-signature") addList(experience.taskSignatures, take());
+    else if (token.startsWith("--experience-task-signature=")) addList(experience.taskSignatures, token.slice(28));
+    else if (token === "--experience-task-class") addList(experience.declaredTaskClasses, take());
+    else if (token.startsWith("--experience-task-class=")) addList(experience.declaredTaskClasses, token.slice(24));
+    else if (token === "--experience-environment") addList(experience.environmentTags, take());
+    else if (token.startsWith("--experience-environment=")) addList(experience.environmentTags, token.slice(25));
+    else if (token === "--experience-desktop-loadout") experience.desktopLoadout = true;
+    else if (
+      token === "--experience-loadout" || token === "--experience-loadout-file" ||
+      token.startsWith("--experience-loadout=") || token.startsWith("--experience-loadout-file=")
+    ) {
+      throw new Error("Custom Experience loadout paths are no longer supported; use --experience-desktop-loadout.");
+    }
+    else if (token === "--no-experience") experience.disabled = true;
+    else prompt.push(token);
+  }
+  return { prompt: prompt.join(" "), experience };
+}
+
+function resolveRuntimeExperienceCli(agent, prompt, requested, cwd, overrides = {}) {
+  const prepared = desktopOntologyLoadout.prepareDesktopLoadoutRequest({
+    db: overrides.db,
+    agent,
+    userDataDir: overrides.userDataDir || userDataDir(),
+    requested: requested || {},
+    now: overrides.now,
+  });
+  if (prepared.mode === "skip") {
+    return { disabled: true, observableReason: prepared.reason, resolution: "skipped" };
+  }
+  const resolved = terminalExperienceExchange.resolveRuntimeExperienceForAgent({
+    userDataDir: overrides.userDataDir || userDataDir(),
+    cwd,
+    prompt,
+    requested: prepared.requested || requested || {},
+    agent,
+    agentRoot: agent ? (overrides.agentRoot || agentFolder(agent)) : null,
+    ...(overrides.platform ? { platform: overrides.platform } : {}),
+    ...(overrides.arch ? { arch: overrides.arch } : {}),
+    ...(overrides.runtime ? { runtime: overrides.runtime } : {}),
+  });
+  if (prepared.mode !== "resolved") return resolved;
+  const authority = prepared.authority;
+  const tasteRuntime = {
+    tasteRuntimeOverlay: authority.tasteRuntimeOverlay || null,
+    loadoutAuthority: "desktop-terminal-exact-loadout",
+    projectionRevision: authority.projectionRevision,
+    loadoutRevision: authority.loadoutRevision,
+  };
+  if (!authority.experiencePackReleaseId) {
+    return {
+      disabled: true,
+      resolution: "desktop-loadout-taste-only",
+      ...tasteRuntime,
+    };
+  }
+  if (resolved.disabled === true) return { ...resolved, ...tasteRuntime };
+  if (
+    resolved.agentDefinitionId !== authority.agentDefinitionId ||
+    resolved.baseAgentReleaseId !== authority.baseAgentReleaseId ||
+    !Array.isArray(resolved.experiencePackReleaseIds) ||
+    resolved.experiencePackReleaseIds.length !== 1 ||
+    resolved.experiencePackReleaseIds[0] !== authority.experiencePackReleaseId
+  ) {
+    return {
+      disabled: true,
+      observableReason: "desktop-loadout-runtime-resolution-mismatch",
+      resolution: "skipped",
+      ...tasteRuntime,
+    };
+  }
+  return {
+    ...resolved,
+    ...tasteRuntime,
+  };
+}
+
+async function cmdRun(db, query, prompt, runtimeOverride, runtimeExperience = null) {
   const agent = resolveAgent(db, query);
   if (!agent) {
     const routedPrompt = [query, prompt].filter(Boolean).join(" ").trim() || (await readStdin());
-    if (!routedPrompt || !routedPrompt.trim()) fail("프롬프트가 비어 있습니다. agentlas run <agent> \"...\" 또는 agentlas run \"...\" 형식으로 입력하세요.");
-    return cmdAutoRun(db, routedPrompt.trim(), runtimeOverride);
+    if (!routedPrompt || !routedPrompt.trim()) fail("Prompt is empty. Use agentlas run <agent> \"...\" or agentlas run \"...\".");
+    return cmdAutoRun(db, routedPrompt.trim(), runtimeOverride, runtimeExperience);
   }
   let userPrompt = prompt;
   if (!userPrompt) userPrompt = await readStdin();
-  if (!userPrompt || !userPrompt.trim()) fail("프롬프트가 비어 있습니다. agentlas run <agent> \"...\" 또는 stdin으로 전달하세요.");
+  if (!userPrompt || !userPrompt.trim()) fail("Prompt is empty. Pass agentlas run <agent> \"...\" or provide it through stdin.");
   process.stderr.write(`▸ ${agent.name}\n`);
-  const code = await executeOnce(db, agentSystemPromptCli(agent), userPrompt.trim(), runtimeOverride, { projectPath: activeProjectPath(db), agentId: agent.id, permission: PERMISSION });
+  const projectPath = ensureTerminalProjectForExecutionCli(db, projectCwd(), PERMISSION, "terminal-run");
+  const cwd = projectPath || projectCwd();
+  const resolvedExperience = resolveRuntimeExperienceCli(agent, userPrompt.trim(), runtimeExperience, cwd, { db });
+  const code = await executeOnce(db, agentSystemPromptCli(agent), userPrompt.trim(), runtimeOverride, {
+    projectPath, agentId: agent.id, permission: PERMISSION, runtimeExperience: resolvedExperience,
+  });
   process.exit(code);
 }
 
-async function cmdAutoRun(db, prompt, runtimeOverride) {
+async function cmdAutoRun(db, prompt, runtimeOverride, runtimeExperience = null) {
   const lang = prefsLang();
   const choice = autoRouteAgent(db, prompt, lang);
-  if (!choice) fail("자동 라우팅할 에이전트가 없습니다. agentlas list로 설치 상태를 확인하세요.");
+  if (!choice) fail("No agent is available for automatic routing. Check installation with agentlas list.");
   if (choice.direct) {
     // 전문 에이전트 확신 없음 → 페르소나/능력 라우팅 없이 현재 런타임으로 직답.
     process.stderr.write(`▸ direct (no agent)\n`);
     process.stderr.write(`  ${autoRouteNote(choice, lang)}\n`);
     const sys = `${autoRoutePreamble(choice, lang)}\n\n${directSystemPrompt(lang)}`;
+    const projectPath = ensureTerminalProjectForExecutionCli(db, projectCwd(), PERMISSION, "terminal-auto-run");
+    const cwd = projectPath || projectCwd();
+    const resolvedExperience = resolveRuntimeExperienceCli(null, prompt.trim(), runtimeExperience, cwd, { db });
     const code = await executeOnce(db, sys, prompt.trim(), runtimeOverride, {
-      projectPath: activeProjectPath(db),
+      projectPath,
       agentId: null,
       permission: PERMISSION,
+      runtimeExperience: resolvedExperience,
     });
     process.exit(code);
   }
   process.stderr.write(`▸ ${choice.agent.name} (auto)\n`);
   process.stderr.write(`  ${autoRouteNote(choice, lang)}\n`);
   const sys = `${autoRoutePreamble(choice, lang)}\n\n${agentSystemPromptCli(choice.agent)}`;
+  const projectPath = ensureTerminalProjectForExecutionCli(db, projectCwd(), PERMISSION, "terminal-auto-run");
+  const cwd = projectPath || projectCwd();
+  const resolvedExperience = resolveRuntimeExperienceCli(choice.agent, prompt.trim(), runtimeExperience, cwd, { db });
   const code = await executeOnce(db, sys, prompt.trim(), runtimeOverride, {
-    projectPath: activeProjectPath(db),
+    projectPath,
     agentId: choice.agent.id,
     permission: PERMISSION,
+    runtimeExperience: resolvedExperience,
   });
   process.exit(code);
 }
@@ -8609,7 +10117,7 @@ async function cmdAutoRun(db, prompt, runtimeOverride) {
 // chat / open / 에이전트명 단독 → 네이티브 CLI 대화형 세션 (claude처럼 바로 접속)
 function cmdOpen(db, query, runtimeOverride) {
   const agent = resolveAgent(db, query);
-  if (!agent) fail(`에이전트를 찾을 수 없습니다: ${query}`);
+  if (!agent) fail(`Agent not found: ${query}`);
   launchInteractive(db, agent, runtimeOverride);
 }
 
@@ -8644,15 +10152,37 @@ function firmSystemPrompt(db, firm) {
     /* ignore */
   }
   const base = (ceo && ceo.system_prompt) || `You are the CEO of ${firm.name}.`;
-  return `${base}\n\n[FIRM] 당신은 '${firm.name}' 회사의 CEO입니다. 사용자 명령을 부서에 위임해 처리하세요.\n조직도:\n${roster}`;
+  return `${base}\n\n[FIRM] You are the CEO of '${firm.name}'. Delegate user requests to the appropriate departments.\nOrganization:\n${roster}`;
 }
 async function cmdFirm(db, query, prompt, runtimeOverride) {
   const firm = resolveFirm(db, query);
-  if (!firm) fail(`회사를 찾을 수 없습니다: ${query}`);
+  if (!firm) fail(`Company not found: ${query}`);
   const sys = firmSystemPrompt(db, firm);
   if (prompt && prompt.trim()) {
     process.stderr.write(`▸ ${firm.name} CEO\n`);
-    const code = await executeOnce(db, sys, prompt.trim(), runtimeOverride, { projectPath: activeProjectPath(db), agentId: firm.ceo_agent_id, permission: PERMISSION });
+    const runtime = resolveRuntime(db, runtimeOverride);
+    const projectPath = ensureTerminalProjectForExecutionCli(db, projectCwd(), PERMISSION, "terminal-firm-run");
+    const allocated = await allocateSingleWorkloadCli(db, prompt.trim(), {
+      runtime,
+      cwd: projectCwd(),
+      projectPath,
+      agentId: firm.ceo_agent_id,
+      lang: prefsLang(),
+      mode: "team",
+      onWarning: (message) => process.stderr.write(`▸ ${message}\n`),
+    });
+    process.stderr.write(
+      `▸ team model route · ${allocated.resolution.source} · ${allocated.resolution.model || runtime.kind || runtime.backend}` +
+        `${allocated.resolution.effort ? ` · ${allocated.resolution.effort}` : ""}` +
+        `${allocated.resolution.fallbackReason ? ` · ${allocated.resolution.fallbackReason}` : ""}\n`,
+    );
+    const code = await executeOnce(db, sys, prompt.trim(), runtimeOverride, {
+      projectPath,
+      agentId: firm.ceo_agent_id,
+      permission: PERMISSION,
+      model: allocated.resolution.model,
+      effort: allocated.resolution.effort,
+    });
     process.exit(code);
   }
   // 대화형 — agentlas TUI. CEO 페르소나를 system으로, 작업은 현재 폴더에서.
@@ -8662,7 +10192,7 @@ async function cmdFirm(db, query, prompt, runtimeOverride) {
     slug: firm.slug,
     label: firm.name + " CEO",
     system: sys,
-    capAgent: { name: firm.name, name_en: firm.name_en || firm.name, tagline: firm.tagline, system_prompt: sys },
+    capAgent: { name: firm.name, name_en: firm.name_en || firm.name, tagline: firm.tagline, tagline_en: firm.tagline_en, entity_kind: "team", system_prompt: sys },
   };
   return launchTui(db, subject, runtimeOverride);
 }
@@ -8844,23 +10374,23 @@ async function cmdEnv(db) {
       ...readDotEnvFileCli(path.join(os.homedir(), ".agentlas", "credentials.env")),
     };
     const keys = Object.keys(fromFiles).sort();
-    out(`공유 env 키 ${keys.length}개 (값은 표시 안 함, credentials.env 기준):`);
+    out(`Shared env keys: ${keys.length} (values hidden; from credentials.env):`);
     for (const k of keys) out(`  ${k}`);
     out("");
-    out("키체인 저장 키는 데스크탑 앱의 설정 → 자격증명에서 보입니다.");
+    out("Keychain entries are available in Desktop settings → Credentials.");
     return;
   }
   const keytar = readKeytar();
-  if (!keytar) fail("keytar 모듈을 불러올 수 없습니다(앱 런타임으로 실행 필요).");
+  if (!keytar) fail("The keytar module is unavailable (run through the app runtime).");
   let creds;
   try {
     creds = await keytar.findCredentials(SERVICE);
   } catch (e) {
-    fail("env 조회 실패: " + ((e && e.message) || e));
+    fail("Failed to read environment settings: " + ((e && e.message) || e));
     return;
   }
   const keys = creds.map((c) => c.account).filter((a) => a.startsWith(ENV_PREFIX)).map((a) => a.slice(ENV_PREFIX.length));
-  out(`공유 env 키 ${keys.length}개 (값은 표시 안 함):`);
+  out(`Shared env keys: ${keys.length} (values hidden):`);
   for (const k of keys.sort()) out(`  ${k}`);
 }
 
@@ -8889,7 +10419,7 @@ function setMultimodalCli(db, modality, providerId) {
   const mm = loadMultimodalCatalog();
   if (!["image", "video", "audio"].includes(modality)) fail("usage: agentlas multimodal set <image|video|audio> <provider-id>");
   const provider = mm.MULTIMODAL_PROVIDERS.find((p) => p.id === providerId && p.modality === modality);
-  if (!provider) fail(`provider를 찾을 수 없습니다: ${providerId} (${modality})`);
+  if (!provider) fail(`Provider not found: ${providerId} (${modality})`);
   const key = modality === "image" ? "imageProvider" : modality === "video" ? "videoProvider" : "audioProvider";
   return saveMultimodalSettingsCli(db, { [key]: providerId });
 }
@@ -8952,7 +10482,7 @@ function parseUpdateFlags(args) {
     else if (arg === "--no-launch") flags.launch = false;
     else if (arg === "--url") flags.url = args[++i] || flags.url;
     else if (arg === "--help" || arg === "-h" || arg === "help") flags.help = true;
-    else fail(`알 수 없는 update 옵션: ${arg}`);
+    else fail(`Unknown update option: ${arg}`);
   }
   return flags;
 }
@@ -9027,19 +10557,19 @@ function updateTimeoutError(kind, ms) {
   return updateTransferError(`AGENTLAS_UPDATE_${kind.toUpperCase()}_TIMEOUT`, message);
 }
 
-function parseSafeUpdateUrl(value, label = "업데이트 URL") {
+function parseSafeUpdateUrl(value, label = "update URL") {
   let parsed;
   try {
     parsed = new URL(String(value || ""));
   } catch (error) {
-    throw updateTransferError("AGENTLAS_UPDATE_INVALID_URL", `${label} 형식이 올바르지 않습니다.`, error);
+    throw updateTransferError("AGENTLAS_UPDATE_INVALID_URL", `${label} has an invalid format.`, error);
   }
   const loopback = parsed.hostname === "localhost" || parsed.hostname === "127.0.0.1" || parsed.hostname === "[::1]" || parsed.hostname === "::1";
   if (parsed.protocol !== "https:" && !(parsed.protocol === "http:" && loopback)) {
-    throw updateTransferError("AGENTLAS_UPDATE_INSECURE_URL", `${label}은 HTTPS여야 합니다(로컬 루프백 제외).`);
+    throw updateTransferError("AGENTLAS_UPDATE_INSECURE_URL", `${label} must use HTTPS (except local loopback).`);
   }
   if (parsed.username || parsed.password) {
-    throw updateTransferError("AGENTLAS_UPDATE_INVALID_URL", `${label}에 사용자 정보가 포함될 수 없습니다.`);
+    throw updateTransferError("AGENTLAS_UPDATE_INVALID_URL", `${label} cannot contain user information.`);
   }
   return parsed.toString();
 }
@@ -9186,7 +10716,7 @@ async function fetchDesktopRelease(url) {
     return await fetchUpdateMetadata(url, { signal: controller.signal });
   } catch (error) {
     const message = String((error && error.message) || error);
-    fail(`업데이트 확인 실패: ${message}`);
+    fail(`Update check failed: ${message}`);
   }
 }
 
@@ -9225,19 +10755,19 @@ async function cmdUpdateStandalone(flags) {
   if (flags.json) {
     return out(JSON.stringify({ currentVersion, latestVersion, updateAvailable: comparison == null ? null : comparison < 0, channel: "npm" }, null, 2));
   }
-  out(`현재 버전: ${currentVersion}`);
+  out(`Current version: ${currentVersion}`);
   if (!latestVersion) {
-    out("npm 레지스트리에서 최신 버전을 확인하지 못했습니다 (오프라인이거나 아직 미발행).");
-    out("수동 업데이트:  npm i -g agentlas@latest");
+    out("Could not check the latest version on the npm registry (offline or not published yet).");
+    out("Manual update: npm i -g agentlas@latest");
     return;
   }
-  out(`최신 버전: ${latestVersion}`);
+  out(`Latest version: ${latestVersion}`);
   if (comparison == null) {
-    out("버전 형식을 비교하지 못했습니다. 수동 업데이트:  npm i -g agentlas@latest");
+    out("Could not compare version formats. Manual update: npm i -g agentlas@latest");
   } else if (comparison < 0) {
-    out("업데이트:  npm i -g agentlas@latest");
+    out("Update: npm i -g agentlas@latest");
   } else {
-    out("이미 최신 버전입니다.");
+    out("Already on the latest version.");
   }
 }
 
@@ -9252,7 +10782,7 @@ async function cmdUpdate(args) {
   const latestVersion = String(release.version || "");
   const artifact = findCurrentArtifact(release);
   const comparison = compareSemVer(currentVersion, latestVersion);
-  if (comparison == null) fail(`현재/최신 버전이 SemVer 형식이 아닙니다: current=${currentVersion} latest=${latestVersion}`);
+  if (comparison == null) fail(`Current/latest version is not valid SemVer: current=${currentVersion} latest=${latestVersion}`);
   const updateAvailable = comparison < 0;
   const status = {
     currentVersion,
@@ -9270,15 +10800,15 @@ async function cmdUpdate(args) {
   if (flags.json) return out(JSON.stringify(status, null, 2));
   out(formatUpdateSummary(status));
   if (flags.check) return;
-  if (release.ready !== true) fail("최신 릴리즈가 아직 공개 설치 가능 상태가 아닙니다.");
-  if (!updateAvailable && !flags.force) return out("이미 최신 버전입니다.");
-  if (process.platform !== "darwin") return out("이 OS는 아직 자동 설치를 지원하지 않습니다. 위 릴리즈/다운로드 링크에서 최신 설치 파일을 받으세요.");
-  if (!artifact || !artifact.url) fail("현재 Mac에 맞는 DMG를 찾지 못했습니다.");
+  if (release.ready !== true) fail("The latest release is not ready for public installation.");
+  if (!updateAvailable && !flags.force) return out("Already on the latest version.");
+  if (process.platform !== "darwin") return out("Automatic installation is not supported on this OS yet. Use the release/download link above.");
+  if (!artifact || !artifact.url) fail("Could not find a DMG for this Mac.");
   await installMacDesktopUpdate(release, artifact, flags);
 }
 
 function requirePath(commandPath, label) {
-  if (!fs.existsSync(commandPath)) fail(`업데이트에 필요한 도구가 없습니다: ${label}`);
+  if (!fs.existsSync(commandPath)) fail(`Required update tool not found: ${label}`);
   return commandPath;
 }
 
@@ -9614,9 +11144,9 @@ async function installMacDesktopUpdate(release, artifact, flags) {
   const stagingPath = path.join(targetDir, `.${targetName}.installing.${transactionId}.app`);
 
   try {
-    out(`다운로드: ${fileName}`);
+    out(`Download: ${fileName}`);
     await downloadUpdateFile(validatedArtifact.url, dmgPath, validatedArtifact);
-    out("검증: DMG, notarization, Gatekeeper");
+    out("Verify: DMG, notarization, Gatekeeper");
     await runCommand(hdiutil, ["verify", dmgPath]);
     await runCommand(xcrun, ["stapler", "validate", dmgPath]);
     await runCommand(spctl, ["-a", "-t", "open", "--context", "context:primary-signature", "-vv", dmgPath]);
@@ -9625,16 +11155,16 @@ async function installMacDesktopUpdate(release, artifact, flags) {
     mountPoint = parseHdiutilMountPoint(mount.stdout);
     const sourceApp = mountPoint ? path.join(mountPoint, "Agentlas.app") : "";
     if (!sourceApp || !fs.existsSync(sourceApp)) {
-      throw updateTransferError("AGENTLAS_UPDATE_APP_MISSING", "DMG 안에서 Agentlas.app을 찾지 못했습니다.");
+      throw updateTransferError("AGENTLAS_UPDATE_APP_MISSING", "Agentlas.app was not found in the DMG.");
     }
 
     const installedVersion = await runCommand(plistBuddy, ["-c", "Print :CFBundleShortVersionString", path.join(sourceApp, "Contents", "Info.plist")], { capture: true });
     const appVersion = installedVersion.stdout.trim();
     if (appVersion !== String(release.version)) {
-      throw updateTransferError("AGENTLAS_UPDATE_VERSION_MISMATCH", `앱 버전이 릴리즈와 다릅니다: release=${release.version} app=${appVersion}`);
+      throw updateTransferError("AGENTLAS_UPDATE_VERSION_MISMATCH", `App version does not match the release: release=${release.version} app=${appVersion}`);
     }
 
-    out("설치: 기존 Agentlas 종료 후 앱 교체");
+    out("Install: quit the existing Agentlas app and replace it");
     await runCommand(osascript, ["-e", 'tell application "Agentlas" to quit'], { capture: true, allowFailure: true });
     await sleep(2_000);
     const replacement = await replaceMacAppBundle({
@@ -9645,10 +11175,10 @@ async function installMacDesktopUpdate(release, artifact, flags) {
       runCommand,
       commands: { codesign, spctl, ditto, mv, rm },
     });
-    if (replacement.backupRetained) out(`주의: 검증된 새 앱은 설치됐지만 이전 앱 백업을 지우지 못했습니다: ${replacement.backupPath}`);
+    if (replacement.backupRetained) out(`Warning: the verified app was installed, but the previous app backup could not be removed: ${replacement.backupPath}`);
     if (fs.existsSync(lsregister)) await runCommand(lsregister, ["-f", targetApp], { allowFailure: true });
     if (flags.launch) await runCommand(open, ["-a", "Agentlas"], { allowFailure: true });
-    out(`Agentlas ${release.version} 설치 완료.`);
+    out(`Agentlas ${release.version} installed.`);
   } finally {
     if (mountPoint) await runCommand(hdiutil, ["detach", mountPoint], { allowFailure: true });
     fs.rmSync(tmpDir, { recursive: true, force: true });
@@ -9740,32 +11270,32 @@ function oberonScaffold(args) {
   };
   if (flags.titles) manifest.titles = oberonSampleTitles(title);
   fs.writeFileSync(outPath, JSON.stringify(manifest, null, 2), "utf8");
-  out(`✓ 매니페스트 생성: ${outPath}`);
-  out(`  · 샷 ${shotCount}개 · ${aspect} · ${manifest.provider}`);
-  out(`  · 프롬프트를 채운 뒤:  agentlas oberon render ${path.basename(outPath)}`);
-  out(`  · 또는 에이전트로 채우기:  agentlas run oberon-film-studio "30초 향수 광고 트레일러"`);
-  if (!flags.titles) out(`  · 타이틀/자막 번인 샘플 포함하려면 --titles 플래그`);
+  out(`✓ Manifest created: ${outPath}`);
+  out(`  · ${shotCount} shots · ${aspect} · ${manifest.provider}`);
+  out(`  · fill prompts, then run: agentlas oberon render ${path.basename(outPath)}`);
+  out(`  · or use an agent: agentlas run oberon-film-studio "30-second fragrance ad trailer"`);
+  if (!flags.titles) out(`  · use --titles to include title/subtitle burn-in samples`);
 }
 
 function oberonRender(args) {
   const { flags, rest } = oberonParseFlags(args);
-  if (!rest[0]) fail("렌더할 매니페스트 경로가 필요합니다:  agentlas oberon render <manifest.json>");
+  if (!rest[0]) fail("A manifest path is required: agentlas oberon render <manifest.json>");
   const manifestPath = path.resolve(rest[0]);
-  if (!fs.existsSync(manifestPath)) fail(`매니페스트를 찾을 수 없습니다: ${manifestPath}`);
+  if (!fs.existsSync(manifestPath)) fail(`Manifest not found: ${manifestPath}`);
 
   let manifest;
   try {
     manifest = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
   } catch (e) {
-    return fail(`매니페스트 JSON 파싱 실패: ${e.message}`);
+    return fail(`Failed to parse manifest JSON: ${e.message}`);
   }
-  if (!Array.isArray(manifest.shots) || !manifest.shots.length) fail("매니페스트에 shots[] 가 비어 있습니다.");
+  if (!Array.isArray(manifest.shots) || !manifest.shots.length) fail("The manifest has no shots[].");
 
   const root = oberonRepoRoot();
   const script = path.join(root, "scripts", "render-oberon-live-request.cjs");
   const builtRender = path.join(root, "dist", "electron", "oberon", "render.js");
-  if (!fs.existsSync(script)) fail(`헤드리스 렌더 스크립트가 없습니다(패키지 앱에는 미포함): ${script}`);
-  if (!fs.existsSync(builtRender)) fail(`Electron 빌드가 필요합니다. 먼저:  npm run build:electron   (없는 파일: ${builtRender})`);
+  if (!fs.existsSync(script)) fail(`Headless render script not found (not included in the packaged app): ${script}`);
+  if (!fs.existsSync(builtRender)) fail(`An Electron build is required. Run npm run build:electron first (missing: ${builtRender})`);
 
   // --max-shots 등 오버라이드가 있으면 사용자 매니페스트는 그대로 두고 임시 패치본을 만든다.
   let reqPath = manifestPath;
@@ -9790,18 +11320,18 @@ function oberonRender(args) {
   if (flags["poll-ms"]) childEnv.OBERON_LIVE_POLL_MS = String(flags["poll-ms"]);
   if (flags.open) childEnv.OBERON_LIVE_OPEN_DELIVERY = "1";
 
-  out(`▶ Oberon 렌더: "${manifest.title}"  (${manifest.shots.length}샷, 최대 ${overrides.maxShots ?? manifest.maxShots ?? 3})`);
-  out(`  매니페스트: ${manifestPath}`);
-  out(`  납품 폴더:  ${deliveryDir}`);
-  if (manifest.titles) out(`  타이틀/자막 번인: 활성 → *_titled.mp4 추가 생성`);
+  out(`▶ Oberon render: "${manifest.title}"  (${manifest.shots.length} shots, max ${overrides.maxShots ?? manifest.maxShots ?? 3})`);
+  out(`  Manifest: ${manifestPath}`);
+  out(`  Delivery folder: ${deliveryDir}`);
+  if (manifest.titles) out(`  title/subtitle burn-in: enabled → generating additional *_titled.mp4`);
 
   if (flags["dry-run"]) {
-    out("\n[dry-run] 실행할 명령:");
+    out("\n[dry-run] Command to run:");
     out(`  ${process.execPath} ${script}`);
     out("  env: OBERON_LIVE_VEO=1");
     out(`       OBERON_LIVE_REQUEST_FILE=${reqPath}`);
     out(`       OBERON_LIVE_DELIVERY_DIR=${deliveryDir}`);
-    out("  (full Electron · GEMINI_API_KEY/GOOGLE_CLOUD_PROJECT 볼트 필요)");
+  out("  (full Electron · GEMINI_API_KEY/GOOGLE_CLOUD_PROJECT vault required)");
     return;
   }
 
@@ -9822,11 +11352,11 @@ function oberonRender(args) {
     child.stderr.on("data", (c) => process.stderr.write(c));
     child.on("close", (code) => {
       if (code === 0) {
-        out(`\n✓ 렌더 완료 — 납품 폴더: ${deliveryDir}`);
+        out(`\n✓ Render complete — delivery folder: ${deliveryDir}`);
         const titled = files.filter((f) => f.kind && f.kind.startsWith("titled"));
-        if (titled.length) out(`  타이틀/자막 번인본: ${titled.map((f) => f.name).join(", ")}`);
+        if (titled.length) out(`  title/subtitle burn-in files: ${titled.map((f) => f.name).join(", ")}`);
       } else {
-        process.stderr.write(`\n✖ 렌더 실패 (exit ${code})\n`);
+        process.stderr.write(`\n✖ Render failed (exit ${code})\n`);
         process.exitCode = code || 1;
       }
       resolve();
@@ -9884,7 +11414,7 @@ function slugifyOberon(value) {
 function oberonList() {
   const dir = path.join(userDataDir(), "oberon");
   if (!fs.existsSync(dir)) {
-    out("아직 렌더 산출물이 없습니다.  agentlas oberon scaffold my.json  으로 시작하세요.");
+    out("No render outputs yet. Start with agentlas oberon scaffold my.json.");
     return;
   }
   const entries = fs
@@ -9908,40 +11438,40 @@ function oberonList() {
     .sort((a, b) => b.mtime - a.mtime)
     .slice(0, 15);
   if (!entries.length) {
-    out("아직 렌더 산출물이 없습니다.");
+    out("No render outputs yet.");
     return;
   }
-  out(`최근 Oberon 렌더 (${dir}):\n`);
+  out(`Recent Oberon renders (${dir}):\n`);
   for (const e of entries) {
     const masters = e.files.filter((f) => /master|titled/.test(f) && /\.(mp4|mov)$/.test(f));
     const when = e.mtime ? new Date(e.mtime).toISOString().slice(0, 16).replace("T", " ") : "";
     out(`  ${when}  ${e.name}`);
     if (masters.length) out(`            ${masters.join(", ")}`);
   }
-  out(`\n폴더 열기:  agentlas oberon open`);
+  out(`\nOpen the folder with: agentlas oberon open`);
 }
 
 function oberonOpen(args) {
   const target = args[0] ? path.resolve(args[0]) : path.join(userDataDir(), "oberon");
-  if (!fs.existsSync(target)) fail(`경로가 없습니다: ${target}`);
+  if (!fs.existsSync(target)) fail(`Path not found: ${target}`);
   const opener = process.platform === "darwin" ? "open" : process.platform === "win32" ? "explorer" : "xdg-open";
   spawn(opener, [target], { detached: true, stdio: "ignore" }).unref();
-  out(`폴더 열기: ${target}`);
+  out(`Opening folder: ${target}`);
 }
 
 function oberonHelp() {
   out(
     [
-      "agentlas oberon — 터미널에서 AI 필름 렌더",
+      "agentlas oberon — AI film rendering from the terminal",
       "",
       "  oberon scaffold [out.json] [--title T] [--aspect 16:9] [--shots N] [--titles]",
-      "                         편집 가능한 렌더 매니페스트 생성 (--titles: 타이틀/자막 번인 샘플 포함)",
+      "                         create an editable render manifest (--titles: include title/subtitle burn-in samples)",
       "  oberon render <manifest.json> [--delivery DIR] [--max-shots N] [--open] [--dry-run]",
-      "                         full Electron 렌더 스폰 + 진행률 스트리밍 (GEMINI_API_KEY 볼트 필요)",
+      "                         spawn full Electron render + stream progress (GEMINI_API_KEY vault required)",
       "  oberon list            최근 렌더 산출물",
       "  oberon open [path]     산출물 폴더 열기",
       "",
-      "프롬프트는 직접 채우거나, 에이전트에게:  agentlas run oberon-film-studio \"30초 향수 광고\"",
+      "Fill prompts directly, or ask an agent: agentlas run oberon-film-studio \"30-second fragrance ad\"",
     ].join("\n"),
   );
 }
@@ -9965,7 +11495,7 @@ async function cmdOberon(args) {
     case "-h":
       return oberonHelp();
     default:
-      fail(`알 수 없는 oberon 하위명령: ${sub}  (scaffold|render|list|open|help)`);
+      fail(`Unknown oberon subcommand: ${sub}  (scaffold|render|list|open|help)`);
   }
 }
 
@@ -9983,23 +11513,31 @@ function cmdHelp() {
       hdr("TALK & RUN"),
       "  <agent>                  jump into a chat with one agent (e.g. agentlas seo)",
       "  run [agent] [prompt]     one-shot — omit agent to auto-route (reads stdin if no prompt)",
+      "    --experience-desktop-loadout  use Desktop's fresh exact Operational/Taste loadout receipt",
+      "    --no-experience               highest precedence; do not read or inject a loadout",
       "  firm <firm> [cmd]        delegate to a company's CEO (interactive if no cmd)",
       "  chats [n]                recent conversations   ·   chat resume in REPL: /resume",
       "",
       hdr("AGENTS & HUB   (Agentlas OS surface)"),
       "  search \"<what you need>\" discover agents in the Hub + local            (hep-search)",
       "  install <slug>           install an agent from the Hub                    (hep-cloud)",
+      "  plugin add <slug>        install a Hub plugin (MCP servers) into this machine",
       "  build \"<request>\"        build/repair/package an agent or team           (hep-build)",
       "  upload <path>            save owner-private in Agent Cloud (default)       (hep-upload)",
       "    --visibility marketplace  explicit compatibility flag: publish to Hub",
       "  connect [<sub>]          wire Telegram / platforms to an agent team       (hep-connect)",
       "  import <path>            import a local agent/team folder",
       "  list                     installed agents/companies + active runtime",
+      "  experience <sub>         portable Experience: list|inspect|validate|save|publish|status|export|unpublish",
+      "                            legacy local intents require explicit legacy-* commands",
+      "  variant resolve          local variant selection: selected|fallback|base-only|error",
       "",
       hdr("EXECUTE"),
-      "  storm <goal>             force-robust pipeline: route → verify → execute  (Stormbreaker) [--research]",
+      "  storm <goal>             Agentlas Goal+UltraCode harness: plan → allocate → execute → verify  [--research]",
       "  swarm <goal>             emergent agent swarm — parallel workers + synthesizer [--parallel N]",
-      "  network <request>        decompose a request into an A2A task force       (hep-network)",
+      "  network <request>        host-LLM workforce ontology → exact TF → execute [--benchmark]",
+      "  workforce <request>      same Agent Workforce Ontology route (explicit name)",
+      "  legacy-network <request> compatibility-only Hephaestus network route",
       "  call \"a,b\" \"<ctx>\"       invoke named Hub/Cloud agents                    (hep-call)",
       "  browser [<sub>]          real browser execution hardpoint                 (hep-browser)",
       "  route \"<request>\"        routing preview — which agent/pipeline would take this",
@@ -10062,7 +11600,7 @@ async function main() {
       runtimeOverride = argv[++i];
     } else if (argv[i] === "--permission" || argv[i] === "-P") {
       const p = (argv[++i] || "").toLowerCase();
-      if (!["read", "write", "full"].includes(p)) fail(`알 수 없는 권한: ${p} (read|write|full)`);
+      if (!["read", "write", "full"].includes(p)) fail(`Unknown permission: ${p} (read|write|full)`);
       PERMISSION = p;
       PERMISSION_EXPLICIT = true;
     } else {
@@ -10097,8 +11635,10 @@ async function main() {
       return cmdImport(db, rest[1]);
     case "cd":
       return cmdCd(db, rest[1]);
-    case "run":
-      return cmdRun(db, rest[1], rest.slice(2).join(" "), runtimeOverride);
+    case "run": {
+      const runInput = parseRunExperienceArgs(rest.slice(2));
+      return cmdRun(db, rest[1], runInput.prompt, runtimeOverride, runInput.experience);
+    }
     case "chat":
     case "open":
       return cmdOpen(db, rest[1], runtimeOverride);
@@ -10121,10 +11661,16 @@ async function main() {
       return cmdCloud(db, rest.slice(1), runtimeOverride);
     case "creds":
       return cmdCreds(db, rest.slice(1));
-    case "storm":
-      return parity().cmdStorm(db, rest.slice(1), runtimeOverride);
-    case "swarm":
-      return parity().cmdSwarm(db, rest.slice(1), runtimeOverride);
+    case "storm": {
+      const cwd = projectCwd();
+      const projectPath = ensureTerminalProjectForExecutionCli(db, cwd, PERMISSION, "terminal-storm");
+      return parity().cmdStorm(db, rest.slice(1), runtimeOverride, { cwd, projectPath, permission: PERMISSION });
+    }
+    case "swarm": {
+      const cwd = projectCwd();
+      const projectPath = ensureTerminalProjectForExecutionCli(db, cwd, PERMISSION, "terminal-swarm");
+      return parity().cmdSwarm(db, rest.slice(1), runtimeOverride, { cwd, projectPath, permission: PERMISSION });
+    }
     case "automation":
     case "automations":
       return parity().cmdAutomation(db, rest.slice(1), runtimeOverride);
@@ -10133,16 +11679,54 @@ async function main() {
       return parity().cmdHep(db, rest.slice(1));
     // ── Agentlas OS 정식 표면 (hep-*) 1급 노출 ──
     case "build":
-      // hep-build "<요청>" — 에이전트/팀 빌드 (Meta-Agent Factory)
-      return parity().cmdHep(db, rest.length > 1 ? ["hep-build", rest.slice(1).join(" ")] : ["hep-build"]);
+      // Terminal-owned preflight: trusted system-global MCP metadata first, one consent,
+      // then pass only approved catalog IDs/value-free shortages to the existing builder.
+      ensureTerminalProjectForExecutionCli(db, projectCwd(), PERMISSION, "terminal-build");
+      return terminalAssets.cmdBuild({
+        db,
+        args: rest.slice(1),
+        userDataDir: userDataDir(),
+        cwd: projectCwd(),
+        input: process.stdin,
+        promptOutput: process.stderr,
+        out,
+        probeMcpServer: (server, probeOptions) => probeApprovedTerminalMcp(db, server, runtimeOverride, projectCwd(), probeOptions),
+        invokeBuild: (request, metadata) => runTerminalBuilder(db, request, metadata, runtimeOverride, projectCwd()),
+      });
+    case "experience":
+      return terminalExperienceExchange.cmdExperienceExchange({
+        args: rest.slice(1),
+        userDataDir: userDataDir(),
+        cwd: projectCwd(),
+        out,
+        env: process.env,
+        getSessionCookie: cloudSessionCookieCli,
+        fetchHub: (url, init) => fetchHubCli(url, init),
+        legacyCommand: (legacyOptions) => terminalAssets.cmdExperience(legacyOptions),
+      });
+    case "variant":
+      return terminalAssets.cmdVariant({
+        db,
+        args: rest.slice(1),
+        userDataDir: userDataDir(),
+        cwd: projectCwd(),
+        out,
+      });
     case "search": // hep-search — 에이전트 디렉터리 발견 (Hub + 로컬)
-      if (!rest[1]) return fail('usage: agentlas search "<찾는 일>" [--limit 10]');
+      if (!rest[1]) return fail('usage: agentlas search "<what you need>" [--limit 10]');
       return parity().cloudSearch(db, rest.slice(1));
     case "install": // public Hub package install — slug로 에이전트 설치
-      if (!rest[1]) return fail('usage: agentlas install <slug>   (먼저 agentlas search "할 일" 로 찾으세요)');
+      if (!rest[1]) return fail('usage: agentlas install <slug>   (run agentlas search "what you need" first)');
       return cmdCloudInstall(db, rest[1]);
+    case "plugin": // Hub 플러그인(MCP 서버 번들) — 에이전트 설치(install)와 다른 카탈로그다
+    case "plugins": {
+      const action = rest[1];
+      if (action === "add") return cmdPluginAdd(db, rest[2]);
+      if (action === "list" || !action) return cmdPluginList();
+      return fail("usage: agentlas plugin add <slug> | agentlas plugin list");
+    }
     case "upload": { // 기본은 owner-private Agent Cloud, public Hub는 명시 flag로만.
-      if (!rest[1]) return fail("usage: agentlas upload <에이전트 폴더 경로> [--visibility marketplace]");
+      if (!rest[1]) return fail("usage: agentlas upload <agent-folder-path> [--visibility marketplace]");
       const uploadArgs = rest.slice(1);
       return cmdCloud(db, [cloudActionForTopLevelUpload(uploadArgs), ...uploadArgs], runtimeOverride);
     }
@@ -10152,8 +11736,14 @@ async function main() {
       return parity().cmdHep(db, ["hep-browser", ...rest.slice(1)]);
     case "call": // hep-call — 지정 에이전트 호출/준비
       return parity().cmdHep(db, ["hep-call", ...rest.slice(1)]);
-    case "network": // hep-network — A2A 태스크포스 분해/스케줄
-    case "taskforce":
+    case "workforce":
+    case "network":
+    case "taskforce": {
+      const cwd = projectCwd();
+      const projectPath = ensureTerminalProjectForExecutionCli(db, cwd, PERMISSION, "terminal-workforce");
+      return workforce().cmdWorkforce(db, rest.slice(1), runtimeOverride, { cwd, projectPath, permission: PERMISSION });
+    }
+    case "legacy-network": // explicit compatibility escape hatch only
       return parity().cmdHep(db, ["hep-network", ...rest.slice(1)]);
     case "route": // 라우팅 미리보기 (실행 없음)
       return parity().cmdHep(
@@ -10202,7 +11792,7 @@ async function main() {
       if (firm) return cmdFirm(db, cmd, "", runtimeOverride);
       const prompt = rest.join(" ").trim();
       if (prompt) return cmdAutoRun(db, prompt, runtimeOverride);
-      fail(`에이전트/회사를 찾을 수 없습니다: ${cmd}  (agentlas list 로 확인)`);
+      fail(`Agent/company not found: ${cmd}  (check with agentlas list)`);
     }
   }
 }
@@ -10219,6 +11809,9 @@ module.exports = {
   parseDotEnvCli,
   isProtectedChildEnvKeyCli,
   mergeChildEnvValuesCli,
+  openNodeSqliteDb,
+  ensureMemoryContextColumn,
+  writeJsonPrivateAtomicCli,
   resolveCredentialSourcePath,
   upsertEnvLine,
   fetchHubCli,
@@ -10233,6 +11826,7 @@ module.exports = {
   replaceMacAppBundle,
   captureRuntime,
   buildArgs,
+  codexCaptureAgentText,
   captureOutputLimit,
   materializeCloudListingCli,
   recoverCloudInstallJournalCli,
@@ -10252,6 +11846,28 @@ module.exports = {
   cloudPackageHashVersion,
   cloudPortablePathConflict,
   cloudPortableExecutableForFile,
+  parseRunExperienceArgs,
+  resolveRuntimeExperienceCli,
+  runTerminalBuilder,
+  resolveRuntime,
+  listAvailableRuntimes,
+  probeApprovedTerminalMcp,
+  finalizeExperienceExecutionCli,
+  buildChildEnvCli,
+  augmentSystem,
+  beginMemoryTurnCli,
+  completeMemoryTurnCli,
+  curatorRuntimeEnvCli,
+  ensureGeminiNoToolsPolicyCli,
+  curateCliReply,
+  TERMINAL_MEMORY_CORE,
+  TERMINAL_MEMORY_CORE_MAX_TOKENS,
+  approximatePromptTokens,
+  memoryEmitterPromptFor,
+  credentialIndexReminderFor,
+  ensureCoreProjectCli,
+  ensureTerminalProjectForExecutionCli,
+  ensureAgentlasProjectStateIgnoreCli,
   DEFAULT_API_MODEL,
   ANTHROPIC_COMPAT_API,
   // 자동 라우팅 회귀 테스트 표면 — 약한 매치 직답/오라우팅 방지 규칙 검증용.