agentlas 0.9.7 → 0.9.9

package/CHANGELOG.md

@@ -1,5 +1,44 @@
 # Changelog
 
+## 0.9.9 — 2026-07-26
+
+- In an explicitly initialized project, ordinary runs, firms, Stormbreaker, and
+  Workforce now receive the same local Context Slice from Agentlas OS v1.1.66
+  after the task is concrete. The slice carries inherited goals and constraints
+  plus exact definitions, backlinks, and structurally related files without
+  sending the project map to Hub or Cloud.
+- Read, write, and full task permission no longer doubles as consent to create
+  `.agentlas/` or edit `.gitignore`. `agentlas project status` is passive, and
+  only the explicit `agentlas project init` boundary creates private project
+  state after announcing the side effects.
+- Workload-routing receipts now conform to the public v1 nested schema, treat a
+  missing model/runtime pair as unresolved, and fail closed on unknown required
+  metadata or ambiguous duplicate model identifiers.
+- The shared architecture seeder is monotonic: it preserves newer or
+  unparseable shared state, upgrades older state atomically, and repairs only
+  missing built-ins at an equal version instead of flipping the Desktop-shared
+  database back to an older Terminal bundle.
+- Interactive output is append-only while a task runs, preserves long streamed
+  output and scrollback through resize/cancellation, wraps command meaning at
+  narrow widths, and keeps saved runtime, permission, lifecycle, and Korean/
+  English status text truthful.
+- Release validation targets the exact Agentlas OS v1.1.66 contract commit
+  `3f6f9ac3929b9238330de18c758ba200fb371017`.
+
+## 0.9.8 — 2026-07-25
+
+- No more silent keyword fallback. When the connected model can't judge a route
+  (no runtime, or the model timed out / returned junk), Agentlas no longer picks
+  a specialist by keyword — it answers with the plain assistant and says why. The
+  note distinguishes "no model connected" (connect one) from "the model didn't
+  answer in time" (retry / check it), so a transient timeout isn't mistaken for a
+  missing model. Image-capability routing is likewise model-only: a keyword guess
+  never hijacks which runtime an agent runs on.
+- The embedded Agentlas OS runtime's own judge (content-guard, pipeline,
+  research, privacy) now uses this host's connected model too, via a universal
+  callback — so provider/CLI users, not only local Ollama, get real judgment
+  there, with no model hardcoded. Pins Agentlas OS v1.1.62.
+
 ## 0.9.7 — 2026-07-25
 
 - Fix: the resident judge now reaches API/Ollama/BYOK runtimes, not only CLI

package/README.md

@@ -116,6 +116,25 @@ agentlas import <폴더>             # 로컬 에이전트/팀 임포트
 agentlas list                      # 설치된 에이전트/회사 + 활성 런타임
 ```
 
+**프로젝트 의존관계 지도**
+```sh
+agentlas project status
+agentlas project init
+agentlas context refresh
+agentlas context refs resolveHubEntityKind
+agentlas context slice --task "entity kind 라우팅 수정" \
+  --target src/package-kind.ts --render
+agentlas context impact --changed src/package-kind.ts
+agentlas context verify --changed src/package-kind.ts \
+  --reviewed src/register/route.ts
+```
+
+`agentlas project init`으로 명시적으로 초기화한 프로젝트에서만 일반
+실행, 팀, Stormbreaker, Workforce가 작업이 구체화된 뒤 같은 로컬 Context
+Slice를 자동으로 받는다. 읽기·쓰기·전체 권한만으로는 `.agentlas/`나
+`.gitignore`를 만들거나 수정하지 않는다. Hub/Cloud 검색에는 코드맵,
+소스 경로, 프로젝트 파일 내용이 전송되지 않는다.
+
 **Portable Experience Bundle과 Variant**
 ```sh
 agentlas experience list

package/engine/agentlas-capabilities.cjs

