open-multi-agent-kit 0.90.6 → 0.90.7

package/dist/core/reasoning-router-v4.js

@@ -22,6 +22,7 @@
 import { DEFAULT_WEIGHTS_V4, TASK_CLASSES_V4, } from "./reasoning-router-v4-weights.js";
 export { DEFAULT_WEIGHTS_V4, TASK_CLASSES_V4 } from "./reasoning-router-v4-weights.js";
 import { resolveThinkingLevelCore, TASK_CLASS_THINKING_LEVELS } from "./reasoning-router-resolver.js";
+import { extractGeneralizedIntentEvidenceV4 } from "./reasoning-router-v4-normalize.js";
 /** Prompts shorter than this (trimmed) fall back to trivial when no real signal scores > 0. */
 const TRIVIAL_MAX_CHARS_V4 = 40;
 /** Prompts at/above this length with no real signal fall back to plan (long prose brief). */
@@ -43,13 +44,234 @@ const LANE_FALLBACK_CLASS_V4 = {
     reviewer: "review",
     tester: "code-gen",
 };
+const INTENT_LEXEME_CLUSTERS_V4 = [
+    {
+        id: "debug-leading-actions",
+        taskClass: "debug",
+        role: "leading-intent",
+        surfaces: ["debug", "investigate why", "reproduce", "trace", "fix this traceback/panic/error"],
+        phrases: [/^(?:debug|investigate\s+why|reproduce|trace\b)|^fix\s+this\s+(?:traceback|panic|error)\b/i],
+        negativeControlIds: ["negated-debug-action", "generic-error-handling"],
+    },
+    {
+        id: "review-leading-actions",
+        taskClass: "review",
+        role: "leading-intent",
+        surfaces: ["review", "audit", "critique", "inspect", "assess", "approve", "double-check", "lgtm"],
+        phrases: [/^(?:review|audit(?!\s+log\b)|critique|inspect|assess|approve|double-?check|lgtm)\b/i],
+        negativeControlIds: ["audit-log-not-review", "review-negated-before-code-gen"],
+    },
+    {
+        id: "review-leading-synonyms",
+        taskClass: "review",
+        role: "leading-intent",
+        surfaces: [
+            "give this PR a once-over",
+            "look over",
+            "sanity-check",
+            "eyeball",
+            "poke holes",
+            "pressure-test",
+            "tell me whether/if",
+            "what could go wrong",
+        ],
+        phrases: [
+            /^(?:give\s+(?:this|the|my)?\s*(?:pr|pull\s+request|diff|code|change|branch)?\s*(?:a\s+)?once-?over|look\s+over|sanity[-\s]?check|eyeball|poke\s+holes(?:\s+in)?|pressure[-\s]?test|sign\s+off|tell\s+me\s+(?:if|whether)|tell\s+me\s+what\s+could\s+go\s+wrong|where\s+would\b[^.!?;\n]{0,100}\bfall\s+apart|what\s+am\s+i\s+missing|check\s+whether|look\s+for\s+(?:edge\s+cases|risks?|flaws?)|find\s+(?:flaws|risks?|issues?)|validate\s+(?:the\s+)?reasoning|give\s+me\s+a\s+thumbs[-\s]?up\/?down|read\s+(?:this|the|my)\b[^.!?;\n]{0,80}\bchallenge|(?:is|are|does|do|can|could|would|should)\s+(?:this|these|my|the)\b[^.!?;\n]{0,100}\b(?:right\s+way|handle|cover|safe|sane|clean|overkill|prove|leak|ship|concurrent|hidden\s+coupling)|(?:at\s+architecture\s+level|architecture[-\s]?level)\b[^.!?;\n]{0,80}\bhidden\s+coupling)\b/i,
+        ],
+        negativeControlIds: ["sanity-check-setup-script", "future-self-review-context", "check-whether-implementation"],
+    },
+    {
+        id: "plan-leading-actions",
+        taskClass: "plan",
+        role: "leading-intent",
+        surfaces: ["plan", "design", "architect", "decompose", "map out", "draw up", "think through"],
+        phrases: [
+            /^(?:let(?:'|’)s\s+)?(?:plan|design|architect|decompose|map\s+out|draw\s+up|think\s+through)\b/i,
+            /^(?:write|create)\s+(?:a\s+)?(?:technical\s+)?(?:spec|roadmap|strategy|plan)\b/i,
+        ],
+        negativeControlIds: ["design-token-edit", "draw-up-implementation-only"],
+    },
+    {
+        id: "refactor-leading-actions",
+        taskClass: "refactor",
+        role: "leading-intent",
+        surfaces: ["refactor", "extract", "rename", "deduplicate", "simplify", "clean up", "untangle"],
+        phrases: [
+            /^(?:refactor(?:ing|ed)?|extract|rename|deduplicate|consolidate|modularize|reorganize|simplify|restructure|untangle)\b|^clean\s+up\b|^split\s+(?:the\s+)?module\b|^move\s+logic\b/i,
+        ],
+        negativeControlIds: ["negated-refactor", "future-self-refactor"],
+    },
+    {
+        id: "simple-edit-leading-actions",
+        taskClass: "simple-edit",
+        role: "leading-intent",
+        surfaces: ["correct", "update", "swap", "remove", "adjust", "fix", "add", "change", "trim", "reword"],
+        phrases: [/^(?:correct|update|swap|remove|adjust|fix|add|change|trim|reword|tweak|bump)\b/i],
+        negativeControlIds: ["add-feature-not-simple-edit", "fix-crash-not-simple-edit"],
+    },
+    {
+        id: "code-gen-leading-actions",
+        taskClass: "code-gen",
+        role: "leading-intent",
+        surfaces: [
+            "implement",
+            "write",
+            "create",
+            "build",
+            "generate",
+            "scaffold",
+            "prototype",
+            "add",
+            "whip up",
+            "cook me",
+        ],
+        phrases: [/^(?:implement|write|create|build|generate|scaffold|prototype|add|whip\s+up|cook\s+me)\b/i],
+        negativeControlIds: ["write-a-plan", "create-a-review"],
+    },
+    {
+        id: "debug-whole-prompt",
+        taskClass: "debug",
+        role: "whole-prompt",
+        surfaces: ["debug", "investigate why", "reproduce", "track down", "figure out why", "get to the bottom"],
+        phrases: [
+            /^(?:debug|investigate\s+why|reproduce|trace\b)|\bfix\s+this\s+(?:traceback|panic|error)\b|\btrack\s+down\b|\bfigure\s+out\s+why\b|\bget\s+to\s+the\s+bottom\b|디버깅|디버그|재현|원인\s*분석/i,
+        ],
+        negativeControlIds: ["not-a-bug-report", "error-handling-feature"],
+    },
+    {
+        id: "review-whole-prompt",
+        taskClass: "review",
+        role: "whole-prompt",
+        surfaces: [
+            "review",
+            "critique",
+            "assess",
+            "inspect",
+            "once-over",
+            "look over",
+            "sanity-check",
+            "eyeball",
+            "poke holes",
+            "pressure-test",
+            "tell me whether correct",
+        ],
+        phrases: [
+            /\b(review|critique|assess|inspect|approve|lgtm|double-?check|sanity[-\s]?check|once-?over|look\s+over|eyeball|poke\s+holes|pressure[-\s]?test|sign\s+off|thumbs[-\s]?up\/?down|what\s+could\s+go\s+wrong|what\s+am\s+i\s+missing|challenge\s+the\s+assumptions|hidden\s+coupling|tell\s+me\s+(?:if|whether)[^.!?;\n]{0,80}\bcorrect|audit(?!\s+log\b))\b|리뷰|검토|점검|괜찮은지\s*봐\s*줘|맞는지\s*봐\s*줘|처리되는지\s*확인|허점.{0,10}찾|문제\s*없는지/i,
+        ],
+        negativeControlIds: ["review-free-implementation", "audit-log"],
+    },
+    {
+        id: "plan-whole-prompt",
+        taskClass: "plan",
+        role: "whole-prompt",
+        surfaces: ["plan", "design", "architecture", "roadmap", "map out", "draw up", "think through"],
+        phrases: [
+            /\b(plan|design|architect|architecture|roadmap|spec(?:ification)?|strategy|decompose|milestones?|map\s+out|phases|draw\s+up|think\s+through|write\s+a\s+(?:technical\s+)?spec|create\s+a\s+(?:roadmap|strategy|plan))\b|설계|로드맵|아키텍처|계획.{0,6}세워|기획/i,
+        ],
+        negativeControlIds: ["rather-than-design", "design-token-edit"],
+    },
+    {
+        id: "code-gen-whole-prompt",
+        taskClass: "code-gen",
+        role: "whole-prompt",
+        surfaces: ["implement", "write", "create", "build", "generate", "scaffold", "prototype", "whip up", "cook me"],
+        phrases: [
+            /\b(implement|write|create|build|generate|scaffold|prototype|whip\s+up|cook\s+me)\b|구현|만들어\s*줘|생성|작성|추가해/i,
+        ],
+        negativeControlIds: ["write-plan", "create-roadmap"],
+    },
+    {
+        id: "code-gen-artifact-request",
+        taskClass: "code-gen",
+        role: "object-shape",
+        surfaces: ["I need a script", "we need a utility", "I need an endpoint", "we need a test"],
+        phrases: [
+            /\b(?:i|we)\s+need\s+(?:a|an|the|some)?\s*(?:small\s+|quick\s+|new\s+)?(?:script|utility|helper|component|endpoint|migration|test|tool|function|service)\b(?!\s+(?:plan|strategy|review|audit|roadmap|spec))/i,
+        ],
+        negativeControlIds: ["need-a-plan", "need-a-review", "need-help-debugging"],
+    },
+    {
+        id: "evaluative-review-object",
+        taskClass: "review",
+        role: "object-shape",
+        surfaces: ["holes", "looks off", "correct", "safe", "risky", "issues", "regressions"],
+        phrases: [/\b(holes?|looks?\s+off|correct|safe|risky|issues?|regressions?)\b/i],
+        negativeControlIds: ["fix-holes", "implement-issue-fix"],
+    },
+    {
+        id: "korean-debug-morphology",
+        taskClass: "debug",
+        role: "korean-morphology",
+        surfaces: [
+            "오류",
+            "에러",
+            "실패",
+            "원인 찾아줘",
+            "원인 파악",
+            "숫자가 이상해",
+            "합계가 안 맞아",
+            "빈 파일",
+            "CI가 빨개",
+            "디버깅",
+        ],
+        phrases: [
+            /오류|에러|실패|안\s*돼|안\s*됨|깨졌|깨짐|고장|디버깅|디버그|재현|원인\s*(?:분석|파악|찾(?:아|기)?|찾아\s*줘)?|숫자.{0,12}(?:이상|틀려|안\s*맞)|합계.{0,12}(?:안\s*맞|틀려|이상)|빈\s*파일|(?:CI|러너).{0,12}빨개/i,
+        ],
+        negativeControlIds: ["korean-error-handling-feature", "korean-greeting"],
+    },
+    {
+        id: "korean-simple-edit-morphology",
+        taskClass: "simple-edit",
+        role: "korean-morphology",
+        surfaces: ["오타", "맞춤법", "띄어쓰기", "문구", "제목"],
+        phrases: [/오타|맞춤법|띄어쓰기|문구|제목/i],
+        negativeControlIds: ["korean-feature-edit"],
+    },
+    {
+        id: "korean-review-morphology",
+        taskClass: "review",
+        role: "korean-morphology",
+        surfaces: ["리뷰", "검토", "점검", "괜찮은지 봐줘", "맞는지 봐줘", "허점 찾아줘"],
+        phrases: [/리뷰|검토|점검|괜찮은지\s*봐\s*줘|맞는지\s*봐\s*줘|처리되는지\s*확인|허점.{0,10}찾|문제\s*없는지/i],
+        negativeControlIds: ["korean-review-negated"],
+    },
+    {
+        id: "korean-plan-morphology",
+        taskClass: "plan",
+        role: "korean-morphology",
+        surfaces: ["설계", "로드맵", "아키텍처", "계획 세워", "계획 짜", "계획 수립", "계획 정리"],
+        phrases: [/설계|로드맵|아키텍처|계획.{0,8}(?:세워|짜|수립|정리)|기획/i],
+        negativeControlIds: ["korean-plan-negated"],
+    },
+    {
+        id: "korean-refactor-morphology",
+        taskClass: "refactor",
+        role: "korean-morphology",
+        surfaces: ["리팩토링", "리팩터링", "구조 개선"],
+        phrases: [/리팩토링|리팩터링|구조\s*개선/i],
+        negativeControlIds: ["korean-refactor-negated"],
+    },
+    {
+        id: "korean-code-gen-morphology",
+        taskClass: "code-gen",
+        role: "korean-morphology",
+        surfaces: ["구현", "만들", "생성", "작성", "추가", "테스트", "수정", "변경", "바꿔"],
+        phrases: [/구현|만들|생성|작성|추가|테스트|삭제|지워|지우|제거|고쳐|고치|수정|변경|바꿔|바꾸|옮겨|옮기|넣어/i],
+        negativeControlIds: ["korean-greeting", "korean-codegen-negated"],
+    },
+];
+function clusterMatchesRoleV4(text, taskClass, role) {
+    return INTENT_LEXEME_CLUSTERS_V4.some((cluster) => cluster.taskClass === taskClass &&
+        cluster.role === role &&
+        cluster.phrases.some((pattern) => pattern.test(text)));
+}
 // ============================================================================
 // Whole-prompt / leading-clause patterns used by the v4 scorer.
 // ============================================================================
 const LOCAL_EDIT_OBJECT_PATTERN = /\b(spelling|grammar|capitalization|date\s+format|author\s+e-?mail|copyright\s+year|headline|title|tooltip|placeholder|punctuation|comma|period|semicolon|closing\s+html\s+tag|closing\s+tag|double\s+space|whitespace|indentation|table\s+alignment|typos?|one-?liner?|single\s+line|sentence|stray|trailing)\b|오타|맞춤법|띄어쓰기|문구|제목/i;
 const LOCAL_EDIT_ACTION_OBJECT_PATTERN = /\b(update|change|swap|remove|correct|fix|add|adjust|trim)\s+(?:the\s+|a\s+|an\s+)?(?:missing\s+|stray\s+|author\s+|two\s+)?(?:e-?mail|comma|period|semicolon|tag|word|words|headline|title|copyright|spelling|grammar)\b/i;
 const IMPLEMENTATION_OBJECT_PATTERN = /\b(error\s+handling|input\s+validation|validation|auth(?:entication)?|retry|endpoint|migration|component|function|utility|helper|module|service|database|schema|column|middleware|rate\s+limiter|cache|caching|oauth|jwt|webhook)\b|에러\s*처리|오류\s*처리|입력\s*검증|인증|재시도|엔드포인트|마이그레이션|컴포넌트|함수|유틸|헬퍼|모듈|서비스|데이터베이스|스키마|미들웨어|레이트\s*리미터|캐시|웹훅|기능/i;
-const HARD_DIAGNOSTIC_PATTERN = /\b(stack\s*trace|traceback|panic|segfault|crash(?:es|ing|ed)?|throws?|fails?|failing|flaky|hangs?|timeout|500|EADDRINUSE|silently\s+fails?)\b|\b(?:TypeError|ReferenceError|RangeError|Error):|크래시|스택\s*트레이스|세그폴트|먹통|멈춰|타임아웃/i;
+const HARD_DIAGNOSTIC_PATTERN = /\b(stack\s*trace|traceback|panic|segfault|crash(?:es|ing|ed)?|throws?|fails?|failing|flaky|hangs?|timeout|500|EADDRINUSE|silently\s+(?:fails?|produces?|returns?|creates?)|(?:ci|build)\s+(?:is\s+)?red|runner\s+(?:goes|went|is)\s+red|comes?\s+out\s+wrong|totals?\s+(?:are\s+)?off|drift(?:ed|ing)?|mismatch(?:ed|es)?|mismatched|no\s+longer\s+matches|says\s+success\s+but|exits?\s+0\s+but|empty\s+file|opens?\s+blank|black\s+image|zero[-\s]?byte\s+files?|headers\s+only|rows?\s+are\s+missing|missing\s+rows|stale\s+(?:index|prices?|cache|results?)|search\s+index\s+(?:is\s+)?stale|duplicate\s+rows|NaN|never\s+(?:send|sends|appear|appears|land|lands|writes?|written|updates?)|works\s+locally\s+and\s+breaks|worked\s+yesterday|settings\s+revert|side\s+effect\s+never|stops?\s+updating|data\s+disappears)\b|\b(?:TypeError|ReferenceError|RangeError|Error):|크래시|스택\s*트레이스|세그폴트|먹통|멈춰|타임아웃|숫자.{0,12}(?:이상|틀려|안\s*맞)|합계.{0,12}(?:안\s*맞|틀려|이상)|빈\s*파일|(?:CI|러너).{0,12}빨개/i;
 const BUG_OBJECT_PATTERN = /\b(null\s+pointer|null\s+deref|race(?:\s+condition)?|heap(?:\s+overflow)?|use-after-free|memory\s+leak|leaks?|deadlock|data\s+corruption|stale\s+data|off-by-one|encoding\s+bug|regression\s+(?:was\s+)?introduced|exceptions?|assertion\s+error|bugs?)\b|버그|예외|메모리\s*누수|데드락|무한\s*루프/i;
 const NON_DIAGNOSTIC_DEBUG_CONTEXT_PATTERN = /\berror\s+(?:handling|messages?|budgets?)\b|에러\s*처리|오류\s*처리/i;
 const GENERIC_DIAGNOSTIC_PATTERN = /\b(errors?|broken|wrong\s+results|rolls?\s+back|rollback)\b/i;
@@ -67,21 +289,10 @@ const OPERATIONAL_RUNBOOK_SIGNAL_PATTERNS = [
     { pattern: /\bci\s*\/\s*cd\b|\bgithub\s+actions?\b|\bworkflow\b|깃허브\s*액션|깃헙\s*액션/i, critical: false },
 ];
 const EXPLICIT_RELEASE_RUNBOOK_PATTERN = /\bnpm\s+publish\b|\brelease\b[^\n]{0,80}\bv?\d+\.\d+\.\d+\b|릴리즈[^\n]{0,80}\d+\.\d+\.\d+/i;
-const REVIEW_SCOPE_PATTERN = /\b(pr|pull\s+request|diff|codebase|strategy|plan|spec|schema|design|api|coverage|security\s+posture|licensing|risks?|edge\s+cases|clarity|consistency|dependencies|third-party|ci\s+pipeline|threat\s+model|retry\s+logic|error\s+handling\s+strategy|error\s+messages?)\b/i;
+const REVIEW_SCOPE_PATTERN = /\b(pr|pull\s+request|diff|codebase|approach|structure|module\s+boundary|locking\s+strategy|abstraction|assumptions?|parser\s+change|rollback\s+strategy|concurrent\s+case|concurrency\s+plan|hidden\s+coupling|failure\s+mode|test\s+quality|implementation\s+details|strategy|plan|spec|schema|design|api|coverage|security\s+posture|licensing|risks?|edge\s+cases|clarity|consistency|dependencies|third-party|ci\s+pipeline|threat\s+model|retry\s+logic|error\s+handling\s+strategy|error\s+messages?)\b/i;
 const REFACTOR_CUE_PATTERN = /\b(refactor(?:ing|ed)?|extract|rename|deduplicate|consolidate|modularize|reorganize|simplify|clean\s*up|tidy\s+up|restructure|split\s+module|move\s+logic|untangle|merge\s+duplicate)\b|리팩토링(?!하지\s*마|하지\s*말)|리팩터링(?!하지\s*마|하지\s*말)|구조\s*개선/i;
 const ADD_KEYWORD_PATTERN = /\badd\b/i;
 const LOW_RISK_EDIT_ACTION_PATTERN = /^(?:correct|update|swap|remove|reword|tweak|bump|trim)\b/i;
-/** Whole-prompt keyword-family patterns; refactor/simple-edit reuse the patterns above. */
-const DEBUG_KEYWORD_FAMILY_PATTERN = /^(?:debug|investigate\s+why|reproduce|trace\b)|\bfix\s+this\s+(?:traceback|panic|error)\b|\btrack\s+down\b|디버깅|디버그|재현|원인\s*분석/i;
-const REVIEW_KEYWORD_FAMILY_PATTERN = /\b(review|critique|assess|inspect|approve|lgtm|double-?check|sanity[-\s]?check|once-?over|eyeball|tell\s+me\s+(?:if|whether)[^.!?;\n]{0,80}\bcorrect|audit(?!\s+log\b))\b|리뷰|검토|점검/i;
-const PLAN_KEYWORD_FAMILY_PATTERN = /\b(plan|design|architect|architecture|roadmap|spec(?:ification)?|strategy|decompose|milestones?|map\s+out|phases|write\s+a\s+(?:technical\s+)?spec|create\s+a\s+(?:roadmap|strategy|plan))\b|설계|로드맵|아키텍처|계획.{0,6}세워|기획/i;
-const CODE_GEN_KEYWORD_FAMILY_PATTERN = /\b(implement|write|create|build|generate|scaffold|prototype)\b|구현|만들어\s*줘|생성|작성|추가해/i;
-const KO_SHORT_DEBUG_SIGNAL_PATTERN_V4 = /오류|에러|실패|안\s*돼|안\s*됨|깨졌|깨짐|고장|디버깅|디버그|재현|원인\s*(?:분석|파악)?/i;
-const KO_SHORT_SIMPLE_EDIT_SIGNAL_PATTERN_V4 = /오타|맞춤법|띄어쓰기|문구|제목/i;
-const KO_SHORT_REVIEW_SIGNAL_PATTERN_V4 = /리뷰|검토|점검/i;
-const KO_SHORT_PLAN_SIGNAL_PATTERN_V4 = /설계|로드맵|아키텍처|계획.{0,6}세워|기획/i;
-const KO_SHORT_REFACTOR_SIGNAL_PATTERN_V4 = /리팩토링|리팩터링|구조\s*개선/i;
-const KO_SHORT_CODE_GEN_SIGNAL_PATTERN_V4 = /구현|만들|생성|작성|추가|테스트|삭제|지워|지우|제거|고쳐|고치|수정|변경|바꿔|바꾸|옮겨|옮기|넣어/i;
 /** Short-range compound-clause conjunction boundary. Only bare/compound "then"/"and also"/";" — never bare "and". */
 const COMPOUND_SPLIT_PATTERN = /\band\s+then\b|\bthen\b|\band\s+also\b|;/i;
 /**
@@ -116,22 +327,22 @@ function firstClause(prompt) {
 // never match one of these: none of the alternations include "don't"/"never"/
 // etc, so they are negation-immune by construction.
 function hasLeadingReviewIntent(text) {
-    return /^(?:review|audit(?!\s+log\b)|critique|inspect|assess|approve|double-?check|lgtm)\b/i.test(text);
+    return clusterMatchesRoleV4(text, "review", "leading-intent");
 }
 function hasLeadingPlanIntent(text) {
-    return /^(?:plan|design|architect|decompose)\b|^(?:write|create)\s+(?:a\s+)?(?:technical\s+)?(?:spec|roadmap|strategy|plan)\b/i.test(text);
+    return clusterMatchesRoleV4(text, "plan", "leading-intent");
 }
 function hasLeadingRefactorIntent(text) {
-    return /^(?:refactor(?:ing|ed)?|extract|rename|deduplicate|consolidate|modularize|reorganize|simplify|restructure|untangle)\b|^clean\s+up\b|^split\s+(?:the\s+)?module\b|^move\s+logic\b/i.test(text);
+    return clusterMatchesRoleV4(text, "refactor", "leading-intent");
 }
 function hasLeadingDebugAction(text) {
-    return /^(?:debug|investigate\s+why|reproduce|trace\b)|^fix\s+this\s+(?:traceback|panic|error)\b/i.test(text);
+    return clusterMatchesRoleV4(text, "debug", "leading-intent");
 }
 function hasLeadingCodeGenIntent(text) {
-    return /^(?:implement|write|create|build|generate|scaffold|prototype|add)\b/i.test(text);
+    return clusterMatchesRoleV4(text, "code-gen", "leading-intent");
 }
 function hasLeadingSimpleEditIntent(text) {
-    return /^(?:correct|update|swap|remove|adjust|fix|add|change|trim|reword|tweak|bump)\b/i.test(text);
+    return clusterMatchesRoleV4(text, "simple-edit", "leading-intent");
 }
 const NO_MATCH_RESULT_V4 = { matched: false, suppressed: false };
 function matchOperationalRunbookV4(prompt, windowChars) {
@@ -199,9 +410,21 @@ function matchUnnegated(prompt, pattern, windowChars) {
     }
     return { matched: sawUnnegated, suppressed: sawMatch && !sawUnnegated };
 }
-// ============================================================================
-// Bounded compound-intent detection
-// ============================================================================
+function matchClusterUnnegatedV4(prompt, taskClass, role, windowChars) {
+    let sawSuppressed = false;
+    for (const cluster of INTENT_LEXEME_CLUSTERS_V4) {
+        if (cluster.taskClass !== taskClass || cluster.role !== role)
+            continue;
+        for (const pattern of cluster.phrases) {
+            const result = matchUnnegated(prompt, pattern, windowChars);
+            if (result.matched)
+                return { matched: true, suppressed: false };
+            if (result.suppressed)
+                sawSuppressed = true;
+        }
+    }
+    return { matched: false, suppressed: sawSuppressed };
+}
 /**
  * Splits off a bounded second clause after a short-range conjunction
  * ("then"/"and then"/"and also"/";"), only when the split point is within the
@@ -213,19 +436,33 @@ function splitCompoundClauseV4(prompt) {
     const match = COMPOUND_SPLIT_PATTERN.exec(prompt);
     if (match === null || match.index > COMPOUND_SPLIT_MAX_INDEX_V4)
         return null;
-    const second = prompt.slice(match.index + match[0].length).trim();
+    const startIndex = match.index + match[0].length;
+    const second = prompt.slice(startIndex).trim();
     if (second.length < COMPOUND_SECOND_CLAUSE_MIN_CHARS_V4)
         return null;
-    return second;
+    return { text: second, startIndex };
+}
+function hasFutureSelfClauseV4(clause) {
+    return /^(?:(?:i|we)(?:'|’)ll\b|(?:i|we)\s+will\b|(?:i|we)(?:'|’)m\s+going\s+to\b|before\s+(?:i|we)\b|after\s+(?:i|we)\b)/i.test(clause);
+}
+function agentDirectedSecondClauseV4(clause) {
+    if (hasFutureSelfClauseV4(clause))
+        return null;
+    return clause.replace(/^(?:please|pls|also|then|can\s+you|could\s+you|would\s+you|help\s+me(?:\s+to)?)\s+/i, "");
 }
 /**
  * Leading-intent test for a compound prompt's SECOND clause. Reuses the same
  * `^`-anchored leading-intent tests as the primary clause (so it is equally
  * negation-immune), without the primary clause's diagnosticEvidence/localEdit
  * gating (a short second-clause fragment carries no such context of its own).
+ * First-person future/context clauses ("I'll...", "we will...", "before I...")
+ * are user context, not an agent-directed second task.
  */
 function secondClauseLeadingIntentV4(clause) {
-    const bounded = clause.slice(0, COMPOUND_SECOND_CLAUSE_SCAN_CHARS_V4);
+    const agentDirectedClause = agentDirectedSecondClauseV4(clause);
+    if (agentDirectedClause === null)
+        return null;
+    const bounded = agentDirectedClause.slice(0, COMPOUND_SECOND_CLAUSE_SCAN_CHARS_V4);
     return leadingIntentFromLeadingClauseV4(bounded);
 }
 function leadingIntentFromLeadingClauseV4(leading) {
@@ -248,18 +485,27 @@ function leadingIntentIsPostNegatedV4(leading, windowChars) {
     return (leadingIntentMatch !== null && hasPostPositionedNegationCueV4(leading, leadingIntentMatch[0].length, windowChars));
 }
 function classifyShortKoreanZeroScoreTaskV4(prompt, windowChars) {
-    if (matchUnnegated(prompt, KO_SHORT_DEBUG_SIGNAL_PATTERN_V4, windowChars).matched)
+    const generalizedEvidence = extractGeneralizedIntentEvidenceV4(prompt);
+    for (const taskClass of TASK_CLASSES_V4) {
+        if (generalizedEvidence.skeletonMatch[taskClass])
+            return taskClass;
+    }
+    if (matchClusterUnnegatedV4(prompt, "debug", "korean-morphology", windowChars).matched)
         return "debug";
-    if (matchUnnegated(prompt, KO_SHORT_SIMPLE_EDIT_SIGNAL_PATTERN_V4, windowChars).matched)
+    if (matchClusterUnnegatedV4(prompt, "simple-edit", "korean-morphology", windowChars).matched)
         return "simple-edit";
-    if (matchUnnegated(prompt, KO_SHORT_REVIEW_SIGNAL_PATTERN_V4, windowChars).matched)
+    if (matchClusterUnnegatedV4(prompt, "review", "korean-morphology", windowChars).matched)
         return "review";
-    if (matchUnnegated(prompt, KO_SHORT_PLAN_SIGNAL_PATTERN_V4, windowChars).matched)
+    if (matchClusterUnnegatedV4(prompt, "plan", "korean-morphology", windowChars).matched)
         return "plan";
-    if (matchUnnegated(prompt, KO_SHORT_REFACTOR_SIGNAL_PATTERN_V4, windowChars).matched)
+    if (matchClusterUnnegatedV4(prompt, "refactor", "korean-morphology", windowChars).matched)
         return "refactor";
-    if (matchUnnegated(prompt, KO_SHORT_CODE_GEN_SIGNAL_PATTERN_V4, windowChars).matched)
+    if (matchClusterUnnegatedV4(prompt, "code-gen", "korean-morphology", windowChars).matched)
         return "code-gen";
+    for (const taskClass of TASK_CLASSES_V4) {
+        if (generalizedEvidence.clusterMatch[taskClass])
+            return taskClass;
+    }
     return null;
 }
 /** Decision order for the leading intent classifier. */
@@ -288,6 +534,27 @@ function hasDiagnosticEvidenceV4(leading, hardDiagnosticMatched, bugObjectMatche
         return false;
     return !hasLeadingReviewIntent(leading) && !hasLeadingPlanIntent(leading) && !hasLeadingRefactorIntent(leading);
 }
+function isDeferredClassV4(evidence, taskClass) {
+    return evidence.deferredClasses.includes(taskClass);
+}
+function suppressGeneralizedClassesV4(evidence, suppressedClasses) {
+    if (suppressedClasses.length === 0)
+        return evidence;
+    const clusterMatch = { ...evidence.clusterMatch };
+    const skeletonMatch = { ...evidence.skeletonMatch };
+    for (const taskClass of suppressedClasses) {
+        clusterMatch[taskClass] = false;
+        skeletonMatch[taskClass] = false;
+    }
+    return { ...evidence, clusterMatch, skeletonMatch };
+}
+function countGeneralizedEvidenceV4(evidence) {
+    const counts = emptyScoresV4();
+    for (const taskClass of TASK_CLASSES_V4) {
+        counts[taskClass] = (evidence.clusterMatch[taskClass] ? 1 : 0) + (evidence.skeletonMatch[taskClass] ? 1 : 0);
+    }
+    return counts;
+}
 /**
  * Extracts every v4 feature from one prompt, negation-gating every
  * whole-prompt scan exactly once and recording a `negation:<channel>` id in
@@ -296,65 +563,106 @@ function hasDiagnosticEvidenceV4(leading, hardDiagnosticMatched, bugObjectMatche
 function extractFeaturesV4(prompt, weights, suppressed) {
     const leading = firstClause(prompt);
     const window = weights.negationWindowChars;
-    const implementationObjectResult = matchUnnegated(prompt, IMPLEMENTATION_OBJECT_PATTERN, window);
+    const secondClause = splitCompoundClauseV4(prompt);
+    const agentSignalPrompt = secondClause !== null && hasFutureSelfClauseV4(secondClause.text)
+        ? prompt.slice(0, secondClause.startIndex).trim()
+        : prompt;
+    const generalizedEvidence = extractGeneralizedIntentEvidenceV4(agentSignalPrompt);
+    const shortKoreanPrompt = prompt.length < TRIVIAL_MAX_CHARS_V4 && /[가-힣]/.test(prompt);
+    const shortKoreanDebugFallbackOnly = shortKoreanPrompt &&
+        (generalizedEvidence.clusterMatch.debug || generalizedEvidence.skeletonMatch.debug) &&
+        !generalizedEvidence.clusterMatch.refactor &&
+        !generalizedEvidence.skeletonMatch.refactor &&
+        !generalizedEvidence.clusterMatch.review &&
+        !generalizedEvidence.skeletonMatch.review;
+    const scoredGeneralizedEvidence = suppressGeneralizedClassesV4(generalizedEvidence, shortKoreanDebugFallbackOnly
+        ? [...generalizedEvidence.deferredClasses, "debug"]
+        : generalizedEvidence.deferredClasses);
+    for (const taskClass of generalizedEvidence.deferredClasses)
+        suppressed.push(`deferral:${taskClass}`);
+    const implementationObjectResult = matchUnnegated(agentSignalPrompt, IMPLEMENTATION_OBJECT_PATTERN, window);
     if (implementationObjectResult.suppressed)
         suppressed.push("negation:implementation-object");
-    const implementationObject = implementationObjectResult.matched;
+    const implementationObject = !shortKoreanDebugFallbackOnly && implementationObjectResult.matched;
+    const codeGenArtifactResult = matchClusterUnnegatedV4(agentSignalPrompt, "code-gen", "object-shape", window);
+    if (codeGenArtifactResult.suppressed)
+        suppressed.push("negation:code-gen-artifact-request");
+    const codeGenArtifactRequest = codeGenArtifactResult.matched;
     const lowRiskEditAction = LOW_RISK_EDIT_ACTION_PATTERN.test(leading);
-    const localEditObjectResult = matchUnnegated(prompt, LOCAL_EDIT_OBJECT_PATTERN, window);
+    const localEditObjectResult = matchUnnegated(agentSignalPrompt, LOCAL_EDIT_OBJECT_PATTERN, window);
     if (localEditObjectResult.suppressed)
         suppressed.push("negation:local-edit-object");
-    const localEditActionResult = matchUnnegated(prompt, LOCAL_EDIT_ACTION_OBJECT_PATTERN, window);
+    const localEditActionResult = matchUnnegated(agentSignalPrompt, LOCAL_EDIT_ACTION_OBJECT_PATTERN, window);
     if (localEditActionResult.suppressed)
         suppressed.push("negation:local-edit-action-object");
-    const localEdit = !implementationObject && (lowRiskEditAction || localEditObjectResult.matched || localEditActionResult.matched);
-    const hardDiagnosticResult = matchUnnegated(prompt, HARD_DIAGNOSTIC_PATTERN, window);
+    const localEdit = !implementationObject &&
+        !scoredGeneralizedEvidence.clusterMatch.review &&
+        !scoredGeneralizedEvidence.skeletonMatch.review &&
+        (lowRiskEditAction || localEditObjectResult.matched || localEditActionResult.matched);
+    const hardDiagnosticResult = matchUnnegated(agentSignalPrompt, HARD_DIAGNOSTIC_PATTERN, window);
     if (hardDiagnosticResult.suppressed)
         suppressed.push("negation:hard-diagnostic");
-    const bugObjectResult = matchUnnegated(prompt, BUG_OBJECT_PATTERN, window);
+    const bugObjectResult = matchUnnegated(agentSignalPrompt, BUG_OBJECT_PATTERN, window);
     if (bugObjectResult.suppressed)
         suppressed.push("negation:bug-object");
-    const genericDiagnosticResult = matchUnnegated(prompt, GENERIC_DIAGNOSTIC_PATTERN, window);
-    const nonDiagnosticContext = NON_DIAGNOSTIC_DEBUG_CONTEXT_PATTERN.test(prompt);
+    const genericDiagnosticResult = matchUnnegated(agentSignalPrompt, GENERIC_DIAGNOSTIC_PATTERN, window);
+    const nonDiagnosticContext = NON_DIAGNOSTIC_DEBUG_CONTEXT_PATTERN.test(agentSignalPrompt);
     if (genericDiagnosticResult.suppressed && !nonDiagnosticContext)
         suppressed.push("negation:generic-diagnostic");
-    const diagnosticEvidence = hasDiagnosticEvidenceV4(leading, hardDiagnosticResult.matched, bugObjectResult.matched, genericDiagnosticResult.matched, nonDiagnosticContext);
-    const reviewScopeResult = matchUnnegated(prompt, REVIEW_SCOPE_PATTERN, window);
+    const diagnosticEvidence = !isDeferredClassV4(generalizedEvidence, "debug") &&
+        hasDiagnosticEvidenceV4(leading, hardDiagnosticResult.matched, bugObjectResult.matched, genericDiagnosticResult.matched, nonDiagnosticContext);
+    const reviewScopeResult = matchUnnegated(agentSignalPrompt, REVIEW_SCOPE_PATTERN, window);
     if (reviewScopeResult.suppressed)
         suppressed.push("negation:review-scope");
-    const reviewScope = hasLeadingReviewIntent(leading) && reviewScopeResult.matched;
-    const planBriefResult = matchUnnegated(prompt, PLAN_BRIEF_PATTERN, window);
+    const reviewScope = !isDeferredClassV4(generalizedEvidence, "review") && hasLeadingReviewIntent(leading) && reviewScopeResult.matched;
+    const planBriefResult = matchUnnegated(agentSignalPrompt, PLAN_BRIEF_PATTERN, window);
     if (planBriefResult.suppressed)
         suppressed.push("negation:plan-brief");
-    const planBrief = hasLeadingPlanIntent(leading) && (planBriefResult.matched || prompt.length >= LONG_BRIEF_MIN_CHARS_V4);
-    const operationalRunbookResult = matchOperationalRunbookV4(prompt, window);
+    const planBrief = !isDeferredClassV4(generalizedEvidence, "plan") &&
+        hasLeadingPlanIntent(leading) &&
+        (planBriefResult.matched || prompt.length >= LONG_BRIEF_MIN_CHARS_V4);
+    const operationalRunbookResult = matchOperationalRunbookV4(agentSignalPrompt, window);
     if (operationalRunbookResult.suppressed)
         suppressed.push("negation:operational-runbook");
     const operationalRunbook = operationalRunbookResult.matched;
-    const refactorCueResult = matchUnnegated(prompt, REFACTOR_CUE_PATTERN, window);
+    const refactorCueResult = matchUnnegated(agentSignalPrompt, REFACTOR_CUE_PATTERN, window);
     if (refactorCueResult.suppressed)
         suppressed.push("negation:refactor-cue");
-    const refactorCue = refactorCueResult.matched;
+    const refactorCue = !isDeferredClassV4(generalizedEvidence, "refactor") && refactorCueResult.matched;
     const rawPrimaryIntent = leadingIntentV4({ firstClause: leading, localEdit, diagnosticEvidence });
-    const primaryIntent = rawPrimaryIntent !== null && leadingIntentIsPostNegatedV4(leading, window) ? null : rawPrimaryIntent;
-    const secondClauseText = splitCompoundClauseV4(prompt);
-    const secondClauseIntent = secondClauseText === null ? null : secondClauseLeadingIntentV4(secondClauseText);
+    const primaryIntent = rawPrimaryIntent !== null &&
+        (leadingIntentIsPostNegatedV4(leading, window) || isDeferredClassV4(generalizedEvidence, rawPrimaryIntent))
+        ? null
+        : rawPrimaryIntent;
+    const secondClauseIntent = secondClause === null ? null : secondClauseLeadingIntentV4(secondClause.text);
     const compoundIntent = secondClauseIntent !== null && secondClauseIntent !== primaryIntent;
     const debugKeywordResult = diagnosticEvidence
-        ? matchUnnegated(prompt, DEBUG_KEYWORD_FAMILY_PATTERN, window)
+        ? matchClusterUnnegatedV4(agentSignalPrompt, "debug", "whole-prompt", window)
         : NO_MATCH_RESULT_V4;
     if (debugKeywordResult.suppressed)
         suppressed.push("negation:keyword-debug");
-    const reviewKeywordResult = matchUnnegated(prompt, REVIEW_KEYWORD_FAMILY_PATTERN, window);
+    const reviewKeywordResult = isDeferredClassV4(generalizedEvidence, "review")
+        ? NO_MATCH_RESULT_V4
+        : matchClusterUnnegatedV4(agentSignalPrompt, "review", "whole-prompt", window);
     if (reviewKeywordResult.suppressed)
         suppressed.push("negation:keyword-review");
-    const planKeywordResult = matchUnnegated(prompt, PLAN_KEYWORD_FAMILY_PATTERN, window);
+    const planKeywordResult = isDeferredClassV4(generalizedEvidence, "plan")
+        ? NO_MATCH_RESULT_V4
+        : matchClusterUnnegatedV4(agentSignalPrompt, "plan", "whole-prompt", window);
     if (planKeywordResult.suppressed)
         suppressed.push("negation:keyword-plan");
-    const codeGenKeywordResult = matchUnnegated(prompt, CODE_GEN_KEYWORD_FAMILY_PATTERN, window);
+    const codeGenKeywordResult = matchClusterUnnegatedV4(agentSignalPrompt, "code-gen", "whole-prompt", window);
     if (codeGenKeywordResult.suppressed)
         suppressed.push("negation:keyword-code-gen");
-    const addKeywordResult = localEdit ? NO_MATCH_RESULT_V4 : matchUnnegated(prompt, ADD_KEYWORD_PATTERN, window);
+    const evaluativeReviewResult = !isDeferredClassV4(generalizedEvidence, "review") && hasLeadingReviewIntent(leading)
+        ? matchClusterUnnegatedV4(agentSignalPrompt, "review", "object-shape", window)
+        : NO_MATCH_RESULT_V4;
+    if (evaluativeReviewResult.suppressed)
+        suppressed.push("negation:evaluative-review-object");
+    const evaluativeReviewObject = evaluativeReviewResult.matched;
+    const addKeywordResult = localEdit
+        ? NO_MATCH_RESULT_V4
+        : matchUnnegated(agentSignalPrompt, ADD_KEYWORD_PATTERN, window);
     if (addKeywordResult.suppressed)
         suppressed.push("negation:add-keyword");
     return {
@@ -368,6 +676,8 @@ function extractFeaturesV4(prompt, weights, suppressed) {
         operationalRunbook,
         refactorCue,
         implementationObject,
+        codeGenArtifactRequest,
+        evaluativeReviewObject,
         leadingIntent: primaryIntent,
         secondClauseIntent,
         compoundIntent,
@@ -380,6 +690,9 @@ function extractFeaturesV4(prompt, weights, suppressed) {
             "simple-edit": localEditObjectResult.matched,
             "code-gen": codeGenKeywordResult.matched,
         },
+        normalizedIntentClusterMatch: scoredGeneralizedEvidence.clusterMatch,
+        intentSkeletonMatch: scoredGeneralizedEvidence.skeletonMatch,
+        generalizedEvidenceCount: countGeneralizedEvidenceV4(scoredGeneralizedEvidence),
         addKeywordMatch: addKeywordResult.matched,
     };
 }
@@ -419,9 +732,17 @@ function computeScoresV4(features, weights) {
         scores.refactor += weights.refactorCue;
     if (features.implementationObject)
         scores["code-gen"] += weights.implementationObject;
+    if (features.codeGenArtifactRequest)
+        scores["code-gen"] += weights.codeGenArtifactRequest;
+    if (features.evaluativeReviewObject)
+        scores.review += weights.evaluativeReviewObject;
     for (const taskClass of TASK_CLASSES_V4) {
         if (features.keywordFamilyMatch[taskClass])
             scores[taskClass] += weights.keywordFamily[taskClass];
+        if (features.normalizedIntentClusterMatch[taskClass])
+            scores[taskClass] += weights.normalizedIntentCluster;
+        if (features.intentSkeletonMatch[taskClass])
+            scores[taskClass] += weights.intentSkeleton;
     }
     if (features.addKeywordMatch)
         scores["code-gen"] += weights.addKeyword;
@@ -449,6 +770,16 @@ function applyExtensionSignalsV4(scores, input, weights) {
         scores.plan += bump;
     }
 }
+function clampConfidenceV4(value) {
+    return Math.max(0, Math.min(1, value));
+}
+function confidenceEvidenceStrengthV4(topScore, margin, weights) {
+    if (topScore <= 0)
+        return 0;
+    const separation = clampConfidenceV4(margin / topScore);
+    const evidenceFloor = weights.leadingIntent > 0 ? weights.leadingIntent : 1;
+    return Math.min(separation, clampConfidenceV4(topScore / evidenceFloor));
+}
 // ============================================================================
 // Classifier
 // ============================================================================
@@ -458,7 +789,7 @@ function applyExtensionSignalsV4(scores, input, weights) {
  * Pipeline: extract negation/compound-aware contextual features -> score every
  * class from `weights` -> argmax with `TASK_CLASSES_V4` precedence tie-break,
  * tracking the runner-up -> compute margin/confidence/confidenceBand/tieBreak
- * from the RAW scores -> if `topScore <= 0`, replace `taskClass` (and record
+ * from RAW score separation plus evidence strength -> if `topScore <= 0`, replace `taskClass` (and record
  * `fallbackReason`) via the zero-score cascade (fence/diff -> code-gen;
  * length < 40 -> trivial; length >= 2400 -> plan; lane fallback; default
  * code-gen) — the raw scores/margin/runnerUp/tieBreak fields still reflect the
@@ -488,7 +819,12 @@ export function classifyTaskV4(input, weights = DEFAULT_WEIGHTS_V4) {
     const runnerUpScore = runnerUp !== null ? scores[runnerUp] : 0;
     const margin = topScore - runnerUpScore;
     const tieBreak = runnerUp !== null && topScore === runnerUpScore;
-    const confidence = topScore <= 0 ? 0 : Math.max(0, Math.min(1, margin / topScore));
+    const rawConfidence = confidenceEvidenceStrengthV4(topScore, margin, weights);
+    const singleGeneralizedEvidence = features.generalizedEvidenceCount[top] === 1 &&
+        topScore <= Math.max(weights.normalizedIntentCluster, weights.intentSkeleton);
+    const confidence = singleGeneralizedEvidence
+        ? Math.min(rawConfidence, Math.max(0, weights.highConfidenceThreshold - 0.01))
+        : rawConfidence;
     const confidenceBand = confidence <= weights.lowConfidenceThreshold
         ? "low"
         : confidence >= weights.highConfidenceThreshold