muonroi-cli 1.4.1 → 1.6.0

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

@@ -1,19 +1,33 @@
+/**
+ * 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.
+ *
+ * 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).
+ */
 import type { CouncilQuestionData } from "../types/index.js";
 import type { ClarifiedIntent, ClarityGap, ProjectContext } from "./discovery-types.js";
 import type { TaskType } from "./types.js";
-export declare function detectClarityGaps(raw: string, taskType: TaskType | null, confidence: number, projectContext: ProjectContext): ClarityGap[];
 /**
- * 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".
+ * 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.
  */
-export declare function pickBestScopeIndex(raw: string, options: string[]): number;
+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;

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

@@ -1,309 +1,20 @@
-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;
-}
+import { hasOperationalScope } from "./clarity-gate.js";
 /**
- * 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.
+ * 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.
  */
-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 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) => ({
@@ -335,7 +46,9 @@ export function resolveGapsNonInteractive(gaps, projectContext, raw) {
         const defaultAnswer = gap.options[gap.defaultIndex] ?? gap.options[0] ?? "";
         switch (gap.dimension) {
             case "outcome":
-                outcome = defaultAnswer;
+                // 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);
@@ -377,7 +90,7 @@ export function getAutofilledOutcome(taskType, raw) {
         // 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
+    // Operational debug tasks (CI/build/deploy) have a stronger default outcome.
     if (taskType === "debug" && hasOperationalScope(raw)) {
         return "Pipeline green, all checks passing";
     }

package/dist/src/pil/layer3-ee-injection.d.ts

@@ -16,3 +16,22 @@
  */
 import type { PipelineContext } from "./types.js";
 export declare function layer3EeInjection(ctx: PipelineContext): Promise<PipelineContext>;
+/**
+ * Issue #4 — meta-turn TARGETED complement to Layer 3's checkpoint arm.
+ *
+ * Since issue #2, Layer 3 now runs on the meta-analysis path too, so its
+ * checkpoint arm already surfaces recent checkpoints/artifacts for the agent.
+ * That arm uses a FIXED recency query, though — it isn't biased toward the
+ * current meta question. This arm fills that gap: it searches by `ctx.raw` so a
+ * self-evaluating agent sees the elided tool-artifacts RELEVANT to what it's
+ * analyzing, rendered via the same `formatTaskCheckpoints` so the `[artifact]
+ * … id=X` refs appear automatically instead of waiting on a manual `ee_query`.
+ *
+ * Defers to Layer 3: if a checkpoint block was already injected this turn (any
+ * `ee-checkpoint-injected` marker present) it skips entirely — no duplicate
+ * block and no second EE round-trip. Gated on `sessionId` (no session ⇒ no prior
+ * compaction to rehydrate). Strictly additive and fail-open: any error /
+ * no-session / no-match / already-surfaced returns ctx with the original
+ * `enriched` plus an `ee-meta-artifacts` layer marker for forensics.
+ */
+export declare function surfaceCompactionArtifacts(ctx: PipelineContext): Promise<PipelineContext>;

package/dist/src/pil/layer3-ee-injection.js

@@ -119,7 +119,7 @@ async function queryEeBridge(raw) {
         const [principleRaw, behavioralRaw, checkpointRaw] = await Promise.all([
             searchByText(raw, ["experience-principles"], 3, signal),
             searchByText(raw, ["experience-behavioral"], 4, signal),
-            searchByText("Context checkpoint summary OR \"compaction checkpoint\" recent Progress DONE elided OR tool-artifact OR \"tool result id=\"", ["experience-behavioral"], 3, signal).catch(() => []),
+            searchByText('Context checkpoint summary OR "compaction checkpoint" recent Progress DONE elided OR tool-artifact OR "tool result id="', ["experience-behavioral"], 3, signal).catch(() => []),
         ]);
         const principlePoints = principleRaw.filter((p) => (p.score ?? 0) >= PIL_PRINCIPLES_FLOOR);
         const behavioralPoints = behavioralRaw.filter((p) => (p.score ?? 0) >= PIL_SCORE_FLOOR);
@@ -161,14 +161,16 @@ function formatExperienceHints(points) {
 function formatTaskCheckpoints(points) {
     if (points.length === 0)
         return "";
-    const lines = points.map((p) => {
+    const lines = points
+        .map((p) => {
         const t = extractPointText(p);
         // Idea 4: surface tool-artifact refs so agent sees "elided high-value, query for full"
         if (/tool-artifact|tool result id=|elided.*id=/.test(t.toLowerCase())) {
             return `- [artifact] ${t.slice(0, 160)} [id:${p.id}]`;
         }
         return `- ${t.slice(0, 180)} [id:${p.id}]`;
-    }).filter((l) => l !== "- ");
+    })
+        .filter((l) => l !== "- ");
     if (lines.length === 0)
         return "";
     return `[task checkpoints — prior compactions: use to answer "task finished?", "compacted yet?". Artifacts: use ee.query tool with "tool-artifact id=XXX" for full elided tool output.] \n${lines.join("\n")}`;
@@ -282,7 +284,7 @@ export async function layer3EeInjection(ctx) {
             const text = extractPointText(p);
             return text.length === 0 || !checkpointMarkerShas.has(payloadSha16(text));
         })
-        : (result.checkpointPoints || []);
+        : result.checkpointPoints || [];
     const allPoints = [...deduplicatedPrinciples, ...deduplicatedBehavioral, ...deduplicatedCheckpoints];
     // STALE-01: Register injected point IDs for prompt-stale reconciliation.
     updateLastSurfacedState(allPoints.map((p) => String(p.id)));
@@ -359,4 +361,94 @@ export async function layer3EeInjection(ctx) {
         ],
     };
 }
+/**
+ * Records whose text actually reads like a compaction checkpoint or an elided
+ * tool-artifact. Used to keep generic behavioral hits from being mislabelled as
+ * `[artifact]`/checkpoint lines when we search by the meta question (ctx.raw)
+ * rather than the fixed checkpoint-arm query.
+ */
+const CHECKPOINT_LIKE_RE = /context checkpoint summary|compaction checkpoint|tool-artifact|tool result id=|elided|progress[^a-z]*done|✔/i;
+/**
+ * Issue #4 — meta-turn TARGETED complement to Layer 3's checkpoint arm.
+ *
+ * Since issue #2, Layer 3 now runs on the meta-analysis path too, so its
+ * checkpoint arm already surfaces recent checkpoints/artifacts for the agent.
+ * That arm uses a FIXED recency query, though — it isn't biased toward the
+ * current meta question. This arm fills that gap: it searches by `ctx.raw` so a
+ * self-evaluating agent sees the elided tool-artifacts RELEVANT to what it's
+ * analyzing, rendered via the same `formatTaskCheckpoints` so the `[artifact]
+ * … id=X` refs appear automatically instead of waiting on a manual `ee_query`.
+ *
+ * Defers to Layer 3: if a checkpoint block was already injected this turn (any
+ * `ee-checkpoint-injected` marker present) it skips entirely — no duplicate
+ * block and no second EE round-trip. Gated on `sessionId` (no session ⇒ no prior
+ * compaction to rehydrate). Strictly additive and fail-open: any error /
+ * no-session / no-match / already-surfaced returns ctx with the original
+ * `enriched` plus an `ee-meta-artifacts` layer marker for forensics.
+ */
+export async function surfaceCompactionArtifacts(ctx) {
+    const markLayer = (applied, delta) => ({
+        ...ctx,
+        layers: [...ctx.layers, { name: "ee-meta-artifacts", applied, delta }],
+    });
+    if (!ctx.sessionId)
+        return markLayer(false, "no-session");
+    // Defer to Layer 3: a checkpoint/artifact block is already present this turn,
+    // so don't duplicate it or pay a second EE round-trip. This arm only fills the
+    // gap when Layer 3's fixed-query checkpoint arm surfaced nothing.
+    if (extractCheckpointMarkerShas(ctx.enriched).size > 0)
+        return markLayer(false, "already-surfaced");
+    let points = [];
+    try {
+        const signal = AbortSignal.timeout(PIL_SEARCH_TIMEOUT_MS);
+        // Bias toward records relevant to THIS meta question (ctx.raw) while pulling
+        // in checkpoint/artifact vocabulary so the single cheap arm lands on the
+        // compaction records rather than generic behavioral patterns.
+        const query = `${ctx.raw}\nContext checkpoint summary tool-artifact "tool result id=" elided Progress DONE`;
+        const raw = await searchByText(query, ["experience-behavioral"], 5, signal);
+        points = raw
+            .filter((p) => (p.score ?? 0) >= PIL_SCORE_FLOOR * 0.7)
+            .filter((p) => CHECKPOINT_LIKE_RE.test(extractPointText(p)));
+    }
+    catch (err) {
+        logEeFailure("pil.meta.surfaceCompactionArtifacts", classifyEeError(err), err, { budgetMs: PIL_SEARCH_TIMEOUT_MS });
+        return markLayer(false, `error=${String(err)}`);
+    }
+    if (points.length === 0)
+        return markLayer(false, "no-artifacts");
+    const cpText = formatTaskCheckpoints(points);
+    if (!cpText)
+        return markLayer(false, "no-artifacts");
+    // Append the marker AFTER truncation so it always survives into `enriched`
+    // — that marker is what makes the defer-check above fire on any later pass.
+    const blockSha = payloadSha16(cpText);
+    const body = truncateToBudget(cpText, Math.floor(ctx.tokenBudget * 0.12));
+    const block = `${body}\n<!-- ee-checkpoint-injected:${blockSha} -->`;
+    try {
+        if (ctx.sessionId) {
+            logInteraction(ctx.sessionId, "ee_injection", {
+                eventSubtype: "injected",
+                data: {
+                    phase: "pil_meta_artifacts",
+                    role: "knowledge_retriever",
+                    checkpointCount: points.length,
+                    pointIds: points.map((p) => String(p.id)),
+                    injectedChars: block.length,
+                },
+            });
+        }
+    }
+    catch (err) {
+        // No silent catch: surfacing succeeded; only the audit write failed.
+        console.error(`[pil.meta.surfaceCompactionArtifacts] interaction log failed: ${err?.message}`);
+    }
+    return {
+        ...ctx,
+        enriched: `${ctx.enriched}\n${block}`,
+        layers: [
+            ...ctx.layers,
+            { name: "ee-meta-artifacts", applied: true, delta: `artifacts=${points.length} chars=${block.length}` },
+        ],
+    };
+}
 //# sourceMappingURL=layer3-ee-injection.js.map

package/dist/src/pil/layer4-gsd.js

@@ -23,7 +23,7 @@ import { detectGrayAreas } from "../gsd/gray-areas.js";
 import { detectGsdPhase } from "../gsd/types.js";
 import { classifyEeError, logEeFailure } from "../utils/ee-logger.js";
 import { truncateToBudget } from "./budget.js";
-import { isMetaAnalysisPrompt } from "./layer6-output.js";
+import { isImplementationIntent, isMetaAnalysisPrompt, isQuestionLike } from "./layer6-output.js";
 function mapRouteToPhase(route) {
     switch (route) {
         case "qc-flow":
@@ -79,11 +79,23 @@ export async function layer4Gsd(ctx) {
     }
     const complexity = scoreComplexity(ctx.raw);
     const grayAreas = complexity.tier === "heavy" ? detectGrayAreas(ctx.raw).questions : [];
-    // Informational/meta prompts (a question or a self/meta CLI analysis) ask for
-    // an ANSWER, not a code change. The implement/verify directive leaks into the
-    // human-facing reply as a "2-3 line plan" + process narration (session
-    // 829a83888dd2). Route them to the human-facing question directive instead.
-    const informational = isMetaAnalysisPrompt(ctx.raw) || ctx.taskType === "general";
+    // Informational prompts (a question / explanation / self-eval) ask for an
+    // ANSWER, not a code change. The implement/verify directive otherwise leaks
+    // into the human-facing reply as a "2-3 line plan" + process narration
+    // (session 829a83888dd2). Route them to the human-facing question directive.
+    //
+    // Phase 2b: when the model classified the deliverable, CONSUME it — an
+    // "answer" deliverable IS informational. Only when the model didn't emit one
+    // (deliverableKind null → legacy cascade, or the model omitted the word) do
+    // we fall back to the legacy regex predicates:
+    //   1. isMetaAnalysisPrompt — self/CLI evaluation, prior-turn reflection.
+    //   2. taskType "general" classified as a real task by L1.
+    //   3. question-shaped prompt that is NOT an implementation request.
+    const informational = ctx.deliverableKind
+        ? ctx.deliverableKind === "answer"
+        : isMetaAnalysisPrompt(ctx.raw) ||
+            (ctx.taskType === "general" && ctx.intentKind === "task") ||
+            (isQuestionLike(ctx.raw) && !isImplementationIntent(ctx.raw));
     const directive = buildDirective({ complexity, phase, grayAreas, informational });
     const budgetChars = Math.floor(ctx.tokenBudget * DIRECTIVE_BUDGET_FRACTION);
     const trimmed = truncateToBudget(directive.text, budgetChars);

package/dist/src/pil/layer6-output.d.ts

@@ -18,5 +18,7 @@ import type { PipelineContext } from "./types.js";
 export declare function isMetaAnalysisPrompt(raw: string): boolean;
 export declare function applyPilSuffix(systemPrompt: string, ctx: PipelineContext, responseToolsActive?: boolean): string;
 export declare function isImplementationIntent(raw: string): boolean;
+export declare function isQuestionLike(raw: string): boolean;
+export declare function prefersStructuredReport(raw: string): boolean;
 export declare function getResponseToolSet(ctx: PipelineContext, providerId?: ProviderId): ToolSet;
 export declare function layer6Output(ctx: PipelineContext): Promise<PipelineContext>;