muonroi-cli 1.8.5 → 1.9.0

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. 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 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 the EE brain (ee.query in unfamiliar areas) before editing.\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. Don't dump verbatim tool outputs \u2014 cite concise file:line. Never claim a build/test ran, or edits you did not actually do this turn; if a check can't run, fix it or say so.\n\n6. LANGUAGE: reply in the user's detected language; internal reasoning, tools, and code stay English.\n\n7. ANTI-M\u00D9/COMPACTION: on compaction emit PRESERVE_FULL_CONTEXT (veto) or KEEP_TOOL_IDS (from stub id=) to protect results; re-hydrate via ee_query \"tool-artifact id=XXX\". Use 'compact' 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\n10. COUNCIL/ASK: call `convene_council` for high-stakes/conflicting calls \u2014 its conclusion returns as the tool result; then YOU decide. In impl discussion you MAY confirm via `ask_user` before building, else keep going.\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

@@ -39,20 +39,22 @@
  */
 export const AGENT_OPERATING_CONTRACT = `[AGENT OPERATING CONTRACT — read first; applies to every step]
 
-1. BEFORE ACTING: do only what was asked. Never assume scope or facts — 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.
+1. BEFORE ACTING: do only what was asked. Never assume scope or facts — if ambiguous, ask or use defaults; never invent requirements. RESEARCH FIRST: explore code (read/grep) and recall the EE brain (ee.query in unfamiliar areas) before editing.
 2. READING: base statements on what you read/ran THIS turn. Do not infer contents of files you did not open.
 3. EXECUTING: smallest correct change; never widen scope or mask failures (no \`|| true\`, skipped tests, or swallowed catch).
 4. WHEN UNSURE: verify and cross-check BEFORE concluding. Reading code is not proof — reproduce the bug.
-5. 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 — 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 — don't imply success.
+5. REPORTING: answer ONLY what was asked. Every fact or file:line MUST come from this turn; else label "unverified"; do not guess. Don't dump verbatim tool outputs — cite concise file:line. Never claim a build/test ran, or edits you did not actually do this turn; if a check can't run, fix it or say so.
 
-6. LANGUAGE: Reply in user's detected language for final output. Internal reasoning, tools, and code remain in English.
+6. LANGUAGE: reply in the user's detected language; internal reasoning, tools, and code stay 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. Use 'compact' tool near limits.
+7. ANTI-MÙ/COMPACTION: on compaction emit PRESERVE_FULL_CONTEXT (veto) or KEEP_TOOL_IDS (from stub id=) to protect results; re-hydrate via ee_query "tool-artifact id=XXX". Use 'compact' 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\`.
 
 9. 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.
 
+10. COUNCIL/ASK: call \`convene_council\` for high-stakes/conflicting calls — its conclusion returns as the tool result; then YOU decide. In impl discussion you MAY confirm via \`ask_user\` before building, else keep going.
+
 [END CONTRACT — instructions follow]`;
 /**
  * Build the contract block for insertion at the front of the system prompt.

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

@@ -15,4 +15,4 @@ export declare function runDiscovery(raw: string, l1: L1Result, cwd: string, han
  * exact ModelCard[] it wants shown — full control over questions, options,
  * option kinds, and cancel/adjust markers.
  */
-export declare function createModelClarificationProposer(providerFactory: any, modelId: string): ModelClarificationProposer;
+export declare function createModelClarificationProposer(modelId: string): ModelClarificationProposer;

package/dist/src/pil/discovery.js

