muonroi-cli 1.4.1 → 1.6.0

package/dist/src/pil/clarity-gate.d.ts

@@ -1,22 +1,24 @@
-import type { TaskType } from "./types.js";
-export interface L1Signal {
-    confidence: number;
-    taskType: TaskType | null;
-    complexity: "low" | "medium" | "high";
-}
-export declare function isDirectImperative(raw: string): boolean;
-export declare function canInferOutcome(taskType: TaskType | null, raw: string): boolean;
 /**
- * PIL-L6 fix — operational-domain scope (CI, deploy, build, lint) implies
- * scope is the project's pipeline/infra, not a specific file. "fix ci fail"
- * doesn't have a file path but the scope is unambiguous: it's the .github/
- * workflows + whatever those workflows run. Treat as scoped for auto-pass.
+ * src/pil/clarity-gate.ts
+ *
+ * Phase 2 (2026-06-16): the regex/keyword ASK gate (`shouldAutoPass`,
+ * `canInferOutcome`, and the per-modality scope detectors) was removed. The
+ * configured chat model is now the sole decider of whether a turn needs
+ * clarification — see `proposeModelGaps` in `discovery.ts`. Keyword heuristics
+ * deciding what/whether to ask were "bad bad bad UX" (miss billions of cases)
+ * per the user directive; there is no regex fallback by design.
+ *
+ * Two helpers survive because they are NOT ask-gating:
+ *   - `detectNoClarifySignal` — honours an explicit USER instruction ("don't
+ *     ask" / "đừng hỏi"). That is user consent, not classification.
+ *   - `hasOperationalScope` — used only by `getAutofilledOutcome` to pick a
+ *     better outcome LABEL for CI/build/deploy debug turns (output polish, not
+ *     a decision about whether to interview).
+ */
+/**
+ * Operational-domain detector (CI / deploy / build / lint). Used by
+ * `getAutofilledOutcome` to refine the resolved outcome label for pipeline
+ * debug turns; it no longer gates any askcard.
  */
 export declare function hasOperationalScope(raw: string): boolean;
-export declare function countFileReferences(raw: string): number;
-export declare function hasExplicitScope(raw: string): boolean;
-export declare function hasImageScope(raw: string): boolean;
-export declare function hasExternalInfoScope(raw: string): boolean;
-export declare function hasWholeRepoScope(raw: string): boolean;
-export declare function hasSelfContainedComputationScope(raw: string): boolean;
-export declare function shouldAutoPass(l1: L1Signal, raw: string): boolean;
+export declare function detectNoClarifySignal(raw: string): boolean;

package/dist/src/pil/clarity-gate.js