@@ -63,9 +63,10 @@ const IMAGE_TOOL_MARKERS = [/nano-?banana/i, /\bimagen\b/i, /gpt-image/i, /grok\
 // 겹치는 정규식 여러 개를 동시에 때려도 1클러스터다.
 const MIN_BODY_IMAGE_SENTENCES = 3;
 const BODY_SCAN_CAP = 16000; // 로컬 임포트 상한과 동일 — 클라우드 무제한 프롬프트의 전문 스캔 방지
-// 어휘 판정 — 연결 모델이 없을 때의 결정적 폴백이자, 모델 판정 전의 참고 프리필터.
-// 하우스 룰: 단어목록은 최종 결정을 내리지 않는다. 최종 판정은 resolveNeedsImage가
-// 상주 판정 서비스(judgeLabels)에 묻고, 이 함수는 그 폴백으로만 살아남는다.
+// 어휘 스코어 — IMAGE_HINTS 단어목록에 대한 참고용 스코어러. 하우스 룰(2026-07-25):
+// 단어목록은 최종 결정을 내리지 않는다. resolveNeedsImage가 IMAGE_HINTS를 힌트로만 모델에
+// 넘기고, 연결 모델이 없으면 이미지 여부를 판정하지 않는다(어휘 폴백 제거). 이 함수는 힌트
+// 품질을 고정하는 참조 스코어러로만 남는다(회귀 테스트가 정밀도를 검증).
 function needsImageLexical(agent) {
   if (!agent) return false;
   if (NON_IMAGE_ROLES.has(String(agent.role || "").toLowerCase())) return false;
@@ -93,7 +94,7 @@ function needsImageLexical(agent) {
 // ── 상주 판정 서비스 배선 — 모델이 의미로 최종 판정, IMAGE_HINTS는 참고 힌트 ──────
 // needsImage 호출자(REPL 배지·autoRuntimeFor·routingNote)는 동기라서 warm-cache 패턴:
 // 비동기 경로(resolveNeedsImage)가 먼저 판정해 캐시를 데우고, 동기 needsImage는 캐시만
-// 읽는다. 캐시 미스 = 어휘 폴백 그대로 — imageJudgmentSource가 어느 쪽이었는지 라벨한다.
+// 읽는다. 캐시 미스 = "이미지 아님"으로 처리(어휘 폴백 없음) — 모델 판정만 이미지로 인정한다.
 const IMAGE_VERDICT_CACHE_MAX = 200;
 const imageVerdicts = new Map();
 function imageJudgeInput(agent) {
@@ -109,17 +110,20 @@ function imageJudgeVetoed(agent) {
   return false;
 }
 // 이 에이전트의 직무가 이미지 생산인지를 연결 모델이 의미로 판정한다.
-// 러너 없음/타임아웃/정크 → 어휘 판정을 "fallback"으로 라벨해 반환 (조용한 회귀 금지).
+// 하우스 룰(2026-07-25): 연결 모델이 없으면 단어목록으로 이미지 여부를 결정하지 않는다.
+// 러너 없음/타임아웃/정크 → source:"unavailable"(판정 불가)로 반환하고, 호출자는 안전
+// 기본값(세션 런타임 유지, gemini/codex 하이재킹 금지)을 지킨다. 이미지 판정은 저위험
+// 능력 추론이라 실패-닫힘이 아니라 "판정 안 함"으로 정직하게 둔다.
 async function resolveNeedsImage(agent) {
-  const lexical = needsImageLexical(agent);
-  if (imageJudgeVetoed(agent)) return { image: lexical, source: "deterministic" };
+  // 팀/역할 하드 가드는 구조적 판단(키워드 아님) — 판정 대상에서 제외하고 결정적으로 not-image.
+  if (imageJudgeVetoed(agent)) return { image: false, source: "deterministic" };
   let judgment;
   try {
     judgment = require("./agentlas-judgment.cjs");
   } catch {
     judgment = null;
   }
-  if (!judgment || !judgment.hasJudgmentRunner()) return { image: lexical, source: "fallback" };
+  if (!judgment || !judgment.hasJudgmentRunner()) return { image: false, source: "unavailable", decided: false };
   const input = imageJudgeInput(agent);
   const cached = imageVerdicts.get(input);
   if (cached) return cached;
@@ -136,9 +140,10 @@ async function resolveNeedsImage(agent) {
       "producing them: builders, orchestrators, PMs, curators, and coordination brains that commission or " +
       "delegate image work are 'not-image'. Refusals or prohibitions ('never generate images') declare the " +
       "opposite of a capability.",
-    fallback: [lexical ? "image" : "not-image"],
+    fallback: [],
   });
-  if (verdict.source !== "llm" || !verdict.labels.length) return { image: lexical, source: "fallback" };
+  // 모델이 판정을 못 냈다 → 어휘 폴백 없이 "판정 불가". 캐시하지 않아 이후 모델 연결 시 재판정한다.
+  if (verdict.source !== "llm" || !verdict.labels.length) return { image: false, source: "unavailable", decided: false };
   const out = { image: verdict.labels[0] === "image", source: "llm", reason: verdict.reason || "" };
   imageVerdicts.set(input, out);
   if (imageVerdicts.size > IMAGE_VERDICT_CACHE_MAX) {
@@ -148,14 +153,15 @@ async function resolveNeedsImage(agent) {
   return out;
 }
 // Does this agent's job involve generating/handling images? Sync surface for badges and
-// autoRuntimeFor: model verdict from the warm cache wins; miss = deterministic lexical fallback.
+// autoRuntimeFor. House rule (2026-07-25): only a warm MODEL verdict counts as "image".
+// A cache miss (no model judgment / not warmed) is treated as "not specifically an image
+// agent" so a keyword guess can never hijack the runtime to gemini/codex. The lexical
+// scorer (needsImageLexical) survives only as the hint source for the judge, not a decision.
 function needsImage(agent) {
   if (!agent) return false;
-  if (!imageJudgeVetoed(agent)) {
-    const cached = imageVerdicts.get(imageJudgeInput(agent));
-    if (cached) return cached.image;
-  }
-  return needsImageLexical(agent);
+  if (imageJudgeVetoed(agent)) return false;
+  const cached = imageVerdicts.get(imageJudgeInput(agent));
+  return cached ? cached.image : false;
 }
 // 라벨용 — 이 에이전트의 현재 이미지 판정이 모델("llm")인지 결정적 경로("deterministic")인지.
 function imageJudgmentSource(agent) {

package/engine/agentlas-workforce.cjs

@@ -1643,7 +1643,13 @@ function create(deps = {}) {
   }
 
   async function runModel(runtime, system, prompt, context) {
-    if (typeof D.runModel === "function") return normalizeModelText(await D.runModel({ runtime, system, prompt, context }));
+    const localContextSlice = typeof D.projectContextSlice === "function"
+      ? D.projectContextSlice(context.cwd, context.task || "")
+      : "";
+    const effectiveSystem = localContextSlice
+      ? `${system}\n\n${localContextSlice}`
+      : system;
+    if (typeof D.runModel === "function") return normalizeModelText(await D.runModel({ runtime, system: effectiveSystem, prompt, context }));
     if (runtime.mode === "cli") {
       const authorityMode = context.authorityMode || "no-authority";
       if (runtime.kind === "codex" && authorityMode === "no-authority") {
@@ -1658,7 +1664,7 @@ function create(deps = {}) {
           "Gemini CLI workforce execution is blocked until this host proves an empty built-in and MCP tool inventory",
         );
       }
-      return normalizeModelText(await D.captureRuntime(runtime.kind, system, prompt, {
+      return normalizeModelText(await D.captureRuntime(runtime.kind, effectiveSystem, prompt, {
         cwd: context.cwd,
         env: context.env,
         permission: context.permission,
@@ -1667,7 +1673,7 @@ function create(deps = {}) {
         authorityMode,
       }));
     }
-    return normalizeModelText(await D.runApi(runtime.backend, context.modelPin || runtime.model, system, prompt));
+    return normalizeModelText(await D.runApi(runtime.backend, context.modelPin || runtime.model, effectiveSystem, prompt));
   }
 
   async function callHubTool(name, args) {
@@ -1888,7 +1894,15 @@ function create(deps = {}) {
     const env = typeof D.buildChildEnv === "function" ? await D.buildChildEnv(db, {
       projectPath: ctx.projectPath || null, permission, cwd, lang: ui.lang,
     }) : process.env;
-    const modelContext = { cwd, permission, env, modelPin: ctx.modelPin || null, effortPin: ctx.effortPin, authorityMode: "no-authority" };
+    const modelContext = {
+      cwd,
+      permission,
+      env,
+      modelPin: ctx.modelPin || null,
+      effortPin: ctx.effortPin,
+      authorityMode: "no-authority",
+      task,
+    };
     const prompts = buildPrompts(task, identity);
     const runId = `workforce-run:${crypto.randomUUID()}`;
     const provider = runtime.mode === "cli" ? runtime.kind : runtime.backend;

package/engine/agentlas.cjs

@@ -573,6 +573,34 @@ function directRouteChoice(lang) {
       : "this is a general request that needs no specialist agent",
   };
 }
+// 연결 모델 없음 직답 — 하우스 룰: 모델이 없으면 어휘(단어목록)로 전문 에이전트를 고르지
+// 않는다. 어떤 전문 에이전트가 맞는지 "판단하지 못한다"고 정직하게 밝히고 기본 어시스턴트로
+// 답한다. routeSource는 "deterministic"(=판정 없음)으로 유지하되 noModel 플래그로 구분해
+// 사용자에게 "모델 연결" 안내를 띄운다. 이 경로가 조용히 키워드로 결정하던 것이 사고의 근본.
+// reason 구분: "no_runtime"=연결된 런타임이 아예 없음(드묾), "model_unavailable"=런타임은
+// 연결됐지만 그 한 번의 판정이 타임아웃/불량 응답으로 실패(현실적 케이스). 모델이 거의 항상
+// 연결돼 있으므로 후자를 "연결 안 됨"으로 오인시키지 않도록 문구를 다르게 준다.
+function noModelRouteChoice(lang, reason = "no_runtime") {
+  const resolvedLang = lang || prefsLang();
+  const message = reason === "model_unavailable"
+    ? (resolvedLang === "ko"
+        ? "연결된 모델이 제때 응답하지 않아 어떤 전문 에이전트가 맞는지 판단하지 못했습니다. 잠시 후 다시 시도하거나 모델 상태를 확인해 주세요. 지금은 기본 어시스턴트로 답합니다"
+        : "the connected model didn't answer in time, so I couldn't judge which specialist agent fits; retry in a moment or check the model, and I'll answer with the default assistant for now")
+    : (resolvedLang === "ko"
+        ? "연결된 모델이 없어 어떤 전문 에이전트가 맞는지 판단하지 못했습니다. 모델을 연결하면 자동 라우팅이 됩니다. 지금은 기본 어시스턴트로 답합니다"
+        : "no model is connected, so I couldn't judge which specialist agent fits; connect a model to enable auto-routing, and I'll answer with the default assistant for now");
+  return {
+    direct: true,
+    agent: null,
+    score: 0,
+    terms: [],
+    strong: false,
+    noModel: true,
+    noModelReason: reason,
+    routeSource: "deterministic",
+    reason: message,
+  };
+}
 // 직답 모드 시스템 프롬프트 — 페르소나·라우팅 오염 없이 현재 런타임 그대로 답한다.
 function directSystemPrompt(lang) {
   const resolvedLang = lang || prefsLang();
@@ -630,8 +658,10 @@ function autoRouteAgent(db, prompt, lang) {
 // direct) 중에서 의미로 하나를 고른다 — 어휘 점수 0점인 에이전트(아랍어 등 어떤 언어의
 // 요청이든)도 모델은 뽑을 수 있다. 닫힌형 가드는 결정적으로 유지: 잡담 short-circuit
 // (isTrivialRoutePrompt)과 경로 스트리핑(ROUTE_PATH_RE)은 모델 호출 전에 그대로 적용.
-// 러너 없음/타임아웃/정크 → 기존 어휘 라우팅(autoRouteAgent)을 routeSource:"deterministic"
-// 으로 라벨해 반환한다 — 조용한 폴백 금지(라우트 노트에 판정 주체가 찍힌다).
+// 러너 없음/타임아웃/정크 → 어휘로 전문 에이전트를 고르지 않는다. 연결 모델이 없으면
+// "판단 못 함"을 정직하게 밝히고 기본 어시스턴트로 직답한다(noModelRouteChoice) —
+// 어휘 스코어러(autoRouteAgent/rankRouteAgents)는 후보 모집 전용이지 반환 결정이 아니다.
+// routeSource:"deterministic"은 "판정 없음"을 뜻하는 기계 플래그로만 남는다(키워드 픽 아님).
 const ROUTE_JUDGE_CANDIDATE_CAP = 30;
 const ROUTE_JUDGE_DIRECT_LABEL = "direct";
 const ROUTE_JUDGE_META_LABEL = "meta-builder";
@@ -639,7 +669,6 @@ const ROUTE_JUDGE_APP_LABEL = "app-builder";
 const APP_BUILDER_ROUTE_SLUG = "agentlas-app-builder";
 async function resolveAutoRoute(db, prompt, lang) {
   const resolvedLang = lang || prefsLang();
-  const prefilter = autoRouteAgent(db, prompt, resolvedLang);
   ensureJudgmentRunnerInstalled(db);
   let judgment;
   try {
@@ -647,13 +676,15 @@ async function resolveAutoRoute(db, prompt, lang) {
   } catch {
     judgment = null;
   }
-  if (!judgment || !judgment.hasJudgmentRunner()) return { ...prefilter, routeSource: "deterministic" };
+  // 연결 모델 없음 → 어휘로 전문 에이전트를 고르지 않는다. 정직하게 "판단 못 함" + 모델 연결 안내.
+  if (!judgment || !judgment.hasJudgmentRunner()) return noModelRouteChoice(resolvedLang, "no_runtime");
   const promptText = routeNormalize(routeStripPaths(prompt));
-  // 잡담("hi")까지 모델에 물으면 매 턴이 느려진다 — 정확 매칭 가드는 닫힌형이라 결정적 유지.
-  if (!promptText.trim() || isTrivialRoutePrompt(promptText)) return { ...prefilter, routeSource: "deterministic" };
+  // 잡담("hi")은 닫힌형 결정적 가드로 직답 — 모델은 연결돼 있으니 "모델 연결" 안내는 필요 없다.
+  if (!promptText.trim() || isTrivialRoutePrompt(promptText)) return { ...directRouteChoice(resolvedLang), routeSource: "deterministic" };
   const ranked = rankRouteAgents(db, prompt, resolvedLang);
   const meta = resolveMetaBuilder(db);
-  if (!ranked.length && !meta) return { ...prefilter, routeSource: "deterministic" };
+  // 라우팅할 후보 자체가 없음(설치 에이전트 0) → 직답. 모델은 연결돼 있으니 일반 직답 사유.
+  if (!ranked.length && !meta) return { ...directRouteChoice(resolvedLang), routeSource: "deterministic" };
   // App Builder는 합성 라벨로만 제시한다(동의 핸드셰이크가 걸린 특수 라우트임을 모델에 명시).
   const appBuilder = ranked.find((r) => r.agent.slug === APP_BUILDER_ROUTE_SLUG) || null;
   const candidates = ranked.filter((r) => r.agent.slug !== APP_BUILDER_ROUTE_SLUG).slice(0, ROUTE_JUDGE_CANDIDATE_CAP);
@@ -707,7 +738,9 @@ async function resolveAutoRoute(db, prompt, lang) {
     // model still aborts cleanly at this deadline rather than hanging forever.
     timeoutMs: 40000,
   });
-  if (verdict.source !== "llm" || !verdict.labels.length) return { ...prefilter, routeSource: "deterministic" };
+  // 모델이 판정을 못 냈다(러너 실패/타임아웃/정크 응답) → 어휘 픽으로 떨어지지 않는다.
+  // 연결 모델이 사실상 판단하지 못한 것이므로 "판단 못 함" 직답으로 정직하게 종결한다.
+  if (verdict.source !== "llm" || !verdict.labels.length) return noModelRouteChoice(resolvedLang, "model_unavailable");
   const picked = verdict.labels[0];
   const reason =
     verdict.reason ||
@@ -717,15 +750,24 @@ async function resolveAutoRoute(db, prompt, lang) {
     return { agent: meta, score: 1000, strong: true, terms: [], reason, routeSource: "llm" };
   }
   const chosen = picked === ROUTE_JUDGE_APP_LABEL ? appBuilder : bySlug.get(picked);
-  if (!chosen) return { ...prefilter, routeSource: "deterministic" };
+  // 모델이 라벨을 골랐지만 설치 에이전트로 해석되지 않음(경계 케이스) → 어휘 픽 대신 직답.
+  if (!chosen) return { ...directRouteChoice(resolvedLang), routeSource: "deterministic" };
   // 모델 확답은 strong 계약을 충족한다 — 어휘 근거(terms/score)는 참고로 보존.
   return { ...chosen, strong: true, reason, routeSource: "llm" };
 }
 // 라우트 영수증 라벨 — 누가 최종 판정했는지 반드시 찍는다(조용한 폴백 금지 하우스 룰).
+// noModel 경로는 사유(reason)에 이미 "모델 연결" 안내가 담겨 있으니 짧은 기계 라벨만 덧붙인다.
+// 그 외 deterministic(잡담·후보 없음: 모델은 연결됨)은 사유가 이미 설명하므로 라벨을 붙이지 않는다.
 function routeJudgeSourceNote(choice, lang) {
   if (!choice || !choice.routeSource) return "";
   if (choice.routeSource === "llm") return lang === "ko" ? " (판정: 연결 모델)" : " (judged by the connected model)";
-  return lang === "ko" ? " (판정: 결정적 폴백 — 연결 모델 없음)" : " (deterministic fallback — no connected-model verdict)";
+  if (choice.noModel) {
+    if (choice.noModelReason === "model_unavailable") {
+      return lang === "ko" ? " (판정 없음 — 모델 응답 없음)" : " (no judgment — model did not answer)";
+    }
+    return lang === "ko" ? " (판정 없음 — 연결 모델 없음)" : " (no judgment — no model connected)";
+  }
+  return "";
 }
 function autoRouteNote(choice, lang) {
   const resolvedLang = lang || prefsLang();
@@ -8292,7 +8334,39 @@ function ensureTerminalProjectForExecutionCli(db, projectPath, permission = PERM
   if (permission === "read") return activeProjectPath(db, { projectPath: root });
   return activeProjectPath(db, { projectPath: root, activate: true, reason });
 }
-function cliMemoryContext(db, projectPath, agentId = null) {
+
+function cliProjectContextSlice(projectPath, task) {
+  if (!projectPath || !String(task || "").trim()) return "";
+  try {
+    const coreRoot = resolveCoreRuntimeRoot();
+    if (!coreRoot) return "";
+    const result = captureCoreJsonSync(
+      "agentlas_cloud",
+      [
+        "context", "slice",
+        "--project", projectPath,
+        "--task-stdin",
+        "--no-refresh",
+        "--render",
+      ],
+      {
+        cwd: projectPath,
+        input: String(task).slice(0, 12_000),
+        timeout: 4_000,
+      },
+      coreRoot,
+    );
+    return result
+      && result.schemaVersion === "agentlas.context-slice.v1"
+      && typeof result.rendered === "string"
+      ? result.rendered.trim()
+      : "";
+  } catch {
+    return "";
+  }
+}
+
+function cliMemoryContext(db, projectPath, agentId = null, task = "") {
   const sections = [];
   const arch = loadArch();
   ensureMemoryContextColumn(db);
@@ -8305,6 +8379,8 @@ function cliMemoryContext(db, projectPath, agentId = null) {
         if (s.trim()) sections.push(`### Project memory (${projectPath})\n${s.trim()}`);
       }
     } catch { /* ignore */ }
+    const contextSlice = cliProjectContextSlice(projectPath, task);
+    if (contextSlice) sections.push(contextSlice);
   }
   if (tableExists(db, "memory_entries")) {
     try {
@@ -8472,7 +8548,7 @@ function augmentSystem(db, baseSystem, ctx, withEmitter, request = "") {
   sys = langDirective(lang) + (sys ? "\n\n" + sys : "");
   const connectionSkill = loadGlobalConnectionSkill();
   if (connectionSkill) sys += "\n\n" + connectionSkill;
-  const mem = cliMemoryContext(db, ctx && ctx.projectPath, ctx && ctx.agentId);
+  const mem = cliMemoryContext(db, ctx && ctx.projectPath, ctx && ctx.agentId, request);
   if (mem) sys += "\n\n" + mem;
   if (withEmitter) {
     sys += "\n\n" + memoryEmitterPromptFor(request, arch, ctx && ctx.turnId, ctx && ctx.permission);
@@ -8623,8 +8699,9 @@ const RUNTIME_BIN = {
  * Wire the resident judgment service to whatever runtime the user actually has connected.
  * This is what lets classification be decided by MEANING instead of by a wordlist: the
  * judge asks the connected model, and the old keyword maps are passed only as hints. It is
- * invisible to the user (no output, read-only, no tools) and every judged call falls back
- * to the deterministic prefilter when no runtime answers.
+ * invisible to the user (no output, read-only, no tools). When no runtime answers, judged
+ * callers do NOT keyword-decide: routing/intent go to the plain assistant with a "connect a
+ * model" note, capability inference returns undecided, and gates fail closed.
  */
 function installJudgmentRunner(db, rt) {
   let judgment;
@@ -8712,6 +8789,52 @@ function ensureJudgmentRunnerInstalled(db) {
   }
 }
 
+// Hand the embedded Agentlas OS runtime a UNIVERSAL judge callback so ITS
+// resident judge (content-guard, pipeline, research, privacy) decides by meaning
+// for EVERY connected runtime — Claude/Codex/Gemini CLIs, all BYOK providers, and
+// local models alike — with no model hardcoded and no provider code duplicated in
+// Python. The OS engine stays BYOC: it never calls a model on its own; it only
+// invokes this host command, which runs the user's own connected runtime. If no
+// runtime resolves, the env is left unset and OS judged sites honestly report
+// "connect a model" instead of keyword-deciding.
+function exportOsJudgeRuntimeEnv(db) {
+  try {
+    const ar = activeRuntime(db);
+    if (!ar) return;
+    const config = {
+      kind: "host-cmd",
+      cmd: [process.execPath, path.resolve(__dirname, "..", "bin", "agentlas.cjs"), "__judge"],
+    };
+    process.env.AGENTLAS_JUDGE_RUNTIME = JSON.stringify(config);
+  } catch {
+    // Leave the env unset — OS judged sites then report "connect a model" rather
+    // than keyword-deciding.
+  }
+}
+
+// Hidden helper the embedded OS runtime calls for one-shot classification. Reads
+// {"system","prompt"} JSON on stdin, runs the connected runtime (any provider/CLI)
+// as a silent read-only turn, prints the reply text on stdout. Judgment is a
+// lightweight task, so this uses whatever model the user already has connected —
+// no hardcoded model, no separate credentials.
+async function cmdInternalJudge(db) {
+  let raw = "";
+  try {
+    raw = await readStdin();
+    const { system, prompt } = JSON.parse(raw || "{}");
+    if (!prompt || !prompt.trim()) { process.stdout.write(""); return; }
+    let judgment;
+    try { judgment = require("./agentlas-judgment.cjs"); } catch { judgment = null; }
+    ensureJudgmentRunnerInstalled(db);
+    if (!judgment || !judgment.hasJudgmentRunner()) { process.stdout.write(""); return; }
+    // Reuse the installed runner directly for an opaque system+prompt turn.
+    const text = await judgment.runRaw(String(system || ""), String(prompt), 40000);
+    process.stdout.write(text || "");
+  } catch {
+    process.stdout.write("");
+  }
+}
+
 function resolveRuntime(db, override) {
   const ar = activeRuntime(db);
   const activeCli = ar && RUNTIME_BIN[ar.kind]
@@ -9714,7 +9837,7 @@ function buildHelpers(db) {
     autoRouteNote: (choice, lang) => autoRouteNote(choice, lang),
     autoRoutePreamble: (choice, lang) => autoRoutePreamble(choice, lang),
     directSystemPrompt: (lang) => directSystemPrompt(lang),
-    cliMemoryContext: (db_, pp, agentId) => cliMemoryContext(db_, pp, agentId),
+    cliMemoryContext: (db_, pp, agentId, task) => cliMemoryContext(db_, pp, agentId, task),
     importLocal: (db_, p) => importLocalFolderCli(db_, p),
     // REPL-safe public Hub install: fail()(process.exit) 대신 Error를 throw 해 REPL이 직접 렌더하게 한다.
     cloudInstall: async (db_, slug) => {
@@ -10196,6 +10319,7 @@ function workforce() {
       fetchHub: (url, init) => fetchHubCli(url, init),
       listWorkforceTools: listWorkforceToolsCli,
       supportsWorkforceToolAuthority: async () => false,
+      projectContextSlice: cliProjectContextSlice,
       prefsLang,
       out,
     });
@@ -11860,6 +11984,7 @@ function cmdHelp() {
       "  research <sub>           Research Engine: status|gather|search|read|plan",
       "  career-graph <sub>       source routing index: status|list|add",
       "  ontology <sub>           project knowledge: status|list|add   (REPL: /ontology)",
+      "  context <sub>            project map: refresh|locate|refs|slice|impact|verify",
       "  journal <sub>            Stormbreaker run journal: status|verify|repair|gate",
       "",
       hdr("ACCOUNT & OPS"),
@@ -11940,6 +12065,11 @@ async function main() {
   // in the REPL and in one-shot commands alike — instead of silently falling to
   // the deterministic label until executeOnce eventually installs it.
   ensureJudgmentRunnerInstalled(db);
+  // Hidden judge-callback for the embedded OS runtime — handle before exporting
+  // the env or dispatching, and never re-enter the OS from here.
+  if (cmd === "__judge") return cmdInternalJudge(db);
+  // Hand the same connected model to the embedded Agentlas OS runtime's judge.
+  exportOsJudgeRuntimeEnv(db);
 
   // 인자 없이 `agentlas` → 에이전트 1개면 바로 대화형, 아니면 목록 + 사용법
   if (cmd === "") {
@@ -11969,6 +12099,17 @@ async function main() {
     case "memory":
       // Phase 1b: 기존 마크다운 메모리 → 공유 agentlas.sqlite 이관(dry-run 기본, --apply).
       return require("./agentlas-memory-import.cjs").cmdMemory({ db, args: rest.slice(1), out, fail });
+    case "context": {
+      if (!rest[1]) return fail("usage: agentlas context refresh|locate|refs|slice|impact|verify [options]");
+      const cwd = projectCwd();
+      ensureTerminalProjectForExecutionCli(db, cwd, PERMISSION, "terminal-context");
+      const contextArgs = rest.slice(1);
+      const hasProject = contextArgs.includes("--project");
+      return parity().cmdHep(
+        db,
+        ["context", ...contextArgs, ...(hasProject ? [] : ["--project", cwd])],
+      );
+    }
     case "evolve":
       // Phase 2/2+: 데스크탑 트리거가 만든 성장 제안 검토·적용·되돌리기(공유 DB).
       return require("./agentlas-evolution.cjs").cmdEvolve({ db, args: rest.slice(1), out, fail, agentFolder });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentlas",
-  "version": "0.9.7",
+  "version": "0.9.9",
   "description": "Agentlas agent terminal — chat with your installed AI agents and teams from the terminal, Claude Code style. Standalone: no desktop app required.",
   "bin": {
     "agentlas": "bin/agentlas.cjs"