agentlas 0.9.6 → 0.9.8

package/CHANGELOG.md

@@ -1,5 +1,35 @@
 # Changelog
 
+## 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
+  subprocess runtimes. Previously, when your connected runtime was Ollama or a
+  BYOK API model, every route, intent, and classification silently used the
+  deterministic wordlist fallback because the judge was wired to null — so a
+  non-English request the keyword lists could not read never got a model
+  verdict. The judge now runs on whatever runtime you actually have connected,
+  and its timeout signal aborts the underlying request cleanly.
+- Fix: the judge is installed at startup, before the first routing decision.
+  It was previously wired only inside the run turn, which happens after routing,
+  so the very first auto-route in a one-shot always fell back.
+- Routing gives the model a more generous deadline (a one-shot pre-run gate), so
+  a slower local model is judged rather than frequently falling back. When it
+  still cannot answer in time, the route receipt says so explicitly.
+
 ## 0.9.6 — 2026-07-25
 
 - Agent and App Builder routing is now decided by the connected model: lexical

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.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,20 +669,22 @@ 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 {
     judgment = require("./agentlas-judgment.cjs");
   } 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);
@@ -700,8 +732,15 @@ async function resolveAutoRoute(db, prompt, lang) {
     ].join("\n"),
     multi: false,
     fallback: [],
+    // Routing is a one-shot pre-run gate: correctness matters more than latency,
+    // and a local 30B model with a full roster can need well over the 20s default.
+    // The judge's abort signal is threaded into the request, so a genuinely hung
+    // 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 ||
@@ -711,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();
@@ -8617,8 +8665,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;
@@ -8627,32 +8676,129 @@ function installJudgmentRunner(db, rt) {
   } catch {
     return;
   }
-  if (!rt || rt.mode !== "cli" || !RUNTIME_BIN[rt.kind]) {
-    judgment.setJudgmentRunner(null);
+  // CLI runtime (claude-code/codex/gemini): the judge runs a silent native turn.
+  if (rt && rt.mode === "cli" && RUNTIME_BIN[rt.kind]) {
+    judgment.setJudgmentRunner(async ({ system, prompt, signal }) => {
+      const { runNativeTurn } = require("./agentlas-native-host.cjs");
+      const { Ui } = require("./agentlas-ui.cjs");
+      const silent = new Ui({ lang: prefsLang(), quiet: true });
+      for (const method of ["write", "warn", "info", "tool", "result", "status", "line"]) {
+        if (typeof silent[method] === "function") silent[method] = () => {};
+      }
+      const res = await runNativeTurn({
+        kind: rt.kind,
+        bin: RUNTIME_BIN[rt.kind],
+        prompt,
+        systemPrompt: system,
+        cwd: projectCwd(),
+        permission: "read",
+        session: {},
+        ui: silent,
+        env: process.env,
+        signal,
+      });
+      if (res && res.error) return "";
+      return (res && res.text) || "";
+    });
     return;
   }
-  judgment.setJudgmentRunner(async ({ system, prompt, signal }) => {
-    const { runNativeTurn } = require("./agentlas-native-host.cjs");
-    const { Ui } = require("./agentlas-ui.cjs");
-    const silent = new Ui({ lang: prefsLang(), quiet: true });
-    for (const method of ["write", "warn", "info", "tool", "result", "status", "line"]) {
-      if (typeof silent[method] === "function") silent[method] = () => {};
-    }
-    const res = await runNativeTurn({
-      kind: rt.kind,
-      bin: RUNTIME_BIN[rt.kind],
-      prompt,
-      systemPrompt: system,
-      cwd: projectCwd(),
-      permission: "read",
-      session: {},
-      ui: silent,
-      env: process.env,
-      signal,
+
+  // API runtime (BYOK / Ollama): the judge uses the same one-shot API path the
+  // rest of the terminal uses, so "the connected model decides" holds for the
+  // user's actual runtime — not only CLI subprocess runtimes. Without this, an
+  // Ollama/BYOK user silently gets the deterministic wordlist fallback for every
+  // route, intent, and classification decision.
+  if (rt && rt.mode === "api" && rt.backend) {
+    judgment.setJudgmentRunner(async ({ system, prompt, signal }) => {
+      // Thread the judge's timeout signal into the actual HTTP request so a slow
+      // model aborts the fetch instead of hanging past the deadline.
+      const baseFetch = globalThis.fetch;
+      const fetchImpl = typeof baseFetch === "function" && signal
+        ? (url, init) => baseFetch(url, { ...(init || {}), signal })
+        : baseFetch;
+      try {
+        return await runApi(rt.backend, rt.model, system, prompt, { fetch: fetchImpl });
+      } catch {
+        return "";
+      }
     });
-    if (res && res.error) return "";
-    return (res && res.text) || "";
-  });
+    return;
+  }
+
+  judgment.setJudgmentRunner(null);
+}
+
+// Make sure the resident judge can reach the connected model BEFORE the first
+// judged decision (routing, image capability, task class). The only other
+// install site is inside executeOnce, which runs AFTER routing — so a one-shot
+// `run`/auto-route would always fall to the deterministic label without this.
+// Uses the active runtime (CLI or API/Ollama/BYOK); a pinned override still
+// reinstalls in executeOnce for the actual task turn.
+function ensureJudgmentRunnerInstalled(db) {
+  let judgment;
+  try {
+    judgment = require("./agentlas-judgment.cjs");
+  } catch {
+    return;
+  }
+  if (judgment.hasJudgmentRunner()) return;
+  try {
+    const ar = activeRuntime(db);
+    let rt = null;
+    if (ar && RUNTIME_BIN[ar.kind]) rt = { mode: "cli", kind: ar.kind, model: ar.model || null };
+    else if (ar && ar.kind === "byok" && ar.backend) rt = { mode: "api", backend: ar.backend, model: ar.model };
+    else if (ar && ar.kind === "ollama") rt = { mode: "api", backend: "ollama", model: ar.model };
+    if (rt) installJudgmentRunner(db, rt);
+  } catch {
+    // No resolvable runtime → leave the runner unset; judged sites use their
+    // labeled deterministic fallback rather than crashing.
+  }
+}
+
+// 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) {
@@ -11878,6 +12024,17 @@ async function main() {
   // Agentlas 아키텍처 빌트인 에이전트를 보장(앱과 동일, 멱등·버전 게이팅). 스키마가 준비됐을 때만.
   try { seedBuiltins(db); } catch { /* best-effort */ }
 
+  // Wire the resident judge to the connected runtime up front, so the FIRST
+  // routing / image-capability / task-class decision is judged by the model —
+  // 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 === "") {
     const agents = listAgents(db);
@@ -12140,6 +12297,9 @@ module.exports = {
   autoRouteNote,
   autoRoutePreamble,
   directSystemPrompt,
+  // Test bridge: prove the resident judge is wired to API/Ollama/BYOK runtimes,
+  // not only CLI subprocess runtimes.
+  installJudgmentRunner,
   // Hub 플러그인 설치 회귀 테스트 표면 — 레포 URL을 MCP 서버로 등록하지 않는 규칙 검증용.
   pluginMcpRowCli,
   planPluginMcpInstallCli,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentlas",
-  "version": "0.9.6",
+  "version": "0.9.8",
   "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"