muonroi-cli 1.3.4 → 1.4.1

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

@@ -0,0 +1,394 @@
+import { canInferOutcome, countFileReferences, hasExplicitScope, hasExternalInfoScope, hasImageScope, hasOperationalScope, hasSelfContainedComputationScope, hasWholeRepoScope, } from "./clarity-gate.js";
+export function detectClarityGaps(raw, taskType, confidence, projectContext) {
+    const gaps = [];
+    // PIL-L6 fix — debug joins the autofill set. For "fix ci fail" the outcome
+    // is trivially "error resolved / pipeline green" and forcing an askcard
+    // there produces noise (the user already said "goal: ci green").
+    const AUTOFILL_OUTCOME_TYPES = new Set(["analyze", "plan", "documentation", "debug"]);
+    if (!canInferOutcome(taskType, raw)) {
+        if (taskType && AUTOFILL_OUTCOME_TYPES.has(taskType)) {
+            // These task types have predictable outcomes — auto-fill without asking
+        }
+        else if (!taskType || taskType === "general") {
+            // B2 intent-swallow fix — a `general` (or unclassified) prompt has no
+            // task-specific outcome options, so `buildOutcomeOptions` falls back to
+            // the tautological ["Task completed", "Issue resolved"]. Asking that
+            // askcard adds zero signal, and its default answer overwrites the intent
+            // → "general: Task completed", discarding the user's original request.
+            // Skip it; the outcome defaults to the raw prompt downstream
+            // (buildClarifiedIntentFromAnswers / getDefaultOutcome), preserving intent.
+        }
+        else {
+            const outcomeOptions = buildOutcomeOptions(taskType, projectContext);
+            gaps.push({
+                dimension: "outcome",
+                description: "Cannot infer the expected outcome from the prompt",
+                suggestedQuestion: `What's the expected outcome? ${taskType === "debug" ? "(e.g., error gone, test passes, behavior fixed)" : "(e.g., feature works, file updated, test passes)"}`,
+                options: outcomeOptions,
+                defaultIndex: pickBestOutcomeIndex(taskType, outcomeOptions, raw),
+            });
+        }
+    }
+    // PIL-L6 fix — operational scope (CI / build / deploy / lint) is enough
+    // even without a file path. The task's target is the pipeline itself.
+    //
+    // B2-symmetric scope guard — the scope detector assumes EVERY prompt is a
+    // codebase task: any prompt lacking a file/module/operational reference gets
+    // asked "Which part of the codebase should this target?". For a general or
+    // unclassified prompt that has no codebase dimension at all (e.g. a pure
+    // chat / generation request like "Reply with one word: PONG", live session
+    // 8a87aa060c6a) this question is nonsensical, and because it is the only gap
+    // it also drags in a downstream acceptance card. Skip it for general/null —
+    // the same population the B2 outcome guard above protects. Scope then falls
+    // back to project-root in resolveGapsNonInteractive. Classified code tasks
+    // (debug/generate/refactor/…) still get the scope-narrowing askcard.
+    // Image-scope guard — an image-analysis task (e.g. "analyze diagram.png",
+    // "take a screenshot and describe it") is scoped to the IMAGE, not the
+    // codebase, so the "Which part of the codebase?" askcard is nonsensical for
+    // it. Symmetric to hasOperationalScope (pipeline-scoped). hasImageScope is
+    // deliberately narrow so it never swallows a real codebase task.
+    const scopeAppliesToCodebase = !!taskType && taskType !== "general";
+    if (scopeAppliesToCodebase &&
+        countFileReferences(raw) === 0 &&
+        !hasExplicitScope(raw) &&
+        !hasOperationalScope(raw) &&
+        !hasImageScope(raw) &&
+        !hasExternalInfoScope(raw) &&
+        // Whole-repo / eval prompts ("đánh giá repo", "review the entire codebase")
+        // are already scoped to everything — asking "which part?" (and recommending
+        // a narrow subdir as default) is nonsensical. See hasWholeRepoScope.
+        !hasWholeRepoScope(raw) &&
+        // Self-contained computation ("Compute f([3,1,2]) …") supplies its operand
+        // data inline — there is no codebase to scope. See hasSelfContainedComputationScope.
+        !hasSelfContainedComputationScope(raw)) {
+        const scopeOptions = buildScopeOptions(raw, projectContext);
+        gaps.push({
+            dimension: "scope",
+            description: "No specific file or module referenced",
+            suggestedQuestion: "Which part of the codebase should this target?",
+            options: scopeOptions,
+            defaultIndex: pickBestScopeIndex(raw, scopeOptions),
+        });
+    }
+    const hasConstraint = /\b(\d+\s*ms|\d+\s*%|faster|slower|before|deadline|limit|max|min)\b/i.test(raw);
+    const isPerformanceTask = /\b(optimi[zs]e|performance|speed|fast|slow|latency|throughput)\b/i.test(raw);
+    if (isPerformanceTask && !hasConstraint) {
+        gaps.push({
+            dimension: "constraint",
+            description: "Performance target not specified",
+            suggestedQuestion: "Any specific performance target? (e.g., <200ms response, 50% faster)",
+            options: ["General improvement", "Specific latency target", "Reduce bundle size"],
+            defaultIndex: 0,
+        });
+    }
+    return gaps;
+}
+/**
+ * Phase 5 F8 — context-aware default option for outcome askcards.
+ *
+ * The askcard's "Recommended" badge previously pinned to options[0]
+ * regardless of prompt content. For prompts like "improve test coverage"
+ * (generate options: Feature implemented / File created / Tests added),
+ * defaulting to "Feature implemented" was wrong — the user explicitly
+ * mentioned tests. This picks a more relevant option based on prompt
+ * keywords, with a fallback to 0 when nothing matches.
+ *
+ * Keep this list short — overengineering breaks predictability. We only
+ * encode the keyword→index pairs we've actually seen mismatch in the
+ * 5-baseline + sanity sessions.
+ */
+function pickBestOutcomeIndex(taskType, options, raw) {
+    if (options.length <= 1)
+        return 0;
+    const lower = raw.toLowerCase();
+    const has = (re) => re.test(lower);
+    const find = (substring) => options.findIndex((o) => o.toLowerCase().includes(substring));
+    switch (taskType) {
+        case "generate": {
+            // "improve coverage", "add tests", "viết test" → "Tests added"
+            if (has(/\b(coverage|unit test|viết test|viet test|spec|jest|vitest|pytest)\b/) || has(/\btest(?:s|ing)?\b/)) {
+                const idx = find("test");
+                if (idx >= 0)
+                    return idx;
+            }
+            // "scaffold", "boilerplate", "tạo file mới" → "File created with boilerplate"
+            if (has(/\b(scaffold|boilerplate|template|skeleton)\b/) || has(/\btạo file\b|\btao file\b/)) {
+                const idx = find("file created");
+                if (idx >= 0)
+                    return idx;
+            }
+            return 0; // "Feature implemented and working"
+        }
+        case "refactor": {
+            // "performance", "speed", "faster" → "Better performance"
+            if (has(/\b(performance|speed|fast(er)?|slow|latency|throughput|optimi[zs]e)\b/)) {
+                const idx = find("performance");
+                if (idx >= 0)
+                    return idx;
+            }
+            // "test", "testable" → "Easier to test"
+            if (has(/\b(testable|easier to test|unit test)\b/)) {
+                const idx = find("test");
+                if (idx >= 0)
+                    return idx;
+            }
+            return 0; // "Code cleaner, same behavior"
+        }
+        case "debug": {
+            // "test fail", "test pass" → "Test passes"
+            if (has(/\btest(?:s|ing)? (?:fail|pass)/) || has(/\bspec fail/)) {
+                const idx = find("test passes");
+                if (idx >= 0)
+                    return idx;
+            }
+            return 0; // "Error disappears"
+        }
+        case "documentation": {
+            if (has(/\b(readme)\b/)) {
+                const idx = find("readme");
+                if (idx >= 0)
+                    return idx;
+            }
+            if (has(/\b(api docs|api documentation|openapi|swagger)\b/)) {
+                const idx = find("api docs");
+                if (idx >= 0)
+                    return idx;
+            }
+            return 0;
+        }
+        case "plan": {
+            if (has(/\b(trade-?offs?|alternative|compare)\b/)) {
+                const idx = find("trade");
+                if (idx >= 0)
+                    return idx;
+            }
+            if (has(/\b(step.?by.?step|phase|roadmap)\b/)) {
+                const idx = find("step-by-step");
+                if (idx >= 0)
+                    return idx;
+            }
+            return 0;
+        }
+        case "analyze": {
+            if (has(/\b(root cause|why|tại sao|tai sao|crash|stack trace)\b/)) {
+                const idx = find("root cause");
+                if (idx >= 0)
+                    return idx;
+            }
+            if (has(/\b(recommend|suggest|đề xuất|de xuat)\b/)) {
+                const idx = find("recommendations");
+                if (idx >= 0)
+                    return idx;
+            }
+            return 0;
+        }
+        default:
+            return 0;
+    }
+}
+function buildOutcomeOptions(taskType, ctx) {
+    switch (taskType) {
+        case "debug":
+            return ["Error disappears", "Test passes", "Feature works correctly"];
+        case "refactor":
+            return ["Code cleaner, same behavior", "Better performance", "Easier to test"];
+        case "generate":
+            return ["Feature implemented and working", "File created with boilerplate", "Tests added"];
+        case "documentation":
+            return ["Docs updated", "README reflects current state", "API docs generated"];
+        case "plan":
+            return ["Architecture decided", "Step-by-step plan", "Trade-offs documented"];
+        case "analyze":
+            return ["Root cause identified", "Report generated", "Recommendations listed"];
+        default:
+            return ["Task completed", "Issue resolved"];
+    }
+}
+/**
+ * Pick the "Recommended" default index for the scope askcard.
+ *
+ * Bug fixed (live obs 2026-06-04, deepseek session): the scope gap hardcoded
+ * defaultIndex 0, but buildScopeOptions lists recency-ranked (NOT prompt-matched)
+ * bounded contexts first when nothing matched — so the card recommended an
+ * arbitrary subdir (e.g. "src/cli") for a repo-wide prompt while "Entire project"
+ * was demoted to last. Only recommend a specific bounded context when the prompt
+ * literally names it (same word-overlap test buildScopeOptions uses); otherwise
+ * recommend "Entire project".
+ */
+export function pickBestScopeIndex(raw, options) {
+    const entireIdx = options.findIndex((o) => /entire project/i.test(o));
+    const fallback = entireIdx >= 0 ? entireIdx : Math.max(0, options.length - 1);
+    const words = raw
+        .toLowerCase()
+        .split(/\s+/)
+        .filter((w) => w.length > 2);
+    for (let i = 0; i < options.length; i++) {
+        const opt = options[i] ?? "";
+        if (/entire project/i.test(opt))
+            continue;
+        const nameMatch = opt.match(/\(([^)]+)\)\s*$/);
+        const name = (nameMatch?.[1] ?? opt).toLowerCase();
+        if (words.some((w) => name.includes(w) || w.includes(name)))
+            return i;
+    }
+    return fallback;
+}
+function buildScopeOptions(raw, ctx) {
+    const words = raw
+        .toLowerCase()
+        .split(/\s+/)
+        .filter((w) => w.length > 2);
+    const matching = ctx.boundedContexts.filter((bc) => {
+        const name = bc.name.toLowerCase();
+        return words.some((w) => name.includes(w) || w.includes(name));
+    });
+    const options = matching.map((bc) => `${bc.path} (${bc.name})`);
+    if (options.length === 0 && ctx.boundedContexts.length > 0) {
+        // Phase 5 F4 — when no keyword matches a module name, the previous
+        // fallback returned the first 3 alphabetically (which on muonroi-cli
+        // surfaced `agent-harness`, `billing`, `chat` — three OLD scaffolding
+        // folders that almost never match a fresh prompt). Rank by recency
+        // signal instead: most recently modified module dir comes first.
+        const ranked = rankModulesByRecency(ctx.boundedContexts, ctx.cwd);
+        options.push(...ranked.slice(0, 3).map((bc) => `${bc.path} (${bc.name})`));
+    }
+    options.push("Entire project");
+    return options.slice(0, 4);
+}
+/**
+ * F4 — rank bounded contexts by recency-of-modification of any tracked file
+ * inside. Falls back to alphabetical order when stat() throws for the dir.
+ * The 4-level depth cap + 50-entry-per-level cap keeps the walk under 200ms
+ * even on huge monorepos.
+ */
+function rankModulesByRecency(contexts, cwd) {
+    const fs = require("node:fs");
+    const path = require("node:path");
+    const scored = contexts.map((bc) => {
+        const dirPath = path.join(cwd, bc.path);
+        let maxMtime = 0;
+        try {
+            // walk up to 4 levels deep, cap entries per level
+            const walk = (dir, depth) => {
+                if (depth > 4)
+                    return;
+                let entries = [];
+                try {
+                    entries = fs.readdirSync(dir).slice(0, 50);
+                }
+                catch {
+                    return;
+                }
+                for (const e of entries) {
+                    if (e.startsWith(".") || e === "node_modules" || e === "dist")
+                        continue;
+                    try {
+                        const full = path.join(dir, e);
+                        const st = fs.statSync(full);
+                        if (st.mtimeMs > maxMtime)
+                            maxMtime = st.mtimeMs;
+                        if (st.isDirectory())
+                            walk(full, depth + 1);
+                    }
+                    catch {
+                        /* skip unreadable entries */
+                    }
+                }
+            };
+            walk(dirPath, 0);
+        }
+        catch {
+            /* fall back to mtime=0 — keeps the entry at the bottom of the ranked list */
+        }
+        return { bc, mtime: maxMtime };
+    });
+    scored.sort((a, b) => b.mtime - a.mtime);
+    return scored.map((s) => s.bc);
+}
+export function buildInterviewQuestion(gap, questionId) {
+    const options = gap.options.map((label) => ({
+        label,
+        value: label,
+        kind: "choice",
+    }));
+    options.push({
+        label: "Type something",
+        description: "Enter a custom answer",
+        value: "",
+        kind: "freetext",
+    });
+    return {
+        questionId,
+        question: gap.suggestedQuestion,
+        context: gap.description,
+        isRequired: false,
+        phase: "pil-interview",
+        options,
+        defaultIndex: gap.defaultIndex,
+    };
+}
+export function resolveGapsNonInteractive(gaps, projectContext, raw) {
+    let outcome = "";
+    let scope = [];
+    const constraints = [];
+    for (const gap of gaps) {
+        const defaultAnswer = gap.options[gap.defaultIndex] ?? gap.options[0] ?? "";
+        switch (gap.dimension) {
+            case "outcome":
+                outcome = defaultAnswer;
+                break;
+            case "scope": {
+                const relevant = projectContext.relevantModules.map((m) => m.path);
+                scope = relevant.length > 0 ? relevant : [defaultAnswer];
+                break;
+            }
+            case "constraint":
+                constraints.push(defaultAnswer);
+                break;
+        }
+    }
+    if (!outcome)
+        outcome = getDefaultOutcome(raw);
+    if (scope.length === 0) {
+        scope = projectContext.relevantModules.map((m) => m.path);
+        if (scope.length === 0)
+            scope = ["project root"];
+    }
+    return {
+        outcome,
+        scope,
+        constraints,
+        gaps: gaps.map((g) => ({ ...g, answer: null })),
+    };
+}
+const DEFAULT_OUTCOMES = {
+    analyze: "Detailed analysis with concrete improvement recommendations",
+    plan: "Step-by-step plan",
+    documentation: "Docs updated",
+    debug: "Error resolved, expected behavior restored",
+};
+export function getAutofilledOutcome(taskType, raw) {
+    if (!taskType || !raw)
+        return null;
+    const lower = raw.toLowerCase();
+    const isNativeMeta = /đánh giá|phân tích|cải thiện|fix|native|agent.*inside|cli.*bên trong|phỏng vấn|discovery/i.test(lower);
+    if (isNativeMeta) {
+        // Force good outcome for self-review / native meta prompts regardless of L1 taskType (analyze/debug)
+        // Prevents generic "Local path...", "In prompts/ directory...", "Complete the task..." in [Discovery]
+        return "Native self-assessment of the CLI with specific, actionable code fixes proposed and verified";
+    }
+    // PIL-L6 fix — operational debug tasks have a stronger default outcome
+    if (taskType === "debug" && hasOperationalScope(raw)) {
+        return "Pipeline green, all checks passing";
+    }
+    return DEFAULT_OUTCOMES[taskType] ?? null;
+}
+function getDefaultOutcome(raw) {
+    const lower = raw.toLowerCase();
+    const isNativeMeta = /đánh giá|phân tích|cải thiện|fix|native|agent.*inside|cli.*bên trong|phỏng vấn|discovery/i.test(lower);
+    if (isNativeMeta) {
+        return "Native self-assessment of muonroi-cli with concrete improvements identified and implemented";
+    }
+    return `Complete the task described in: "${raw.slice(0, 80)}"`;
+}
+//# sourceMappingURL=layer16-clarity.js.map

