agentlas 0.9.7 → 0.9.8

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # 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

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,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();
@@ -8623,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;
@@ -8712,6 +8755,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]
@@ -11940,6 +12029,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 === "") {

package/package.json

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