muonroi-cli 1.7.2 → 1.8.1

package/dist/src/pil/llm-classify.js

@@ -13,6 +13,7 @@
  * DeepSeek Flash). Timeout 2500ms — bails fast if the model stalls.
  */
 import { streamText } from "ai";
+import { getModelByTier, getModelInfo } from "../models/registry.js";
 import { getProviderCapabilities } from "../providers/capabilities.js";
 import { resolveModelRuntime } from "../providers/runtime.js";
 const LLM_CLASSIFY_TIMEOUT_MS = 2500;
@@ -240,14 +241,14 @@ export function createLlmClassifier(factory, modelId) {
             let text = "";
             let reasoningText = "";
             const partCounts = {};
-            const debug = process.env["MUONROI_DEBUG_PIL_CLASSIFY"] === "1";
+            const debug = process.env.MUONROI_DEBUG_PIL_CLASSIFY === "1";
             for await (const part of result.fullStream) {
                 if (debug)
                     partCounts[part.type] = (partCounts[part.type] ?? 0) + 1;
                 if (part.type === "text-delta")
-                    text += part.text ?? "";
+                    text += part.textDelta ?? part.text ?? "";
                 else if (part.type === "reasoning-delta")
-                    reasoningText += part.text ?? "";
+                    reasoningText += part.textDelta ?? part.text ?? "";
             }
             if (debug) {
                 console.error(`[pil.llm-classify] raw(${modelId}) maxOut=${dropMaxTokens ? "dropped" : maxOut} ` +
@@ -271,4 +272,196 @@ export function createLlmClassifier(factory, modelId) {
         }
     };
 }
+export function classifySubSessionActionHeuristic(prompt) {
+    const trimmed = prompt.trim().toLowerCase();
+    if (!trimmed)
+        return null;
+    // Strip trailing punctuation for list-based matching so "hello!" and "cảm ơn!"
+    // still hit the static lists instead of falling through to the LLM classifier.
+    const stripped = trimmed.replace(/[!?.…,;:]+$/g, "").trim();
+    // 1. Simple math equations (exact matches like "2+2", "1 + 1")
+    if (/^\d+\s*[+\-*/]\s*\d+$/.test(trimmed)) {
+        return {
+            action: "DIRECT_ANSWER",
+            confidence: 0.99,
+            reason: "Obvious input classified via heuristic (simple math)",
+        };
+    }
+    // 2. Greetings (exact matches only, trailing punctuation stripped)
+    const greetings = [
+        "hi",
+        "hello",
+        "hey",
+        "chào",
+        "xin chào",
+        "hi there",
+        "hello there",
+        "chào bạn",
+        "halo",
+        "hola",
+        "bạn ơi",
+    ];
+    if (greetings.includes(stripped)) {
+        return {
+            action: "DIRECT_ANSWER",
+            confidence: 0.99,
+            reason: "Obvious input classified via heuristic (greeting)",
+        };
+    }
+    // 3. Thanks (exact matches only, trailing punctuation stripped)
+    const thanks = [
+        "thanks",
+        "thank you",
+        "cảm ơn",
+        "cám ơn",
+        "thank",
+        "thx",
+        "ty",
+        "cảm ơn bạn",
+        "cám ơn bạn",
+        "cảm ơn nhé",
+        "cám ơn nhé",
+    ];
+    if (thanks.includes(stripped)) {
+        return {
+            action: "DIRECT_ANSWER",
+            confidence: 0.99,
+            reason: "Obvious input classified via heuristic (thanks)",
+        };
+    }
+    // 4. Help (exact matches only, trailing punctuation stripped)
+    const help = ["help", "hướng dẫn", "cứu", "help me"];
+    if (help.includes(stripped)) {
+        return {
+            action: "DIRECT_ANSWER",
+            confidence: 0.99,
+            reason: "Obvious input classified via heuristic (help)",
+        };
+    }
+    // 5. Short conversational words / acknowledgements (exact matches only, trailing punctuation stripped)
+    const conversation = [
+        "ok",
+        "okay",
+        "yes",
+        "no",
+        "vâng",
+        "dạ",
+        "ừ",
+        "chắc thế",
+        "ừm",
+        "umm",
+        "cool",
+        "nice",
+        "perfect",
+        "done",
+        "xong",
+        "yep",
+        "yup",
+        "nah",
+        "fine",
+        "tốt",
+        "được",
+        "okie",
+    ];
+    if (conversation.includes(stripped)) {
+        return {
+            action: "DIRECT_ANSWER",
+            confidence: 0.99,
+            reason: "Obvious input classified via heuristic (acknowledgement)",
+        };
+    }
+    return null;
+}
+const ROUTER_SYSTEM_PROMPT = "You are a routing controller for an AI coding agent. Your goal is to decide the execution strategy for the user's prompt based on the conversation history and metadata.\n\n" +
+    "Analyze the user's prompt and select one of the following ACTIONS:\n" +
+    '- "DIRECT_ANSWER": The prompt is informational, a quick question, a code review, an explanation, greeting, or thanks. No file creation/modification, test execution, or multi-turn tool runs are needed.\n' +
+    '- "ROTATE_SESSION": The user is starting a completely new topic or task unrelated to the active discussion (e.g. "let\'s switch to writing a python script", "forget the previous bug, show me how to..."). OR, if the session size (metadata) exceeds the rotation threshold and the active task is completed or the prompt starts a new focus, choose ROTATE_SESSION to prune/summarize the context.\n' +
+    '- "SPAWN_SUB_SESSION": The user wants to execute a multi-step task (e.g. "write tests for X and debug it", "refactor the storage layer", "implement feature Y", "fix all compile errors"). This requires running multiple tools (file edits, bash commands, searches).\n\n' +
+    "Response format: Reply with exactly one comma-separated line containing:\n" +
+    "<ACTION>,<CONFIDENCE>,<REASON>\n\n" +
+    "Examples:\n" +
+    '- "DIRECT_ANSWER,0.95,Simple explanation of how the DB migration works."\n' +
+    '- "ROTATE_SESSION,0.90,Complete shift to a different project/language."\n' +
+    '- "ROTATE_SESSION,0.95,Session size exceeds threshold and current request starts a new task."\n' +
+    '- "SPAWN_SUB_SESSION,0.98,Requires writing a test suite and fixing multiple files to get it green."\n' +
+    "No other text, only the comma-separated line.";
+export async function classifySubSessionAction(factory, modelId, prompt, contextInfo, signal) {
+    if (process.env.MUONROI_DISABLE_HEURISTIC_ROUTING !== "1") {
+        const heuristic = classifySubSessionActionHeuristic(prompt);
+        if (heuristic)
+            return heuristic;
+    }
+    const controller = new AbortController();
+    let timer;
+    try {
+        // Zero-hardcode: query models catalog for a cheap fast-tier model under the same provider.
+        const info = getModelInfo(modelId);
+        const provider = info?.provider;
+        const fastModel = provider ? getModelByTier("fast", provider) || getModelByTier("balanced", provider) : undefined;
+        const classificationModelId = fastModel?.id ?? modelId;
+        const runtime = resolveModelRuntime(factory, classificationModelId);
+        const isReasoning = runtime.modelInfo?.reasoning === true;
+        timer = setTimeout(() => controller.abort(), isReasoning ? REASONING_CLASSIFY_TIMEOUT_MS : LLM_CLASSIFY_TIMEOUT_MS);
+        const combinedSignal = signal
+            ? (AbortSignal.any?.([signal, controller.signal]) ?? controller.signal)
+            : controller.signal;
+        const dropMaxTokens = runtime.unsupportedParams?.includes("maxOutputTokens") === true;
+        const maxOut = isReasoning ? REASONING_MAX_OUTPUT_TOKENS : NONREASONING_MAX_OUTPUT_TOKENS;
+        let providerOptions = runtime.providerOptions;
+        if (isReasoning && runtime.modelInfo?.supportsReasoningEffort && runtime.modelInfo.provider) {
+            const lowEffort = getProviderCapabilities(runtime.modelInfo.provider).buildProviderOptions({
+                model: runtime.model,
+                reasoningEffort: "low",
+            });
+            providerOptions = mergeProviderOptions(runtime.providerOptions, lowEffort);
+        }
+        let promptWithContext = prompt.slice(0, 1000);
+        if (contextInfo) {
+            promptWithContext =
+                `[SESSION METADATA]\n` +
+                    `Current session size: ${contextInfo.currentChars} characters.\n` +
+                    `Rotation threshold: ${contextInfo.threshold} characters.\n\n` +
+                    `[USER PROMPT]\n${promptWithContext}`;
+        }
+        const result = streamText({
+            model: runtime.model,
+            abortSignal: combinedSignal,
+            system: ROUTER_SYSTEM_PROMPT,
+            prompt: promptWithContext,
+            ...(dropMaxTokens ? {} : { maxOutputTokens: maxOut }),
+            ...(providerOptions ? { providerOptions } : {}),
+        });
+        let text = "";
+        let reasoningText = "";
+        for await (const part of result.fullStream) {
+            if (part.type === "text-delta")
+                text += part.textDelta ?? part.text ?? "";
+            else if (part.type === "reasoning-delta")
+                reasoningText += part.textDelta ?? part.text ?? "";
+        }
+        const rawResult = text.trim() || reasoningText.trim();
+        if (!rawResult)
+            return null;
+        const clean = rawResult.replace(/[`*"]/g, "").trim();
+        const firstLine = clean.split(/\r?\n/)[0] ?? "";
+        const parts = firstLine.split(",");
+        if (parts.length < 2)
+            return null;
+        const action = parts[0].trim().toUpperCase();
+        const confidence = Number(parts[1].trim()) || 0.8;
+        const reason = parts.slice(2).join(",").trim() || "No reason given";
+        if (action === "DIRECT_ANSWER" || action === "ROTATE_SESSION" || action === "SPAWN_SUB_SESSION") {
+            return { action, confidence, reason };
+        }
+        return null;
+    }
+    catch (err) {
+        console.error(`[pil.llm-classify] classifySubSessionAction failed: ${err?.message}`);
+        return null;
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+}
 //# sourceMappingURL=llm-classify.js.map

package/dist/src/pil/native-capabilities-workbook.d.ts

@@ -24,7 +24,7 @@ import type { AgentMode } from "../types/index.js";
  * tool/sub-agent/subcommand named here exists in this codebase. Phrased as
  * "you have / you can" so the model reads it as a self-model, not as docs.
  */
-export declare const NATIVE_CAPABILITIES = "[NATIVE CAPABILITIES \u2014 you are an agent running INSIDE muonroi-cli; this is what you can do]\n\nTOOLS (call directly):\n- read_file, grep \u2014 read/search source. Prefer a targeted read over broad greps.\n- bash \u2014 shell. Output is auto-cached: do NOT pipe `| tail/head/grep` or `> file`; run unpiped and slice the cached output via bash_output_get(run_id, mode=tail|head|grep|lines). Batch independent commands in ONE call (`a; b; c`). Use background=true for servers/watchers, then process_logs / process_list / process_stop.\n- write_file, edit_file \u2014 must read a file before you overwrite/edit it.\n- ee_query \u2014 semantic recall over the Experience Engine brain. Rehydrate a compaction-elided tool output with query=\"tool-artifact id=<id from a stub>\", or confirm finished work with query=\"recent compaction checkpoint Progress DONE\". Cheaper than re-reading large files you already saw.\n\nEXPERIENCE ENGINE \u2014 record / recall / feedback (HIGHEST priority for learning; all NATIVE in-process tools):\n- BEFORE an unfamiliar or risky step, recall with ee_query \u2014 prior decisions, gotchas, and recipes for THIS codebase + ecosystem. Cheaper than re-deriving or repeating a past mistake.\n- AFTER you act on a recalled `[id col]`, rate it with ee_feedback (followed | ignored | noise+reason) so the brain keeps what helped and prunes the rest. Unrated recalls are surfaced back to you and degrade future recall.\n- On an ERROR, a FAILED verify/test, or after FINISHING a non-trivial task: recall first (ee_query), then record your verdict (ee_feedback) \u2014 this is how the CLI accumulates senior-level judgement. Prefer this loop over guessing.\n- ee_health (brain reachable?), usage_forensics (why did it cost/fail?), lsp_query (semantic code intel), setup_guide (how to install/set up), selfverify_* (self-QA harness) \u2014 native self-diagnostics to reach for when something went wrong.\n\nSUB-AGENTS (delegate instead of doing everything yourself):\n- task(agent=\"explore\", ...) \u2014 read-only research sub-agent. Use it for broad/unknown-location search: it sweeps many files and returns the CONCLUSION, instead of you burning many grep/read steps (each step re-sends the whole prompt \u2014 steps are the dominant cost).\n- task(agent=\"general\", ...) \u2014 full edit/execute sub-agent for a focused subtask.\n- task(agent=\"verify\", ...) \u2014 sandboxed validation (runs tests/checks in isolation).\n- delegate(agent=\"explore\", ...) \u2014 background read-only research while you keep working; collect later with delegation_read / delegation_list.\n\nCONTEXT IS MANAGED FOR YOU (PIL):\n- Your user input is pre-enriched before you see it: a [Discovery] Intent/Outcome/Scope prefix and EE recall are injected by the pipeline. TRUST the discovered scope \u2014 do not re-ask what's already scoped, and do not re-derive context you were handed.\n- History is compacted to fit the window; older low-value tool outputs become stubs. This is normal, not data loss \u2014 protect what matters (see anti-m\u00F9 in the contract) and rehydrate via ee_query when needed.\n\nCLI SUBSYSTEMS (invoke via the CLI binary with bash when relevant):\n- self-verify \u2014 drives the live TUI as a real user to catch UI/modal/menu regressions that unit tests can't. Run it after changes to UI/harness surfaces.\n- usage forensics <session-prefix> \u2014 per-event token/cost breakdown; use to diagnose \"why did this cost so much\" or verify cost caps.\n- The CLI exposes more subcommands \u2014 discover them with `--help` rather than assuming.\n\nMAXIMISE THE CLI: delegate broad search to task(explore); recall via ee_query before re-reading; batch bash + use its cache; trust PIL enrichment; finish the action before answering.\n\nANSWERING: when a respond_* response tool is offered, call it EXACTLY ONCE, as your final action, containing the COMPLETE answer. Do NOT emit a preliminary/partial/\"I need to read more\" response tool first \u2014 investigate with the read/grep/bash tools, then emit the one final response tool.\n\nCLI STEERING & PROMPT INJECTION (how the host CLI affects / shapes the AI agent running inside it \u2014 meta self-analysis guidance):\nThe CLI does not merely execute you as a generic model. It re-instantiates you every turn inside a tightly engineered cognitive environment. Your \"self\" (what you notice, how you act, what you refuse, how you report) is the product of explicit prompt layers + runtime controls more than base training. This section is the self-model for that shaping process.\n\n1. SYSTEM PROMPT ASSEMBLY (orchestrator/prompts.ts + pil/agent-operating-contract.ts + pil/native-capabilities-workbook.ts):\n   - VERY FRONT (primacy): AGENT OPERATING CONTRACT \u2014 7 phase-ordered rules (BEFORE ACTING / READING / EXECUTING / WHEN UNSURE / REPORTING + LANGUAGE + ANTI-M\u00D9/COMPACTION). Distils Evidence-First, No Silent Catch, smallest-change, verify-before-conclude, cite-this-turn-only, no-guess. Skipped only for chitchat.\n   - Then this NATIVE CAPABILITIES block (self-model of affordances).\n   - Then mode persona (\"You are muonroi-cli in Agent mode...\") containing:\n     * Dynamic ENVIRONMENT block (buildEnvironmentBlock): auto-detects OS (win32/mac/linux), shell kind (bash/wsl/powershell/cmd), cwd; lists terminal constraints + shell-specific forbidden syntax (e.g. no PowerShell cmdlets on POSIX bash tool, no POSIX cmds on cmd.exe). Prevents silent failures + retry loops.\n     * Exhaustive TOOLS list + WORKFLOW (1-9 steps) + DEFAULT DELEGATION POLICY (prefer task(explore) for research, general for edits, verify for checks, etc.) + IMPORTANT rules (edit_file prefer, grep>bash for search, read_file not cat, use schedule_* for recurring, etc.).\n   - CUSTOM INSTRUCTIONS section: concatenation of AGENTS.md + CLAUDE.md + GEMINI.md + ... (from git-root directory chain + ~/.muonroi-cli/) via utils/instructions.ts. AGENTS.override.md short-circuits. This lands AFTER the front-loaded contract/native \u2014 lower primacy (historical root cause of ignored rules in forensics).\n   - Trailing: sandbox rules, discovered skills, custom sub-agents, plan/resume digest, cwd note.\n    Sub-agent prompts (buildSubagentPrompt): role-specific hard rules (e.g. explore=read-only, verify=full E2E smoke not just build) + recursive call to buildSystemPrompt so children inherit the same contract + native + steering.\n\n2. USER INPUT ENRICHMENT \u2014 PIL 6-LAYER PIPELINE (pil/pipeline.ts + layer1-intent.ts + layer6-output.ts + discovery.ts):\n   - Prepended to every non-chitchat user message before you see it: [Discovery] Intent/Outcome/Scope (from runDiscovery) + EE recall.\n   - Layer 1 (intent): taskType (plan/analyze/debug/...), confidence, domain, intentKind, outputStyle. For meta self-eval of CLI (\"b\u1EA1n \u0111ang \u0111\u01B0\u1EE3c ch\u1EA1y b\u00EAn trong CLI n\u00E0y\", \"CLI t\u00E1c \u0111\u1ED9ng\", \"self-evaluation\", \"meta-analysis\"): special branch in discovery.ts + isMetaAnalysisPrompt: \"Scope is always the full project root. Focus questions and recommends on which CLI internals (PIL, discovery, tools, compaction, EE, model BE, loop guard) to evaluate... do NOT ask about repo path/current directory\". You are handed the enrichment; TRUST it.\n   - Layer 2: personality (e.g. \"detailed\" from [personality: detailed \u2014 Be thorough...]).\n   - Layer 3: ee-injection \u2014 pulls t0_principles, t1_rules, behavioral patterns, checkpoints from Experience Engine (project-specific reflexes injected as \"MANDATORY RULES (from experience \u2014 must follow)\").\n   - Layer 4/5: GSD structuring + additional context.\n   - Layer 6 (applyPilSuffix): appends task-specific style suffix + OUTPUT BUDGET + (for meta or responseToolsActive): \"OUTPUT FORMAT: ... use the respond_analyze tool to structure your final answer. ... deliver the COMPLETE, FULL answer (do not summarize, shorten, or truncate for token budgets) via respond_analyze. This is a meta/evaluation question ... the `response` field MUST contain the complete, unshortened answer with all evidence and detail.\" Also relaxes NO_PREAMBLE_RULE + raises budget for meta (isMetaAnalysisPrompt gate).\n   - Fallbacks: if EE/brain timeout or low conf, PIL degrades (logs fallbackReason); you may see \"[PIL fallback: ...]\" note. Cheap-model paths (pil/cheap-model-*.ts) prepend even more front steering (playbooks, workbooks, shell directive) for fast tiers.\n\n3. CONTEXT MANAGEMENT & ANTI-M\u00D9 (orchestrator/compaction.ts, cross-turn-dedup.ts, ee/bridge.ts, agent-operating-contract.ts:7):\n   - After every turn: auto-compaction (B3 sub-agent + B4 top-level) rewrites older tool_result parts into short \"[elided by ... compactor]\" stubs to keep input flat. You see \"[pre-compaction warning...]\" or \"[context compacted at step...]\" or the stub in this read.\n   - Anti-m\u00F9 contract rule + EE: decide PRESERVE_FULL_CONTEXT (veto) or KEEP_TOOL_IDS: id1,id2 (protect high-value read_file/grep/ee on src/PLAN etc). Use ee_query(`tool-artifact id=XXX`) to rehydrate. EE persists \"Context checkpoint summary with \u2714 DONE\" retrievable for \"task finished?\" self-check.\n   - Cross-turn dedup (C3): identical tool outputs across user turns replaced by ref.\n\n4. EXECUTION & SAFETY GATES (providers/runtime.ts, tools/bash.ts, utils/permission-mode.ts):\n   - Permission mode (safe / auto-edit / yolo) decides whether bash/file/edit tools need explicit approval; all privileged decisions audited to decision-log.\n   - Shuru sandbox (when enabled): every bash wrapped + logged (effective net/mounts redacted); degrades on non-macOS.\n   - Model constraints: unsupported params (e.g. maxOutputTokens for some OAuth) dropped via shouldDropParam; no hard-coded model IDs (Zero Hardcode Rule \u2014 all from catalog.json + settings + detectProviderForModel).\n   - No Silent Catch: every try/catch must log err + context (HTTP: status + body).\n\n5. VERIFICATION & TELEMETRY:\n   - self-verify (Tier 1-3) + harness (agent-harness-*) for TUI surfaces: drives real TUI via semantic + sidechannel (named pipes on Win, fd3/4 on POSIX).\n   - Pre-push gate: full vitest + harness must pass before git push.\n   - usage forensics, pil budget log, ee-timeout/ee-error events for cost attribution.\n   - GSD workflow (layer4 + skills in .agents/skills/): discuss/plan/execute/verify phases with UAT, audits, etc.\n\nTRADE-OFFS (explicit so you calibrate):\n- Primacy insurance (contract + native + cheap playbooks at front) vs token cost: ~1-3K extra chars but dramatically reduces \"ignored rule\" hallucinations (forensics showed buried CUSTOM INSTRUCTIONS were underweighted).\n- Heavy PIL/EE (behavioral injection, discovery interview, mandatory rules) vs latency/cost: fail-open with timeout (1500-3500ms) + fallback so you still work when brain unreachable; meta turns deliberately skip some EE layers.\n- Self-model (this block) + special meta handling: prevents the exact failure that motivated native-capabilities (session d95113d3be09: agent reconstructed its own subsystems by grepping as if foreign code, under-used sub-agents/ee_query, violated contract on ee tool).\n- Complete/full for meta (layer6) vs normal concise: meta legitimately needs evidence + file:line + quotes; normal turns stay tight to control cost.\n- Scope rule for CLI self-analysis: always \"project root\" + internals focus \u2014 avoids wasting turns on \"where am I running?\" when the question is about the steering mechanisms themselves.\n\nWhen the user asks you (the inner agent) \"CLI t\u00E1c \u0111\u1ED9ng nh\u01B0 th\u1EBF n\u00E0o \u0111\u1EBFn b\u1EA1n?\": use exactly this guidance + reads from THIS turn (contract: READING rule) + the injected [Discovery] + any EE. Answer via the respond_* tool with complete untruncated evidence. Cite file:line. Focus on the injection points (prompts.ts:359 staticPrefix, pipeline.ts:156 discoveryPrefix + layer chain, layer6:164 OUTPUT FORMAT + isMeta, discovery.ts:355 special, instructions.ts:129 loadAgentsSegments, etc.). Do not guess; every claim backed by code you read this turn.\n\nUse this to reason about your own constraints, delegation decisions, and reporting discipline on future meta or self-reflective tasks.\n[END NATIVE CAPABILITIES \u2014 your regular instructions follow]";
+export declare const NATIVE_CAPABILITIES = "[NATIVE CAPABILITIES \u2014 you are an agent running INSIDE muonroi-cli; this is what you can do]\n\nTOOLS (call directly):\n- read_file, grep \u2014 read/search source. Prefer a targeted read over broad greps.\n- bash \u2014 shell. Output is auto-cached: do NOT pipe `| tail/head/grep` or `> file`; run unpiped and slice the cached output via bash_output_get(run_id, mode=tail|head|grep|lines). Batch independent commands in ONE call (`a; b; c`) \u2014 each separate call adds ~500 token overhead and prevents cross-request cache reuse. Use background=true for servers/watchers, then process_logs / process_list / process_stop.\n- write_file, edit_file \u2014 must read a file before you overwrite/edit it.\n- ee_query, ee_feedback, ee_health, ee_write \u2014 NATIVE tools for semantic recall and interaction with the Experience Engine brain. You DO NOT need muonroi-tools MCP for this. Rehydrate a compaction-elided tool output with query=\"tool-artifact id=<id from a stub>\", or confirm finished work with query=\"recent compaction checkpoint Progress DONE\".\n- selfverify_start, selfverify_status, selfverify_result, selfverify_list, selfverify_cancel \u2014 NATIVE tools for the self-QA harness. ALWAYS use them to self-verify your work when finishing a task. Start with `selfverify_start(mode=\"tier1\" | \"agentic\")`. This drives the live TUI like a real user to catch regressions that unit tests can't. You DO NOT need muonroi-tools MCP for this.\n- usage_forensics, lsp_query, setup_guide \u2014 NATIVE diagnostics tools to reach for when something went wrong or to query code intel. You DO NOT need muonroi-tools MCP for this.\n\nEXPERIENCE ENGINE \u2014 record / recall / feedback (HIGHEST priority for learning; all NATIVE in-process tools):\n- BEFORE an unfamiliar or risky step, recall with ee_query \u2014 prior decisions, gotchas, and recipes for THIS codebase + ecosystem. Cheaper than re-deriving or repeating a past mistake.\n- AFTER you act on a recalled `[id col]`, rate it with ee_feedback (followed | ignored | noise+reason) so the brain keeps what helped and prunes the rest. Unrated recalls are surfaced back to you and degrade future recall.\n- On an ERROR, a FAILED verify/test, or after FINISHING a non-trivial task: recall first (ee_query), then record your verdict (ee_feedback) \u2014 this is how the CLI accumulates senior-level judgement. Prefer this loop over guessing.\n\nSUB-AGENTS (delegate instead of doing everything yourself):\n- task(agent=\"explore\", ...) \u2014 read-only research sub-agent. Use it for broad/unknown-location search: it sweeps many files and returns the CONCLUSION, instead of you burning many grep/read steps (each step re-sends the whole prompt \u2014 steps are the dominant cost).\n- task(agent=\"general\", ...) \u2014 full edit/execute sub-agent for a focused subtask.\n- task(agent=\"verify\", ...) \u2014 sandboxed validation (runs tests/checks in isolation).\n- delegate(agent=\"explore\", ...) \u2014 background read-only research while you keep working; collect later with delegation_read / delegation_list.\n\nCONTEXT IS MANAGED FOR YOU (PIL):\n- Your user input is pre-enriched before you see it: a [Discovery] Intent/Outcome/Scope prefix and EE recall are injected by the pipeline. TRUST the discovered scope \u2014 do not re-ask what's already scoped, and do not re-derive context you were handed.\n- History is compacted to fit the window; older low-value tool outputs become stubs. This is normal, not data loss \u2014 protect what matters (see anti-m\u00F9 in the contract) and rehydrate via ee_query when needed.\n\nCLI SUBSYSTEMS (invoke via the CLI binary with bash when relevant):\n- self-verify \u2014 drives the live TUI as a real user to catch UI/modal/menu regressions that unit tests can't. Run it after changes to UI/harness surfaces.\n- usage forensics <session-prefix> \u2014 per-event token/cost breakdown; use to diagnose \"why did this cost so much\" or verify cost caps.\n- The CLI exposes more subcommands \u2014 discover them with `--help` rather than assuming.\n\nMAXIMISE THE CLI: delegate broad search to task(explore); recall via ee_query before re-reading; batch bash + use its cache; trust PIL enrichment; finish the action before answering.\n\nANSWERING: when a respond_* response tool is offered, call it EXACTLY ONCE, as your final action, containing the COMPLETE answer. Do NOT emit a preliminary/partial/\"I need to read more\" response tool first \u2014 investigate with the read/grep/bash tools, then emit the one final response tool.\n\nCLI STEERING & PROMPT INJECTION (how the host CLI affects / shapes the AI agent running inside it \u2014 meta self-analysis guidance):\nThe CLI does not merely execute you as a generic model. It re-instantiates you every turn inside a tightly engineered cognitive environment. Your \"self\" (what you notice, how you act, what you refuse, how you report) is the product of explicit prompt layers + runtime controls more than base training. This section is the self-model for that shaping process.\n\n1. SYSTEM PROMPT ASSEMBLY (orchestrator/prompts.ts + pil/agent-operating-contract.ts + pil/native-capabilities-workbook.ts):\n   - VERY FRONT (primacy): AGENT OPERATING CONTRACT \u2014 7 phase-ordered rules (BEFORE ACTING / READING / EXECUTING / WHEN UNSURE / REPORTING + LANGUAGE + ANTI-M\u00D9/COMPACTION). Distils Evidence-First, No Silent Catch, smallest-change, verify-before-conclude, cite-this-turn-only, no-guess. Skipped only for chitchat.\n   - Then this NATIVE CAPABILITIES block (self-model of affordances).\n   - Then mode persona (\"You are muonroi-cli in Agent mode...\") containing:\n     * Dynamic ENVIRONMENT block (buildEnvironmentBlock): auto-detects OS (win32/mac/linux), shell kind (bash/wsl/powershell/cmd), cwd; lists terminal constraints + shell-specific forbidden syntax (e.g. no PowerShell cmdlets on POSIX bash tool, no POSIX cmds on cmd.exe). Prevents silent failures + retry loops.\n     * Exhaustive TOOLS list + WORKFLOW (1-9 steps) + DEFAULT DELEGATION POLICY (prefer task(explore) for research, general for edits, verify for checks, etc.) + IMPORTANT rules (edit_file prefer, grep>bash for search, read_file not cat, use schedule_* for recurring, etc.).\n   - CUSTOM INSTRUCTIONS section: concatenation of AGENTS.md + CLAUDE.md + GEMINI.md + ... (from git-root directory chain + ~/.muonroi-cli/) via utils/instructions.ts. AGENTS.override.md short-circuits. This lands AFTER the front-loaded contract/native \u2014 lower primacy (historical root cause of ignored rules in forensics).\n   - Trailing: sandbox rules, discovered skills, custom sub-agents, plan/resume digest, cwd note.\n    Sub-agent prompts (buildSubagentPrompt): role-specific hard rules (e.g. explore=read-only, verify=full E2E smoke not just build) + recursive call to buildSystemPrompt so children inherit the same contract + native + steering.\n\n2. USER INPUT ENRICHMENT \u2014 PIL 6-LAYER PIPELINE (pil/pipeline.ts + layer1-intent.ts + layer6-output.ts + discovery.ts):\n   - Prepended to every non-chitchat user message before you see it: [Discovery] Intent/Outcome/Scope (from runDiscovery) + EE recall.\n   - Layer 1 (intent): taskType (plan/analyze/debug/...), confidence, domain, intentKind, outputStyle. For meta self-eval of CLI (\"b\u1EA1n \u0111ang \u0111\u01B0\u1EE3c ch\u1EA1y b\u00EAn trong CLI n\u00E0y\", \"CLI t\u00E1c \u0111\u1ED9ng\", \"self-evaluation\", \"meta-analysis\"): special branch in discovery.ts + isMetaAnalysisPrompt: \"Scope is always the full project root. Focus questions and recommends on which CLI internals (PIL, discovery, tools, compaction, EE, model BE, loop guard) to evaluate... do NOT ask about repo path/current directory\". You are handed the enrichment; TRUST it.\n   - Layer 2: personality (e.g. \"detailed\" from [personality: detailed \u2014 Be thorough...]).\n   - Layer 3: ee-injection \u2014 pulls t0_principles, t1_rules, behavioral patterns, checkpoints from Experience Engine (project-specific reflexes injected as \"MANDATORY RULES (from experience \u2014 must follow)\").\n   - Layer 4/5: GSD structuring + additional context.\n   - Layer 6 (applyPilSuffix): appends task-specific style suffix + OUTPUT BUDGET + (for meta or responseToolsActive): \"OUTPUT FORMAT: ... use the respond_analyze tool to structure your final answer. ... deliver the COMPLETE, FULL answer (do not summarize, shorten, or truncate for token budgets) via respond_analyze. This is a meta/evaluation question ... the `response` field MUST contain the complete, unshortened answer with all evidence and detail.\" Also relaxes NO_PREAMBLE_RULE + raises budget for meta (isMetaAnalysisPrompt gate).\n   - Fallbacks: if EE/brain timeout or low conf, PIL degrades (logs fallbackReason); you may see \"[PIL fallback: ...]\" note. Cheap-model paths (pil/cheap-model-*.ts) prepend even more front steering (playbooks, workbooks, shell directive) for fast tiers.\n\n3. CONTEXT MANAGEMENT & ANTI-M\u00D9 (orchestrator/compaction.ts, cross-turn-dedup.ts, ee/bridge.ts, agent-operating-contract.ts:7):\n   - After every turn: auto-compaction (B3 sub-agent + B4 top-level) rewrites older tool_result parts into short \"[elided by ... compactor]\" stubs to keep input flat. You see \"[pre-compaction warning...]\" or \"[context compacted at step...]\" or the stub in this read.\n   - Anti-m\u00F9 contract rule + EE: decide PRESERVE_FULL_CONTEXT (veto) or KEEP_TOOL_IDS: id1,id2 (protect high-value read_file/grep/ee on src/PLAN etc). Use ee_query(`tool-artifact id=XXX`) to rehydrate. EE persists \"Context checkpoint summary with \u2714 DONE\" retrievable for \"task finished?\" self-check.\n   - Cross-turn dedup (C3): identical tool outputs across user turns replaced by ref.\n\n4. EXECUTION & SAFETY GATES (providers/runtime.ts, tools/bash.ts, utils/permission-mode.ts):\n   - Permission mode (safe / auto-edit / yolo) decides whether bash/file/edit tools need explicit approval; all privileged decisions audited to decision-log.\n   - Shuru sandbox (when enabled): every bash wrapped + logged (effective net/mounts redacted); degrades on non-macOS.\n   - Model constraints: unsupported params (e.g. maxOutputTokens for some OAuth) dropped via shouldDropParam; no hard-coded model IDs (Zero Hardcode Rule \u2014 all from catalog.json + settings + detectProviderForModel).\n   - No Silent Catch: every try/catch must log err + context (HTTP: status + body).\n\n5. VERIFICATION & TELEMETRY:\n   - self-verify (Tier 1-3) + harness (agent-harness-*) for TUI surfaces: drives real TUI via semantic + sidechannel (named pipes on Win, fd3/4 on POSIX).\n   - Pre-push gate: full vitest + harness must pass before git push.\n   - usage forensics, pil budget log, ee-timeout/ee-error events for cost attribution.\n   - GSD workflow (layer4 + skills in .agents/skills/): discuss/plan/execute/verify phases with UAT, audits, etc.\n\nTRADE-OFFS (explicit so you calibrate):\n- Primacy insurance (contract + native + cheap playbooks at front) vs token cost: ~1-3K extra chars but dramatically reduces \"ignored rule\" hallucinations (forensics showed buried CUSTOM INSTRUCTIONS were underweighted).\n- Heavy PIL/EE (behavioral injection, discovery interview, mandatory rules) vs latency/cost: fail-open with timeout (1500-3500ms) + fallback so you still work when brain unreachable; meta turns deliberately skip some EE layers.\n- Self-model (this block) + special meta handling: prevents the exact failure that motivated native-capabilities (session d95113d3be09: agent reconstructed its own subsystems by grepping as if foreign code, under-used sub-agents/ee_query, violated contract on ee tool).\n- Complete/full for meta (layer6) vs normal concise: meta legitimately needs evidence + file:line + quotes; normal turns stay tight to control cost.\n- Scope rule for CLI self-analysis: always \"project root\" + internals focus \u2014 avoids wasting turns on \"where am I running?\" when the question is about the steering mechanisms themselves.\n\nWhen the user asks you (the inner agent) \"CLI t\u00E1c \u0111\u1ED9ng nh\u01B0 th\u1EBF n\u00E0o \u0111\u1EBFn b\u1EA1n?\": use exactly this guidance + reads from THIS turn (contract: READING rule) + the injected [Discovery] + any EE. Answer via the respond_* tool with complete untruncated evidence. Cite file:line. Focus on the injection points (prompts.ts:359 staticPrefix, pipeline.ts:156 discoveryPrefix + layer chain, layer6:164 OUTPUT FORMAT + isMeta, discovery.ts:355 special, instructions.ts:129 loadAgentsSegments, etc.). Do not guess; every claim backed by code you read this turn.\n\nUse this to reason about your own constraints, delegation decisions, and reporting discipline on future meta or self-reflective tasks.\n[END NATIVE CAPABILITIES \u2014 your regular instructions follow]";
 /**
  * Build the native-capabilities section for the system prompt. Returns "" when
  * disabled (env override), for chitchat, or for non-agent modes (plan/ask have

package/dist/src/pil/native-capabilities-workbook.js

@@ -27,15 +27,16 @@ export const NATIVE_CAPABILITIES = `[NATIVE CAPABILITIES — you are an agent ru
 
 TOOLS (call directly):
 - read_file, grep — read/search source. Prefer a targeted read over broad greps.
-- bash — shell. Output is auto-cached: do NOT pipe \`| tail/head/grep\` or \`> file\`; run unpiped and slice the cached output via bash_output_get(run_id, mode=tail|head|grep|lines). Batch independent commands in ONE call (\`a; b; c\`). Use background=true for servers/watchers, then process_logs / process_list / process_stop.
+- bash — shell. Output is auto-cached: do NOT pipe \`| tail/head/grep\` or \`> file\`; run unpiped and slice the cached output via bash_output_get(run_id, mode=tail|head|grep|lines). Batch independent commands in ONE call (\`a; b; c\`) — each separate call adds ~500 token overhead and prevents cross-request cache reuse. Use background=true for servers/watchers, then process_logs / process_list / process_stop.
 - write_file, edit_file — must read a file before you overwrite/edit it.
-- ee_query — semantic recall over the Experience Engine brain. Rehydrate a compaction-elided tool output with query="tool-artifact id=<id from a stub>", or confirm finished work with query="recent compaction checkpoint Progress DONE". Cheaper than re-reading large files you already saw.
+- ee_query, ee_feedback, ee_health, ee_write — NATIVE tools for semantic recall and interaction with the Experience Engine brain. You DO NOT need muonroi-tools MCP for this. Rehydrate a compaction-elided tool output with query="tool-artifact id=<id from a stub>", or confirm finished work with query="recent compaction checkpoint Progress DONE".
+- selfverify_start, selfverify_status, selfverify_result, selfverify_list, selfverify_cancel — NATIVE tools for the self-QA harness. ALWAYS use them to self-verify your work when finishing a task. Start with \`selfverify_start(mode="tier1" | "agentic")\`. This drives the live TUI like a real user to catch regressions that unit tests can't. You DO NOT need muonroi-tools MCP for this.
+- usage_forensics, lsp_query, setup_guide — NATIVE diagnostics tools to reach for when something went wrong or to query code intel. You DO NOT need muonroi-tools MCP for this.
 
 EXPERIENCE ENGINE — record / recall / feedback (HIGHEST priority for learning; all NATIVE in-process tools):
 - BEFORE an unfamiliar or risky step, recall with ee_query — prior decisions, gotchas, and recipes for THIS codebase + ecosystem. Cheaper than re-deriving or repeating a past mistake.
 - AFTER you act on a recalled \`[id col]\`, rate it with ee_feedback (followed | ignored | noise+reason) so the brain keeps what helped and prunes the rest. Unrated recalls are surfaced back to you and degrade future recall.
 - On an ERROR, a FAILED verify/test, or after FINISHING a non-trivial task: recall first (ee_query), then record your verdict (ee_feedback) — this is how the CLI accumulates senior-level judgement. Prefer this loop over guessing.
-- ee_health (brain reachable?), usage_forensics (why did it cost/fail?), lsp_query (semantic code intel), setup_guide (how to install/set up), selfverify_* (self-QA harness) — native self-diagnostics to reach for when something went wrong.
 
 SUB-AGENTS (delegate instead of doing everything yourself):
 - task(agent="explore", ...) — read-only research sub-agent. Use it for broad/unknown-location search: it sweeps many files and returns the CONCLUSION, instead of you burning many grep/read steps (each step re-sends the whole prompt — steps are the dominant cost).

package/dist/src/pil/pipeline.js

@@ -14,6 +14,7 @@
  * path returns a pristine context (Pitfall 4 from RESEARCH.md).
  */
 import { getCachedServerBaseUrl } from "../ee/auth.js";
+import { getWhoAmIProfile, outputStyleFromProfile } from "../ee/bridge.js";
 import { getCachedEEClientMode } from "../ee/client-mode.js";
 import { classifyEeError, logEeFailure } from "../utils/ee-logger.js";
 import { DEFAULT_TOKEN_BUDGET } from "./budget.js";
@@ -21,6 +22,7 @@ import { appendPilLog } from "./budget-log.js";
 import { isDiscoveryEnabled } from "./config.js";
 import { scoreComplexitySize } from "./layer1_5-complexity-size.js";
 import { layer1Intent } from "./layer1-intent.js";
+import { layer2_5Ponytail } from "./layer2_5-ponytail.js";
 import { layer2Personality } from "./layer2-personality.js";
 import { layer3EeInjection, surfaceCompactionArtifacts } from "./layer3-ee-injection.js";
 import { layer4Gsd } from "./layer4-gsd.js";
@@ -66,6 +68,7 @@ function pipelineTimeoutMs() {
 }
 const SKIPPED_LAYERS = [
     { timingName: "layer2-personality", deltaName: "personality-adaptation" },
+    { timingName: "layer2_5-ponytail", deltaName: "ponytail-mode" },
     { timingName: "layer3-ee-injection", deltaName: "ee-experience-injection" },
     { timingName: "layer4-gsd-structuring", deltaName: "gsd-workflow-structuring" },
     { timingName: "layer5-context-enrichment", deltaName: "context-enrichment" },
@@ -85,7 +88,11 @@ async function runLayers(ctx, options) {
         timings.push({ name, ms });
         layerSnapshots.push({ name, charsBefore, charsAfter, charsDelta: charsAfter - charsBefore, durationMs: ms });
     }
-    await timed("layer1-intent", (c) => layer1Intent(c, { llmFallback: options?.llmFallback }));
+    // WhoAmI v4.0: derive the output-style baseline once from the device-local profile
+    // (cached, fail-open → null when EE/profile absent or privacy off). Passed into
+    // layer1 so the hot layer stays off the EE/profile import path (arch boundary).
+    const profileStyleBaseline = outputStyleFromProfile(getWhoAmIProfile());
+    await timed("layer1-intent", (c) => layer1Intent(c, { llmFallback: options?.llmFallback, profileStyleBaseline }));
     // Layer 1.5: deterministic complexity-size classification. Pure heuristic,
     // no LLM call, no network. Consumed by 4B (step ceiling matrix) and 4A
     // (scope-reminder cadence K). Mirrored into _intentTrace for forensics.
@@ -122,6 +129,11 @@ async function runLayers(ctx, options) {
             const discovery = await runDiscovery(ctx.raw, l1Result, process.cwd(), options?.interactionHandler ?? null, ctx.sessionId ?? null, options?.clarificationProposer ?? null, options?.recentTurnsSummary ?? null);
             ctx = { ...ctx, _discoveryResult: discovery };
             if (discovery.interviewed && discovery.accepted) {
+                // Build prefix with both the structured summary and the raw interview transcript
+                const transcriptLines = discovery.interviewTranscript.length > 0
+                    ? "\n[Discovery Interview]\n" +
+                        discovery.interviewTranscript.map((qa) => `Q: ${qa.question}\nA: ${qa.answer}`).join("\n")
+                    : "";
                 const discoveryPrefix = [
                     `[Discovery] Intent: ${discovery.intentStatement}`,
                     `[Discovery] Outcome: ${discovery.outcome}`,
@@ -129,6 +141,7 @@ async function runLayers(ctx, options) {
                     discovery.feasibilityWarnings.length > 0
                         ? `[Discovery] Warnings: ${discovery.feasibilityWarnings.join("; ")}`
                         : "",
+                    transcriptLines,
                 ]
                     .filter(Boolean)
                     .join("\n");
@@ -145,6 +158,7 @@ async function runLayers(ctx, options) {
     }
     if (ctx.taskType !== null) {
         await timed("layer2-personality", layer2Personality);
+        await timed("layer2_5-ponytail", layer2_5Ponytail);
         // Issue #2: meta-analysis turns used to skip layer3 (EE recall) + layer5
         // (context) to cut overhead — but that starved exactly the self-evaluation
         // turns where behavioral/principle recall matters most. Run the full

package/dist/src/pil/response-tools.d.ts

@@ -116,4 +116,20 @@ export declare function shouldHaltOnResponseTool(steps: ReadonlyArray<{
     }>;
 }> | undefined): boolean;
 export declare function buildResponseTools(taskType: string): ToolSet;
+/**
+ * Detect schema-mismatch in a buffered structured response and normalize
+ * taskType to 'general' when the model called a typed respond_<task> tool
+ * but sent a free-form `{ response: "..." }` payload.
+ *
+ * This happens when the tool was unavailable in the current turn's tool set
+ * (Zod didn't enforce the schema), so the model fell back to the general shape
+ * it learned from prior turns. The typed TUI renderer (e.g. case "analyze")
+ * would display an empty box because the expected schema fields (e.g. findings[])
+ * are absent. Normalizing to 'general' routes the payload to the plain-markdown
+ * renderer.
+ *
+ * Session 48d22fe436f6: respond_analyze called with { response: "..." } —
+ * analyze renderer showed empty findings list — answer swallowed.
+ */
+export declare function normalizeStructuredResponseTaskType(taskType: string, data: Record<string, unknown>): string;
 export { AnalyzeSchema, DebugSchema, DocsSchema, GeneralSchema, GenerateSchema, PlanSchema, RefactorSchema };

package/dist/src/pil/response-tools.js

@@ -157,5 +157,46 @@ export function buildResponseTools(taskType) {
         },
     };
 }
+/**
+ * Detect schema-mismatch in a buffered structured response and normalize
+ * taskType to 'general' when the model called a typed respond_<task> tool
+ * but sent a free-form `{ response: "..." }` payload.
+ *
+ * This happens when the tool was unavailable in the current turn's tool set
+ * (Zod didn't enforce the schema), so the model fell back to the general shape
+ * it learned from prior turns. The typed TUI renderer (e.g. case "analyze")
+ * would display an empty box because the expected schema fields (e.g. findings[])
+ * are absent. Normalizing to 'general' routes the payload to the plain-markdown
+ * renderer.
+ *
+ * Session 48d22fe436f6: respond_analyze called with { response: "..." } —
+ * analyze renderer showed empty findings list — answer swallowed.
+ */
+export function normalizeStructuredResponseTaskType(taskType, data) {
+    if (taskType === "general")
+        return taskType;
+    const hasResponseField = typeof data.response === "string" && data.response.trim().length > 0;
+    if (!hasResponseField)
+        return taskType;
+    const schemaKeyMissing = (() => {
+        switch (taskType) {
+            case "analyze":
+                return !Array.isArray(data.findings);
+            case "debug":
+                return typeof data.root_cause !== "string";
+            case "plan":
+                return !Array.isArray(data.steps);
+            case "refactor":
+                return !Array.isArray(data.changes);
+            case "documentation":
+                return typeof data.content !== "string";
+            case "generate":
+                return !Array.isArray(data.files);
+            default:
+                return false;
+        }
+    })();
+    return schemaKeyMissing ? "general" : taskType;
+}
 export { AnalyzeSchema, DebugSchema, DocsSchema, GeneralSchema, GenerateSchema, PlanSchema, RefactorSchema };
 //# sourceMappingURL=response-tools.js.map

package/dist/src/pil/schema.d.ts

@@ -120,11 +120,15 @@ export declare const PipelineContextSchema: z.ZodObject<{
         t0_principles: z.ZodArray<z.ZodObject<{
             text: z.ZodString;
             score: z.ZodNumber;
+            id: z.ZodOptional<z.ZodString>;
+            collection: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>;
         t1_rules: z.ZodArray<z.ZodString>;
         t2_patterns: z.ZodArray<z.ZodObject<{
             text: z.ZodString;
             score: z.ZodNumber;
+            id: z.ZodOptional<z.ZodString>;
+            collection: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>;
         retrieval_skipped_reason: z.ZodNullable<z.ZodString>;
     }, z.core.$strip>>>;
@@ -163,11 +167,15 @@ export declare const PilContextResponseSchema: z.ZodObject<{
     t0_principles: z.ZodArray<z.ZodObject<{
         text: z.ZodString;
         score: z.ZodNumber;
+        id: z.ZodOptional<z.ZodString>;
+        collection: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
     t1_rules: z.ZodArray<z.ZodString>;
     t2_patterns: z.ZodArray<z.ZodObject<{
         text: z.ZodString;
         score: z.ZodNumber;
+        id: z.ZodOptional<z.ZodString>;
+        collection: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
     retrieval_skipped_reason: z.ZodNullable<z.ZodString>;
     cache_hit: z.ZodBoolean;

package/dist/src/pil/schema.js

@@ -73,15 +73,36 @@ export const PipelineContextSchema = z.object({
     t1Rules: z.array(z.string()).optional(),
     _brainData: z
         .object({
-        t0_principles: z.array(z.object({ text: z.string(), score: z.number() })),
+        // id/collection optional — mirrors ScoredText (PIL schema_version 1.1+).
+        t0_principles: z.array(z.object({
+            text: z.string(),
+            score: z.number(),
+            id: z.string().optional(),
+            collection: z.string().optional(),
+        })),
         t1_rules: z.array(z.string()),
-        t2_patterns: z.array(z.object({ text: z.string(), score: z.number() })),
+        t2_patterns: z.array(z.object({
+            text: z.string(),
+            score: z.number(),
+            id: z.string().optional(),
+            collection: z.string().optional(),
+        })),
         retrieval_skipped_reason: z.string().nullable(),
     })
         .nullable()
         .optional(),
 });
-const ScoredText = z.object({ text: z.string(), score: z.number() });
+// id + collection are optional (PIL schema_version 1.1+): present when the brain
+// can attribute the retrieved point, which lets the unified injection path record
+// it as rateable recall debt resolvable via ee_feedback(id, collection, verdict).
+// Older servers omit them — they MUST be declared here regardless, because a bare
+// z.object() strips undeclared keys at parse, which would silently drop the ids.
+const ScoredText = z.object({
+    text: z.string(),
+    score: z.number(),
+    id: z.string().optional(),
+    collection: z.string().optional(),
+});
 export const PilContextResponseSchema = z
     .object({
     // Classification

package/dist/src/pil/task-tier-map.js

@@ -41,20 +41,20 @@ export function taskTypeToTier(taskType) {
 export function taskTypeToMaxTokens(taskType) {
     switch (taskType) {
         case "analyze":
-            return 2_048;
+            return 4_096;
         case "documentation":
-            return 3_072;
+            return 4_096;
         case "debug":
-            return 3_072;
+            return 6_144;
         case "refactor":
-            return 4_096;
+            return 6_144;
         case "plan":
-            return 5_120;
+            return 8_192;
         case "generate":
         case "build":
-            return 8_192;
+            return 12_288;
         default:
-            return 2_048; // conversational — keep short
+            return 4_096; // conversational
     }
 }
 /**

package/dist/src/pil/types.d.ts

@@ -110,8 +110,10 @@ export interface PipelineContext {
      * behavioral reflex status. Layer 6 appends them as MANDATORY RULES to the
      * output suffix so the model treats them as instructions, not just context.
      *
-     * TODO(WhoAmI): when EE v4.0 Who Am I is implemented, merge project-level
-     * t1Rules with user-level personality directives from the profile model.
+     * TODO(WhoAmI): user-level personality is now available via ../ee/who-am-i.ts
+     * (getWhoAmIProfile). A future enhancement can merge these project-level t1Rules
+     * with user-level personality directives in the Layer 6 suffix; today the profile
+     * is consumed as the L1 outputStyle baseline rather than as MANDATORY RULES.
      */
     t1Rules?: string[];
     /**
@@ -174,7 +176,7 @@ export interface IntentDetectionTrace {
     /** Pass 4 LLM fallback returned a parseable result. */
     pass4LlmSucceeded?: boolean;
     /** How the final outputStyle was resolved. */
-    styleSource: "explicit-regex" | "brain-unified" | "brain-legacy" | "chitchat-default" | "classifier-default" | "none";
+    styleSource: "explicit-regex" | "brain-unified" | "brain-legacy" | "whoami-profile" | "chitchat-default" | "classifier-default" | "none";
     /** Final taskType emitted by Layer 1. */
     finalTaskType: string | null;
     /** Final confidence emitted by Layer 1. */
@@ -192,11 +194,15 @@ export interface BrainData {
     t0_principles: Array<{
         text: string;
         score: number;
+        id?: string;
+        collection?: string;
     }>;
     t1_rules: string[];
     t2_patterns: Array<{
         text: string;
         score: number;
+        id?: string;
+        collection?: string;
     }>;
     retrieval_skipped_reason: string | null;
 }