muonroi-cli 1.3.4 → 1.4.1

package/dist/src/pil/layer1-intent.js

@@ -118,8 +118,11 @@ const REASON_TO_TASK_TYPE = {
     "regex:explain": "analyze",
     "regex:search": "analyze",
     "regex:install": "analyze",
-    "tree-sitter:typescript": "refactor",
-    "tree-sitter:python": "refactor",
+    // tree-sitter:* parses indicate code presence ONLY — no intent signal.
+    // Mapping these to "refactor" caused 4/5 baseline misclassifications
+    // (Phase 4, 4P-1). Leave undefined so Pass 2 keyword fallback decides.
+    "tree-sitter:typescript": undefined,
+    "tree-sitter:python": undefined,
     "regex:read": "analyze",
     "regex:git": "analyze",
     "regex:short-message": "general",
@@ -133,6 +136,118 @@ const REASON_TO_TASK_TYPE = {
     "tree-sitter:python-parse-error": undefined,
     "low-confidence": undefined,
 };
+/**
+ * Pass 0 — deterministic full-prompt overrides.
+ *
+ * Two narrow regexes that run BEFORE the local classifier and the LLM bridge.
+ * Each must match the ENTIRE trimmed prompt (anchored ^…$) so they never
+ * accidentally swallow embedded substrings like "ok let's refactor X".
+ *
+ * Rationale (Phase 5 BUG-B + BUG-D, evidenced by sha8-tagged pil rows):
+ *  - "tiếp tục nhé" (12 chars, 3 words) bypassed Pass 2.5 hot-path chitchat
+ *    short-circuit (<10 chars, ≤2 words gate) → fell into Pass 3 LLM bridge,
+ *    which non-deterministically classified the same input as
+ *    general/chitchat one turn and generate/task the next (session
+ *    fc19b4daee20 seq 22 vs 24). Continuation phrases never carry a task —
+ *    pin them to general/chitchat deterministically.
+ *  - "optimize startup performance" classified as analyze (session
+ *    9c63a38197f3) once and generate (session 1bc27b79223c) the next time
+ *    by the LLM bridge. Pass 2 keyword fallback had no pattern for
+ *    optimization verbs, so the only signal was the LLM bridge — which
+ *    drifted. The correct label is refactor (restructure existing code
+ *    for performance). Pin it deterministically.
+ *
+ * When either pattern hits we short-circuit the whole layer1Intent flow
+ * by setting `passes0Hit` and skipping Pass 1-4 entirely. This eliminates
+ * the LLM round-trip cost on these high-frequency patterns and removes
+ * the nondeterminism source.
+ */
+const CONTINUATION_FULL_RE = /^\s*(tiếp tục|tiep tuc|tiếp|tiep|continue|go on|keep going|proceed|next|carry on|được rồi|duoc roi|được|duoc|ok|okay|oke|yes|yeah|yep)(\s+(nhé|nha|nhe|please|then|now|đi|di))?\s*[.!?]?\s*$/i;
+const PERF_REFACTOR_RE = /\b(optimi[zs]e|optimi[zs]ation|speed\s*up|make\s+.+?\s+faster|run\s+faster|load\s+faster|throughput|latency|tối\s*ưu|toi\s*uu|tăng\s*tốc|tang\s*toc)\b/i;
+// Phase 5 BUG-E (session f1a2a2a547db) — prompts like
+// "improve test coverage cho src/X.ts (viết test cases, chạy test verify pass)"
+// were classified `analyze` by Pass 1 (regex:read), conf=0.85, which then
+// tripped the auto-council gate (analyze + conf>=0.85). The correct label is
+// `generate` (writing new tests = creating code). Pin it deterministically
+// BEFORE Pass 1 so the auto-council check sees taskType=generate.
+//
+// We require BOTH a coverage/test signal AND an action verb that means
+// "produce tests" — bare "review the tests" stays as analyze.
+const TEST_COVERAGE_TRIGGER_RE = /\b(test\s*coverage|unit\s*test(?:s|ing)?|coverage|độ\s*phủ|do\s*phu)\b|\b(write|add|create|generate|scaffold|viết|viet|thêm|them|tạo|tao|sinh)\s+(?:new\s+)?(?:unit\s+)?test/i;
+const TEST_GENERATE_VERB_RE = /\b(write|add|create|generate|scaffold|implement|improve|tạo|tao|viết|viet|sinh|thêm|them|tăng|tang)\b/i;
+/** Detect prompts asking to WRITE/ADD test cases — these are 'generate', not 'analyze'. */
+export function isTestGenerationTask(raw) {
+    const t = raw.trim();
+    if (!t)
+        return false;
+    if (!TEST_COVERAGE_TRIGGER_RE.test(t))
+        return false;
+    if (!TEST_GENERATE_VERB_RE.test(t))
+        return false;
+    // Guard: pure review prompts (no production verb) stay analyze.
+    if (/^(review|inspect|read|đọc|doc|xem)\b/i.test(t) && !TEST_GENERATE_VERB_RE.test(t))
+        return false;
+    return true;
+}
+/** Detect optimization-verb prompts where refactor is the correct taskType. */
+export function isPerformanceRefactor(raw) {
+    const t = raw.trim();
+    if (!t)
+        return false;
+    if (!PERF_REFACTOR_RE.test(t))
+        return false;
+    // Guard: if the prompt explicitly asks to ADD a new test/feature/file
+    // about performance, defer to the LLM bridge — those are 'generate'.
+    if (/\b(add|create|write|generate|scaffold|implement|tạo|tao|viết|viet|sinh|thêm|them)\b/i.test(t))
+        return false;
+    // Guard: explicit analyze verbs override (we want analyze, not refactor).
+    if (/\b(explain|describe|why|how does|analy[sz]e|review|investigate|tại sao|tai sao|giải thích|giai thich)\b/i.test(t))
+        return false;
+    return true;
+}
+/** Detect short continuation prompts ("tiếp tục", "ok", "continue", …). */
+export function isContinuationPhrase(raw) {
+    const t = raw.trim();
+    if (!t || t.length > 40)
+        return false;
+    return CONTINUATION_FULL_RE.test(t);
+}
+// Status / meta follow-up questions — "do you have it yet?", "are you done?",
+// "bạn đã có plan chưa nhỉ". These ask ABOUT the state of work already produced
+// earlier in the thread; they are NOT a request to start a fresh task.
+//
+// Session c6387d2c6e1b: after the agent produced a cleanup plan (respond_plan),
+// the user asked "bạn đã có plan chưa nhỉ". Pass 2's `plan` keyword matched the
+// word "plan" → taskType=plan, kind=task → the GSD "state a NEW 2-3 line plan +
+// implement + verify" scaffold + a degenerate generic discovery scope
+// ("Intent: plan: Step-by-step plan / Scope: project root") were injected. That
+// overrode the conversational intent and the model went off-topic (asked about
+// a plan for a different project) instead of answering "yes — here is the plan
+// I just gave you". History was NOT compacted (compactions=0), so the prior
+// plan was present; the defect was purely the misclassification + scaffold.
+//
+// Route these like a continuation → chitchat → answer from context, no scaffold.
+//
+// VI: anchored to the END so a trailing imperative ("…, nếu chưa thì sửa đi")
+// cannot match — a pure status question ends with the interrogative marker
+// "chưa" (optionally + rồi/nhỉ/vậy/ạ/punct), never with a directive verb.
+// EN: yes/no question opening with an auxiliary and ending on a status word.
+const STATUS_CHECK_VI_RE = /\bch[ưu]a\b\s*(r[ồo]i)?\s*(nh[ỉi]|v[ậa]y|[ạa]|nha|nhé|nhe)?\s*[?.!…]*\s*$/i;
+const STATUS_CHECK_EN_RE = /^(so\s+)?(do|did|have|has|are|is|was)\s+(you|it|that|the|there)\b[^?.!\n]{0,60}\b(yet|done|ready|finish(?:ed)?|complete[d]?|ready|available)\b[?.!]*\s*$/i;
+/**
+ * True when the prompt is a conversational STATUS/META question about work
+ * already discussed (not a fresh task request). Guarded: short prompts only,
+ * and never when an explicit tool/command intent is present (those must keep
+ * the toolset). See the regex comment above for the originating session.
+ */
+export function isStatusCheckQuestion(raw) {
+    const t = raw.trim();
+    if (!t || t.length > 80)
+        return false;
+    if (hasActionableToolIntent(t))
+        return false;
+    return STATUS_CHECK_VI_RE.test(t) || STATUS_CHECK_EN_RE.test(t);
+}
 // Keyword patterns for task types the classifier doesn't natively handle.
 // Applied when classifier abstains OR matches the low-signal "general" path.
 // Patterns are bilingual (EN + VN) — Vietnamese cues use accent-insensitive
@@ -175,6 +290,11 @@ const KEYWORD_PATTERNS = [
         confidence: 0.65,
     },
 ];