@@ -1,162 +1,35 @@
-import { getAutoPassThreshold } from "./config.js";
 /**
- * A direct imperative command — "run the tests", "echo ok", "show the config",
- * "list the ports" — has a self-evident outcome (the command executes / the
- * thing is shown), so it should NOT trigger an outcome-clarification askcard.
- * Requires an executable verb at the very start followed by a concrete object
- * (a bare "run" with no object stays ambiguous → false).
- */
-const DIRECT_IMPERATIVE_RE = /^\s*(run|execute|show|list|print|echo)\b\s+\S/i;
-export function isDirectImperative(raw) {
-    return DIRECT_IMPERATIVE_RE.test(raw);
-}
-export function canInferOutcome(taskType, raw) {
-    if (!taskType)
-        return false;
-    // PIL clarity over-trigger fix: a "general" prompt normally can't infer its
-    // outcome, but a direct imperative command is the exception — its outcome is
-    // obvious, so asking "what's the expected outcome?" is pure noise.
-    if (taskType === "general")
-        return isDirectImperative(raw);
-    const hasErrorRef = /error|exception|stack|TypeError|Cannot|failed|crash|fail(?:s|ed|ing)?|broken|red/i.test(raw);
-    const hasFileLineRef = /\.\w+:\d+/.test(raw);
-    const hasTargetState = /should|must|expect|return|produce|output|become/i.test(raw);
-    const hasAddPattern = /\b(add|create|implement|write|generate)\b.*\b(to|in|for|into)\b/i.test(raw);
-    // PIL-L6 fix — explicit goal phrase in the prompt is itself an outcome
-    // ("goal sẽ là ci green", "want: tests passing", "expect: 0 errors").
-    // Without this, debug prompts that name the desired end-state still
-    // tripped the interview because none of the verb-noun patterns matched.
-    const hasExplicitGoal = /\b(goal|target|expect|want|mong muốn|mong muon|kết quả|ket qua)\b[:\s]/i.test(raw);
-    return hasErrorRef || hasFileLineRef || hasTargetState || hasAddPattern || hasExplicitGoal;
-}
-/**
- * PIL-L6 fix — operational-domain scope (CI, deploy, build, lint) implies
- * scope is the project's pipeline/infra, not a specific file. "fix ci fail"
- * doesn't have a file path but the scope is unambiguous: it's the .github/
- * workflows + whatever those workflows run. Treat as scoped for auto-pass.
- */
-export function hasOperationalScope(raw) {
-    return /\b(ci|cd|build|deploy(?:ment)?|action(?:s)?|workflow|pipeline|lint|tests?|coverage|gh\s+(check|run|workflow))\b/i.test(raw);
-}
-export function countFileReferences(raw) {
-    return (raw.match(/[\w-]+\.\w{1,5}/g) ?? []).filter((m) => /\.(ts|tsx|js|jsx|py|rs|go|java|cs|rb|vue|svelte|css|scss|json|yaml|yml|toml|md)$/i.test(m)).length;
-}
-export function hasExplicitScope(raw) {
-    return /\b(src\/|lib\/|app\/|pages\/|components\/|modules\/|packages\/)\S+/.test(raw);
-}
-/**
- * An image-analysis prompt is scoped to the IMAGE, not the codebase. "analyze
- * diagram.png", "take a screenshot and describe it" name their target directly,
- * so the "Which part of the codebase should this target?" askcard is
- * nonsensical for them — exactly like operational (CI/build) prompts are scoped
- * to the pipeline (see hasOperationalScope). Detect a concrete image signal: an
- * image file extension, a data:image URI, or an unambiguous image noun.
+ * src/pil/clarity-gate.ts
  *
- * Deliberately NARROW: a false positive here SUPPRESSES a legitimate clarifying
- * question (quality risk), so overloaded words are excluded —
- *   - "logo" / "icon" / "diagram" / "chart" / "mockup" appear in real codebase
- *     tasks ("add a logo to the header"),
- *   - bare "image" collides with container/Docker usage ("rebuild the image"),
- *   - "picture" collides with the "bigger picture" idiom,
- *   - Vietnamese substrings (ảnh/hình) collide with frequent non-image words
- *     ("ảnh hưởng", "màn hình", "hình thức").
- * Only a file extension, data:image URI, "screenshot", or "photo" qualify.
- */
-const IMAGE_SCOPE_RE = /\.(png|jpe?g|gif|webp|svg|bmp|tiff?|heic|avif|ico)\b|data:image\/|\bscreen-?shots?\b|\bphotos?\b/i;
-export function hasImageScope(raw) {
-    return IMAGE_SCOPE_RE.test(raw);
-}
-/**
- * A web-search / external-information prompt ("search the web for X", "google
- * the error", a bare URL, "latest news on Y") is scoped to the WEB, not the
- * codebase, so the "Which part of the codebase should this target?" askcard is
- * nonsensical for it — symmetric to hasOperationalScope / hasImageScope. (Live:
- * "search the web for the latest vitest release notes" → taskType=analyze fired
- * the scope askcard and recorded a wrong scope of "src/mcp".)
+ * Phase 2 (2026-06-16): the regex/keyword ASK gate (`shouldAutoPass`,
+ * `canInferOutcome`, and the per-modality scope detectors) was removed. The
+ * configured chat model is now the sole decider of whether a turn needs
+ * clarification — see `proposeModelGaps` in `discovery.ts`. Keyword heuristics
+ * deciding what/whether to ask were "bad bad bad UX" (miss billions of cases)
+ * per the user directive; there is no regex fallback by design.
  *
- * Deliberately NARROW — only UNAMBIGUOUSLY-external intent. It must not reuse
- * the broad hasDocsSignal vocabulary (library/api/install/package), because
- * those words routinely describe real codebase tasks ("add the zod library to
- * the auth module") that genuinely need the scope askcard. In particular a bare
- * "search" is excluded so "search the codebase" / "implement the search
- * feature" still get scoped.
+ * Two helpers survive because they are NOT ask-gating:
+ *   - `detectNoClarifySignal` — honours an explicit USER instruction ("don't
+ *     ask" / "đừng hỏi"). That is user consent, not classification.
+ *   - `hasOperationalScope` — used only by `getAutofilledOutcome` to pick a
+ *     better outcome LABEL for CI/build/deploy debug turns (output polish, not
+ *     a decision about whether to interview).
  */