package/dist/src/pil/layer16-clarity.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/pil/layer16-clarity.test.js

@@ -0,0 +1,31 @@
+import { describe, expect, it } from "vitest";
+import { pickBestScopeIndex } from "./layer16-clarity.js";
+/**
+ * Bug (live obs 2026-06-04, deepseek session): the scope askcard hardcoded
+ * defaultIndex 0, but buildScopeOptions lists recency-ranked (NOT prompt-matched)
+ * bounded contexts first when nothing matches — so the "Recommended" default was
+ * an arbitrary subdir (e.g. src/cli) for a repo-wide prompt, with "Entire
+ * project" demoted to last. The default must prefer "Entire project" unless the
+ * prompt names a specific module.
+ */
+describe("pickBestScopeIndex", () => {
+    const opts = ["src/cli (cli)", "src/council (council)", "Entire project"];
+    it("recommends 'Entire project' when the prompt names no specific module", () => {
+        expect(pickBestScopeIndex("đánh giá repo này: điểm mạnh, điểm yếu", opts)).toBe(2);
+        expect(pickBestScopeIndex("summarize the whole project", opts)).toBe(2);
+        expect(pickBestScopeIndex("tóm tắt repo", opts)).toBe(2);
+    });
+    it("recommends the matching bounded context when the prompt names it", () => {
+        expect(pickBestScopeIndex("fix the cli command parser", opts)).toBe(0);
+        expect(pickBestScopeIndex("refactor the council debate flow", opts)).toBe(1);
+    });
+    it("never recommends a ranked (non-matching) bounded context as the default", () => {
+        // The core bug: options[0] is arbitrary when nothing matched → must not win.
+        expect(pickBestScopeIndex("improve overall quality", opts)).not.toBe(0);
+    });
+    it("falls back to the last option when 'Entire project' is absent", () => {
+        // Prompt names neither module → no match → last option is the safe fallback.
+        expect(pickBestScopeIndex("xyz qrs", ["src/auth (auth)", "src/billing (billing)"])).toBe(1);
+    });
+});
+//# sourceMappingURL=layer16-clarity.test.js.map