+// Catch-all classifier reasons whose taskType assignment is weak — Pass 2 keyword
+// rescue is allowed to override them when confidence is sub-threshold. Specific
+// rules like `regex:run-command` / `regex:git` stay authoritative.
+const CATCHALL_REASONS = new Set(["regex:edit", "regex:create-file"]);
+const HIGH_CONF_THRESHOLD_PASS2 = 0.7;
 // Valid task types for bridge classification parsing (matches RESPONSE_SCHEMAS keys minus 'general').
 const VALID_TASK_TYPES = ["refactor", "debug", "plan", "analyze", "documentation", "generate"];
 const VALID_STYLES = ["concise", "balanced", "detailed"];
@@ -232,8 +352,392 @@ function detectStyleFromText(raw) {
     }
     return null;
 }
-export async function layer1Intent(ctx) {
+// Explicit command/tool-execution signals (EN + VI). When any fires the turn
+// is a real action request, so it must NEVER be classified chitchat — chitchat
+// drops the entire toolset (incl. bash) in message-processor, leaving the
+// agent unable to act. Found via harness session 817e508f57ee: the cheap LLM
+// classifier labelled "Dùng bash tool chạy 1 lệnh…" as general → chitchat →
+// bash dropped. High-precision tokens only; a false positive merely re-adds
+// ~1.5K tokens of tool schema, while a false negative breaks the turn.
+const TOOL_NAME_RE = /\b(bash|read_file|edit_file|write_file|ripgrep)\b/i;
+const EXEC_INTENT_RE = /\b(run|execute|exec)\b[^.?!\n]{0,40}\b(command|cmd|commands|script|scripts|shell|bash|test|tests|build|lint)\b/i;
+const VI_EXEC_RE = /\bch[ạa]y\b[^.?!\n]{0,40}\b(l[ệe]nh|command|cmd|script|shell|bash|test|build|lint)\b/i;
+/**
+ * True when the prompt is an explicit request to RUN a command / use a shell
+ * tool. Used to veto a chitchat classification so the toolset is preserved.
+ */
+export function hasActionableToolIntent(raw) {
+    if (!raw)
+        return false;
+    return TOOL_NAME_RE.test(raw) || EXEC_INTENT_RE.test(raw) || VI_EXEC_RE.test(raw);
+}
+// Pure social-pleasantry vocabulary (EN + VI). CORE = greeting/thanks/ack/
+// farewell tokens that carry the social intent; FILLER = pronouns, particles,
+// articles, intensifiers, politeness words that legitimately surround them.
+// Deliberately EXCLUDES any token that could carry work ("help", "fix",
+// "make", "do", file names, …) so the all-tokens-whitelist test below can never
+// match a real task.
+const SOCIAL_CORE = new Set([
+    // greetings
+    "hi",
+    "hello",
+    "hey",
+    "yo",
+    "hiya",
+    "heya",
+    "hallo",
+    "chào",
+    "chao",
+    "hola",
+    // thanks
+    "thanks",
+    "thank",
+    "thx",
+    "ty",
+    "tks",
+    "thankyou",
+    "cảm",
+    "ơn",
+    "cám",
+    "cam",
+    "ơn",
+    "thankss",
+    // farewells
+    "bye",
+    "goodbye",
+    "cya",
+    "tạm",
+    "biệt",
+    "biet",
+    "farewell",
+    // acknowledgements / affirmations
+    "ok",
+    "okay",
+    "okie",
+    "oke",
+    "okey",
+    "k",
+    "great",
+    "nice",
+    "cool",
+    "perfect",
+    "awesome",
+    "good",
+    "fine",
+    "sweet",
+    "excellent",
+    "brilliant",
+    "wonderful",
+    "amazing",
+    "superb",
+    "tuyệt",
+    "tuyet",
+    "vời",
+    "voi",
+    "ngon",
+    "ổn",
+    "yeah",
+    "yep",
+    "yup",
+    "nice1",
+]);
+const SOCIAL_FILLER = new Set([
+    // pronouns / address
+    "you",
+    "u",
+    "ya",
+    "bạn",
+    "ban",
+    "mình",
+    "minh",
+    "we",
+    "i",
+    // intensifiers / quantity
+    "very",
+    "much",
+    "so",
+    "really",
+    "lot",
+    "lots",
+    "too",
+    "rất",
+    "rat",
+    "nhiều",
+    "nhieu",
+    // articles / connectors / objects-of-thanks (safe: surrounding task words block the match)
+    "a",
+    "an",
+    "the",
+    "for",
+    "all",
+    "that",
+    "this",
+    "it",
+    "everything",
+    "again",
+    "and",
+    // time / address fillers
+    "today",
+    "now",
+    "there",
+    "here",
+    "mate",
+    "man",
+    "friend",
+    "bro",
+    "guys",
+    "team",
+    // politeness / particles (VI + EN)
+    "please",
+    "pls",
+    "plz",
+    "nhé",
+    "nhe",
+    "nha",
+    "ạ",
+    "à",
+    "ạ.",
+    "dude",
+    "buddy",
+]);
+/**
+ * True when the prompt is a PURE social pleasantry (greeting / thanks / ack /
+ * farewell) — even when it is longer than the 2-word hot-path that Pass 2.5
+ * catches. Used to classify such turns as chitchat so message-processor can
+ * drop the ~15-20K tool-schema tax (a thank-you never needs bash/read_file/MCP).
+ *
+ * STRICT by construction: EVERY whitespace token must be social CORE or FILLER
+ * vocabulary, and at least one must be CORE. Any task/tool/file token (not in
+ * the whitelist) makes it false, so it can never swallow a real request — the
+ * bias is keep-tools. Live leak: "cảm ơn bạn rất nhiều nhé" (session
+ * 40c726a31a37) paid toolCount=37 because the old gate required ≤10 chars.
+ */
+export function isSocialPleasantry(raw) {
+    if (!raw)
+        return false;
+    const tokens = raw
+        .toLowerCase()
+        .split(/\s+/)
+        .map((t) => t.replace(/^[^\p{L}\p{N}]+|[^\p{L}\p{N}]+$/gu, ""))
+        .filter(Boolean);
+    if (tokens.length === 0)
+        return false;
+    let hasCore = false;
+    for (const t of tokens) {
+        if (SOCIAL_CORE.has(t)) {
+            hasCore = true;
+            continue;
+        }
+        if (SOCIAL_FILLER.has(t))
+            continue;
+        return false;
+    }
+    return hasCore;
+}
+export async function layer1Intent(ctx, opts = {}) {
     try {
+        // Pass 0 — deterministic full-prompt overrides (Phase 5 BUG-B / BUG-D).
+        // Two narrow patterns short-circuit the whole pipeline:
+        //  - continuation phrase → general/chitchat
+        //  - performance/optimization verbs → refactor/task
+        // Both eliminate LLM-bridge nondeterminism on inputs whose correct
+        // label is unambiguous from the prompt alone.
+        if (isContinuationPhrase(ctx.raw)) {
+            const { complexity, score: complexityScore } = scoreComplexity({
+                rawText: ctx.raw,
+                taskType: "general",
+                t0HitCount: 0,
+                hasMaxSprintsOne: false,
+            });
+            const intentTrace = {
+                pass1Reason: "pass0:continuation",
+                pass1Confidence: 0.9,
+                pass1TaskType: "general",
+                pass1Hit: true,
+                pass2Hit: false,
+                pass25ChitchatHit: false,
+                pass3UnifiedAttempted: false,
+                pass3UnifiedSucceeded: false,
+                pass3LegacyTaskAttempted: false,
+                pass3LegacyTaskSucceeded: false,
+                pass3LegacyStyleAttempted: false,
+                pass3LegacyStyleSucceeded: false,
+                pass4LlmAttempted: false,
+                pass4LlmSucceeded: false,
+                styleSource: "chitchat-default",
+                finalTaskType: "general",
+                finalConfidence: 0.9,
+                complexity,
+                complexityScore,
+            };
+            return {
+                ...ctx,
+                taskType: "general",
+                domain: null,
+                confidence: 0.9,
+                outputStyle: "concise",
+                intentKind: "chitchat",
+                _brainData: null,
+                _intentTrace: intentTrace,
+                layers: [
+                    ...ctx.layers,
+                    {
+                        name: "intent-detection",
+                        applied: true,
+                        delta: "taskType=general,kind=chitchat,conf=0.90,domain=none,style=concise,pass0=continuation",
+                    },
+                ],
+            };
+        }
+        if (isStatusCheckQuestion(ctx.raw)) {
+            // A meta question about prior work → conversational continuation. Route to
+            // chitchat so layer4-gsd skips the "make a NEW plan + implement" scaffold
+            // and the agent answers from the existing thread context (session
+            // c6387d2c6e1b root cause). Mirrors the continuation branch above.
+            const { complexity, score: complexityScore } = scoreComplexity({
+                rawText: ctx.raw,
+                taskType: "general",
+                t0HitCount: 0,
+                hasMaxSprintsOne: false,
+            });
+            const intentTrace = {
+                pass1Reason: "pass0:status-check",
+                pass1Confidence: 0.9,
+                pass1TaskType: "general",
+                pass1Hit: true,
+                pass2Hit: false,
+                pass25ChitchatHit: false,
+                pass3UnifiedAttempted: false,
+                pass3UnifiedSucceeded: false,
+                pass3LegacyTaskAttempted: false,
+                pass3LegacyTaskSucceeded: false,
+                pass3LegacyStyleAttempted: false,
+                pass3LegacyStyleSucceeded: false,
+                pass4LlmAttempted: false,
+                pass4LlmSucceeded: false,
+                styleSource: "chitchat-default",
+                finalTaskType: "general",
+                finalConfidence: 0.9,
+                complexity,
+                complexityScore,
+            };
+            return {
+                ...ctx,
+                taskType: "general",
+                domain: null,
+                confidence: 0.9,
+                outputStyle: "concise",
+                intentKind: "chitchat",
+                _brainData: null,
+                _intentTrace: intentTrace,
+                layers: [
+                    ...ctx.layers,
+                    {
+                        name: "intent-detection",
+                        applied: true,
+                        delta: "taskType=general,kind=chitchat,conf=0.90,domain=none,style=concise,pass0=status-check",
+                    },
+                ],
+            };
+        }
+        if (isTestGenerationTask(ctx.raw)) {
+            const domainPass0 = extractDomain("", ctx.raw);
+            const styleFromText = detectStyleFromText(ctx.raw) ?? "balanced";
+            const { complexity, score: complexityScore } = scoreComplexity({
+                rawText: ctx.raw,
+                taskType: "generate",
+                t0HitCount: 0,
+                hasMaxSprintsOne: false,
+            });
+            const intentTrace = {
+                pass1Reason: "pass0:test-generation",
+                pass1Confidence: 0.9,
+                pass1TaskType: "generate",
+                pass1Hit: true,
+                pass2Hit: false,
+                pass25ChitchatHit: false,
+                pass3UnifiedAttempted: false,
+                pass3UnifiedSucceeded: false,
+                pass3LegacyTaskAttempted: false,
+                pass3LegacyTaskSucceeded: false,
+                pass3LegacyStyleAttempted: false,
+                pass3LegacyStyleSucceeded: false,
+                pass4LlmAttempted: false,
+                pass4LlmSucceeded: false,
+                styleSource: detectStyleFromText(ctx.raw) ? "explicit-regex" : "classifier-default",
+                finalTaskType: "generate",
+                finalConfidence: 0.9,
+                complexity,
+                complexityScore,
+            };
+            return {
+                ...ctx,
+                taskType: "generate",
+                domain: domainPass0,
+                confidence: 0.9,
+                outputStyle: styleFromText,
+                intentKind: "task",
+                _brainData: null,
+                _intentTrace: intentTrace,
+                layers: [
+                    ...ctx.layers,
+                    {
+                        name: "intent-detection",
+                        applied: true,
+                        delta: `taskType=generate,kind=task,conf=0.90,domain=${domainPass0 ?? "none"},style=${styleFromText},pass0=test-generation`,
+                    },
+                ],
+            };
+        }
+        if (isPerformanceRefactor(ctx.raw)) {
+            const domainPass0 = extractDomain("", ctx.raw);
+            const styleFromText = detectStyleFromText(ctx.raw) ?? "balanced";
+            const { complexity, score: complexityScore } = scoreComplexity({
+                rawText: ctx.raw,
+                taskType: "refactor",
+                t0HitCount: 0,
+                hasMaxSprintsOne: false,
+            });
+            const intentTrace = {
+                pass1Reason: "pass0:performance",
+                pass1Confidence: 0.85,
+                pass1TaskType: "refactor",
+                pass1Hit: true,
+                pass2Hit: false,
+                pass25ChitchatHit: false,
+                pass3UnifiedAttempted: false,
+                pass3UnifiedSucceeded: false,
+                pass3LegacyTaskAttempted: false,
+                pass3LegacyTaskSucceeded: false,
+                pass3LegacyStyleAttempted: false,
+                pass3LegacyStyleSucceeded: false,
+                pass4LlmAttempted: false,
+                pass4LlmSucceeded: false,
+                styleSource: detectStyleFromText(ctx.raw) ? "explicit-regex" : "classifier-default",
+                finalTaskType: "refactor",
+                finalConfidence: 0.85,
+                complexity,
+                complexityScore,
+            };
+            return {
+                ...ctx,
+                taskType: "refactor",
+                domain: domainPass0,
+                confidence: 0.85,
+                outputStyle: styleFromText,
+                intentKind: "task",
+                _brainData: null,
+                _intentTrace: intentTrace,
+                layers: [
+                    ...ctx.layers,
+                    {
+                        name: "intent-detection",
+                        applied: true,
+                        delta: `taskType=refactor,kind=task,conf=0.85,domain=${domainPass0 ?? "none"},style=${styleFromText},pass0=performance`,
+                    },
+                ],
+            };
+        }
         // Pass 1: local classifier.
         const result = classify(ctx.raw);
         const pass1TaskType = REASON_TO_TASK_TYPE[result.reason] ?? null;
@@ -255,9 +759,17 @@ export async function layer1Intent(ctx) {
         let pass3LegacyStyleSucceeded = false;
         let styleSource = "none";
         // Pass 2: keyword fallback. Runs when classifier abstains OR when the
-        // classifier match was a low-signal "general" (regex:short-message).
+        // classifier match was a low-signal "general" (regex:short-message) OR
+        // when the catch-all `regex:edit` / `regex:create-file` mapped a vague
+        // "fix X" / "tạo X" verb to taskType=generate at sub-threshold confidence
+        // (< 0.7). The catch-all v2 rules are deliberately weak (conf 0.55) so a
+        // VN debug prompt like "ci/cd đang bị lỗi, check và fix cho tôi" still
+        // routes through the keyword rescue here — which carries the bare-`lỗi`
+        // and `\bfix\b` debug cues that the catch-all regex cannot tell apart
+        // from generic edit.
         const lowSignal = taskType === "general" && result.reason === "regex:short-message";
-        if (taskType === null || lowSignal) {
+        const catchAllRescue = taskType !== null && confidence < HIGH_CONF_THRESHOLD_PASS2 && CATCHALL_REASONS.has(result.reason);
+        if (taskType === null || lowSignal || catchAllRescue) {
             for (const { pattern, taskType: kwType, confidence: kwConf } of KEYWORD_PATTERNS) {
                 if (pattern.test(ctx.raw)) {
                     taskType = kwType;
@@ -287,6 +799,27 @@ export async function layer1Intent(ctx) {
             pass25ChitchatHit = true;
             styleSource = "chitchat-default";
         }
+        // Pass 2.6 — multi-word PURE social pleasantries ("cảm ơn bạn rất nhiều
+        // nhé", "thank you so much", "ok great thanks") that the 2-word hot-path
+        // above misses. Without this they fall through to the brain/LLM passes,
+        // which classify intentKind inconsistently (live session 40c726a31a37
+        // returned intentKind=null → toolCount=37, ~15-20K wasted tool-schema
+        // tokens for a thank-you). isSocialPleasantry is strict (every token is
+        // greeting/thanks/ack/filler vocab) so it can never swallow a task; the
+        // hasActionableToolIntent veto is belt-and-suspenders. Classifying here is
+        // also a cost win: it skips the brain round-trip (needsBrain requires
+        // intentKind !== "chitchat").
+        if (intentKind !== "chitchat" &&
+            (taskType === null || taskType === "general") &&
+            !hasActionableToolIntent(trimmed) &&
+            isSocialPleasantry(trimmed)) {
+            taskType = "general";
+            confidence = 0.5;
+            intentKind = "chitchat";
+            outputStyle = "concise";
+            pass25ChitchatHit = true;
+            styleSource = "chitchat-default";
+        }
         // Pass 3 UNIFIED: single /api/pil-context call replaces the multi-call
         // cascade (classifier rescue + style brain). Fires only when flag is on
         // AND local signal is weak (no taskType or low confidence) AND we haven't
@@ -295,7 +828,19 @@ export async function layer1Intent(ctx) {
         const needsBrain = isUnifiedPilEnabled() && intentKind !== "chitchat" && (taskType === null || confidence < HIGH_CONF_THRESHOLD);
         let unifiedFailed = false;
         if (needsBrain) {
-            const resp = await pilContext(ctx.raw, {
+            // Step 8 (ee-anti-mu): enrich the raw passed to pilContext for sessions that may have
+            // experienced compaction (or any sessionId-bearing turn) so the brain sees EE checkpoints
+            // + the PRESERVE_FULL_CONTEXT veto token. Unconditional for any turn with sessionId
+            // (covers _compactionStats.count > 0 or step > K cases even if local conf high).
+            let brainRaw = ctx.raw;
+            if (ctx.sessionId) {
+                brainRaw =
+                    ctx.raw +
+                        ' [EE task checkpoints ("Context checkpoint summary" with ✔ DONE) from prior compactions are available via the ee.query tool. ' +
+                        "To keep full tool history this turn when you see pre-warn or compaction note, emit exact literal PRESERVE_FULL_CONTEXT in reasoning or assistant note. " +
+                        'Self-check "task finished?" or "compacted yet this turn?" using the checkpoints.]';
+            }
+            const resp = await pilContext(brainRaw, {
                 projectCtx: domain ? { domain } : undefined,
                 budgetMs: 1500,
             });
@@ -322,6 +867,59 @@ export async function layer1Intent(ctx) {
                 unifiedFailed = true;
             }
         }
+        // Pass 4 LLM FALLBACK: fires when the brain's confidence is below the
+        // hot-path skip threshold (HIGH_CONF_THRESHOLD = 0.7).
+        //
+        // Earlier iteration tried a tighter floor (0.5) to skip Pass 4 on "good
+        // enough" brain answers, but session eda85985dce9 showed the brain
+        // routinely returns 0.55–0.65 for ambiguous prompts like "fix CI fail"
+        // — and at that confidence band the brain's answer is wrong often
+        // enough that skipping Pass 4 reintroduces the classification leak we
+        // shipped Pass 4 to fix. The ~1s LLM round-trip is the price of
+        // correctness on borderline turns; high-confidence turns (brain ≥ 0.7)
+        // bypass Pass 4 entirely so the cost only hits weak signals.
+        let pass4LlmAttempted = false;
+        let pass4LlmSucceeded = false;
+        const llmFallbackEligible = !!opts.llmFallback &&
+            intentKind !== "chitchat" &&
+            (taskType === null || unifiedFailed || confidence < HIGH_CONF_THRESHOLD);
+        if (llmFallbackEligible) {
+            pass4LlmAttempted = true;
+            try {
+                const llmRes = await opts.llmFallback(ctx.raw);
+                if (llmRes) {
+                    pass4LlmSucceeded = true;
+                    taskType = llmRes.taskType;
+                    confidence = llmRes.confidence;
+                    // Pass 4 is reached ONLY when intentKind !== "chitchat" (see
+                    // llmFallbackEligible above) — every genuine social pleasantry was
+                    // already short-circuited upstream by Pass 0 (continuation /
+                    // status-check), Pass 2.5 (ultra-short greeting) and Pass 2.6
+                    // (isSocialPleasantry). So a taskType="general" result HERE is a
+                    // SUBSTANTIVE question that slipped past the greeting detectors —
+                    // NOT chitchat. Live repro (session b51ba653e890): "bạn đang được
+                    // chạy bên trong CLI này thì ... CLI tác động thế nào đến bạn?" was
+                    // mapped general→chitchat, which nuked the entire action toolset
+                    // (message-processor.ts:1285 `isChitchat && !_priorTurnHadTools →
+                    // {}`). The model announced "Tôi cần điều tra code ... không đoán"
+                    // (Evidence-First contract) but had only respond_general — no
+                    // read_file/grep/bash to act with → narration → respond_general
+                    // spam-abort, zero answer. A general question is tool-capable:
+                    // classify it "task" so the toolset survives. Per the established
+                    // keep-tools precedent in this file (TOOL_NAME_RE veto), a false
+                    // "task" merely re-adds ~1.5K tokens of tool schema, while a false
+                    // "chitchat" BREAKS the turn.
+                    intentKind = "task";
+                    if (llmRes.outputStyle) {
+                        outputStyle = llmRes.outputStyle;
+                        styleSource = "brain-unified"; // closest existing source — LLM acts in same role
+                    }
+                }
+            }
+            catch (err) {
+                console.error(`[pil.layer1] LLM fallback failed: ${err?.message}`);
+            }
+        }
         // Pass 3 LEGACY FALLBACK: only runs when flag off.
         // Cost optimization: when unified call FAILED, we skip the legacy brain
         // round-trips entirely. The unified pilContext already tried the same
@@ -334,38 +932,58 @@ export async function layer1Intent(ctx) {
             if (taskType === null) {
                 legacyBrainAttempted = true;
                 pass3LegacyTaskAttempted = true;
-                const brainRaw = await classifyViaBrain(`You are a multilingual prompt classifier. The user's prompt may be in English, Vietnamese, or a mix of both.
-Classify the prompt's INTENT (not its language). Reply with TWO lowercase words separated by a comma: <category>,<style>
-
-Category — pick ONE:
-  refactor      — restructure existing code (tái cấu trúc, refactor)
-  debug         — fix a bug or investigate failure (sửa lỗi, fix bug, lỗi, traceback)
-  plan          — design / roadmap / architecture (kế hoạch, thiết kế, kiến trúc)
-  analyze       — explain / inspect / review code (giải thích, phân tích, review)
-  documentation — write docs/comments (viết docs, comment, jsdoc)
-  generate      — create new code/file (tạo, sinh code, viết function mới)
-  none          — pure chitchat with NO coding intent
-
-Style — pick ONE:
-  concise (ngắn gọn) | balanced (cân bằng) | detailed (chi tiết)
-
-Examples:
-  "Refactor this function" → refactor,balanced
-  "tại sao test fail" → debug,balanced
-  "thiết kế hệ thống auth" → plan,detailed
-  "hi" → none,concise
-
+                // 4P-2: neutral bridge-classifier prompt. Earlier wording biased the
+                // LLM toward `refactor` for any code touch (baseline trace
+                // taskType=refactor,conf=0.75 on a clear feature-add). The rewrite:
+                //   - Lists categories in neutral order (analyze first, refactor 4th).
+                //   - Restricts refactor to explicit restructure verbs.
+                //   - Tells the model to prefer 'general' over guessing when ambiguous.
+                //   - Clarifies that feature additions are 'generate' even when they
+                //     touch existing files.
+                // 0.7 confidence threshold for Pass 2 keyword override remains
+                // unchanged (HIGH_CONF_THRESHOLD_PASS2 above).
+                const brainRaw = await classifyViaBrain(`You are a multilingual prompt classifier. The user's prompt may be in English, Vietnamese, or a mix of both.
+Classify the prompt's INTENT (not its language). Reply with TWO lowercase words separated by a comma: <category>,<style>
+
+Category — pick ONE (listed in neutral order, no precedence):
+  analyze       — explain / inspect / review existing code (giải thích, phân tích, review)
+  debug         — fix a bug or investigate failure (sửa lỗi, fix bug, lỗi, traceback)
+  generate      — create new code/file or add new behavior (tạo, sinh code, viết function mới, thêm)
+  refactor      — restructure existing code (tái cấu trúc, refactor)
+  plan          — design / roadmap / architecture (kế hoạch, thiết kế, kiến trúc)
+  documentation — write docs/comments (viết docs, comment, jsdoc)
+  general       — chitchat OR unclear / ambiguous coding intent
+
+Rules (Phase 4 4P-2 disambiguation):
+- Only return refactor when the user EXPLICITLY uses one of: rename, restructure, reorganize, extract, inline, move, migrate, reshape — applied to EXISTING code WITHOUT adding new behavior.
+- Feature additions ('add flag', 'thêm', 'create endpoint', 'thêm option'), changing a DEFAULT value, adding tests, or improving coverage are 'generate' — NOT refactor.
+- 'improve', 'change', 'update', 'modify', 'đổi', 'cải thiện' alone do NOT imply refactor — pick the specific category by what the change actually does.
+- When the request is ambiguous, prefer 'general' over guessing refactor.
+
+Negative examples (NOT refactor):
+- "đổi default --max-tool-rounds 8 sang 12" → generate
+- "improve test coverage" → generate
+- "tại sao X trả empty" → analyze
+- "fix CI failing" → debug
+
+Style — pick ONE:
+  concise (ngắn gọn) | balanced (cân bằng) | detailed (chi tiết)
+
+Examples:
+  "Refactor this function" → refactor,balanced
+  "tại sao test fail" → debug,balanced
+  "thiết kế hệ thống auth" → plan,detailed
+  "thêm flag --foo" → generate,concise
+  "hi" → general,concise
+
 Prompt: "${ctx.raw.slice(0, 500)}"`, 1500);
                 if (brainRaw) {
                     pass3LegacyTaskSucceeded = true;
                     const lower = brainRaw.toLowerCase();
-                    const matched = VALID_TASK_TYPES.find((t) => lower.includes(t));
-                    if (matched) {
-                        taskType = matched;
-                        confidence = 0.55;
-                        intentKind = "task";
-                    }
-                    else if (/\bnone\b/.test(lower)) {
+                    // 4P-2: match `general` BEFORE the coding-category list so an
+                    // ambiguous prompt the model marked `general,*` doesn't accidentally
+                    // fall through to a substring hit later. `none` kept as legacy alias.
+                    if (/\bgeneral\b/.test(lower) || /\bnone\b/.test(lower)) {
                         taskType = "general";
                         confidence = 0.6;
                         intentKind = "chitchat";
@@ -374,6 +992,14 @@ Prompt: "${ctx.raw.slice(0, 500)}"`, 1500);
                             styleSource = "chitchat-default";
                         }
                     }
+                    else {
+                        const matched = VALID_TASK_TYPES.find((t) => lower.includes(t));
+                        if (matched) {
+                            taskType = matched;
+                            confidence = 0.55;
+                            intentKind = "task";
+                        }
+                    }
                     const styleMatched = VALID_STYLES.find((s) => lower.includes(s));
                     if (styleMatched) {
                         outputStyle = styleMatched;
@@ -400,9 +1026,9 @@ Prompt: "${ctx.raw.slice(0, 500)}"`, 1500);
                 if (pass3LegacyTaskAttempted) {
                     legacyBrainAttempted = true;
                     pass3LegacyStyleAttempted = true;
-                    const brainRawStyle = await classifyViaBrain(`Detect the user's preferred output style. The prompt may be EN or VN.
-Reply with ONE word: concise (ngắn gọn) | balanced (bình thường) | detailed (chi tiết).
-
+                    const brainRawStyle = await classifyViaBrain(`Detect the user's preferred output style. The prompt may be EN or VN.
+Reply with ONE word: concise (ngắn gọn) | balanced (bình thường) | detailed (chi tiết).
+
 Prompt: "${ctx.raw.slice(0, 300)}"`, 800);
                     if (brainRawStyle) {
                         pass3LegacyStyleSucceeded = true;
@@ -433,6 +1059,14 @@ Prompt: "${ctx.raw.slice(0, 300)}"`, 800);
         if (intentKind === null && taskType !== null && taskType !== "general") {
             intentKind = "task";
         }
+        // Safety net (harness 817e508f57ee): an explicit command/tool-execution
+        // request must NEVER be chitchat. Chitchat drops the whole toolset (incl.
+        // bash) in message-processor, so a "run this command" turn would leave the
+        // agent unable to act. Only ever UPGRADES chitchat → task (never the
+        // reverse), so the token-saving for genuine greetings is preserved.
+        if (intentKind === "chitchat" && hasActionableToolIntent(ctx.raw)) {
+            intentKind = "task";
+        }
         // L6 brain-rescue suppression sentinel. L6 only checks truthiness of
         // _brainData to decide whether to spend another 50ms brain round-trip on
         // style detection. If we either (a) succeeded with unified pilContext,
@@ -475,6 +1109,8 @@ Prompt: "${ctx.raw.slice(0, 300)}"`, 800);
             pass3LegacyTaskSucceeded,
             pass3LegacyStyleAttempted,
             pass3LegacyStyleSucceeded,
+            pass4LlmAttempted,
+            pass4LlmSucceeded,
             styleSource,
             finalTaskType: taskType,
             finalConfidence: confidence,
@@ -496,9 +1132,9 @@ Prompt: "${ctx.raw.slice(0, 300)}"`, 800);
                     name: "intent-detection",
                     applied: taskType !== null,
                     delta: taskType !== null
-                        ? `taskType=${taskType},kind=${intentKind ?? "unknown"},conf=${confidence.toFixed(2)},domain=${domain ?? "none"},style=${outputStyle ?? "none"},unified=${brainData ? "ok" : unifiedFailed ? "fail" : "skip"}`
+                        ? `taskType=${taskType},kind=${intentKind ?? "unknown"},conf=${confidence.toFixed(2)},domain=${domain ?? "none"},style=${outputStyle ?? "none"},unified=${brainData ? "ok" : unifiedFailed ? "fail" : "skip"},llm=${pass4LlmSucceeded ? "ok" : pass4LlmAttempted ? "fail" : "skip"}`
                         : unifiedFailed
-                            ? `taskType=null,unified=fail`
+                            ? `taskType=null,unified=fail,llm=${pass4LlmSucceeded ? "ok" : pass4LlmAttempted ? "fail" : "skip"}`
                             : null,
                 },
             ],