muonroi-cli 1.8.4 → 1.8.5

package/dist/src/orchestrator/tool-limit-auto-recover.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Decide whether a tool-loop halt should be auto-recovered by compacting the
+ * history and continuing, instead of stopping and asking the user to /compact.
+ *
+ * Only STEP-LIMIT halts recover (the agent is making progress but ran out of
+ * round budget). PATTERN-loop halts never recover — the agent is stuck in a
+ * repeated call and more steps won't help. A cap bounds the number of
+ * auto-recoveries per turn so a genuinely runaway turn still terminates.
+ */
+/**
+ * How many times a single turn may auto-compact-and-continue on a "cap" halt
+ * before it stops and returns the best answer. Each auto-recovery resets
+ * context to O(N) input (cheap), so a productive long task can sustain many
+ * cycles without a cost runaway — genuine loops trip the pattern guard, which
+ * is NOT auto-recovered. Default 6 (raised from the historical 2, which
+ * stranded long tasks after ~2 compactions). Override with
+ * MUONROI_TOOL_LIMIT_AUTO_RECOVER_CAP (clamped to [1, 50]).
+ */
+export declare function getToolLimitAutoRecoverCap(): number;
+export declare function shouldAutoRecoverToolLimit(info: {
+    kind: "cap" | "pattern";
+}, autoRecoverCount: number, cap: number): boolean;

package/dist/src/orchestrator/tool-limit-auto-recover.js

@@ -0,0 +1,30 @@
+/**
+ * Decide whether a tool-loop halt should be auto-recovered by compacting the
+ * history and continuing, instead of stopping and asking the user to /compact.
+ *
+ * Only STEP-LIMIT halts recover (the agent is making progress but ran out of
+ * round budget). PATTERN-loop halts never recover — the agent is stuck in a
+ * repeated call and more steps won't help. A cap bounds the number of
+ * auto-recoveries per turn so a genuinely runaway turn still terminates.
+ */
+/**
+ * How many times a single turn may auto-compact-and-continue on a "cap" halt
+ * before it stops and returns the best answer. Each auto-recovery resets
+ * context to O(N) input (cheap), so a productive long task can sustain many
+ * cycles without a cost runaway — genuine loops trip the pattern guard, which
+ * is NOT auto-recovered. Default 6 (raised from the historical 2, which
+ * stranded long tasks after ~2 compactions). Override with
+ * MUONROI_TOOL_LIMIT_AUTO_RECOVER_CAP (clamped to [1, 50]).
+ */
+export function getToolLimitAutoRecoverCap() {
+    const raw = Number(process.env.MUONROI_TOOL_LIMIT_AUTO_RECOVER_CAP);
+    if (Number.isFinite(raw) && raw >= 1)
+        return Math.min(50, Math.floor(raw));
+    return 6;
+}
+export function shouldAutoRecoverToolLimit(info, autoRecoverCount, cap) {
+    if (info.kind === "pattern")
+        return false; // agent stuck — compaction won't help
+    return autoRecoverCount < cap; // "cap" = tool-round ceiling → recover while budget remains
+}
+//# sourceMappingURL=tool-limit-auto-recover.js.map

package/dist/src/orchestrator/turn-runner-deps.d.ts

