muonroi-cli 1.7.2 → 1.8.1

package/dist/src/pil/layer1-intent.js

@@ -11,7 +11,7 @@
  */
 import { classifyViaBrain, pilContext } from "../ee/bridge.js";
 import { classify } from "../router/classifier/index.js";
-import { isLlmFirstClassifyEnabled, isUnifiedPilEnabled } from "./config.js";
+import { getUnifiedPilBudgetMs, isLlmFirstBrainEnabled, isLlmFirstClassifyEnabled, isUnifiedPilEnabled, } from "./config.js";
 /** File/path reference regex — matches common source-file extensions. */
 const FILE_REF_RE = /[\w./-]+\.(ts|tsx|js|jsx|json|md|py|rs|go|cs)\b/gi;
 /** Keywords that force a "low" complexity signal (additive score -3). */
@@ -645,6 +645,49 @@ export async function layer1Intent(ctx, opts = {}) {
                     complexity,
                     complexityScore,
                 };
+                // G3 (b1): reach the unified injection on the default (model-first)
+                // path. Without this, _brainData stays null and layer3 falls back to a
+                // legacy dense-only /api/search round-trip with divergent source
+                // attribution. Populate _brainData from the SAME server-side unified
+                // retrieval the offline cascade uses (one round-trip, bounded by budget)
+                // so layer3 renders the richer source="unified" block AND records the
+                // rateable ledger consistently. On chitchat / null / failure, _brainData
+                // stays null → layer3 legacy path (behaviour unchanged). Gate:
+                // MUONROI_LLM_FIRST_BRAIN=0 reverts.
+                let llmFirstBrainData = null;
+                if (isLlmFirstBrainEnabled() && intentKind !== "chitchat") {
+                    let brainRaw = ctx.raw;
+                    if (ctx.sessionId) {
+                        brainRaw =
+                            ctx.raw +
+                                ' [EE task checkpoints ("Context checkpoint summary" with ✔ DONE) from prior compactions are available via the ee.query tool. ' +
+                                "To keep full tool history this turn when you see pre-warn or compaction note, emit exact literal PRESERVE_FULL_CONTEXT in reasoning or assistant note. " +
+                                'Self-check "task finished?" or "compacted yet this turn?" using the checkpoints.]';
+                    }
+                    intentTrace.pass3UnifiedAttempted = true;
+                    // try/catch (not .catch) so a SYNC throw from pilContext (e.g. no EE
+                    // client configured, as in unit tests) is also swallowed — it must
+                    // never break the model-first return; _brainData just stays null.
+                    let resp = null;
+                    try {
+                        resp = await pilContext(brainRaw, {
+                            projectCtx: domain ? { domain } : undefined,
+                            budgetMs: getUnifiedPilBudgetMs(),
+                        });
+                    }
+                    catch (err) {
+                        console.error(`[pil/layer1] llm-first unified brain fetch failed: ${err?.message}`);
+                    }
+                    if (resp) {
+                        llmFirstBrainData = {
+                            t0_principles: resp.t0_principles,
+                            t1_rules: resp.t1_rules,
+                            t2_patterns: resp.t2_patterns,
+                            retrieval_skipped_reason: resp.retrieval_skipped_reason,
+                        };
+                        intentTrace.pass3UnifiedSucceeded = true;
+                    }
+                }
                 return {
                     ...ctx,
                     taskType: llmRes.taskType,
@@ -665,9 +708,10 @@ export async function layer1Intent(ctx, opts = {}) {
                     // the raw prompt.
                     ecosystemScope: llmRes.ecosystemScope,
                     replyLanguage: llmRes.replyLanguage,
-                    // null lets L6 run its cheap style-rescue if outputStyle is still null;
-                    // EE retrieval enrichment happens downstream in layer3 as usual.
-                    _brainData: null,
+                    // G3 (b1): populated from the unified pil-context fetch above so
+                    // layer3 renders source="unified" instead of its legacy dense-only
+                    // round-trip. null (chitchat / fetch failed) → layer3 legacy path.
+                    _brainData: llmFirstBrainData,
                     _intentTrace: intentTrace,
                     layers: [
                         ...ctx.layers,
@@ -1040,8 +1084,11 @@ export async function layer1Intent(ctx, opts = {}) {
         // accidentally swallow phrases like "refactor this" or "fix the bug" that
         // happen to be short.
         //
-        // TODO(WhoAmI-Pass0): when EE v4.0 Who Am I profile is available, read
-        // communication.brevity + decision_speed here as outputStyle baseline.
+        // WhoAmI v4.0: the outputStyle baseline from communication.brevity +
+        // decision_speed is now wired below (getWhoAmIProfile/outputStyleFromProfile
+        // at the classifier-default branch — it replaces "balanced" when no per-turn
+        // signal resolves the style). Not applied at this chitchat hot-path: greetings
+        // already force "concise" regardless of profile.
         const trimmed = ctx.raw.trim();
         const wordCount = trimmed.split(/\s+/).filter(Boolean).length;
         const noTaskSignal = taskType === null || (taskType === "general" && result.reason === "regex:short-message");
@@ -1096,7 +1143,7 @@ export async function layer1Intent(ctx, opts = {}) {
             }
             const resp = await pilContext(brainRaw, {
                 projectCtx: domain ? { domain } : undefined,
-                budgetMs: 1500,
+                budgetMs: getUnifiedPilBudgetMs(),
             });
             if (resp) {
                 if (resp.taskType)
@@ -1293,6 +1340,14 @@ Prompt: "${ctx.raw.slice(0, 300)}"`, 800);
                         }
                     }
                 }
+                else if (opts.profileStyleBaseline) {
+                    // WhoAmI v4.0 baseline: a standing communication.brevity/decision_speed
+                    // preference (computed once in the pipeline from the on-device profile)
+                    // fills in when no per-turn signal resolved the style. Per-turn detection
+                    // above still wins (override); this only replaces the generic "balanced".
+                    outputStyle = opts.profileStyleBaseline;
+                    styleSource = "whoami-profile";
+                }
                 else {
                     outputStyle = "balanced";
                     styleSource = "classifier-default";

package/dist/src/pil/layer1-intent.test.js

@@ -12,14 +12,23 @@ vi.mock("./config.js", () => ({
     // Default OFF so the existing cascade tests below exercise the regex passes.
     // The model-first gate has its own describe block that flips this to true.
     isLlmFirstClassifyEnabled: vi.fn(() => false),
+    // G3 (b1): default OFF so the existing model-first classification tests don't
+    // trigger the unified brain fetch; the brain-path test flips it true.
+    isLlmFirstBrainEnabled: vi.fn(() => false),
+    // Pass-3 unified reads the client-side budget; provided so the whole-module
+    // mock does not drop the export (the model-first tests never hit it, but the
+    // cascade tests can).
+    getUnifiedPilBudgetMs: vi.fn(() => 3500),
 }));
-import { classifyViaBrain } from "../ee/bridge.js";
+import { classifyViaBrain, pilContext } from "../ee/bridge.js";
 import { classify } from "../router/classifier/index.js";
-import { isLlmFirstClassifyEnabled } from "./config.js";
+import { isLlmFirstBrainEnabled, isLlmFirstClassifyEnabled } from "./config.js";
 import { hasActionableToolIntent, isGreenfieldBuildTask, isSocialPleasantry, isStatusCheckQuestion, layer1Intent, } from "./layer1-intent.js";
 const mockedClassify = vi.mocked(classify);
 const mockedClassifyViaBrain = vi.mocked(classifyViaBrain);
 const mockedLlmFirst = vi.mocked(isLlmFirstClassifyEnabled);
+const mockedLlmFirstBrain = vi.mocked(isLlmFirstBrainEnabled);
+const mockedPilContext = vi.mocked(pilContext);
 function makeCtx(raw) {
     return {
         raw,
@@ -560,6 +569,10 @@ describe("Pass 2.6 — social pleasantries route to chitchat (drop the tool-sche
 describe("layer1Intent — model-first gate (MUONROI_LLM_FIRST_CLASSIFY)", () => {
     beforeEach(() => {
         mockedLlmFirst.mockReturnValue(true);
+        // G3 (b1): brain fetch OFF by default so the classification tests don't
+        // trigger pilContext; the brain-path tests flip it on explicitly.
+        mockedLlmFirstBrain.mockReturnValue(false);
+        mockedPilContext.mockReset();
         // Make the regex cascade obviously WRONG so passing tests prove the model won.
         mockedClassify.mockReturnValue({ tier: "hot", reason: "regex:create-file", confidence: 0.9 });
     });
@@ -582,6 +595,75 @@ describe("layer1Intent — model-first gate (MUONROI_LLM_FIRST_CLASSIFY)", () =>
         expect(result._intentTrace?.pass1Reason).toBe("llm-first");
         expect(mockedClassify).not.toHaveBeenCalled();
     });
+    it("G3 (b1): populates _brainData from pilContext on the model-first path (→ layer3 unified)", async () => {
+        mockedLlmFirstBrain.mockReturnValue(true);
+        // biome-ignore lint/suspicious/noExplicitAny: partial pil-context shape for the test
+        mockedPilContext.mockResolvedValue({
+            taskType: "general",
+            intentKind: "task",
+            outputStyle: "concise",
+            confidence: 0.9,
+            t0_principles: [{ text: "principle-1", score: 0.9 }],
+            t1_rules: [{ text: "rule-1", score: 0.8 }],
+            t2_patterns: [],
+            retrieval_skipped_reason: null,
+        });
+        const result = await layer1Intent(makeCtx("explain the auth flow"), {
+            llmFallback: async () => ({
+                taskType: "general",
+                outputStyle: "concise",
+                confidence: 0.9,
+                intentKind: "task",
+                deliverableKind: "answer",
+                depthTier: null,
+                ecosystemScope: null,
+                replyLanguage: null,
+            }),
+        });
+        // _brainData now carries the unified brain → layer3 renders source="unified"
+        // instead of its legacy dense-only /api/search round-trip.
+        expect(result._brainData?.t0_principles).toHaveLength(1);
+        expect(result._brainData?.t1_rules).toHaveLength(1);
+        expect(result._intentTrace?.pass3UnifiedAttempted).toBe(true);
+        expect(result._intentTrace?.pass3UnifiedSucceeded).toBe(true);
+        expect(mockedPilContext).toHaveBeenCalledTimes(1);
+    });
+    it("G3 (b1): chitchat skips the brain fetch (no pilContext round-trip)", async () => {
+        mockedLlmFirstBrain.mockReturnValue(true);
+        const result = await layer1Intent(makeCtx("cảm ơn nhé"), {
+            llmFallback: async () => ({
+                taskType: "general",
+                outputStyle: "concise",
+                confidence: 0.9,
+                intentKind: "chitchat",
+                deliverableKind: "answer",
+                depthTier: null,
+                ecosystemScope: null,
+                replyLanguage: null,
+            }),
+        });
+        expect(result._brainData).toBeNull();
+        expect(mockedPilContext).not.toHaveBeenCalled();
+    });
+    it("G3 (b1): a failed/empty pilContext leaves _brainData null (layer3 legacy path)", async () => {
+        mockedLlmFirstBrain.mockReturnValue(true);
+        mockedPilContext.mockResolvedValue(null);
+        const result = await layer1Intent(makeCtx("explain the auth flow"), {
+            llmFallback: async () => ({
+                taskType: "general",
+                outputStyle: "concise",
+                confidence: 0.9,
+                intentKind: "task",
+                deliverableKind: "answer",
+                depthTier: null,
+                ecosystemScope: null,
+                replyLanguage: null,
+            }),
+        });
+        expect(result._brainData).toBeNull();
+        expect(result.taskType).toBe("general"); // classification still intact
+        expect(mockedPilContext).toHaveBeenCalledTimes(1);
+    });
     it("marks chitchat from the model for a pure greeting", async () => {
         const result = await layer1Intent(makeCtx("cảm ơn bạn nhé"), {
             llmFallback: async () => ({
@@ -651,4 +733,32 @@ describe("layer1Intent — model-first gate (MUONROI_LLM_FIRST_CLASSIFY)", () =>
         expect(result.taskType).toBe("debug");
     });
 });
+describe("layer1Intent — WhoAmI v4.0 output-style baseline (opts.profileStyleBaseline)", () => {
+    // A cheap regex task hit (high conf, unified PIL mocked off) skips the brain and
+    // lands on the classifier-default branch — exactly where the profile baseline now
+    // applies. The pipeline derives the baseline from the profile; layer1 just consumes
+    // the option. The prompt carries no explicit style cue.
+    const REFACTOR_PROMPT = "refactor the authentication module to use the new provider";
+    it("uses the profile-derived style baseline when no per-turn signal resolves it", async () => {
+        mockedClassify.mockReturnValue({ tier: "hot", reason: "regex:refactor", confidence: 0.9 });
+        const result = await layer1Intent(makeCtx(REFACTOR_PROMPT), { profileStyleBaseline: "concise" });
+        expect(result.taskType).toBe("refactor");
+        expect(result.outputStyle).toBe("concise");
+        expect(result._intentTrace?.styleSource).toBe("whoami-profile");
+    });
+    it("falls back to balanced when there is no profile baseline (behaviour unchanged)", async () => {
+        mockedClassify.mockReturnValue({ tier: "hot", reason: "regex:refactor", confidence: 0.9 });
+        const result = await layer1Intent(makeCtx(REFACTOR_PROMPT), { profileStyleBaseline: null });
+        expect(result.outputStyle).toBe("balanced");
+        expect(result._intentTrace?.styleSource).toBe("classifier-default");
+    });
+    it("an explicit per-turn style request still overrides the profile baseline", async () => {
+        mockedClassify.mockReturnValue({ tier: "hot", reason: "regex:refactor", confidence: 0.9 });
+        const result = await layer1Intent(makeCtx("refactor the auth module and explain step by step"), {
+            profileStyleBaseline: "concise",
+        });
+        expect(result.outputStyle).toBe("detailed");
+        expect(result._intentTrace?.styleSource).toBe("explicit-regex");
+    });
+});
 //# sourceMappingURL=layer1-intent.test.js.map

package/dist/src/pil/layer15-context-scan.js

@@ -76,7 +76,7 @@ export function scanBoundedContexts(cwd) {
         const entryNames = ["index.ts", "index.tsx", "index.js", "mod.rs", "__init__.py"];
         const entryFiles = entryNames.map((e) => join(dirPath, e)).filter((e) => existsSync(join(cwd, e)));
         const exportedSymbols = extractExports(cwd, entryFiles).slice(0, 20);
-        return { path: dirPath + "/", name: d, entryFiles, exportedSymbols };
+        return { path: `${dirPath}/`, name: d, entryFiles, exportedSymbols };
     });
 }
 function extractExports(cwd, entryFiles) {

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

@@ -1,33 +1,29 @@
 /**
  * src/pil/layer16-clarity.ts
  *
- * Phase 2 (2026-06-16): `detectClarityGaps` and its keyword option-builders
- * (`buildOutcomeOptions` / `buildScopeOptions` / `pickBest*` / recency ranking)
- * were removed. The configured chat model now decides every clarification —
- * its questions, options, recommended default, and reason — in
- * `proposeModelGaps` (`discovery.ts`). There is no regex gap synthesis.
+ * Phase 3 (2026-06-23): the model now generates full ModelCard[] directly
+ * (questions, options, kinds, cancel/adjust markers) — no ClarityGap
+ * intermediate, no sentinel strings, no hardcoded "Type something" option.
  *
- * What remains here is gap RENDERING + RESOLUTION (consumed by the model path):
- *   - the "provide my own details" no-answer sentinel,
- *   - `buildInterviewQuestion` (ClarityGap → askcard),
- *   - `resolveGapsNonInteractive` (default-answer resolution when headless),
- *   - `getAutofilledOutcome` / `getDefaultOutcome` (outcome-label polish).
+ * What remains here is thin RENDERING + HEADLESS RESOLUTION:
+ *   - `modelCardToQuestion` (ModelCard → CouncilQuestionData)
+ *   - `resolveGapsNonInteractive` (default-answer resolution when headless)
  */
 import type { CouncilQuestionData } from "../types/index.js";
-import type { ClarifiedIntent, ClarityGap, ProjectContext } from "./discovery-types.js";
-import type { TaskType } from "./types.js";
+import type { ClarifiedIntent, ModelCard, ProjectContext } from "./discovery-types.js";
 /**
- * The default "no specific answer" meta-option offered for a model-generated
- * clarification when the model supplies no concrete recommendations. Selecting
- * it means "use your judgment / I have nothing specific to add" — it is a
- * sentinel, NOT a real outcome, so it must never surface verbatim as the
- * resolved outcome. Centralised here so discovery.ts (which presents the
- * option) and the outcome-resolution paths agree on the exact strings.
+ * Map a model-designed card into a CouncilQuestionData for TUI rendering.
+ * The model controls every field; the CLI only assigns questionId and maps
+ * the card options 1:1 into CouncilQuestionOptions (keeping isCancel/isAdjust).
  */
-export declare const PROVIDE_OWN_DETAILS_OPTION_EN = "I will provide my own details / constraints";
-export declare const PROVIDE_OWN_DETAILS_OPTION_VI = "T\u00F4i s\u1EBD tr\u1EA3 l\u1EDDi t\u1EF1 do / cung c\u1EA5p chi ti\u1EBFt c\u1EA7n thi\u1EBFt";
-/** True when an answer is the "I'll provide my own details" meta-option (any locale). */
-export declare function isProvideOwnDetailsSentinel(answer: string | null | undefined): boolean;
-export declare function buildInterviewQuestion(gap: ClarityGap, questionId: string): CouncilQuestionData;
-export declare function resolveGapsNonInteractive(gaps: ClarityGap[], projectContext: ProjectContext, raw: string): ClarifiedIntent;
-export declare function getAutofilledOutcome(taskType: TaskType | null, raw?: string): string | null;
+export declare function modelCardToQuestion(card: ModelCard, questionId: string): CouncilQuestionData;
+/**
+ * Resolve model cards with best-effort defaults when there is no interactive
+ * handler (headless mode). Picks the default option for each card.
+ */
+export declare function resolveGapsNonInteractive(cards: ModelCard[], projectContext: ProjectContext, raw: string): ClarifiedIntent;
+/**
+ * Get a default outcome label for well-known task types when no outcome
+ * was voiced by the user and no card provided one.
+ */
+export declare function getDefaultOutcome(taskType: string | null, raw?: string): string;

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

@@ -1,107 +1,71 @@
-import { hasOperationalScope } from "./clarity-gate.js";
 /**
- * The default "no specific answer" meta-option offered for a model-generated
- * clarification when the model supplies no concrete recommendations. Selecting
- * it means "use your judgment / I have nothing specific to add" — it is a
- * sentinel, NOT a real outcome, so it must never surface verbatim as the
- * resolved outcome. Centralised here so discovery.ts (which presents the
- * option) and the outcome-resolution paths agree on the exact strings.
+ * Map a model-designed card into a CouncilQuestionData for TUI rendering.
+ * The model controls every field; the CLI only assigns questionId and maps
+ * the card options 1:1 into CouncilQuestionOptions (keeping isCancel/isAdjust).
  */
-export const PROVIDE_OWN_DETAILS_OPTION_EN = "I will provide my own details / constraints";
-export const PROVIDE_OWN_DETAILS_OPTION_VI = "Tôi sẽ trả lời tự do / cung cấp chi tiết cần thiết";
-/** True when an answer is the "I'll provide my own details" meta-option (any locale). */
-export function isProvideOwnDetailsSentinel(answer) {
-    if (!answer)
-        return false;
-    const norm = answer.trim().toLowerCase();
-    return norm === PROVIDE_OWN_DETAILS_OPTION_EN.toLowerCase() || norm === PROVIDE_OWN_DETAILS_OPTION_VI.toLowerCase();
-}
-export function buildInterviewQuestion(gap, questionId) {
-    const options = gap.options.map((label) => ({
-        label,
-        value: label,
-        kind: "choice",
+export function modelCardToQuestion(card, questionId) {
+    const options = card.options.map((o) => ({
+        label: o.label,
+        value: o.label,
+        kind: o.kind,
+        description: o.description,
+        isCancel: o.isCancel,
+        isAdjust: o.isAdjust,
     }));
-    options.push({
-        label: "Type something",
-        description: "Enter a custom answer",
-        value: "",
-        kind: "freetext",
-    });
     return {
         questionId,
-        question: gap.suggestedQuestion,
-        context: gap.description,
-        isRequired: false,
+        question: card.question,
+        context: card.context,
+        isRequired: true,
         phase: "pil-interview",
         options,
-        defaultIndex: gap.defaultIndex,
+        defaultIndex: card.defaultIndex ?? 0,
     };
 }
-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":
-                // The "provide my own details" meta-option is a no-answer sentinel —
-                // leave outcome empty so the inferred/default outcome is used downstream.
-                outcome = isProvideOwnDetailsSentinel(defaultAnswer) ? "" : 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;
+/**
+ * Resolve model cards with best-effort defaults when there is no interactive
+ * handler (headless mode). Picks the default option for each card.
+ */
+export function resolveGapsNonInteractive(cards, projectContext, raw) {
+    const answers = [];
+    for (const card of cards) {
+        const defaultIdx = card.defaultIndex ?? 0;
+        const opt = card.options[defaultIdx];
+        if (opt?.kind === "freetext") {
+            // Freetext can't be auto-answered; fall back to raw-derived outcome
+            answers.push("");
+        }
+        else {
+            answers.push(opt?.label ?? "");
         }
     }
-    if (!outcome)
-        outcome = getDefaultOutcome(raw);
-    if (scope.length === 0) {
-        scope = projectContext.relevantModules.map((m) => m.path);
-        if (scope.length === 0)
-            scope = ["project root"];
-    }
+    const outcome = answers.find((a) => a.length > 0) ?? `Complete: ${raw.slice(0, 80)}`;
+    const scope = projectContext.relevantModules.length > 0 ? projectContext.relevantModules.map((m) => m.path) : ["project root"];
     return {
         outcome,
         scope,
-        constraints,
-        gaps: gaps.map((g) => ({ ...g, answer: null })),
+        constraints: [],
+        gaps: [],
     };
 }
-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";
-    }
-    // Operational debug tasks (CI/build/deploy) 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";
+/**
+ * Get a default outcome label for well-known task types when no outcome
+ * was voiced by the user and no card provided one.
+ */
+export function getDefaultOutcome(taskType, raw) {
+    if (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 the CLI with specific, actionable improvements";
+        }
     }
-    return `Complete the task described in: "${raw.slice(0, 80)}"`;
+    const map = {
+        analyze: "Detailed analysis with concrete improvement recommendations",
+        plan: "Step-by-step plan",
+        documentation: "Docs updated",
+        debug: "Error resolved, expected behavior restored",
+    };
+    return map[taskType ?? ""] ?? `Complete: ${(raw ?? "").slice(0, 80)}`;
 }
 //# sourceMappingURL=layer16-clarity.js.map

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

@@ -1,4 +1,14 @@
-import type { CouncilQuestionData } from "../types/index.js";
+/**
+ * src/pil/layer18-acceptance.ts
+ *
+ * Phase 3 (2026-06-23): acceptance is now model-driven — the model includes
+ * acceptance/rejection options in its own ModelCard[]. The CLI no longer
+ * builds hardcoded Accept/Adjust/Cancel buttons.
+ *
+ * What remains here is a simplified summary card builder used by the
+ * `showAcceptance` replacement: when feasibility warnings exist, the CLI
+ * appends them as context to the model's last card rather than creating a
+ * separate acceptance ceremony.
+ */
 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;
+export declare function buildAcceptanceCard(intentStatement: string, intent: ClarifiedIntent, feasibility: FeasibilityResult, _raw?: string): AcceptanceCardData;

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

@@ -1,14 +1,5 @@
-export function buildAcceptanceCard(intentStatement, intent, feasibility, raw) {
+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,
@@ -16,69 +7,4 @@ export function buildAcceptanceCard(intentStatement, intent, feasibility, raw) {
         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/layer2-personality.js

@@ -1,12 +1,11 @@
 import { truncateToBudget } from "./budget.js";
-// TODO(WhoAmI-L2): when EE v4.0 Who Am I profile is available, replace
-// static PERSONALITY_HINTS with a dynamically-built hint from the user profile:
-//   communication.brevity       → concise/detailed bias
-//   decision_speed              → skip exhaustive options, recommend once
-//   feedback_style              → implicit = don't re-explain on "ok"
-//   work_patterns.delegation    → autonomous = lead with action, not question
-// ctx.outputStyle from L1 becomes an override signal, not the primary source.
-// Until WhoAmI ships, L2 relies entirely on L1's per-turn detection.
+// WhoAmI v4.0 (partly wired): ctx.outputStyle now carries the profile baseline
+// from communication.brevity / decision_speed (resolved in layer1-intent.ts via
+// ../ee/who-am-i.ts), so the concise/detailed bias below is already profile-aware
+// without changing this layer — L1's per-turn detection overrides it. Still future:
+// a richer hint built directly from feedback_style (EE emits implicit |
+// precise-correction). NOTE: `work_patterns.delegation_style` is NOT emitted by EE
+// slice-1 — do not wire it until a later EE slice adds it.
 const DEFAULT_PERSONALITY = "balanced";
 const PERSONALITY_HINTS = {
     concise: "[personality: concise — Be direct and terse. Lead with the answer. Skip preamble. " +

package/dist/src/pil/layer2_5-ponytail.d.ts

@@ -0,0 +1,2 @@
+import type { PipelineContext } from "./types.js";
+export declare function layer2_5Ponytail(ctx: PipelineContext): Promise<PipelineContext>;