-const EXTERNAL_INFO_SCOPE_RE = /https?:\/\/\S+|\bsearch\s+(the\s+)?(web|internet|online)\b|\bweb\s*search\b|\bon\s+the\s+(web|internet)\b|\bgoogle\b|\b(news|weather|headlines)\b/i;
-export function hasExternalInfoScope(raw) {
-    return EXTERNAL_INFO_SCOPE_RE.test(raw);
-}
 /**
- * A whole-repo / whole-project prompt ("đánh giá repo này", "review the entire
- * codebase", "audit the whole project") is ALREADY scoped — to everything — so
- * the "Which part of the codebase should this target?" askcard is nonsensical
- * (and worse, it recommends a single bounded context like "src/cli" as the
- * default, which is wrong for a repo-wide eval). Symmetric to the other scope
- * predicates. Live: gemini-2.5-flash classified "đánh giá repo …" as analyze and
- * got the scope askcard whose recommended option was a narrow subdir.
- *
- * Deliberately NARROW — it must NOT fire on a narrow task that merely mentions a
- * repo/project ("add X to this repo", "fix the bug in the project"), or those
- * would wrongly skip a legitimate scope question. So it requires EITHER an
- * explicit wholeness qualifier (whole/entire/all/toàn bộ/cả) on a repo/project/
- * codebase noun, OR an evaluation/overview verb (review/audit/evaluate/assess/
- * analyze/overview · đánh giá/phân tích/tổng quan/kiểm tra) applied to that noun.
+ * Operational-domain detector (CI / deploy / build / lint). Used by
+ * `getAutofilledOutcome` to refine the resolved outcome label for pipeline
+ * debug turns; it no longer gates any askcard.
  */