package/dist/src/pil/layer17-feasibility.d.ts

@@ -0,0 +1,4 @@
+import type { ClarifiedIntent, FeasibilityResult, ProjectContext } from "./discovery-types.js";
+type ExistsFn = (p: string) => boolean;
+export declare function checkFeasibility(intent: ClarifiedIntent, projectContext: ProjectContext, exists?: ExistsFn): Promise<FeasibilityResult>;
+export {};

package/dist/src/pil/layer17-feasibility.js

@@ -0,0 +1,30 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+export async function checkFeasibility(intent, projectContext, exists = (p) => existsSync(join(projectContext.cwd, p))) {
+    const warnings = [];
+    const adjustedScope = [];
+    for (const scopeItem of intent.scope) {
+        if (scopeItem === "project root" || scopeItem === "Entire project") {
+            adjustedScope.push(scopeItem);
+            continue;
+        }
+        const cleanPath = scopeItem.replace(/\s*\(.*\)\s*$/, "").trim();
+        if (exists(cleanPath)) {
+            adjustedScope.push(cleanPath);
+        }
+        else {
+            warnings.push(`File/directory not found: ${cleanPath}`);
+            const matchingBc = projectContext.boundedContexts.find((bc) => cleanPath.startsWith(bc.path) || bc.path.startsWith(cleanPath));
+            if (matchingBc) {
+                adjustedScope.push(matchingBc.path);
+                warnings.push(`→ Adjusted scope to nearest module: ${matchingBc.path}`);
+            }
+        }
+    }
+    return {
+        viable: true,
+        warnings,
+        adjustedScope: adjustedScope.length > 0 ? adjustedScope : intent.scope,
+    };
+}
+//# sourceMappingURL=layer17-feasibility.js.map