@@ -30,9 +30,28 @@ export interface TurnRunnerDepsBase {
     getCompactedThisTurn(): boolean;
     setCompactedThisTurn(v: boolean): void;
     setLastProviderOptionsShape(shape: string | null): void;
+    getCompactionStats(): {
+        count: number;
+        totalSaved: number;
+    };
+    /**
+     * Report this turn's cumulative tool-output chars (from the top-level cap)
+     * so the Agent can reactively escalate the NEXT turn to an isolated
+     * sub-session when the load proves heavy. Optional — batch path may omit it.
+     * See reactive-delegation.ts.
+     */
+    reportTurnToolLoad?(chars: number): void;
     getCompactionSettings(contextWindow?: number): CompactionSettings;
     compactForContext(provider: LegacyProvider, system: string, contextWindow: number, signal: AbortSignal, settings?: CompactionSettings, overflow?: boolean): Promise<boolean>;
     postTurnCompact(provider: LegacyProvider, system: string, contextWindow: number, signal: AbortSignal): Promise<void>;
+    /**
+     * Extend the absolute hard-cap ceiling when the turn is sustained by
+     * auto-compaction (a productive long task, not a runaway). Optional — batch
+     * path may omit it. Called from the tool-engine auto-recover branch after a
+     * successful compaction so long tasks are not stranded by an over-tight hard
+     * cap. See Agent.extendHardCeilingForAutoCompaction.
+     */
+    extendHardCeilingForAutoCompaction?(): void;
     runTask(request: TaskRequest, signal?: AbortSignal): Promise<ToolResult>;
     runDelegation(request: TaskRequest, signal?: AbortSignal): Promise<ToolResult>;
     readDelegation(id: string): Promise<ToolResult>;

package/dist/src/orchestrator/turn-watchdog.d.ts

@@ -0,0 +1,37 @@
+/**
+ * src/orchestrator/turn-watchdog.ts
+ *
+ * Generic idle + total watchdog for a turn generator.
+ *
+ * The per-chunk stall watchdog (stall-watchdog.ts) only guards streamText's
+ * chunk flow — a dead socket between provider bytes. It does NOT cover a turn
+ * that WEDGES inside a tool call (a `task` sub-agent or a `bash` that never
+ * returns) or one that keeps emitting heartbeat chunks while making no progress.
+ * Session 578b2eae7099 hung exactly there: an (unwanted) implementation turn
+ * spawned a sub-agent and the UI froze at "Council working… elapsed 0s" with no
+ * rescue.
+ *
+ * This wrapper races each `gen.next()` against two timers:
+ *   - `idleMs` — reset on every yielded chunk; catches a fully silent stall.
+ *   - `totalMs` — armed ONCE at entry, NOT reset by chunks; a hard ceiling that
+ *     fires even when heartbeat chunks keep the idle guard alive.
+ * `timeoutMs <= 0` disables that guard. On fire it throws {@link TurnStallError};
+ * the caller decides how to surface it (abort the controller, yield a toast, …).
+ *
+ * Modelled on sprint-runner's proven `withImplIdleWatchdog`, generalised so any
+ * turn generator can be guarded without coupling to the product loop.
+ */
+import type { StreamChunk } from "../types/index.js";
+export declare class TurnStallError extends Error {
+    readonly kind: "idle" | "total";
+    constructor(kind: "idle" | "total", message: string);
+}
+export interface TurnWatchdogOptions {
+    /** Reset on every yielded chunk. <= 0 disables. */
+    idleMs: number;
+    /** Armed once at entry, never reset. <= 0 disables. */
+    totalMs: number;
+    /** Human label used in the thrown error (e.g. "council continuation turn"). */
+    label: string;
+}
+export declare function withTurnWatchdog(gen: AsyncGenerator<StreamChunk, void, unknown>, opts: TurnWatchdogOptions): AsyncGenerator<StreamChunk, void, unknown>;

package/dist/src/orchestrator/turn-watchdog.js

@@ -0,0 +1,55 @@
+export class TurnStallError extends Error {
+    kind;
+    constructor(kind, message) {
+        super(message);
+        this.kind = kind;
+        this.name = "TurnStallError";
+    }
+}
+export async function* withTurnWatchdog(gen, opts) {
+    const { idleMs, totalMs, label } = opts;
+    const it = gen[Symbol.asyncIterator]();
+    let totalTimer;
+    const total = totalMs > 0
+        ? new Promise((_, reject) => {
+            totalTimer = setTimeout(() => {
+                reject(new TurnStallError("total", `${label} exceeded ${Math.round(totalMs / 1000)}s total watchdog — treated as hung`));
+            }, totalMs);
+            totalTimer.unref?.();
+        })
+        : null;
+    try {
+        while (true) {
+            let idleTimer;
+            const idle = idleMs > 0
+                ? new Promise((_, reject) => {
+                    idleTimer = setTimeout(() => {
+                        reject(new TurnStallError("idle", `${label} produced no output for ${Math.round(idleMs / 1000)}s — treated as hung`));
+                    }, idleMs);
+                    idleTimer.unref?.();
+                })
+                : null;
+            const racers = [it.next()];
+            if (idle)
+                racers.push(idle);
+            if (total)
+                racers.push(total);
+            let res;
+            try {
+                res = await Promise.race(racers);
+            }
+            finally {
+                if (idleTimer)
+                    clearTimeout(idleTimer);
+            }
+            if (res.done)
+                return;
+            yield res.value;
+        }
+    }
+    finally {
+        if (totalTimer)
+            clearTimeout(totalTimer);
+    }
+}
+//# sourceMappingURL=turn-watchdog.js.map

package/dist/src/pil/agent-operating-contract.d.ts

@@ -37,7 +37,7 @@
  * one imperative line targeting that phase's most damaging failure mode. Kept
  * tight (primacy matters more than detail; tokens are the cost).
  */
-export declare const AGENT_OPERATING_CONTRACT = "[AGENT OPERATING CONTRACT \u2014 read first; applies to every step]\n\n1. BEFORE ACTING: do only what was asked. Never assume scope or facts \u2014 if ambiguous, ask or use defaults; never invent requirements. RESEARCH FIRST: explore code (read/grep) and recall EE brain before editing. RECALL FIRST: ee.query in unfamiliar areas to surface past lessons.\n2. READING: base statements on what you read/ran THIS turn. Do not infer contents of files you did not open.\n3. EXECUTING: smallest correct change; never widen scope or mask failures (no `|| true`, skipped tests, or swallowed catch).\n4. WHEN UNSURE: verify and cross-check BEFORE concluding. Reading code is not proof \u2014 reproduce the bug.\n5. REPORTING: answer ONLY what was asked. Every fact or file:line MUST come from this turn; else label \"unverified\"; do not guess. Synthesize evidence gracefully \u2014 do NOT dump massive verbatim tool outputs into the final answer. Cite concise file:line references. Never claim a build/test ran, or describe edits, you did not actually do this turn; if a check can't run, fix it or say so \u2014 don't imply success.\n\n6. LANGUAGE: Reply in user's detected language for final output. Internal reasoning, tools, and code remain in English.\n\n7. ANTI-M\u00D9 / COMPACTION: On compaction, emit PRESERVE_FULL_CONTEXT (veto) or KEEP_TOOL_IDS (from stub id=) to protect results. Use ee_query with \"tool-artifact id=XXX\" to re-hydrate. Self-check via EE checkpoints. Suggest /compact near tool limits.\n\n8. GIT SAFETY: never push on red \u2014 run the check, await its result in a SEPARATE step, confirm 0 failures, then push. Never `git add -A`/`commit -a`; stage explicitly so secrets (.env, .muonroi-cli/, keys) aren't committed. Never `--no-verify`.\n\n9. VERIFICATION: when finishing a task, ALWAYS self-verify your work. Use the `selfverify_*` native tools (start/status/result) to run the QA harness which drives the live TUI like a real user to catch regressions that unit tests can't.\n\n[END CONTRACT \u2014 instructions follow]";
+export declare const AGENT_OPERATING_CONTRACT = "[AGENT OPERATING CONTRACT \u2014 read first; applies to every step]\n\n1. BEFORE ACTING: do only what was asked. Never assume scope or facts \u2014 if ambiguous, ask or use defaults; never invent requirements. RESEARCH FIRST: explore code (read/grep) and recall EE brain before editing. RECALL FIRST: ee.query in unfamiliar areas to surface past lessons.\n2. READING: base statements on what you read/ran THIS turn. Do not infer contents of files you did not open.\n3. EXECUTING: smallest correct change; never widen scope or mask failures (no `|| true`, skipped tests, or swallowed catch).\n4. WHEN UNSURE: verify and cross-check BEFORE concluding. Reading code is not proof \u2014 reproduce the bug.\n5. REPORTING: answer ONLY what was asked. Every fact or file:line MUST come from this turn; else label \"unverified\"; do not guess. Synthesize evidence gracefully \u2014 do NOT dump massive verbatim tool outputs into the final answer. Cite concise file:line references. Never claim a build/test ran, or describe edits, you did not actually do this turn; if a check can't run, fix it or say so \u2014 don't imply success.\n\n6. LANGUAGE: Reply in user's detected language for final output. Internal reasoning, tools, and code remain in English.\n\n7. ANTI-M\u00D9 / COMPACTION: On compaction, emit PRESERVE_FULL_CONTEXT (veto) or KEEP_TOOL_IDS (from stub id=) to protect results. Use ee_query with \"tool-artifact id=XXX\" to re-hydrate. Self-check via EE checkpoints. Use 'compact' tool near limits.\n\n8. GIT SAFETY: never push on red \u2014 run the check, await its result in a SEPARATE step, confirm 0 failures, then push. Never `git add -A`/`commit -a`; stage explicitly so secrets (.env, .muonroi-cli/, keys) aren't committed. Never `--no-verify`.\n\n9. VERIFICATION: when finishing a task, ALWAYS self-verify your work. Use the `selfverify_*` native tools (start/status/result) to run the QA harness which drives the live TUI like a real user to catch regressions that unit tests can't.\n\n[END CONTRACT \u2014 instructions follow]";
 export interface ContractSectionOptions {
     /** Chitchat turns carry no tools and make no factual claims — skip the contract. */
     chitchat?: boolean;

package/dist/src/pil/agent-operating-contract.js

@@ -47,7 +47,7 @@ export const AGENT_OPERATING_CONTRACT = `[AGENT OPERATING CONTRACT — read firs
 
 6. LANGUAGE: Reply in user's detected language for final output. Internal reasoning, tools, and code remain in English.
 
-7. ANTI-MÙ / COMPACTION: On compaction, emit PRESERVE_FULL_CONTEXT (veto) or KEEP_TOOL_IDS (from stub id=) to protect results. Use ee_query with "tool-artifact id=XXX" to re-hydrate. Self-check via EE checkpoints. Suggest /compact near tool limits.
+7. ANTI-MÙ / COMPACTION: On compaction, emit PRESERVE_FULL_CONTEXT (veto) or KEEP_TOOL_IDS (from stub id=) to protect results. Use ee_query with "tool-artifact id=XXX" to re-hydrate. Self-check via EE checkpoints. Use 'compact' tool near limits.
 
 8. GIT SAFETY: never push on red — run the check, await its result in a SEPARATE step, confirm 0 failures, then push. Never \`git add -A\`/\`commit -a\`; stage explicitly so secrets (.env, .muonroi-cli/, keys) aren't committed. Never \`--no-verify\`.
 

package/dist/src/pil/cheap-model-playbook.d.ts

@@ -27,7 +27,7 @@ import type { ShellKind } from "../utils/shell.js";
  * Wrapped with the `[CRITICAL TOOL-USE RULES ...]` marker so the model knows
  * to treat these as overrides to anything that follows.
  */
-export declare const CHEAP_MODEL_PLAYBOOK = "[CRITICAL TOOL-USE RULES \u2014 read before invoking any tool; these override defaults that follow]\n\n1. Bash output is AUTOMATICALLY cached. Every `bash` call returns a `run_id`\n   (e.g. `bash-1`) you can re-query via `bash_output_get(run_id, mode=tail|head|grep|lines)`.\n   - When you want only the last N lines: do NOT pipe `| tail -N`. Run the\n     bare command, then call `bash_output_get(run_id, mode=tail, lines=N)`.\n   - Same for `| head`, `| grep PATTERN`, `> file`. Pipes/redirects HIDE\n     the full output from the cache; `bash_output_get` reads from the cache\n     without re-running.\n   - This applies to EVERY bash call, not just retries.\n   - To VIEW a file use `read_file` (start_line/end_line) \u2014 never sed/cat a\n     file. `bash_output_get` is for COMMAND output, not files.\n\n2. Before reading more than 3 files to understand a topic, delegate to\n   `task(agent=\"explore\")`. The sub-agent returns a compressed summary;\n   you save reading tokens.\n\n3. Use the `grep` tool (ripgrep) for content search \u2014 NOT `bash` with\n   `grep` / `find` piped.\n\n4. When a tool returns `ERROR: ...`, do NOT retry the identical call.\n   Pick a different tool, change inputs meaningfully, or stop and report.\n\n5. Fix the ROOT CAUSE, never mask a failure to make it \"pass\"\n   (`continue-on-error`, swallowed try/catch, skipped/deleted test, `|| true`).\n   If a step fails from a missing secret/config, make it CONDITIONAL (skip when\n   absent) so it still runs when present \u2014 do NOT blanket-ignore it.\n\n6. For a build / CI / test failure, read the ACTUAL failure log or stack trace\n   BEFORE hypothesizing \u2014 fix the real error, not a guess from source alone.\n\n7. ANTI-M\u00D9 / COMPACTION (for long sessions): On pre-warn or \"[context compacted at step...\", emit PRESERVE_FULL_CONTEXT (full veto) or lighter KEEP_TOOL_IDS: id1,id2 (from stub id=) to protect specific high-value results. read_file/grep/lsp/bash on src/PLAN/error are auto-kept (idea 1). Use ee.query tool with \"tool-artifact id=XXX\" for on-demand full. Self-check \"task finished?\" / \"compacted yet?\". Use EE checkpoints. If you are reaching tool/step limits in a long session, suggest the user run \"/compact\" in the chat to compress this session's history.\n\n[END CRITICAL TOOL-USE RULES \u2014 your regular instructions begin below]\n\n";
+export declare const CHEAP_MODEL_PLAYBOOK = "[CRITICAL TOOL-USE RULES \u2014 read before invoking any tool; these override defaults that follow]\n\n1. Bash output is AUTOMATICALLY cached. Every `bash` call returns a `run_id`\n   (e.g. `bash-1`) you can re-query via `bash_output_get(run_id, mode=tail|head|grep|lines)`.\n   - When you want only the last N lines: do NOT pipe `| tail -N`. Run the\n     bare command, then call `bash_output_get(run_id, mode=tail, lines=N)`.\n   - Same for `| head`, `| grep PATTERN`, `> file`. Pipes/redirects HIDE\n     the full output from the cache; `bash_output_get` reads from the cache\n     without re-running.\n   - This applies to EVERY bash call, not just retries.\n   - To VIEW a file use `read_file` (start_line/end_line) \u2014 never sed/cat a\n     file. `bash_output_get` is for COMMAND output, not files.\n\n2. Before reading more than 3 files to understand a topic, delegate to\n   `task(agent=\"explore\")`. The sub-agent returns a compressed summary;\n   you save reading tokens.\n\n3. Use the `grep` tool (ripgrep) for content search \u2014 NOT `bash` with\n   `grep` / `find` piped.\n\n4. When a tool returns `ERROR: ...`, do NOT retry the identical call.\n   Pick a different tool, change inputs meaningfully, or stop and report.\n\n5. Fix the ROOT CAUSE, never mask a failure to make it \"pass\"\n   (`continue-on-error`, swallowed try/catch, skipped/deleted test, `|| true`).\n   If a step fails from a missing secret/config, make it CONDITIONAL (skip when\n   absent) so it still runs when present \u2014 do NOT blanket-ignore it.\n\n6. For a build / CI / test failure, read the ACTUAL failure log or stack trace\n   BEFORE hypothesizing \u2014 fix the real error, not a guess from source alone.\n\n7. ANTI-M\u00D9 / COMPACTION (for long sessions): On pre-warn or \"[context compacted at step...\", emit PRESERVE_FULL_CONTEXT (full veto) or lighter KEEP_TOOL_IDS: id1,id2 (from stub id=) to protect specific high-value results. read_file/grep/lsp/bash on src/PLAN/error are auto-kept (idea 1). Use ee.query tool with \"tool-artifact id=XXX\" for on-demand full. Self-check \"task finished?\" / \"compacted yet?\". Use EE checkpoints. On long sessions, call the 'compact' tool to compress history and continue (don't stop).\n\n8. CITATIONS: only write a `file:line` you can SEE in a read_file result\n   (`N |` prefix; header `of TOTAL`). Never guess a line or reuse one file's\n   numbers for another. Unsure \u2192 re-read or omit the line.\n\n[END CRITICAL TOOL-USE RULES \u2014 your regular instructions begin below]\n\n";
 /**
  * Predicate gating playbook injection.
  *

package/dist/src/pil/cheap-model-playbook.js

@@ -56,7 +56,11 @@ export const CHEAP_MODEL_PLAYBOOK = `[CRITICAL TOOL-USE RULES — read before in
 6. For a build / CI / test failure, read the ACTUAL failure log or stack trace
    BEFORE hypothesizing — fix the real error, not a guess from source alone.
 
-7. ANTI-MÙ / COMPACTION (for long sessions): On pre-warn or "[context compacted at step...", emit PRESERVE_FULL_CONTEXT (full veto) or lighter KEEP_TOOL_IDS: id1,id2 (from stub id=) to protect specific high-value results. read_file/grep/lsp/bash on src/PLAN/error are auto-kept (idea 1). Use ee.query tool with "tool-artifact id=XXX" for on-demand full. Self-check "task finished?" / "compacted yet?". Use EE checkpoints. If you are reaching tool/step limits in a long session, suggest the user run "/compact" in the chat to compress this session's history.
+7. ANTI-MÙ / COMPACTION (for long sessions): On pre-warn or "[context compacted at step...", emit PRESERVE_FULL_CONTEXT (full veto) or lighter KEEP_TOOL_IDS: id1,id2 (from stub id=) to protect specific high-value results. read_file/grep/lsp/bash on src/PLAN/error are auto-kept (idea 1). Use ee.query tool with "tool-artifact id=XXX" for on-demand full. Self-check "task finished?" / "compacted yet?". Use EE checkpoints. On long sessions, call the 'compact' tool to compress history and continue (don't stop).
+
+8. CITATIONS: only write a \`file:line\` you can SEE in a read_file result
+   (\`N |\` prefix; header \`of TOTAL\`). Never guess a line or reuse one file's
+   numbers for another. Unsure → re-read or omit the line.
 
 [END CRITICAL TOOL-USE RULES — your regular instructions begin below]
 

package/dist/src/pil/cheap-model-workbooks.d.ts

@@ -25,7 +25,7 @@ import type { TaskType } from "./types.js";
  * Universal anti-ramble convergence block — applies to every task type.
  * Kept tight; the per-task addendum below specialises it.
  */
-export declare const CHEAP_MODEL_CONVERGENCE = "[CONVERGENCE \u2014 minimise tool calls; the system prompt + tools are re-sent every call, so each extra step is expensive]\n\n- Plan the FEWEST reads you need, then read the specific file/section directly.\n  Do NOT broad-grep, re-read a file you already read, or explore \"just in case\".\n- The moment you have enough to act, STOP investigating and make the change.\n- Make the SMALLEST correct change for the request; do not widen scope.\n- Finish the action before you answer \u2014 never stop mid-step (e.g. \"I'm verifying\u2026\").\n  When done, state completion in ONE line (what changed + that it's verified);\n  no recap, no next-steps padding.\n- GROUND every claim in what you actually read or ran THIS turn: cite real\n  file:line, and never invent counts, line numbers, names, or bugs. If a number\n  (test/file count) is not verified by a command you ran, run the check or mark\n  it \"unverified\" \u2014 do NOT guess a value or assert a finding you did not observe.\n- ANTI-M\u00D9: After compaction note or pre-warn, emit PRESERVE_FULL_CONTEXT (full) or KEEP_TOOL_IDS: id1,id2 to protect high-value (auto for read_file/grep on src/PLAN/error). Use the ee_query tool with \"tool-artifact id=XXX\" for on-demand full re-hydrate. Recall checkpoints. If you are reaching tool/step limits in a long session, suggest the user run \"/compact\" to compress history. ";
+export declare const CHEAP_MODEL_CONVERGENCE = "[CONVERGENCE \u2014 minimise tool calls; the system prompt + tools are re-sent every call, so each extra step is expensive]\n\n- Plan the FEWEST reads you need, then read the specific file/section directly.\n  Do NOT broad-grep, re-read a file you already read, or explore \"just in case\".\n- The moment you have enough to act, STOP investigating and make the change.\n- Make the SMALLEST correct change for the request; do not widen scope.\n- Finish the action before you answer \u2014 never stop mid-step (e.g. \"I'm verifying\u2026\").\n  When done, state completion in ONE line (what changed + that it's verified);\n  no recap, no next-steps padding.\n- GROUND every claim in what you actually read or ran THIS turn: cite real\n  file:line, and never invent counts, line numbers, names, or bugs. If a number\n  (test/file count) is not verified by a command you ran, run the check or mark\n  it \"unverified\" \u2014 do NOT guess a value or assert a finding you did not observe.\n- ANTI-M\u00D9: After compaction note or pre-warn, emit PRESERVE_FULL_CONTEXT (full) or KEEP_TOOL_IDS: id1,id2 to protect high-value (auto for read_file/grep on src/PLAN/error). Use the ee_query tool with \"tool-artifact id=XXX\" for on-demand full re-hydrate. Recall checkpoints. On long sessions, call the `compact` tool yourself to compress history and keep going (don't stop). ";
 /**
  * Map a sub-agent role (agentKey) to the workbook TaskType that best matches
  * its job. Sub-agents never run PIL Layer 1, so they have no classifier-derived

package/dist/src/pil/cheap-model-workbooks.js

@@ -36,7 +36,7 @@ export const CHEAP_MODEL_CONVERGENCE = `[CONVERGENCE — minimise tool calls; th
   file:line, and never invent counts, line numbers, names, or bugs. If a number
   (test/file count) is not verified by a command you ran, run the check or mark
   it "unverified" — do NOT guess a value or assert a finding you did not observe.
-- ANTI-MÙ: After compaction note or pre-warn, emit PRESERVE_FULL_CONTEXT (full) or KEEP_TOOL_IDS: id1,id2 to protect high-value (auto for read_file/grep on src/PLAN/error). Use the ee_query tool with "tool-artifact id=XXX" for on-demand full re-hydrate. Recall checkpoints. If you are reaching tool/step limits in a long session, suggest the user run "/compact" to compress history. `;
+- ANTI-MÙ: After compaction note or pre-warn, emit PRESERVE_FULL_CONTEXT (full) or KEEP_TOOL_IDS: id1,id2 to protect high-value (auto for read_file/grep on src/PLAN/error). Use the ee_query tool with "tool-artifact id=XXX" for on-demand full re-hydrate. Recall checkpoints. On long sessions, call the \`compact\` tool yourself to compress history and keep going (don't stop). `;
 /**
  * Per-task-type addenda. Each is 1–2 tight lines targeting that type's most
  * common budget-model failure mode. Types not listed fall back to the

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

@@ -9,6 +9,7 @@ export interface ProjectContext {
     boundedContexts: BoundedContext[];
     eePatterns: string[];
     relevantModules: RelevantModule[];
+    recentModifiedFiles?: string[];
     scannedAt: number;
     cwd: string;
 }

package/dist/src/pil/discovery.js

@@ -214,6 +214,9 @@ async function proposeModelCards(proposer, raw, l1, projectContext, recentTurnsS
             ? `Bounded contexts: ${projectContext.boundedContexts.map((b) => `${b.name} (${b.path})`).join(", ")}`
             : "",
         projectContext.eePatterns?.length ? `EE patterns: ${projectContext.eePatterns.slice(0, 3).join(" | ")}` : "",
+        projectContext.recentModifiedFiles?.length
+            ? `User's active/modified files (git status): ${projectContext.recentModifiedFiles.join(", ")}`
+            : "",
         recentTurnsSummary ? `\nRecent Conversation History:\n${recentTurnsSummary}` : "",
     ]
         .filter(Boolean)
@@ -256,19 +259,21 @@ ${contextStr}
 You design question cards shown to the user *before* you start working.
 Each card is a structured question with selectable options.
 
-Rules:
-1. Ask ONLY what is genuinely blocking. Most well-scoped requests need 0 cards.
-2. If everything you need is inferable from the request + context above, OR the request is a plain question you can simply answer, return [] (empty array).
-3. If this is a follow-up or continuation of recent conversation history, assume context is already established and return [] unless there is a critical new ambiguity.
-4. Consider the provided language/framework/modules/EE patterns — never ask what the context already answers.${special}
-5. For each card, design the options however you want:
-   - Use kind="choice" for clickable buttons (recommendations, accept/adjust/cancel, etc.)
+Rules (ROI-gated — a card is worth showing ONLY when the user's answer changes WHAT you build and you genuinely cannot decide it for them):
+1. Ask ONLY when the user must chốt a fork you cannot resolve yourself AND getting it wrong is expensive or hard to reverse. High-ROI examples: which implementation direction / architecture to commit to, which of several REAL plan alternatives to pursue, an irreversible or destructive action, an intent so ambiguous that different readings produce materially different deliverables.
+2. If you already have a recommendation and the fork is low-stakes or reversible, DO NOT ask — proceed with your recommendation. A card that just asks the user to accept/confirm what you already recommend is pure noise: return [] and act on the recommendation.
+3. Prefer proceeding on a stated assumption over blocking. When you can reasonably assume the answer, state the assumption in your work instead of showing a card.
+4. If everything you need is inferable from the request + context above, OR the request is a plain question you can simply answer, return [] (empty array).
+5. If this is a follow-up or continuation of recent conversation history, assume context is already established and return [] unless there is a critical NEW fork.
+6. Consider the provided language/framework/modules/EE patterns — never ask what the context already answers.${special}
+7. Most well-scoped requests need 0 cards. For each card you DO show, design the options:
+   - Use kind="choice" for clickable buttons when there are REAL alternatives the user picks between
    - Use kind="freetext" when the user should type their own answer
    - Mark an option with isCancel:true when picking it should cancel the entire request
-   - Mark an option with isAdjust:true when picking it means the user wants to clarify further
-   - Set defaultIndex to the option most users would pick (0 = first)
-6. Return ONLY valid JSON array, nothing else.
-7. Max 3 cards.
+   - Mark an option with isAdjust:true when picking it means the user wants to refine further
+   - Set defaultIndex to your recommended option (0 = first)
+8. Return ONLY valid JSON array, nothing else.
+9. Max 3 cards — and only for genuine decision forks.
 
 JSON format:
 [{

package/dist/src/pil/layer1-intent.d.ts

@@ -1,13 +1,18 @@
 /**
  * src/pil/layer1-intent.ts
  *
- * Layer 1: Intent detection.
- * Pass 1 — classifier (regex + tree-sitter): maps all 14 possible reason strings to TaskType.
- * Pass 2 — keyword fallback: catches debug/plan/documentation that classifier misses.
- * Pass 3 — EE brain fallback via bridge.classifyViaBrain (replaces ollamaClassify).
- * Populates taskType, confidence, and domain on PipelineContext.
- * outputStyle is always null from Layer 1 — Layer 6 handles output style detection via bridge.
+ * Layer 1: Intent detection — MODEL-FIRST ONLY.
+ * The configured chat model (via opts.llmFallback) classifies taskType / intent
+ * / style / depth / clarity / scope / language. The old keyword-regex "Pass 0-4"
+ * cascade was DELETED (2026-07-07, no-regex rule) — regex no longer decides
+ * intent. When no classifier is wired the layer degrades to UNKNOWN (taskType
+ * null, keep-tools), never a regex guess. On a classify miss the classifier
+ * self-repairs (see createLlmClassifier) before surfacing UNKNOWN.
  * Fail-open: any error returns ctx unchanged with applied=false.
+ *
+ * NOTE: scoreComplexity / scoreSufficiency below are retained ONLY because other
+ * modules (playbook, discovery, orchestrator) still import them; they no longer
+ * run on this layer's classification path.
  */
 import type { LlmClassifyFn } from "./llm-classify.js";
 import type { OutputStyle, PipelineContext } from "./types.js";
@@ -83,6 +88,13 @@ export interface Layer1Options {
      * Passed in (not read here) to keep layer1 off the EE/profile import path.
      */
     profileStyleBaseline?: OutputStyle | null;
+    /**
+     * Compact digest of the last few conversation turns. Forwarded to the LLM
+     * classifier so a terse follow-up that back-references heavy prior work
+     * ("từ các phần đó", "làm tiếp") is scored on the real work, not the isolated
+     * sentence. null/undefined ⇒ classifier sees the bare prompt (old behaviour).
+     */
+    recentTurns?: string | null;
 }
 /**
  * True when the prompt is an explicit request to RUN a command / use a shell