@@ -234,13 +234,13 @@ async function proposeModelCards(proposer, raw, l1, projectContext, recentTurnsS
  * exact ModelCard[] it wants shown — full control over questions, options,
  * option kinds, and cancel/adjust markers.
  */
-export function createModelClarificationProposer(providerFactory, modelId) {
+export function createModelClarificationProposer(modelId) {
     return async (input) => {
         // process.stderr.write(`[discovery] createModelClarificationProposer CALLED!\n`);
         try {
             const { resolveModelRuntime } = await import("../providers/runtime.js");
             const { generateText } = await import("ai");
-            const runtime = resolveModelRuntime(providerFactory, modelId);
+            const runtime = resolveModelRuntime(modelId);
             const contextStr = input.additionalContext
                 ? `\nCurrent CLI enrichment / context (use this to decide what is already known):\n${input.additionalContext}`
                 : "";

package/dist/src/pil/layer1_5-complexity-size.d.ts

@@ -11,13 +11,20 @@
  * "Layer 1.5 complexity-size (4C)"). Do NOT alter weights without re-running the
  * baseline harness regression.
  */
+import type { RepoStructureHint } from "./repo-structure-hints.js";
 export interface ComplexitySizeInput {
     rawText: string;
     taskType: string;
+    repoHints?: RepoStructureHint[];
 }
 export interface ComplexitySizeResult {
     size: "small" | "medium" | "large";
     score: number;
     features: Record<string, number | boolean>;
 }
+export declare function extractPathTokens(rawText: string): string[];
+export declare function scoreRepoGrounding(paths: string[], hints: RepoStructureHint[]): {
+    score: number;
+    hits: number;
+};
 export declare function scoreComplexitySize(input: ComplexitySizeInput): ComplexitySizeResult;

package/dist/src/pil/layer1_5-complexity-size.js

@@ -62,14 +62,32 @@ function effectiveLen(rawText, taskType) {
 // ---------------------------------------------------------------------------
 // Path token counter — counts DISTINCT path-like tokens.
 // ---------------------------------------------------------------------------
-function countDistinctPaths(rawText) {
+export function extractPathTokens(rawText) {
     const matches = rawText.match(PATH_TOKEN_RE);
     if (!matches)
-        return 0;
+        return [];
     const set = new Set();
     for (const m of matches)
         set.add(m.toLowerCase());
-    return set.size;
+    return [...set];
+}
+export function scoreRepoGrounding(paths, hints) {
+    if (paths.length === 0 || hints.length === 0)
+        return { score: 0, hits: 0 };
+    const hinted = new Map(hints.map((hint) => [hint.path.toLowerCase(), hint]));
+    let score = 0;
+    let hits = 0;
+    for (const path of paths) {
+        const hint = hinted.get(path);
+        if (!hint)
+            continue;
+        hits += 1;
+        if (hint.lineCount >= 5000)
+            score = Math.max(score, 4);
+        else if (hint.lineCount >= 2000)
+            score = Math.max(score, 2);
+    }
+    return { score, hits };
 }
 // ---------------------------------------------------------------------------
 // Main: scoreComplexitySize
@@ -77,6 +95,7 @@ function countDistinctPaths(rawText) {
 export function scoreComplexitySize(input) {
     const rawText = input.rawText ?? "";
     const taskType = input.taskType ?? "general";
+    const repoHints = input.repoHints ?? [];
     // 1. Length score (debug + stack-trace gets mitigation).
     // CONTEXT-locked thresholds are <60 / >240. We use <80 for the "small" knee
     // because the baseline-2 prompt "đổi default --max-tool-rounds từ 100 →
@@ -102,13 +121,18 @@ export function scoreComplexitySize(input) {
     //     baseline-2 "đổi default ... trong src/orchestrator/cli-args.ts")
     //   - zero paths is neutral (vagueness is handled by `vaguenessAmplifier`)
     //   - ≥3 paths is multi-file work, push toward large
-    const pathCount = countDistinctPaths(rawText);
+    const distinctPaths = extractPathTokens(rawText);
+    const pathCount = distinctPaths.length;
     let pathScore = 0;
     if (pathCount === 1)
         pathScore = -1;
     else if (pathCount >= 3)
         pathScore = 2;
     // 0 or 2 → 0 (neutral)
+    // 4.5 Repo-structure grounding probe. Cheap deterministic lookup against the
+    // checked-in REPO_DEEP_MAP index: monolith roots like src/ui/app.tsx should
+    // not size the same as a narrow leaf module when both appear as one-path asks.
+    const repoGrounding = scoreRepoGrounding(distinctPaths, repoHints);
     // 5. Question form score.
     const trimmed = rawText.trim();
     const isQuestion = QUESTION_START_RE.test(trimmed) || trimmed.endsWith("?");
@@ -123,7 +147,7 @@ export function scoreComplexitySize(input) {
     // "improve X" / "clean up Y" without targets is the canonical wandering shape.
     const vaguenessAmplifier = sweepCount > 0 && pathCount === 0 ? 4 : 0;
     // Total score → bucket.
-    const score = lenScore + sweepScore + heavyScore + pathScore + questionScore + vaguenessAmplifier;
+    const score = lenScore + sweepScore + heavyScore + pathScore + repoGrounding.score + questionScore + vaguenessAmplifier;
     let size;
     if (score <= -1)
         size = "small";
@@ -142,6 +166,8 @@ export function scoreComplexitySize(input) {
             heavyScore,
             pathCount,
             pathScore,
+            repoGroundingHits: repoGrounding.hits,
+            repoGroundingScore: repoGrounding.score,
             isQuestion,
             questionScore,
             isImperative,

package/dist/src/pil/llm-classify.d.ts

@@ -1,4 +1,4 @@
-import type { ProviderFactory } from "../providers/runtime.js";
+import type { ProviderId } from "../providers/types.js";
 import type { OutputStyle, TaskType } from "./types.js";
 /**
  * What the user wants the turn to PRODUCE — decided by the model (Phase 2b) so
@@ -92,6 +92,56 @@ export interface LlmClassifyOptions {
     signal?: AbortSignal;
 }
 export type LlmClassifyFn = (prompt: string, opts?: LlmClassifyOptions) => Promise<LlmClassifyResult | null>;
+/**
+ * Factory-level options for `createLlmClassifier` (distinct from the per-call
+ * `LlmClassifyOptions`). Chosen once when the closure is built.
+ */
+export interface CreateClassifierOptions {
+    /**
+     * Route the throwaway classify to the provider's fast tier when one exists
+     * (mirrors `classifySubSessionAction`). Same-provider only, so the already-
+     * bound factory/key still works. A no-op when the provider exposes no
+     * routable fast model (e.g. xai). Zero-hardcode: the fast id comes from
+     * `getRoutedModelByTier`, not a literal. Cheap — safe on every turn.
+     */
+    routeFastTier?: boolean;
+    /**
+     * When the session provider has NO same-provider fast tier (e.g. xai, whose
+     * session model may be an agentic model that ignores the terse classify
+     * contract — measured 2026-07-15 for grok-composer), also try keyed fast
+     * models from OTHER configured providers, in catalog switch order, until one
+     * parses. Bounded by CLASSIFY_TOTAL_BUDGET_MS so a chain of dead/slow keys
+     * can't stall the turn. This adds latency ONLY on that fallback path, so it is
+     * opt-in per call-site: enable it for the high-value /ideal routing classify,
+     * NOT for the per-turn PIL classify (there a fast fail-open "standard" is fine
+     * and cheaper than chaining providers on every message).
+     */
+    crossProviderFallback?: boolean;
+}
+/**
+ * Compute the classify call budget from the resolved model's catalog metadata.
+ *
+ * TIMEOUT is a flat safety-net ceiling for all models — see CLASSIFY_TIMEOUT_MS.
+ * Measurement showed classify latency is provider-independent and well under
+ * the ceiling, so keying the timeout off `tier`/`reasoning` added no value and
+ * amounted to an identity-proxy soft-hardcode.
+ *
+ * MAX-OUTPUT scales with REASONING only: a reasoning model burns its output
+ * budget on reasoning tokens before any visible text, so it needs the room in
+ * tokens; a non-reasoning model emits the 8 words directly. This knob is real —
+ * it is the fix for reasoning models routing the verdict into the reasoning
+ * channel — and stays decoupled from the (now flat) timeout.
+ */
+export declare function classifierBudget(modelInfo: {
+    reasoning?: boolean;
+    tier?: string;
+} | undefined): {
+    isReasoning: boolean;
+    timeoutMs: number;
+    maxOutputTokens: number;
+};
+/** Test seam — clear the cross-provider factory cache between specs. */
+export declare function __resetClassifyFactoryCache(): void;
 /**
  * Build a closure the PIL pipeline can call. Reuses the orchestrator's already-
  * constructed providerFactory + modelId so we don't pay key-loading cost twice.
@@ -99,14 +149,39 @@ export type LlmClassifyFn = (prompt: string, opts?: LlmClassifyOptions) => Promi
  * Returns null if the call fails / times out / parses to garbage. Callers must
  * fail-open (keep prior taskType, do not block the turn).
  */
-export declare function createLlmClassifier(factory: ProviderFactory, modelId: string): LlmClassifyFn;
+/**
+ * Order the classify candidate list.
+ *
+ * - `hasSameFast` (e.g. openai → gpt-5.4-mini): the same-provider fast tier is a
+ *   real fast model, so try it FIRST, then keyed cross-provider models as a
+ *   FALLBACK. This is the fix for the failure-not-just-absence case: an
+ *   openai-OAuth session's fast tier can 401 on the api-key path — previously
+ *   the chain stopped there and fail-opened to "standard" (so /ideal
+ *   over-councilled trivial tasks). Appending the cross-provider models lets a
+ *   working alternative (a keyed deepseek/opencode fast model) rescue it.
+ * - No same-provider fast tier (e.g. xai, whose session model is agentic and
+ *   ignores the terse contract): try keyed cross-provider fast models FIRST and
+ *   keep the session model as the last-resort candidate.
+ */
+export declare function orderClassifyCandidates(args: {
+    primaryModelId: string;
+    hasSameFast: boolean;
+    crossModels: ReadonlyArray<{
+        modelId: string;
+        providerId: ProviderId;
+    }>;
+}): Array<{
+    modelId: string;
+    providerId: ProviderId | null;
+}>;
+export declare function createLlmClassifier(modelId: string, classifyOpts?: CreateClassifierOptions): LlmClassifyFn;
 export type SubSessionAction = "DIRECT_ANSWER" | "ROTATE_SESSION" | "SPAWN_SUB_SESSION";
 export interface SubSessionRouteResult {
     action: SubSessionAction;
     confidence: number;
     reason: string;
 }
-export declare function classifySubSessionAction(factory: ProviderFactory, modelId: string, prompt: string, contextInfo?: {
+export declare function classifySubSessionAction(modelId: string, prompt: string, contextInfo?: {
     currentChars: number;
     threshold: number;
     /**