package/dist/src/pil/layer18-acceptance.d.ts

@@ -0,0 +1,4 @@
+import type { CouncilQuestionData } from "../types/index.js";
+import type { AcceptanceCardData, ClarifiedIntent, FeasibilityResult } from "./discovery-types.js";
+export declare function buildAcceptanceCard(intentStatement: string, intent: ClarifiedIntent, feasibility: FeasibilityResult, raw?: string): AcceptanceCardData;
+export declare function buildAcceptanceQuestion(card: AcceptanceCardData, questionId: string): CouncilQuestionData;

package/dist/src/pil/layer18-acceptance.js

@@ -0,0 +1,84 @@
+export function buildAcceptanceCard(intentStatement, intent, feasibility, raw) {
+    const warnings = [...feasibility.warnings];
+    // PIL-L6 fix — detect mismatch between user's raw words and the reframed
+    // intent statement. If raw says "ci fail / fix" but statement says
+    // "generate / feature implemented", add a loud warning AND surface a hint
+    // in the card so the user notices before accepting.
+    if (raw) {
+        const mismatch = detectIntentMismatch(raw, intentStatement);
+        if (mismatch)
+            warnings.unshift(mismatch);
+    }
+    return {
+        intentStatement,
+        outcome: intent.outcome,
+        scope: feasibility.adjustedScope.length > 0 ? feasibility.adjustedScope : intent.scope,
+        warnings,
+    };
+}
+/**
+ * PIL-L6 fix — heuristic mismatch detector. Returns a human-readable warning
+ * string when the reframed intent looks wrong relative to the raw prompt.
+ * Returns null when no mismatch is detected. Cheap regex-based — no LLM.
+ */
+function detectIntentMismatch(raw, intentStatement) {
+    const r = raw.toLowerCase();
+    const s = intentStatement.toLowerCase();
+    // Debug signals in raw vs. non-debug intent
+    const debugSignals = /\b(fail(?:s|ed|ing)?|error|exception|crash|broken|bug|fix\s+(?:the\s+)?(?:ci|build|test|action|workflow|deploy)|sửa\s+lỗi|lỗi|hỏng)\b/i;
+    if (debugSignals.test(raw) && !/^debug:/.test(s) && !/(fix|debug|repair|resolve|error|fail)/.test(s)) {
+        return `Detected debug/bug-fix signals in your prompt ("${matchedWord(r, debugSignals)}") but intent reframed as "${intentStatement}". Verify before accepting.`;
+    }
+    return null;
+}
+function matchedWord(haystack, re) {
+    const m = re.exec(haystack);
+    return m?.[0] ?? "";
+}
+/**
+ * Classify a card warning as blocking (should force Adjust default) or
+ * informational (Accept default is fine). Intent-mismatch detector output
+ * is informational — the card body already surfaces it so the user can see
+ * the hint without being routed back into another interview round.
+ */
+function isBlockingWarning(warning) {
+    const w = warning.toLowerCase();
+    if (w.includes("detected") && (w.includes("signals") || w.includes("verify before accepting"))) {
+        return false;
+    }
+    return true;
+}
+export function buildAcceptanceQuestion(card, questionId) {
+    const contextLines = [];
+    contextLines.push(`Outcome: ${card.outcome}`);
+    contextLines.push(`Scope: ${card.scope.join(", ")}`);
+    if (card.warnings.length > 0) {
+        contextLines.push(`⚠ ${card.warnings.join("; ")}`);
+    }
+    const options = [
+        { label: "Accept", value: "accept", kind: "choice", description: "Proceed with this understanding" },
+        { label: "Adjust", value: "adjust", kind: "choice", description: "Let me clarify further" },
+        { label: "Cancel", value: "cancel", kind: "choice", description: "Never mind" },
+    ];
+    // Default-index policy:
+    //  - No warnings → Accept (0).
+    //  - Any blocking warning (feasibility text like "infeasible", "blocked by",
+    //    "cannot") → Adjust (1).
+    //  - Only informational warnings (intent-mismatch detector output —
+    //    "Detected ... signals" / "Verify before accepting") → Accept (0).
+    //  Evidence (session 1f29e238a816): intent-mismatch detector fired on a
+    //  4-word follow-up ("Can you fix it?"), forcing Adjust default and a
+    //  PIL chain that burned 35s on questions the user had already answered.
+    const hasBlockingWarning = card.warnings.some((w) => isBlockingWarning(w));
+    const defaultIndex = hasBlockingWarning ? 1 : 0;
+    return {
+        questionId,
+        question: `I understand you want to: ${card.intentStatement}`,
+        context: contextLines.join("\n"),
+        isRequired: true,
+        phase: "pil-acceptance",
+        options,
+        defaultIndex,
+    };
+}
+//# sourceMappingURL=layer18-acceptance.js.map

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

@@ -0,0 +1,23 @@
+/**
+ * src/pil/layer1_5-complexity-size.ts
+ *
+ * Layer 1.5 — deterministic complexity-size classifier.
+ *
+ * Pure regex/heuristic. NO LLM call, NO network, NO I/O. Output `{size, score,
+ * features}` is consumed by 4B (step ceiling matrix) and 4A (reminder cadence K).
+ *
+ * Heuristic weights are LOCKED verbatim by the Phase 4 CONTEXT (see
+ * `.planning/phases/04-scope-discipline-for-cheap-models/04-CONTEXT.md` §
+ * "Layer 1.5 complexity-size (4C)"). Do NOT alter weights without re-running the
+ * baseline harness regression.
+ */
+export interface ComplexitySizeInput {
+    rawText: string;
+    taskType: string;
+}
+export interface ComplexitySizeResult {
+    size: "small" | "medium" | "large";
+    score: number;
+    features: Record<string, number | boolean>;
+}
+export declare function scoreComplexitySize(input: ComplexitySizeInput): ComplexitySizeResult;