agentlas 0.5.5 → 0.7.0

package/engine/agentlas.cjs

@@ -29,6 +29,8 @@ 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");
 
 // ── 앱과 동일한 userData 경로 (electron app.getPath('userData')와 일치) ──
 function userDataDir() {
@@ -93,6 +95,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");
@@ -280,7 +295,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"
@@ -300,7 +325,11 @@ function resolveMetaBuilder(db) {
   }
   return null;
 }
-const ROUTE_STOP_WORDS = new Set(["the", "and", "for", "with", "this", "that", "from", "into", "make", "build", "create", "agent", "agents", "please", "좀", "해주세요", "해줘", "만들어", "붙여", "연결", "작업", "요청"]);
+// "ai"/"llm" 같은 초범용 토큰은 모든 에이전트 프롬프트에 나오므로 판별력이 0이다 —
+// 이런 단어 하나로 전문 에이전트가 선택되던 오라우팅(예: 일반 맥 질문 → Pitch Deck Architect)을 막는다.
+// "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",
@@ -358,20 +387,46 @@ const ROUTE_HINTS = [
 function routeNormalize(value) {
   return String(value || "").toLowerCase().replace(/[_/]+/g, "-");
 }
+// 경로 디렉터리 성분은 라우팅 의도가 아니다 — 마지막 세그먼트(파일/폴더명)만 남긴다.
+// 사고(2026-07-12): "/Users/mason/Documents/…/Appbridge_Template.이 …" 프롬프트의 경로 토큰
+// ("users","mason","documents","users-mason-documents-")이 임포트 에이전트 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(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",
@@ -414,7 +469,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;
@@ -436,8 +491,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,
@@ -446,27 +503,41 @@ 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 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 (haystack.includes(term)) {
+    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);
     }
   }
   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"
