muonroi-cli 1.7.2 → 1.8.0

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)
@@ -1196,40 +1243,40 @@ export async function layer1Intent(ctx, opts = {}) {
                 //     touch existing files.
                 // 0.7 confidence threshold for Pass 2 keyword override remains
                 // unchanged (HIGH_CONF_THRESHOLD_PASS2 above).
-                const brainRaw = await classifyViaBrain(`You are a multilingual prompt classifier. The user's prompt may be in English, Vietnamese, or a mix of both.
-Classify the prompt's INTENT (not its language). Reply with TWO lowercase words separated by a comma: <category>,<style>
-
-Category — pick ONE (listed in neutral order, no precedence):
-  analyze       — explain / inspect / review existing code (giải thích, phân tích, review)
-  debug         — fix a bug or investigate failure (sửa lỗi, fix bug, lỗi, traceback)
-  generate      — create new code/file or add new behavior (tạo, sinh code, viết function mới, thêm)
-  refactor      — restructure existing code (tái cấu trúc, refactor)
-  plan          — design / roadmap / architecture (kế hoạch, thiết kế, kiến trúc)
-  documentation — write docs/comments (viết docs, comment, jsdoc)
-  general       — chitchat OR unclear / ambiguous coding intent
-
-Rules (Phase 4 4P-2 disambiguation):
-- Only return refactor when the user EXPLICITLY uses one of: rename, restructure, reorganize, extract, inline, move, migrate, reshape — applied to EXISTING code WITHOUT adding new behavior.
-- Feature additions ('add flag', 'thêm', 'create endpoint', 'thêm option'), changing a DEFAULT value, adding tests, or improving coverage are 'generate' — NOT refactor.
-- 'improve', 'change', 'update', 'modify', 'đổi', 'cải thiện' alone do NOT imply refactor — pick the specific category by what the change actually does.
-- When the request is ambiguous, prefer 'general' over guessing refactor.
-
-Negative examples (NOT refactor):
-- "đổi default --max-tool-rounds 8 sang 12" → generate
-- "improve test coverage" → generate
-- "tại sao X trả empty" → analyze
-- "fix CI failing" → debug
-
-Style — pick ONE:
-  concise (ngắn gọn) | balanced (cân bằng) | detailed (chi tiết)
-
-Examples:
-  "Refactor this function" → refactor,balanced
-  "tại sao test fail" → debug,balanced
-  "thiết kế hệ thống auth" → plan,detailed
-  "thêm flag --foo" → generate,concise
-  "hi" → general,concise
-
+                const brainRaw = await classifyViaBrain(`You are a multilingual prompt classifier. The user's prompt may be in English, Vietnamese, or a mix of both.
+Classify the prompt's INTENT (not its language). Reply with TWO lowercase words separated by a comma: <category>,<style>
+
+Category — pick ONE (listed in neutral order, no precedence):
+  analyze       — explain / inspect / review existing code (giải thích, phân tích, review)
+  debug         — fix a bug or investigate failure (sửa lỗi, fix bug, lỗi, traceback)
+  generate      — create new code/file or add new behavior (tạo, sinh code, viết function mới, thêm)
+  refactor      — restructure existing code (tái cấu trúc, refactor)
+  plan          — design / roadmap / architecture (kế hoạch, thiết kế, kiến trúc)
+  documentation — write docs/comments (viết docs, comment, jsdoc)
+  general       — chitchat OR unclear / ambiguous coding intent
+
+Rules (Phase 4 4P-2 disambiguation):
+- Only return refactor when the user EXPLICITLY uses one of: rename, restructure, reorganize, extract, inline, move, migrate, reshape — applied to EXISTING code WITHOUT adding new behavior.
+- Feature additions ('add flag', 'thêm', 'create endpoint', 'thêm option'), changing a DEFAULT value, adding tests, or improving coverage are 'generate' — NOT refactor.
+- 'improve', 'change', 'update', 'modify', 'đổi', 'cải thiện' alone do NOT imply refactor — pick the specific category by what the change actually does.
+- When the request is ambiguous, prefer 'general' over guessing refactor.
+
+Negative examples (NOT refactor):
+- "đổi default --max-tool-rounds 8 sang 12" → generate
+- "improve test coverage" → generate
+- "tại sao X trả empty" → analyze
+- "fix CI failing" → debug
+
+Style — pick ONE:
+  concise (ngắn gọn) | balanced (cân bằng) | detailed (chi tiết)
+
+Examples:
+  "Refactor this function" → refactor,balanced
+  "tại sao test fail" → debug,balanced
+  "thiết kế hệ thống auth" → plan,detailed
+  "thêm flag --foo" → generate,concise
+  "hi" → general,concise
+
 Prompt: "${ctx.raw.slice(0, 500)}"`, 1500);
                 if (brainRaw) {
                     pass3LegacyTaskSucceeded = true;
@@ -1280,9 +1327,9 @@ Prompt: "${ctx.raw.slice(0, 500)}"`, 1500);
                 if (pass3LegacyTaskAttempted) {
                     legacyBrainAttempted = true;
                     pass3LegacyStyleAttempted = true;
-                    const brainRawStyle = await classifyViaBrain(`Detect the user's preferred output style. The prompt may be EN or VN.
-Reply with ONE word: concise (ngắn gọn) | balanced (bình thường) | detailed (chi tiết).
-
+                    const brainRawStyle = await classifyViaBrain(`Detect the user's preferred output style. The prompt may be EN or VN.
+Reply with ONE word: concise (ngắn gọn) | balanced (bình thường) | detailed (chi tiết).
+
 Prompt: "${ctx.raw.slice(0, 300)}"`, 800);
                     if (brainRawStyle) {
                         pass3LegacyStyleSucceeded = true;
@@ -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;