agentlas 0.9.4 → 0.9.6

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## 0.9.6 — 2026-07-25
+
+- Agent and App Builder routing is now decided by the connected model: lexical
+  scores only recruit candidates, and the model can route a request the keyword
+  lists never matched (any language). The App Builder consent handshake is
+  unchanged, and every route receipt says whether the connected model or the
+  deterministic fallback decided.
+- Whether an agent produces images (and therefore which runtime runs it) is now
+  judged by the connected model from the agent's own identity, with the old
+  keyword list demoted to reference hints. Conservative non-image vetoes stay.
+- Task classification, routing, and image judgments all fail over to the
+  previous deterministic behavior — explicitly labeled — when no connected
+  model is available.
+- Publication gates pin the Agentlas OS v1.1.61 runtime commit, which ships the
+  same judgment-engine migration across the bundled Core runtime.
+
 ## 0.9.4 — 2026-07-23
 
 - `plugin add` no longer registers a code-hosting page (GitHub/GitLab/Bitbucket

package/engine/agentlas-capabilities.cjs

@@ -63,7 +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; // 로컬 임포트 상한과 동일 — 클라우드 무제한 프롬프트의 전문 스캔 방지
-function needsImage(agent) {
+// 어휘 판정 — 연결 모델이 없을 때의 결정적 폴백이자, 모델 판정 전의 참고 프리필터.
+// 하우스 룰: 단어목록은 최종 결정을 내리지 않는다. 최종 판정은 resolveNeedsImage가
+// 상주 판정 서비스(judgeLabels)에 묻고, 이 함수는 그 폴백으로만 살아남는다.
+function needsImageLexical(agent) {
   if (!agent) return false;
   if (NON_IMAGE_ROLES.has(String(agent.role || "").toLowerCase())) return false;
   // 정체성 존은 사용자가 선언한 이름/태그라인만 — slug는 폴더명에서 기계 파생되므로
@@ -87,6 +90,82 @@ function needsImage(agent) {
   return false;
 }
 
+// ── 상주 판정 서비스 배선 — 모델이 의미로 최종 판정, IMAGE_HINTS는 참고 힌트 ──────
+// needsImage 호출자(REPL 배지·autoRuntimeFor·routingNote)는 동기라서 warm-cache 패턴:
+// 비동기 경로(resolveNeedsImage)가 먼저 판정해 캐시를 데우고, 동기 needsImage는 캐시만
+// 읽는다. 캐시 미스 = 어휘 폴백 그대로 — imageJudgmentSource가 어느 쪽이었는지 라벨한다.
+const IMAGE_VERDICT_CACHE_MAX = 200;
+const imageVerdicts = new Map();
+function imageJudgeInput(agent) {
+  const identity = [agent.slug, agent.name, agent.name_en, agent.tagline, agent.tagline_en].filter(Boolean).join(" | ");
+  return `${identity}\n---\n${String(agent.system_prompt || "").slice(0, 6000)}`;
+}
+// 역할/팀 베토는 보수적 하드 가드로 유지 — 조율 두뇌가 부서 소개 문장("Design HQ")으로
+// 이미지 팀이 되던 사고(vibecoder/appbridge)는 모델 판정 대상에서 아예 뺀다.
+function imageJudgeVetoed(agent) {
+  if (!agent) return true;
+  if (NON_IMAGE_ROLES.has(String(agent.role || "").toLowerCase())) return true;
+  if (String(agent.entity_kind || "").toLowerCase() === "team") return true;
+  return false;
+}
+// 이 에이전트의 직무가 이미지 생산인지를 연결 모델이 의미로 판정한다.
+// 러너 없음/타임아웃/정크 → 어휘 판정을 "fallback"으로 라벨해 반환 (조용한 회귀 금지).
+async function resolveNeedsImage(agent) {
+  const lexical = needsImageLexical(agent);
+  if (imageJudgeVetoed(agent)) return { image: lexical, source: "deterministic" };
+  let judgment;
+  try {
+    judgment = require("./agentlas-judgment.cjs");
+  } catch {
+    judgment = null;
+  }
+  if (!judgment || !judgment.hasJudgmentRunner()) return { image: lexical, source: "fallback" };
+  const input = imageJudgeInput(agent);
+  const cached = imageVerdicts.get(input);
+  if (cached) return cached;
+  const verdict = await judgment.judgeLabels({
+    kind: "agent-produces-images",
+    question:
+      "Does this agent's OWN job include producing images (generating or designing visual assets such as thumbnails, banners, logos, posters, product shots)?",
+    labels: ["image", "not-image"],
+    multi: false,
+    input,
+    hints: { image: IMAGE_HINTS.map((re) => re.source) },
+    guidance:
+      "Judge the agent's role from its identity and instructions, in any language. Mentioning images is not " +
+      "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"],
+  });
+  if (verdict.source !== "llm" || !verdict.labels.length) return { image: lexical, source: "fallback" };
+  const out = { image: verdict.labels[0] === "image", source: "llm", reason: verdict.reason || "" };
+  imageVerdicts.set(input, out);
+  if (imageVerdicts.size > IMAGE_VERDICT_CACHE_MAX) {
+    const oldest = imageVerdicts.keys().next().value;
+    if (oldest !== undefined) imageVerdicts.delete(oldest);
+  }
+  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.
+function needsImage(agent) {
+  if (!agent) return false;
+  if (!imageJudgeVetoed(agent)) {
+    const cached = imageVerdicts.get(imageJudgeInput(agent));
+    if (cached) return cached.image;
+  }
+  return needsImageLexical(agent);
+}
+// 라벨용 — 이 에이전트의 현재 이미지 판정이 모델("llm")인지 결정적 경로("deterministic")인지.
+function imageJudgmentSource(agent) {
+  if (agent && !imageJudgeVetoed(agent) && imageVerdicts.has(imageJudgeInput(agent))) return "llm";
+  return "deterministic";
+}
+function clearImageJudgments() {
+  imageVerdicts.clear();
+}
+
 // Auto-pick a runtime spec for an agent given installed CLI kinds and the session default spec.
 // Image agents route to an installed image-capable runtime; otherwise keep the session default.
 function autoRuntimeFor(agent, { installedKinds, activeSpec }) {
@@ -103,4 +182,17 @@ function badge(spec) {
   return c.image ? "🖼" : "";
 }
 
-module.exports = { RUNTIME_CAPS, CLI_KINDS, capsFor, specOf, runtimeFromSpec, needsImage, autoRuntimeFor, badge };
+module.exports = {
+  RUNTIME_CAPS,
+  CLI_KINDS,
+  capsFor,
+  specOf,
+  runtimeFromSpec,
+  needsImage,
+  needsImageLexical,
+  resolveNeedsImage,
+  imageJudgmentSource,
+  clearImageJudgments,
+  autoRuntimeFor,
+  badge,
+};

package/engine/agentlas-evolution.cjs

@@ -0,0 +1,299 @@
+"use strict";
+
+// `agentlas evolve [list|apply <id>|revert <id>]` — Phase 2 / 2+ (terminal 표면).
+//
+// 데스크탑 트리거가 만든 "성장 제안"을 공유 agentlas.sqlite에서 읽어 검토·적용·되돌린다.
+// hep/터미널 세션은 UI가 없으므로 이 명령이 4표면 발화 UX의 터미널 창구다.
+//   list  — 대기 중(고위험 candidate) + 자동적용(저위험) 제안을 사람이 읽는 3줄로.
+//   apply <id>  — 고위험 candidate를 명시 승인해 프롬프트에 적용(런타임 authority=system_prompt + 파일).
+//   revert <id> — 적용된 제안을 되돌린다.
+//
+// 적용/되돌리기 게이트는 도구 무관한 "타깃 파일 내용 해시(before_hash/after_hash)"로만 판정한다
+// (데스크탑이 생성 시 저장한 sha256). 그래서 데스크탑이 자동적용한 저위험 제안도 터미널에서
+// 안전하게 되돌릴 수 있다. 어떤 실패도 폴백 없이 상태로 노출한다.
+
+const fs = require("node:fs");
+const path = require("node:path");
+const { createHash, randomUUID } = require("node:crypto");
+
+function sha256(content) {
+  return createHash("sha256").update(String(content), "utf8").digest("hex");
+}
+
+const ABSENT_TARGET_HASH = sha256("agentlas:absent-agent-asset:v1");
+const RULE_TARGETS = new Set([
+  "system-prompt.md",
+  "soul.md",
+  "agent.md",
+  "claude.md",
+  "agents.md",
+  "gemini.md",
+  "persona.md",
+  "prompt.md",
+]);
+
+function parseSource(json) {
+  try {
+    const parsed = JSON.parse(json || "{}");
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+
+/** 대기 중(사람 결정 필요) 고위험 성장 제안 개수 — 터미널 홈 배너용. */
+function countPendingGrowthProposals(db) {
+  try {
+    const row = db
+      .prepare(
+        `SELECT COUNT(*) AS n FROM agent_evolution_proposals
+          WHERE json_extract(source_json, '$._growth') = 1 AND status = 'candidate'`,
+      )
+      .get();
+    return Number(row && row.n ? row.n : 0);
+  } catch {
+    return 0;
+  }
+}
+
+function listGrowthProposals(db, limit = 50) {
+  let rows = [];
+  try {
+    rows = db
+      .prepare(
+        `SELECT * FROM agent_evolution_proposals
+          WHERE json_extract(source_json, '$._growth') = 1
+            AND status IN ('candidate','applied','measured')
+          ORDER BY datetime(updated_at) DESC, datetime(created_at) DESC
+          LIMIT ?`,
+      )
+      .all(limit);
+  } catch {
+    rows = [];
+  }
+  const pending = [];
+  const autoApplied = [];
+  for (const row of rows) {
+    const source = parseSource(row.source_json);
+    const entry = { row, source };
+    if (row.status === "candidate") pending.push(entry);
+    else if (source._autoApplied === true) autoApplied.push(entry);
+  }
+  return { pending, autoApplied };
+}
+
+function agentById(db, id) {
+  try {
+    return db.prepare("SELECT * FROM installed_agents WHERE id = ?").get(id) || null;
+  } catch {
+    return null;
+  }
+}
+
+function targetFilePath(agentFolder, agent, targetPath) {
+  const dir = agentFolder(agent);
+  const safe = path.resolve(dir, targetPath);
+  if (safe !== path.join(dir, targetPath) && !safe.startsWith(path.resolve(dir) + path.sep)) {
+    throw new Error("Evolution target escapes the agent folder");
+  }
+  return safe;
+}
+
+function currentTargetHash(file) {
+  try {
+    const content = fs.readFileSync(file, "utf8");
+    return { exists: true, content, hash: sha256(content) };
+  } catch (error) {
+    if (error && error.code === "ENOENT") return { exists: false, content: "", hash: ABSENT_TARGET_HASH };
+    throw error;
+  }
+}
+
+function printCard(out, entry, index) {
+  const { row, source } = entry;
+  const card = source.humanCard && typeof source.humanCard === "object" ? source.humanCard : null;
+  const tier = source.riskTier === "high" ? "high" : "low";
+  out(`  [${index}] ${row.id}  (${tier} · ${row.status} · ${row.agent_id})`);
+  if (card) {
+    out(`      배운 것 : ${card.learned}`);
+    out(`      바뀌는 것: ${card.change}`);
+    out(`      되돌리기 : ${card.reversible}`);
+  } else {
+    out(`      ${row.summary}`);
+  }
+}
+
+function cmdList(db, out) {
+  const { pending, autoApplied } = listGrowthProposals(db);
+  out("== agent growth proposals ==");
+  out("");
+  out(`대기(승인 필요) ${pending.length}건:`);
+  if (!pending.length) out("  (없음)");
+  pending.forEach((entry, i) => printCard(out, entry, i + 1));
+  out("");
+  out(`자동 적용됨(저위험) ${autoApplied.length}건:`);
+  if (!autoApplied.length) out("  (없음)");
+  autoApplied.forEach((entry, i) => printCard(out, entry, i + 1));
+  out("");
+  out("적용:  agentlas evolve apply <id>   ·   되돌리기: agentlas evolve revert <id>");
+}
+
+function loadProposal(db, id, fail) {
+  const row = db.prepare("SELECT * FROM agent_evolution_proposals WHERE id = ?").get(id);
+  if (!row) return fail(`Proposal not found: ${id}`);
+  if (row.proposal_type !== "rule") {
+    return fail(`Terminal evolve applies rule (prompt) proposals only; ${id} is '${row.proposal_type}'. Use the desktop app.`);
+  }
+  if (!RULE_TARGETS.has(String(row.target_path).toLowerCase())) {
+    return fail(`Unsupported evolution target: ${row.target_path}`);
+  }
+  return row;
+}
+
+// 터미널이 부트스트랩한 DB는 v45라 진화 영수증 테이블이 없을 수 있다(데스크탑 v51+ 마이그레이션이
+// 추가). 앱과 동일한 스키마로 idempotent 생성 — 앱이 이미 만들었으면 no-op.
+function ensureReceiptTable(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS agent_evolution_receipts (
+      id TEXT PRIMARY KEY,
+      proposal_id TEXT NOT NULL,
+      agent_id TEXT NOT NULL,
+      action TEXT NOT NULL,
+      target_path TEXT NOT NULL,
+      version_before INTEGER NOT NULL,
+      version_after INTEGER NOT NULL,
+      target_hash_before TEXT NOT NULL,
+      target_hash_after TEXT NOT NULL,
+      package_hash_before TEXT NOT NULL,
+      package_hash_after TEXT NOT NULL,
+      created_at TEXT NOT NULL,
+      UNIQUE(proposal_id, action)
+    );
+  `);
+}
+
+function insertReceipt(db, row, action, hashBefore, hashAfter, now) {
+  ensureReceiptTable(db);
+  db.prepare(
+    `INSERT INTO agent_evolution_receipts (
+       id, proposal_id, agent_id, action, target_path,
+       version_before, version_after, target_hash_before, target_hash_after,
+       package_hash_before, package_hash_after, created_at
+     ) VALUES (?, ?, ?, ?, ?, 1, 2, ?, ?, ?, ?, ?)
+     ON CONFLICT(proposal_id, action) DO NOTHING`,
+  ).run(
+    `evo_receipt_${randomUUID()}`,
+    row.id,
+    row.agent_id,
+    action,
+    row.target_path,
+    hashBefore,
+    hashAfter,
+    hashBefore,
+    hashAfter,
+    now,
+  );
+}
+
+function cmdApply(db, id, out, fail, agentFolder) {
+  const row = loadProposal(db, id, fail);
+  if (!row) return;
+  if (row.status !== "candidate") {
+    return fail(`Only a pending candidate can be applied; ${id} is '${row.status}'.`);
+  }
+  const agent = agentById(db, row.agent_id);
+  if (!agent) return fail(`Agent not found for proposal: ${row.agent_id}`);
+  const file = targetFilePath(agentFolder, agent, row.target_path);
+  const current = currentTargetHash(file);
+  if (current.hash !== row.before_hash) {
+    return fail("Agent prompt changed after this proposal was created; review it in the desktop app and re-propose.");
+  }
+  const now = new Date().toISOString();
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, row.after_content, "utf8");
+  const verify = sha256(fs.readFileSync(file, "utf8"));
+  if (verify !== row.after_hash) {
+    // 원상복구 후 실패 노출(폴백 금지).
+    fs.writeFileSync(file, row.before_content, "utf8");
+    return fail("Applied content did not match the approved hash; restored the original.");
+  }
+  const tx = db.transaction(() => {
+    db.prepare("UPDATE installed_agents SET system_prompt = ? WHERE id = ?").run(row.after_content, row.agent_id);
+    insertReceipt(db, row, "apply", row.before_hash, row.after_hash, now);
+    db.prepare(
+      `UPDATE agent_evolution_proposals
+         SET status = 'applied', applied_at = COALESCE(applied_at, ?),
+             last_error = NULL, updated_at = ?
+       WHERE id = ? AND status = 'candidate'`,
+    ).run(now, now, row.id);
+  });
+  tx();
+  out(`applied ${id} → ${row.target_path} (agent ${row.agent_id}). Revert with: agentlas evolve revert ${id}`);
+}
+
+function cmdRevert(db, id, out, fail, agentFolder) {
+  const row = loadProposal(db, id, fail);
+  if (!row) return;
+  if (row.status !== "applied" && row.status !== "measured") {
+    return fail(`Only an applied proposal can be reverted; ${id} is '${row.status}'.`);
+  }
+  const applyReceipt = db
+    .prepare("SELECT 1 FROM agent_evolution_receipts WHERE proposal_id = ? AND action = 'apply' LIMIT 1")
+    .get(row.id);
+  if (!applyReceipt) return fail("Revert requires the verified apply receipt.");
+  const agent = agentById(db, row.agent_id);
+  if (!agent) return fail(`Agent not found for proposal: ${row.agent_id}`);
+  const file = targetFilePath(agentFolder, agent, row.target_path);
+  const current = currentTargetHash(file);
+  if (current.hash !== row.after_hash) {
+    return fail("Agent prompt changed after this proposal was applied; revert blocked to avoid clobbering newer edits.");
+  }
+  const now = new Date().toISOString();
+  fs.writeFileSync(file, row.before_content, "utf8");
+  const verify = sha256(fs.readFileSync(file, "utf8"));
+  if (verify !== row.before_hash) {
+    fs.writeFileSync(file, row.after_content, "utf8");
+    return fail("Reverted content did not match the original hash; restored the applied version.");
+  }
+  const tx = db.transaction(() => {
+    db.prepare("UPDATE installed_agents SET system_prompt = ? WHERE id = ?").run(row.before_content, row.agent_id);
+    insertReceipt(db, row, "rollback", row.after_hash, row.before_hash, now);
+    db.prepare(
+      `UPDATE agent_evolution_proposals
+         SET status = 'rolled_back', rolled_back_at = COALESCE(rolled_back_at, ?),
+             last_error = NULL, updated_at = ?
+       WHERE id = ? AND status IN ('applied','measured')`,
+    ).run(now, now, row.id);
+  });
+  tx();
+  out(`reverted ${id} → restored ${row.target_path} (agent ${row.agent_id}).`);
+}
+
+/**
+ * cmdEvolve — `agentlas evolve <sub> ...`.
+ * @param {{db:any,args:string[],out:(s:string)=>void,fail:(s:string)=>void,agentFolder:(a:any)=>string}} ctx
+ */
+function cmdEvolve(ctx) {
+  const { db, out, fail, agentFolder } = ctx;
+  const args = Array.isArray(ctx.args) ? ctx.args : [];
+  const sub = args[0] || "list";
+  if (sub === "help" || sub === "--help" || sub === "-h") {
+    out("usage: agentlas evolve [list | apply <id> | revert <id>]");
+    out("  list          — review pending (approval-needed) and auto-applied agent growth proposals");
+    out("  apply <id>    — approve and apply a pending proposal to the agent prompt");
+    out("  revert <id>   — roll back an applied proposal");
+    return;
+  }
+  if (sub === "list" || sub === "ls") return cmdList(db, out);
+  if (sub === "apply") {
+    if (!args[1]) return fail("usage: agentlas evolve apply <id>");
+    return cmdApply(db, args[1], out, fail, agentFolder);
+  }
+  if (sub === "revert" || sub === "rollback") {
+    if (!args[1]) return fail("usage: agentlas evolve revert <id>");
+    return cmdRevert(db, args[1], out, fail, agentFolder);
+  }
+  return fail(`Unknown evolve subcommand: ${sub} (list|apply|revert)`);
+}
+
+module.exports = { cmdEvolve, countPendingGrowthProposals, listGrowthProposals };

package/engine/agentlas-experience-exchange.cjs

@@ -97,22 +97,20 @@ const SEMVER_RE = /^v?[0-9]+\.[0-9]+\.[0-9]+(?:[-+][A-Za-z0-9.-]+)?$/;
 const ENV_RE = /^[A-Z][A-Z0-9_]*$/;
 const SAFE_IDEMPOTENCY_RE = /^[A-Za-z0-9._:-]{8,200}$/;
 
-const SECRET_PATTERNS = [
-  /\bsk-(?:proj-)?[A-Za-z0-9_-]{20,}\b/i,
-  /\bxox[baprs]-[A-Za-z0-9-]{20,}\b/i,
-  /\bgh[pousr]_[A-Za-z0-9_]{20,}\b/,
-  /\bAKIA[0-9A-Z]{16}\b/,
-  /-----BEGIN (?:RSA |EC |OPENSSH |DSA )?PRIVATE KEY-----/i,
-  /\b(?:api[_-]?key|access[_-]?token|refresh[_-]?token|client[_-]?secret|password|passwd|private[_-]?key|cookie)\b\s*[:=]\s*['"]?[^\s'"]{8,}/i,
-  /\bauthorization\b\s*[:=]\s*['"]?(?:bearer|basic)\s+[A-Za-z0-9._~+/=-]{8,}/i,
-];
+const { SECRET_PATTERNS } = require("./agentlas-secret-patterns.cjs");
 const PII_PATTERNS = [
   /\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b/i,
   /(?<!\w)(?:\+?\d[\d ().-]{8,}\d)(?!\w)/,
   /\b(?:account|customer|client|tenant|workspace|user)[ _-]?(?:id|key|number|no)\s*[:=#]?\s*[A-Za-z0-9_-]{4,}\b|(?:계정|고객|사용자)[ _-]?(?:id|아이디|번호)\s*[:=#]?\s*[A-Za-z0-9_-]{4,}/i,
 ];
+// Absolute LOCAL paths and file URLs only. The previous alternation matched any
+// slash-containing token, so ordinary prose lost its experience: "TCP/IP", "read/write",
+// "and/or", and web routes like "GET /api/users" were all reported as a local path. A
+// leading-slash path now has to look like a real filesystem root (or start from a home /
+// relative marker, a Windows drive, or a UNC share); a lone `/word` — which is what a web
+// route looks like — no longer counts, and neither does `word/word` inside a sentence.
 const LOCAL_PATH_PATTERNS = [
-  /(?:file:\/\/|(?:^|[\s"'`()\[\]{}=:,;])(?:\.\.[/\\]|~[/\\]|\/(?!\/|\s)(?:[^/\s"'`<>]+\/)*[^/\s"'`<>]+|[A-Za-z]:[/\\]\S+|\\\\[^\\/\s]+[\\/][^\\/\s]+))/i,
+  /(?:file:\/\/|(?:^|[\s"'`()\[\]{}=:,;])(?:\.\.[/\\]|~[/\\]|\/(?:Users|home|root|private|var|tmp|opt|etc|srv|mnt|media|Volumes|Applications|System|Library|usr)\/[^\s"'`<>]+|[A-Za-z]:[/\\]\S+|\\\\[^\\/\s]+[\\/][^\\/\s]+))/i,
 ];
 const RAW_INTERACTION_PATTERNS = [
   /(?:^|\n)\s*(?:system|assistant|user|tool|customer|agent)\s*:\s+/i,
@@ -1530,7 +1528,13 @@ function isCanonicalTaskId(value) {
 function keywordOccurs(normalizedPrompt, rawKeyword) {
   const keyword = normalizeClassificationText(rawKeyword);
   if (!keyword) return false;
-  if (/[가-힣]/.test(keyword)) return normalizedPrompt.includes(keyword);
+  if (/[가-힣]/.test(keyword)) {
+    // Korean has no word boundary, so a raw includes() matched inside longer compounds:
+    // 번역 hit 번역기, 금융 hit compound finance words, 영업 hit 영업일 (business day).
+    // Require the keyword not be glued to another Hangul syllable on either side.
+    const escaped = keyword.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    return new RegExp(`(?<![가-힣])${escaped}(?![가-힣])`).test(normalizedPrompt);
+  }
   return ` ${normalizedPrompt} `.includes(` ${keyword} `);
 }
 
@@ -1557,6 +1561,56 @@ function deriveCanonicalTaskClasses(prompt, options = {}) {
   return { taskIds: matches, source: "deterministic-keyword-map", matchedTaskClasses: matches, invalidDeclaredCount: 0 };
 }
 
+/**
+ * Meaning-aware task classification. The resident judge decides; TASK_CLASS_KEYWORDS is
+ * passed as reference hints only. This is what a keyword map cannot do: Korean compounds
+ * (번역 inside 번역기), particle inflection (고객 문의를), dialect, slang, and any other
+ * language all hinge on meaning, and no list enumerates them.
+ *
+ * An explicit declared task class still wins outright (it is data, not a guess), and with
+ * no connected model the deterministic keyword prefilter is the fallback so classification
+ * never stops working.
+ */
+async function resolveCanonicalTaskClasses(prompt, options = {}) {
+  const declaredRaw = options.declaredTaskClasses ?? options.declaredTaskClass;
+  if (declaredRaw != null && (Array.isArray(declaredRaw) ? declaredRaw.length : String(declaredRaw).trim())) {
+    return deriveCanonicalTaskClasses(prompt, options);
+  }
+  const prefilter = deriveCanonicalTaskClasses(prompt, options);
+  const judgment = require("./agentlas-judgment.cjs");
+  if (!judgment.hasJudgmentRunner()) return prefilter;
+
+  const hints = {};
+  for (const slug of CANONICAL_TASK_SLUGS) {
+    const words = TASK_CLASS_KEYWORDS[slug];
+    if (Array.isArray(words) && words.length) hints[slug] = words;
+  }
+  const verdict = await judgment.judgeLabels({
+    kind: "experience-task-class",
+    question:
+      "Which kinds of work does this request actually involve? Judge the user's real task, not words that merely appear.",
+    labels: CANONICAL_TASK_SLUGS,
+    input: String(prompt || ""),
+    guidance:
+      "Return a label only when that kind of work is genuinely part of the request. A word inside an " +
+      "unrelated compound or a different sense of the word does not count. Return an empty list for " +
+      "content with no identifiable task (hashes, ids, random strings).",
+    hints,
+    fallback: [],
+    signal: options.signal,
+  });
+  if (verdict.source !== "llm") return prefilter;
+  const taskIds = CANONICAL_TASK_IDS.filter((id) =>
+    verdict.labels.some((slug) => id === `${CANONICAL_TASK_PREFIX}${slug}`));
+  return {
+    taskIds,
+    source: "model-judgment",
+    matchedTaskClasses: taskIds,
+    invalidDeclaredCount: 0,
+    ...(verdict.reason ? { judgmentReason: verdict.reason } : {}),
+  };
+}
+
 function parseEnvironmentConstraint(value) {
   const normalized = normalizedTaxonomyAtom(value);
   const contract = EXPERIENCE_TAXONOMY_V1.environment;
@@ -2140,6 +2194,7 @@ module.exports = {
   environmentConstraintsMatch,
   selectApplicablePortableItems,
   deriveCanonicalTaskClasses,
+  resolveCanonicalTaskClasses,
   readExactLocalBaseMarker,
   exactTaskSignatureInPrompt,
   resolveRuntimeExperienceForAgent,

package/engine/agentlas-i18n.cjs

@@ -111,6 +111,8 @@ const STRINGS = {
     "team.usage": "usage: /team   ·   /team <agent> <claude-code|codex|gemini|auto>",
     "team.set": "%s → %s",
     "routedImage": "routed to %s for image support",
+    "judge.source.llm": "judged by the connected model",
+    "judge.source.fallback": "deterministic fallback (no connected-model verdict)",
     "usageBar": "tokens",
     "config.title": "Engine auto engagement — explicit on/off (default: off)",
     "config.storm": "Stormbreaker auto-engage on direct-routed real work",
@@ -325,6 +327,8 @@ const STRINGS = {
     "team.usage": "사용법: /team   ·   /team <에이전트> <claude-code|codex|gemini|auto>",
     "team.set": "%s → %s",
     "routedImage": "이미지 지원을 위해 %s로 라우팅",
+    "judge.source.llm": "판정: 연결 모델",
+    "judge.source.fallback": "판정: 결정적 폴백(연결 모델 없음)",
     "usageBar": "토큰",
     "config.title": "엔진 자동 개입 — 명시적 on/off (기본: off)",
     "config.storm": "직답 라우팅된 실작업에 Stormbreaker 자동 개입",

package/engine/agentlas-memory-governance.cjs

@@ -30,17 +30,7 @@ const FINAL_SCOPES = new Set(["user_global", "team", "agent", "project", "sessio
 const SEMANTIC_DISPOSITIONS = new Set(["retain", "session", "discard", "review"]);
 const CONFIDENCE_LEVELS = new Set(["high", "medium", "low"]);
 
-const SECRET_PATTERNS = [
-  /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----/i,
-  /\b(?:sk|rk|pk)-(?:ant|proj|live|test)?-?[A-Za-z0-9_-]{16,}\b/i,
-  /\bgh[pousr]_[A-Za-z0-9]{20,}\b/i,
-  /\bxox[baprs]-[A-Za-z0-9-]{16,}\b/i,
-  /\bAIza[A-Za-z0-9_-]{30,}\b/,
-  /\bAKIA[A-Z0-9]{16}\b/,
-  /\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\b/,
-  /\b(?:password|passwd|api[_-]?key|access[_-]?token|refresh[_-]?token|client[_-]?secret)\s*[:=]\s*[^\s,;]{6,}/i,
-  /\bauthorization\s*:\s*bearer\s+[^\s,;]{8,}/i,
-];
+const { SECRET_PATTERNS } = require("./agentlas-secret-patterns.cjs");
 const ABSOLUTE_PATH_PATTERNS = [
   /(?:^|[\s("'`])~\/[A-Za-z0-9._-]/,
   /(?:^|[\s("'`])\/(?:Users|home|private|var|tmp|opt|etc|Volumes|Applications|System|Library)\//,