-const WHOLE_REPO_SCOPE_RE = 
-// NOTE: leading anchors on Vietnamese-initial alternatives use (?:^|\s) not
-// \b — JS \b is ASCII-only and never matches before a non-ASCII letter like
-// "đ", so "\bđánh" would silently fail to match "đánh giá repo".
-/\b(whole|entire|overall|all\s+of\s+the|across\s+the)\s+(repo(?:sitory)?|code-?base|project)\b|(?:^|\s)(toàn\s*bộ|toan\s*bo|cả|ca)\s+(repo|dự\s*án|du\s*an|m[ãa]\s*ngu[ồo]n|code-?base|project)\b|\b(review|audit|evaluate|assess|analy[sz]e|summari[sz]e|overview\s+of|summary\s+of)\s+(?:\S+\s+){0,2}?(repo(?:sitory)?|code-?base|project)\b|(?:^|\s)(đánh\s*giá|danh\s*gia|phân\s*tích|phan\s*tich|tổng\s*quan|tong\s*quan|kiểm\s*tra|kiem\s*tra|tóm\s*tắt|tom\s*tat)\s+(?:\S+\s+){0,2}?(toàn|toan|repo|dự\s*án|du\s*an|m[ãa]\s*ngu[ồo]n|code-?base|project)\b/i;
-export function hasWholeRepoScope(raw) {
-    return WHOLE_REPO_SCOPE_RE.test(raw);
-}
-/**
- * A self-contained computation / reasoning prompt supplies its operand data
- * INLINE ("Compute f([3,1,2]) …", "what is the median of [10, 4, 7]?") — the
- * task's target is the data in the prompt, not the codebase, so the "Which part
- * of the codebase should this target?" askcard is nonsensical for it. Symmetric
- * to hasOperationalScope / hasImageScope / hasExternalInfoScope / hasWholeRepoScope.
- *
- * Live: "Compute f([3,1,2]) where f sorts the list ascending then returns the
- * sum of the first two elements." classified taskType=analyze — the regex
- * classifier matched the bare word "list" (regex:read, conf 0.80, which also
- * skips the brain) — and fired BOTH the pil-interview scope askcard (auto
- * "Entire project") and the pil-acceptance card on a pure math problem.
- *
- * Deliberately NARROW — a false positive here SUPPRESSES a legitimate scope
- * question (quality risk), so it requires BOTH:
- *   1. an inline DATA literal — a bracketed comma-list of >=2 numeric or quoted
- *      string values (`[3, 1, 2]`, `["a", "b"]`). A bracketed list of bare
- *      identifiers (`[auth.ts, session.ts]`) is NOT data — those are file/symbol
- *      references and stay codebase-scoped; the regex only accepts numbers and
- *      quoted strings, so it never matches them. Single-element `[0]` (array
- *      indexing) is excluded by the >=2-element requirement.
- *   2. computation framing — a compute/evaluate/sort/sum/statistic verb or a
- *      "what is …" / "given the array …" question frame.
- * The AND keeps real codebase tasks that merely embed a literal (e.g. "set the
- * default retry delays to [100, 200, 400] in the config") correctly scoped.
- */
-const INLINE_DATA_LITERAL_RE = /\[\s*(?:-?\d+(?:\.\d+)?|"[^"]*"|'[^']*')(?:\s*,\s*(?:-?\d+(?:\.\d+)?|"[^"]*"|'[^']*'))+\s*\]/;
-const COMPUTE_FRAMING_RE = /\b(comput(?:e|ing)|calculat(?:e|ing|ion)|evaluat(?:e|ing)|solve|sort(?:s|ed|ing)?|sum|median|mean|average|max(?:imum)?|min(?:imum)?|largest|smallest|reverse[ds]?|result\s+of|what(?:'?s|\s+is|\s+are)|given\s+(?:the\s+)?(?:array|list|sequence|set|matrix|string|numbers?))\b/i;
-export function hasSelfContainedComputationScope(raw) {
-    return INLINE_DATA_LITERAL_RE.test(raw) && COMPUTE_FRAMING_RE.test(raw);
+export function hasOperationalScope(raw) {
+    return /\b(ci|cd|build|deploy(?:ment)?|action(?:s)?|workflow|pipeline|lint|tests?|coverage|gh\s+(check|run|workflow))\b/i.test(raw);
 }
-export function shouldAutoPass(l1, raw) {
-    if (l1.confidence < getAutoPassThreshold())
-        return false;
-    if (!canInferOutcome(l1.taskType, raw))
-        return false;
-    // PIL-L6 fix — debug prompts about CI/build/deploy don't need a file path
-    // because their scope is the pipeline itself. Operational scope counts.
-    if (countFileReferences(raw) === 0 &&
-        !hasExplicitScope(raw) &&
-        !hasOperationalScope(raw) &&
-        !hasImageScope(raw) &&
-        !hasExternalInfoScope(raw) &&
-        !hasWholeRepoScope(raw) &&
-        !hasSelfContainedComputationScope(raw))
-        return false;
-    if (l1.complexity === "high")
-        return false;
-    return true;
+// The user explicitly told the agent NOT to clarify ("don't ask", "trả lời
+// thẳng"). When present, discovery skips ALL interview + acceptance cards. Narrow
+// on purpose: the idiom "don't ask me why" (seeking an explanation, not a
+// directive to skip questions) is excluded via a negative lookahead. EN + VI
+// (with diacritics + bare-ASCII transliterations).
+const NO_CLARIFY_RE = /\b(?:don'?t|do not)\s+ask(?!\s+me\s+(?:why|how|what))\b|\bno\s+(?:questions?|clarif(?:ication|ying)|interview)\b|\bwithout\s+asking\b|\bjust\s+answer\b|\banswer\s+(?:me\s+)?directly\b|\bstop\s+asking\b|đừng\s+hỏi|không\s+(?:cần\s+)?hỏi|khỏi\s+hỏi|trả\s+lời\s+(?:thẳng|luôn|liền|ngay|trực\s*tiếp)|\bdung\s+hoi\b|\bkhong\s+(?:can\s+)?hoi\b|\btra\s+loi\s+(?:thang|luon|lien|ngay)\b/i;
+export function detectNoClarifySignal(raw) {
+    return !!raw && NO_CLARIFY_RE.test(raw);
 }
 //# sourceMappingURL=clarity-gate.js.map

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

@@ -5,6 +5,14 @@
  *   Default OFF during rollout; flip to ON after dual-run validation.
  */
 export declare function isUnifiedPilEnabled(): boolean;
+/**
+ * MUONROI_LLM_FIRST_CLASSIFY: model-first Layer-1 classification. When enabled
+ * (default), the configured model classifies taskType/intentKind/style at the
+ * top of the turn and the brittle keyword-regex cascade becomes the OFFLINE
+ * fallback (used only when the model call fails / is not wired). Set to "0" to
+ * revert to the regex-first cascade. Requires opts.llmFallback to be wired
+ * (the orchestrator does this on the main path); without it, the cascade runs.
+ */
+export declare function isLlmFirstClassifyEnabled(): boolean;
 export declare function isDiscoveryEnabled(): boolean;
-export declare function getAutoPassThreshold(): number;
 export declare function getMaxInterviewQuestions(): number;

package/dist/src/pil/config.js

@@ -11,13 +11,24 @@ export function isUnifiedPilEnabled() {
         return true;
     return false;
 }
+/**
+ * MUONROI_LLM_FIRST_CLASSIFY: model-first Layer-1 classification. When enabled
+ * (default), the configured model classifies taskType/intentKind/style at the
+ * top of the turn and the brittle keyword-regex cascade becomes the OFFLINE
+ * fallback (used only when the model call fails / is not wired). Set to "0" to
+ * revert to the regex-first cascade. Requires opts.llmFallback to be wired
+ * (the orchestrator does this on the main path); without it, the cascade runs.
+ */
+export function isLlmFirstClassifyEnabled() {
+    return process.env.MUONROI_LLM_FIRST_CLASSIFY !== "0";
+}
 export function isDiscoveryEnabled() {
     return process.env.MUONROI_PIL_DISCOVERY !== "0";
 }
-export function getAutoPassThreshold() {
-    const v = Number(process.env.MUONROI_PIL_AUTOPASS_THRESHOLD);
-    return Number.isFinite(v) && v >= 0.5 && v <= 1.0 ? v : 0.85;
-}
+// Phase 2 (2026-06-16): getAutoPassThreshold() was removed with the regex
+// auto-pass gate (shouldAutoPass). The model now decides whether a turn needs
+// clarification, so there is no confidence threshold to tune. The
+// MUONROI_PIL_AUTOPASS_THRESHOLD env var is therefore inert.
 export function getMaxInterviewQuestions() {
     const v = Number(process.env.MUONROI_PIL_MAX_QUESTIONS);
     return Number.isFinite(v) && v >= 1 && v <= 5 ? v : 3;