@@ -476,7 +547,33 @@ 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 };
+  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 {
+    direct: true,
+    agent: null,
+    score: 0,
+    terms: [],
+    strong: false,
+    reason: resolvedLang === "ko"
+      ? "특정 전문 에이전트가 필요 없는 일반 요청입니다"
+      : "this is a general request that needs no specialist agent",
+  };
+}
+// 직답 모드 시스템 프롬프트 — 페르소나·라우팅 오염 없이 현재 런타임 그대로 답한다.
+function directSystemPrompt(lang) {
+  const resolvedLang = lang || prefsLang();
+  return resolvedLang === "ko"
+    ? "당신은 Agentlas 터미널의 기본 어시스턴트입니다. 특별한 페르소나 없이 사용자의 요청에 정확하고 간결하게 바로 답하세요. 에이전트 라우팅이나 이미지 생성 능력을 스스로 언급하지 마세요."
+    : "You are the Agentlas terminal's default assistant. Answer the user's request directly and concisely, with no special persona. Do not bring up agent routing or image-generation capabilities on your own.";
 }
 function autoRouteAgent(db, prompt, lang) {
   const resolvedLang = lang || prefsLang();
@@ -487,6 +584,7 @@ function autoRouteAgent(db, prompt, lang) {
       return {
         agent: meta,
         score: 1000,
+        strong: true,
         reason:
           resolvedLang === "ko"
             ? "새 에이전트/팀/회사를 만드는 요청이라 메타에이전트(빌더)로 라우팅했습니다"
@@ -496,28 +594,46 @@ function autoRouteAgent(db, prompt, lang) {
     }
   }
   const agents = listRoutableAgents(db).filter((agent) => !NON_GENERIC_ROUTE_SLUGS.has(agent.slug));
-  if (!agents.length) return null;
-  const terms = routeTokenize(prompt);
-  const ranked = agents.map((agent) => scoreRouteAgent(prompt, terms, agent, resolvedLang)).sort((a, b) => b.score - a.score);
-  if (ranked[0] && ranked[0].score > 0) return ranked[0];
-  const fallback = agents.find((agent) => agent.slug === "agentlas-pm-soul") || agents[0];
-  return {
-    agent: fallback,
-    score: 0,
-    reason: resolvedLang === "ko"
-      ? "명확한 전문 에이전트가 없어 기본 프로젝트 조율 경로를 선택했습니다"
-      : "no specialist matched clearly, so Agentlas chose the default coordination route",
-    terms: [],
-  };
+  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) {
+    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) {
-  const name = (lang || prefsLang()) === "ko" ? choice.agent.name : choice.agent.name_en || choice.agent.name;
-  return (lang || prefsLang()) === "ko"
+  const resolvedLang = lang || prefsLang();
+  if (choice.direct) {
+    return resolvedLang === "ko"
+      ? `사용 에이전트: 없음 — 바로 답합니다. 이유: ${choice.reason}.`
+      : `Selected agent: none — answering directly. Reason: ${choice.reason}.`;
+  }
+  const name = resolvedLang === "ko" ? choice.agent.name : choice.agent.name_en || choice.agent.name;
+  return resolvedLang === "ko"
     ? `사용 에이전트: ${name}. 이유: ${choice.reason}.`
     : `Selected agent: ${name}. Reason: ${choice.reason}.`;
 }
 function autoRoutePreamble(choice, lang) {
   const resolvedLang = lang || prefsLang();
+  if (choice.direct) {
+    return [
+      "## Agentlas direct answer",
+      "",
+      resolvedLang === "ko"
+        ? "이 요청은 전문 에이전트 라우팅 없이 처리합니다. 라우팅이나 에이전트를 언급하지 말고 사용자 요청에 바로 답하세요."
+        : "This request is handled without specialist routing. Answer the user directly, without mentioning routing or agents.",
+    ].join("\n");
+  }
   const appBuilderNeedsConsent = choice.agent && choice.agent.slug === "agentlas-app-builder";
   const instruction = appBuilderNeedsConsent
     ? resolvedLang === "ko"
@@ -708,9 +824,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;
@@ -785,6 +906,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 = [
@@ -1574,6 +1696,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.
@@ -2318,6 +2446,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 } : {}) };
@@ -2663,6 +2802,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);
@@ -2855,7 +3001,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);
@@ -6940,6 +7086,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 {
@@ -7802,10 +7963,30 @@ async function runApi(backend, model, system, prompt, options) {
 async function executeOnce(db, system, prompt, override, ctx) {
   ctx = ctx || { projectPath: null, agentId: null };
   if (!ctx.cwdAtRequest) ctx.cwdAtRequest = projectCwd();
+  let runtimeSystem = system;
+  let localExperienceContext = null;
+  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,
+      taskSignatures: runtimeExperience.taskSignatures || [],
+      environmentTags: Array.isArray(runtimeExperience.environmentTags) && runtimeExperience.environmentTags.length
+        ? runtimeExperience.environmentTags
+        : terminalExperienceExchange.defaultEnvironmentTags(),
+    });
+    runtimeSystem = augmented.systemPrompt;
+    localExperienceContext = augmented.experienceContext;
+    if (localExperienceContext.itemIds.length) {
+      process.stderr.write(`▸ local Experience advisory · ${localExperienceContext.itemIds.length} item(s) · ~${localExperienceContext.estimatedTokens} tokens · no server rental receipt\n`);
+    }
+  }
   const rt = resolveRuntime(db, override);
   if (rt.mode === "cli") {
     // 네이티브 CLI는 자체 세션을 가지므로 emitter는 넣지 않고(노이즈 방지) 메모리 컨텍스트만 주입.
-    const sys = augmentSystem(db, system, ctx, false);
+    const sys = augmentSystem(db, runtimeSystem, ctx, false);
     const cwd = ctx.projectPath || projectCwd();
     const permission = ctx.permission || "write";
     const env = await buildChildEnvCli(db, { ...ctx, cwd });
@@ -7839,7 +8020,7 @@ async function executeOnce(db, system, prompt, override, ctx) {
     return res.error ? 1 : 0;
   }
   // API 경로 — emitter 동봉 → 답변에서 메모리 이벤트를 파싱·큐레이션하고 블록은 제거.
-  const sys = augmentSystem(db, system, ctx, true);
+  const sys = augmentSystem(db, runtimeSystem, ctx, true);
   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`);
@@ -8009,13 +8190,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);
@@ -8024,19 +8220,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);
@@ -8045,7 +8242,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;
@@ -8117,6 +8314,7 @@ function buildHelpers(db) {
     autoRouteAgent: (db_, prompt, lang) => autoRouteAgent(db_, prompt, lang),
     autoRouteNote: (choice, lang) => autoRouteNote(choice, lang),
     autoRoutePreamble: (choice, lang) => autoRoutePreamble(choice, lang),
+    directSystemPrompt: (lang) => directSystemPrompt(lang),
     cliMemoryContext: (db_, pp) => cliMemoryContext(db_, pp),
     importLocal: (db_, p) => importLocalFolderCli(db_, p),
     // REPL-safe public Hub install: fail()(process.exit) 대신 Error를 throw 해 REPL이 직접 렌더하게 한다.
@@ -8164,11 +8362,21 @@ 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),
+    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,
+      invokeBuild: (request) => parity().cmdHep(db_, request ? ["hep-build", request] : ["hep-build"]),
+    }),
     hepRun: (args, opts) => parity().runHephaestusInteractive(args, opts),
     cloudSearch: (db_, args) => parity().cloudSearch(db_, args),
     careerGraphCommand: (text, ctx) => runCareerGraphNaturalCli(text, {
@@ -8517,25 +8725,68 @@ function cmdCd(db, query) {
   process.stdout.write(folder + "\n");
 }
 
-async function cmdRun(db, query, prompt, runtimeOverride) {
+function parseRunExperienceArgs(args) {
+  const prompt = [];
+  const experience = { taskSignatures: [], environmentTags: [] };
+  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-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-environment") addList(experience.environmentTags, take());
+    else if (token.startsWith("--experience-environment=")) addList(experience.environmentTags, token.slice(25));
+    else if (token === "--no-experience") experience.disabled = true;
+    else prompt.push(token);
+  }
+  return { prompt: prompt.join(" "), experience };
+}
+
+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);
+    return cmdAutoRun(db, routedPrompt.trim(), runtimeOverride, runtimeExperience);
   }
   let userPrompt = prompt;
   if (!userPrompt) userPrompt = await readStdin();
   if (!userPrompt || !userPrompt.trim()) fail("프롬프트가 비어 있습니다. agentlas run <agent> \"...\" 또는 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 code = await executeOnce(db, agentSystemPromptCli(agent), userPrompt.trim(), runtimeOverride, {
+    projectPath: activeProjectPath(db), agentId: agent.id, permission: PERMISSION, runtimeExperience,
+  });
   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.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 code = await executeOnce(db, sys, prompt.trim(), runtimeOverride, {
+      projectPath: activeProjectPath(db),
+      agentId: null,
+      permission: PERMISSION,
+      runtimeExperience,
+    });
+    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)}`;
@@ -8543,6 +8794,7 @@ async function cmdAutoRun(db, prompt, runtimeOverride) {
     projectPath: activeProjectPath(db),
     agentId: choice.agent.id,
     permission: PERMISSION,
+    runtimeExperience,
   });
   process.exit(code);
 }
@@ -8603,7 +8855,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);
 }
@@ -9936,6 +10188,9 @@ function cmdHelp() {
       "  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: validate|save|publish|status|export|withdraw",
+      "                            legacy local intents: list|inspect|unpublish|legacy-publish",
+      "  variant resolve          local variant selection: selected|fallback|base-only|error",
       "",
       hdr("EXECUTE"),
       "  storm <goal>             force-robust pipeline: route → verify → execute  (Stormbreaker) [--research]",
@@ -10038,8 +10293,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);
@@ -10074,8 +10331,37 @@ 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.
+      return terminalAssets.cmdBuild({
+        db,
+        args: rest.slice(1),
+        userDataDir: userDataDir(),
+        cwd: projectCwd(),
+        input: process.stdin,
+        promptOutput: process.stderr,
+        out,
+        invokeBuild: (request) => parity().cmdHep(db, request ? ["hep-build", request] : ["hep-build"]),
+      });
+    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]');
       return parity().cloudSearch(db, rest.slice(1));
@@ -10160,6 +10446,9 @@ module.exports = {
   parseDotEnvCli,
   isProtectedChildEnvKeyCli,
   mergeChildEnvValuesCli,
+  openNodeSqliteDb,
+  ensureMemoryContextColumn,
+  writeJsonPrivateAtomicCli,
   resolveCredentialSourcePath,
   upsertEnvLine,
   fetchHubCli,
@@ -10193,6 +10482,12 @@ module.exports = {
   cloudPackageHashVersion,
   cloudPortablePathConflict,
   cloudPortableExecutableForFile,
+  parseRunExperienceArgs,
   DEFAULT_API_MODEL,
   ANTHROPIC_COMPAT_API,
+  // 자동 라우팅 회귀 테스트 표면 — 약한 매치 직답/오라우팅 방지 규칙 검증용.
+  autoRouteAgent,
+  autoRouteNote,
+  autoRoutePreamble,
+  directSystemPrompt,
 };