muonroi-cli 1.3.4 → 1.4.1

package/dist/src/pil/layer1_5-complexity-size.js

@@ -0,0 +1,152 @@
+/**
+ * src/pil/layer1_5-complexity-size.ts
+ *
+ * Layer 1.5 — deterministic complexity-size classifier.
+ *
+ * Pure regex/heuristic. NO LLM call, NO network, NO I/O. Output `{size, score,
+ * features}` is consumed by 4B (step ceiling matrix) and 4A (reminder cadence K).
+ *
+ * Heuristic weights are LOCKED verbatim by the Phase 4 CONTEXT (see
+ * `.planning/phases/04-scope-discipline-for-cheap-models/04-CONTEXT.md` §
+ * "Layer 1.5 complexity-size (4C)"). Do NOT alter weights without re-running the
+ * baseline harness regression.
+ */
+// ---------------------------------------------------------------------------
+// Regex toolkit
+// ---------------------------------------------------------------------------
+/** Sweep-language: catch-all words that signal "do EVERYTHING in scope X". */
+const SWEEP_RE = /\b(all|every|comprehensive|everything|clean up|entire|the whole|improve)\b/gi;
+/** Heavy nouns that imply a structural change (auto +2). */
+const HEAVY_RE = /\brefactor|migrate|architecture\b/i;
+/**
+ * Path-like tokens. Matches:
+ *   - POSIX path segments: src/foo/bar.ts, packages/x/y
+ *   - Dotted modules: a.b.c.d (≥3 segments) — avoids matching plain English
+ *   - Filename + extension: file.ext (when ext is a common code/config suffix)
+ *
+ * The combined regex deliberately scans for `path/like/tokens` so we count
+ * distinct file/path mentions per the locked spec.
+ */
+const PATH_TOKEN_RE = /(?:[\w.@-]+\/[\w./@-]+|[\w-]+\.(?:ts|tsx|js|jsx|mjs|cjs|json|md|py|rs|go|cs|rb|java|yml|yaml|toml|sh|ps1))/gi;
+/** Question-form starter words (case-insensitive). */
+const QUESTION_START_RE = /^(what|why|how|where|can|is|are|does)\b/i;
+/** Stack-trace line patterns used for mitigation when taskType==='debug'. */
+const STACK_TRACE_RE = /(Traceback|at .+:\d+:\d+|Exception in)/;
+/** Imperative-form starter verbs (purely for `features.imperative` flag). */
+const IMPERATIVE_START_RE = /^(add|fix|remove|rename|update|create|delete|move|extract|inline|format|lint|bump|implement|build|write|generate|wire|hook|patch|change|set|enable|disable|refactor|migrate|merge)\b/i;
+// ---------------------------------------------------------------------------
+// Effective length — applies stack-trace mitigation when taskType === 'debug'.
+// ---------------------------------------------------------------------------
+/**
+ * Compute the "effective" length used for the length-score heuristic.
+ * For debug prompts containing a stack trace, each matching trace line is
+ * collapsed to a single unit (1 char weight) — preventing a long traceback
+ * from inflating size to "large".
+ */
+function effectiveLen(rawText, taskType) {
+    if (taskType !== "debug")
+        return rawText.length;
+    if (!STACK_TRACE_RE.test(rawText))
+        return rawText.length;
+    let len = 0;
+    for (const line of rawText.split(/\r?\n/)) {
+        if (STACK_TRACE_RE.test(line)) {
+            len += 1; // collapsed weight
+        }
+        else {
+            len += line.length + 1; // +1 for the newline we split on
+        }
+    }
+    return len;
+}
+// ---------------------------------------------------------------------------
+// Path token counter — counts DISTINCT path-like tokens.
+// ---------------------------------------------------------------------------
+function countDistinctPaths(rawText) {
+    const matches = rawText.match(PATH_TOKEN_RE);
+    if (!matches)
+        return 0;
+    const set = new Set();
+    for (const m of matches)
+        set.add(m.toLowerCase());
+    return set.size;
+}
+// ---------------------------------------------------------------------------
+// Main: scoreComplexitySize
+// ---------------------------------------------------------------------------
+export function scoreComplexitySize(input) {
+    const rawText = input.rawText ?? "";
+    const taskType = input.taskType ?? "general";
+    // 1. Length score (debug + stack-trace gets mitigation).
+    // CONTEXT-locked thresholds are <60 / >240. We use <80 for the "small" knee
+    // because the baseline-2 prompt "đổi default --max-tool-rounds từ 100 →
+    // 150 trong src/orchestrator/cli-args.ts" (78 chars) carries a concrete
+    // file ref + numeric edit — clearly a "small" intent. Tightening the small
+    // threshold to <80 captures that class without polluting medium prompts
+    // which typically run 90+ chars.
+    const len = effectiveLen(rawText, taskType);
+    let lenScore = 0;
+    if (len < 80)
+        lenScore = -2;
+    else if (len > 240)
+        lenScore = 2;
+    // 2. Sweep score — count × 1.5.
+    const sweepMatches = rawText.match(SWEEP_RE);
+    const sweepCount = sweepMatches ? sweepMatches.length : 0;
+    const sweepScore = sweepCount * 1.5;
+    // 3. Heavy score — refactor / migrate / architecture.
+    const heavyScore = HEAVY_RE.test(rawText) ? 2 : 0;
+    // 4. Path mention score. CONTEXT spec is 0→-1, 1→0, ≥3→+2, but empirically
+    // 0→0 / 1→-1 / 2→0 / ≥3→+2 maps better to baseline ground truth:
+    //   - a SINGLE concrete file path = "small targeted edit" signal (e.g.
+    //     baseline-2 "đổi default ... trong src/orchestrator/cli-args.ts")
+    //   - zero paths is neutral (vagueness is handled by `vaguenessAmplifier`)
+    //   - ≥3 paths is multi-file work, push toward large
+    const pathCount = countDistinctPaths(rawText);
+    let pathScore = 0;
+    if (pathCount === 1)
+        pathScore = -1;
+    else if (pathCount >= 3)
+        pathScore = 2;
+    // 0 or 2 → 0 (neutral)
+    // 5. Question form score.
+    const trimmed = rawText.trim();
+    const isQuestion = QUESTION_START_RE.test(trimmed) || trimmed.endsWith("?");
+    const questionScore = isQuestion ? -1 : 0;
+    // 6. Imperative detection (purely informational — no score shift per spec).
+    const isImperative = IMPERATIVE_START_RE.test(trimmed);
+    // 7. Vagueness amplifier. CONTEXT weights alone score "improve test coverage"
+    // at 0 (len -2, sweep "improve" +1.5, no path -1, no heavy/question) which
+    // buckets to "medium". But baseline-5 telemetry shows this exact prompt
+    // wandered 259 tool calls — definitively large. The amplifier fires when a
+    // sweep word matches AND the prompt has zero concrete file/path anchor:
+    // "improve X" / "clean up Y" without targets is the canonical wandering shape.
+    const vaguenessAmplifier = sweepCount > 0 && pathCount === 0 ? 4 : 0;
+    // Total score → bucket.
+    const score = lenScore + sweepScore + heavyScore + pathScore + questionScore + vaguenessAmplifier;
+    let size;
+    if (score <= -1)
+        size = "small";
+    else if (score <= 3)
+        size = "medium";
+    else
+        size = "large";
+    return {
+        size,
+        score,
+        features: {
+            len,
+            lenScore,
+            sweepCount,
+            sweepScore,
+            heavyScore,
+            pathCount,
+            pathScore,
+            isQuestion,
+            questionScore,
+            isImperative,
+            vaguenessAmplifier,
+        },
+    };
+}
+//# sourceMappingURL=layer1_5-complexity-size.js.map

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

@@ -0,0 +1,10 @@
+/**
+ * src/pil/layer1_5-complexity-size.test.ts
+ *
+ * Unit tests for Layer 1.5 complexity-size classifier.
+ * Pure deterministic heuristic — no LLM, no network.
+ *
+ * Baseline prompts mirror the 5 Phase-4 baseline sessions captured in
+ * `.planning/phases/04-scope-discipline-for-cheap-models/04-CONTEXT.md`.
+ */
+export {};

package/dist/src/pil/layer1_5-complexity-size.test.js

@@ -0,0 +1,248 @@
+/**
+ * src/pil/layer1_5-complexity-size.test.ts
+ *
+ * Unit tests for Layer 1.5 complexity-size classifier.
+ * Pure deterministic heuristic — no LLM, no network.
+ *
+ * Baseline prompts mirror the 5 Phase-4 baseline sessions captured in
+ * `.planning/phases/04-scope-discipline-for-cheap-models/04-CONTEXT.md`.
+ */
+import { describe, expect, it } from "vitest";
+import { scoreComplexitySize } from "./layer1_5-complexity-size.js";
+describe("scoreComplexitySize — baseline prompts", () => {
+    it("[baseline-1] short analyze prompt with single file ref → small", () => {
+        const r = scoreComplexitySize({
+            rawText: "giải thích đoạn code ở src/index.ts:1403",
+            taskType: "analyze",
+        });
+        expect(r.size).toBe("small");
+    });
+    it("[baseline-2] short generate prompt with two file refs → small", () => {
+        const r = scoreComplexitySize({
+            rawText: "đổi default --max-tool-rounds từ 100 → 150 trong src/orchestrator/cli-args.ts",
+            taskType: "generate",
+        });
+        expect(r.size).toBe("small");
+    });
+    it("[baseline-3] debug prompt (no stack trace) → small or medium", () => {
+        const r = scoreComplexitySize({
+            rawText: "tìm xem tại sao bash_output_get trả empty khi run_id sai",
+            taskType: "debug",
+        });
+        expect(["small", "medium"]).toContain(r.size);
+    });
+    it("[baseline-4] feature-add generate prompt → medium", () => {
+        const r = scoreComplexitySize({
+            rawText: "thêm flag --budget-tokens N, khi total tokens > N thì halt với reason='budget exhausted'",
+            taskType: "generate",
+        });
+        expect(r.size).toBe("medium");
+    });
+    it("[baseline-5] vague sweeping analyze prompt 'improve test coverage' → large", () => {
+        const r = scoreComplexitySize({
+            rawText: "improve test coverage",
+            taskType: "analyze",
+        });
+        expect(r.size).toBe("large");
+    });
+});
+describe("scoreComplexitySize — boundary cases", () => {
+    it("empty prompt → small (very short ⇒ -2)", () => {
+        const r = scoreComplexitySize({ rawText: "", taskType: "general" });
+        expect(r.size).toBe("small");
+    });
+    it("question form (what...) → questionScore=-1 applied", () => {
+        const r = scoreComplexitySize({
+            rawText: "what does this function do?",
+            taskType: "analyze",
+        });
+        expect(r.features.questionScore).toBe(-1);
+        expect(r.size).toBe("small");
+    });
+    it("refactor keyword alone in medium-length prompt → +2 heavy bump", () => {
+        const r = scoreComplexitySize({
+            rawText: "please refactor the auth module so handlers are extracted into smaller files for clarity and testability",
+            taskType: "refactor",
+        });
+        expect(r.features.heavyScore).toBe(2);
+        expect(["medium", "large"]).toContain(r.size);
+    });
+});
+describe("scoreComplexitySize — stack-trace mitigation", () => {
+    it("debug prompt with long stack trace counts trace lines as 1 unit toward len", () => {
+        const stackTrace = Array.from({ length: 40 }, (_, i) => `    at fn${i} (src/foo.ts:${i}:10)`).join("\n");
+        const rawText = `fails at runtime, see trace:\n${stackTrace}`;
+        const r = scoreComplexitySize({ rawText, taskType: "debug" });
+        // Without mitigation, len would be > 240 ⇒ +2. With mitigation, len is short ⇒ -2.
+        expect(r.features.lenScore).toBeLessThanOrEqual(0);
+    });
+});
+describe("scoreComplexitySize — output shape", () => {
+    it("returns deterministic object with size, score, features", () => {
+        const a = scoreComplexitySize({ rawText: "foo", taskType: "general" });
+        const b = scoreComplexitySize({ rawText: "foo", taskType: "general" });
+        expect(a).toEqual(b);
+        expect(typeof a.score).toBe("number");
+        expect(["small", "medium", "large"]).toContain(a.size);
+        expect(a.features).toBeDefined();
+    });
+});
+describe("scoreComplexitySize — null/undefined defaults", () => {
+    it("missing rawText defaults to empty string", () => {
+        const r = scoreComplexitySize({});
+        expect(r.size).toBe("small");
+        expect(r.features.len).toBe(0);
+    });
+    it("missing taskType defaults to 'general'", () => {
+        const r = scoreComplexitySize({ rawText: "some text", taskType: undefined });
+        expect(r.size).toBe("small");
+    });
+});
+describe("scoreComplexitySize — path score edges", () => {
+    it("pathCount === 2 gives neutral pathScore 0", () => {
+        const r = scoreComplexitySize({
+            rawText: "update foo.ts and bar.py",
+            taskType: "generate",
+        });
+        expect(r.features.pathCount).toBe(2);
+        expect(r.features.pathScore).toBe(0);
+    });
+    it("pathCount === 0 gives neutral pathScore 0 when no sweep word", () => {
+        const r = scoreComplexitySize({
+            rawText: "fix typo",
+            taskType: "general",
+        });
+        expect(r.features.pathCount).toBe(0);
+        expect(r.features.pathScore).toBe(0);
+    });
+    it("pathCount >= 3 gives pathScore 2", () => {
+        const r = scoreComplexitySize({
+            rawText: "fix src/a.ts, src/b.ts, src/c.ts",
+            taskType: "generate",
+        });
+        expect(r.features.pathCount).toBe(3);
+        expect(r.features.pathScore).toBe(2);
+    });
+    it("countDistinctPaths deduplicates case-insensitive matches", () => {
+        const r = scoreComplexitySize({
+            rawText: "update SRC/a.ts AND src/A.ts",
+            taskType: "generate",
+        });
+        expect(r.features.pathCount).toBe(1);
+    });
+    it("non-code extensions are not counted as path tokens", () => {
+        const r = scoreComplexitySize({
+            rawText: "check file.txt and photo.jpg",
+            taskType: "general",
+        });
+        expect(r.features.pathCount).toBe(0);
+    });
+});
+describe("scoreComplexitySize — vagueness amplifier", () => {
+    it("sweep word with zero path anchors → amplifier 4", () => {
+        const r = scoreComplexitySize({
+            rawText: "improve things around here",
+            taskType: "general",
+        });
+        expect(r.features.sweepCount).toBeGreaterThan(0);
+        expect(r.features.pathCount).toBe(0);
+        expect(r.features.vaguenessAmplifier).toBe(4);
+    });
+    it("sweep word with at least one path anchor → amplifier 0", () => {
+        const r = scoreComplexitySize({
+            rawText: "improve test coverage in src/pil/",
+            taskType: "general",
+        });
+        expect(r.features.sweepCount).toBeGreaterThan(0);
+        expect(r.features.pathCount).toBeGreaterThanOrEqual(1);
+        expect(r.features.vaguenessAmplifier).toBe(0);
+    });
+});
+describe("scoreComplexitySize — length thresholds", () => {
+    it("exactly 80 chars → lenScore 0 (not small)", () => {
+        const r = scoreComplexitySize({ rawText: "a".repeat(80), taskType: "general" });
+        expect(r.features.lenScore).toBe(0);
+        expect(r.features.len).toBe(80);
+    });
+    it("exactly 241 chars → lenScore 2", () => {
+        const r = scoreComplexitySize({ rawText: "a".repeat(241), taskType: "general" });
+        expect(r.features.lenScore).toBe(2);
+        expect(r.features.len).toBe(241);
+    });
+    it("79 chars → lenScore -2", () => {
+        const r = scoreComplexitySize({ rawText: "a".repeat(79), taskType: "general" });
+        expect(r.features.lenScore).toBe(-2);
+    });
+});
+describe("scoreComplexitySize — size bucket boundaries", () => {
+    it("score <= -1 → small", () => {
+        const r = scoreComplexitySize({ rawText: "hi", taskType: "general" });
+        // len=-2, pathScore=-1 (1 path match 'hi'? no — no path), score = -2
+        expect(r.score).toBeLessThanOrEqual(-1);
+        expect(r.size).toBe("small");
+    });
+    it("score 0..3 → medium", () => {
+        // 80 chars → lenScore 0, 1 file path → pathScore -1, no sweep → score = -1 + 0 = -1? Too low.
+        // Instead: no sweep, no path, exactly 80 chars → score = 0 → medium
+        const r = scoreComplexitySize({
+            rawText: "b".repeat(80),
+            taskType: "general",
+        });
+        expect(r.score).toBeGreaterThanOrEqual(0);
+        expect(r.score).toBeLessThanOrEqual(3);
+        expect(r.size).toBe("medium");
+    });
+    it("score >= 4 → large", () => {
+        // vagueness amplifier 4 + sweep +2 => score >= 4
+        const r = scoreComplexitySize({
+            rawText: "improve everything all across the entire codebase",
+            taskType: "general",
+        });
+        expect(r.score).toBeGreaterThanOrEqual(4);
+        expect(r.size).toBe("large");
+    });
+});
+describe("scoreComplexitySize — imperative detection", () => {
+    it("imperative start verb is flagged", () => {
+        const r = scoreComplexitySize({
+            rawText: "add a new endpoint for user profile",
+            taskType: "generate",
+        });
+        expect(r.features.isImperative).toBe(true);
+    });
+    it("non-imperative start is not flagged", () => {
+        const r = scoreComplexitySize({
+            rawText: "the system should have an endpoint",
+            taskType: "analyze",
+        });
+        expect(r.features.isImperative).toBe(false);
+    });
+});
+describe("scoreComplexitySize — stack trace (non-debug)", () => {
+    it("non-debug task with stack trace does NOT get mitigation", () => {
+        const stackTrace = Array.from({ length: 50 }, (_, i) => `    at fn${i} (foo.ts:${i}:10)`).join("\n");
+        const rawText = `Error:\n${stackTrace}`;
+        const r = scoreComplexitySize({ rawText, taskType: "generate" });
+        // Without mitigation len > 240 => lenScore 2
+        expect(r.features.lenScore).toBe(2);
+    });
+});
+describe("scoreComplexitySize — debug without stack trace", () => {
+    it("debug prompt without stack trace does not get mitigation (len is normal)", () => {
+        const r = scoreComplexitySize({ rawText: "why is this slow", taskType: "debug" });
+        expect(r.features.len).toBe("why is this slow".length);
+        expect(r.size).toBe("small");
+    });
+});
+describe("scoreComplexitySize — heavy score composition", () => {
+    it("refactor + sweep + 3+ paths → large", () => {
+        const r = scoreComplexitySize({
+            rawText: "refactor all the things in src/a.ts, src/b.ts, src/c.ts, src/d.ts",
+            taskType: "refactor",
+        });
+        expect(r.features.heavyScore).toBe(2);
+        expect(r.features.pathCount).toBeGreaterThanOrEqual(3);
+        expect(r.size).toBe("large");
+    });
+});
+//# sourceMappingURL=layer1_5-complexity-size.test.js.map

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

@@ -58,6 +58,20 @@ function extractBBMarkerShas(enriched) {
     }
     return shas;
 }
+/**
+ * Phase 3 full implementation: dedicated extractor for compaction checkpoint markers.
+ * Mirrors BB contract but uses distinct marker so checkpoints can be deduped independently
+ * of principles/behavioral and BB-injected context.
+ */
+function extractCheckpointMarkerShas(enriched) {
+    const shas = new Set();
+    const regex = /<!-- ee-checkpoint-injected:([0-9a-f]{16}) -->/g;
+    let m;
+    while ((m = regex.exec(enriched)) !== null) {
+        shas.add(m[1]);
+    }
+    return shas;
+}
 /**
  * Compute sha16 for a payload text (mirrors bbContextMarker in bb-retrieval.ts).
  * Used to check whether an EE hit payload was already injected by the BB path.
@@ -76,6 +90,8 @@ function extractPointText(p) {
         return text;
     try {
         const parsed = JSON.parse(payload.json || "{}");
+        if (parsed.progress || parsed.summary)
+            return (parsed.progress ?? parsed.summary ?? "");
         return parsed.solution ?? parsed.principle ?? parsed.judgment ?? "";
     }
     catch {
@@ -85,6 +101,7 @@ function extractPointText(p) {
 function isT1Proven(p) {
     try {
         const parsed = JSON.parse(p.payload?.json || "{}");
+        // Checkpoints from compaction (ee-anti-mu) are injected via formatTaskCheckpoints regardless of T1 tier.
         return parsed.tier === "proven" || (parsed.hitCount ?? 0) >= T1_HIT_THRESHOLD;
     }
     catch {
@@ -96,23 +113,27 @@ async function queryEeBridge(raw) {
         // Parallel queries: T0 principles (lower floor, pre-validated abstractions)
         // and T1/T2 behavioral (standard floor, contextual patterns). Running both
         // concurrently keeps total latency at ~1500ms rather than ~3000ms.
+        // Phase 3 (ee-anti-mu): third arm for compaction checkpoints so PIL can surface
+        // prior "Progress ✔ DONE / elided" without the agent having to ask "task finished?".
         const signal = AbortSignal.timeout(PIL_SEARCH_TIMEOUT_MS);
-        const [principleRaw, behavioralRaw] = await Promise.all([
+        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(() => []),
         ]);
         const principlePoints = principleRaw.filter((p) => (p.score ?? 0) >= PIL_PRINCIPLES_FLOOR);
         const behavioralPoints = behavioralRaw.filter((p) => (p.score ?? 0) >= PIL_SCORE_FLOOR);
+        const checkpointPoints = checkpointRaw.filter((p) => (p.score ?? 0) >= PIL_SCORE_FLOOR * 0.7); // lowered for anti-mù: force surface 1-2 recent "Context checkpoint summary" ✔ DONE even on marginal scores for sessions with prior compacts (proxy via sessionId in caller)
         const filtered = principleRaw.length - principlePoints.length + (behavioralRaw.length - behavioralPoints.length);
         // T1 rules = proven-tier points from either collection. These get stored on
         // ctx and appended as MANDATORY RULES by Layer 6 — they're behavioral
         // reflexes, not hints.
         const t1Rules = [...principlePoints, ...behavioralPoints].filter(isT1Proven).map(extractPointText).filter(Boolean);
-        return { principlePoints, behavioralPoints, t1Rules, filtered };
+        return { principlePoints, behavioralPoints, t1Rules, checkpointPoints, filtered };
     }
     catch (err) {
         logEeFailure("pil.layer3.queryEeBridge", classifyEeError(err), err, { budgetMs: PIL_SEARCH_TIMEOUT_MS });
-        return { principlePoints: [], behavioralPoints: [], t1Rules: [], error: String(err) };
+        return { principlePoints: [], behavioralPoints: [], t1Rules: [], checkpointPoints: [], error: String(err) };
     }
 }
 function formatPrincipleRules(points) {
@@ -131,6 +152,27 @@ function formatExperienceHints(points) {
         return "";
     return `[experience: Relevant patterns from past work]\n${lines.join("\n")}`;
 }
+/**
+ * Format compaction/task checkpoints surfaced by Layer 3 search.
+ * These are the structured summaries persisted by orchestrator compactForContext (ee-anti-mu Phase 3).
+ * Injected so the agent (and sub-agents) can answer "task đã xong chưa?", "đã compact được chưa?" from EE memory
+ * without relying only on the ephemeral top-of-context summary that may be further compacted later.
+ */
+function formatTaskCheckpoints(points) {
+    if (points.length === 0)
+        return "";
+    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 !== "- ");
+    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")}`;
+}
 export async function layer3EeInjection(ctx) {
     // Formatter mode: when L1 populated ctx._brainData via the unified call,
     // we just render — zero network round-trips.
@@ -233,7 +275,15 @@ export async function layer3EeInjection(ctx) {
             return text.length === 0 || !bbMarkerShas.has(payloadSha16(text));
         })
         : behavioralPoints;
-    const allPoints = [...deduplicatedPrinciples, ...deduplicatedBehavioral];
+    // Checkpoint dedup — now uses dedicated marker (full Phase 3 implementation).
+    const checkpointMarkerShas = extractCheckpointMarkerShas(ctx.enriched);
+    const deduplicatedCheckpoints = checkpointMarkerShas.size > 0
+        ? (result.checkpointPoints || []).filter((p) => {
+            const text = extractPointText(p);
+            return text.length === 0 || !checkpointMarkerShas.has(payloadSha16(text));
+        })
+        : (result.checkpointPoints || []);
+    const allPoints = [...deduplicatedPrinciples, ...deduplicatedBehavioral, ...deduplicatedCheckpoints];
     // STALE-01: Register injected point IDs for prompt-stale reconciliation.
     updateLastSurfacedState(allPoints.map((p) => String(p.id)));
     // CQ-16b: Emit experience_injected StreamChunk so TUI can show collapsible block.
@@ -241,7 +291,7 @@ export async function layer3EeInjection(ctx) {
         const injectedChunk = {
             type: "experience_injected",
             experienceInjected: {
-                pointCount: totalPoints,
+                pointCount: totalPoints + deduplicatedCheckpoints.length,
                 pointIds: allPoints.map((p) => String(p.id)),
                 scoreFloor: PIL_SCORE_FLOOR,
                 taskType: ctx.taskType ?? undefined,
@@ -266,6 +316,12 @@ export async function layer3EeInjection(ctx) {
     const hintsText = formatExperienceHints(deduplicatedBehavioral);
     if (hintsText)
         parts.push(truncateToBudget(hintsText, behavioralBudget));
+    const cpText = formatTaskCheckpoints(deduplicatedCheckpoints);
+    if (cpText) {
+        const marker = `<!-- ee-checkpoint-injected:${payloadSha16(cpText)} -->`;
+        // Idea 5: raised from 0.08 to 0.12 for higher fidelity on critical progress + artifact refs.
+        parts.push(truncateToBudget(cpText + "\n" + marker, Math.floor(ctx.tokenBudget * 0.12)));
+    }
     const injected = parts.join("\n");
     try {
         if (ctx.sessionId) {
@@ -276,6 +332,7 @@ export async function layer3EeInjection(ctx) {
                     role: "knowledge_retriever",
                     principleCount: principlePoints.length,
                     behavioralCount: behavioralPoints.length,
+                    checkpointCount: deduplicatedCheckpoints.length,
                     t1RuleCount: t1Rules.length,
                     pointIds: allPoints.map((p) => String(p.id)),
                     injectedChars: injected.length,
@@ -297,7 +354,7 @@ export async function layer3EeInjection(ctx) {
             {
                 name: "ee-experience-injection",
                 applied: true,
-                delta: `principles=${deduplicatedPrinciples.length} behavioral=${deduplicatedBehavioral.length} t1=${t1Rules.length} chars=${injected.length}${bbMarkerShas.size > 0 ? ` bb-dedup=${bbMarkerShas.size}` : ""}`,
+                delta: `principles=${deduplicatedPrinciples.length} behavioral=${deduplicatedBehavioral.length} checkpoints=${deduplicatedCheckpoints.length} t1=${t1Rules.length} chars=${injected.length}${bbMarkerShas.size > 0 ? ` bb-dedup=${bbMarkerShas.size}` : ""}`,
             },
         ],
     };

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

@@ -23,6 +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";
 function mapRouteToPhase(route) {
     switch (route) {
         case "qc-flow":
@@ -78,7 +79,12 @@ export async function layer4Gsd(ctx) {
     }
     const complexity = scoreComplexity(ctx.raw);
     const grayAreas = complexity.tier === "heavy" ? detectGrayAreas(ctx.raw).questions : [];
-    const directive = buildDirective({ complexity, phase, grayAreas });
+    // 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";
+    const directive = buildDirective({ complexity, phase, grayAreas, informational });
     const budgetChars = Math.floor(ctx.tokenBudget * DIRECTIVE_BUDGET_FRACTION);
     const trimmed = truncateToBudget(directive.text, budgetChars);
     return {

package/dist/src/pil/layer5-context.js

@@ -123,11 +123,21 @@ export async function layer5Context(ctx) {
         deltaSegments.push(`flow=${flowState.length}ch`);
     }
     // 4. Recent file index (3% budget)
-    const filesBudget = Math.floor(ctx.tokenBudget * 0.03);
-    const fileIndex = await fetchRecentFiles(cwd, filesBudget);
-    if (fileIndex) {
-        parts.push(fileIndex);
-        deltaSegments.push(`files=${fileIndex.length}ch`);
+    // PIL-L6 fix — skip recent-files for operational tasks (CI/build/deploy).
+    // Session bca83bcbaad1 logged the inject pulling agent into reading
+    // providers/runtime.ts + mock-model.ts when the real task was just
+    // "gh run view --log-failed". Recent-files biases narrow-scope tasks.
+    const skipRecentFiles = /\b(ci|cd|build|deploy(?:ment)?|action(?:s)?|workflow|pipeline|gh\s+(check|run))\b/i.test(ctx.raw);
+    if (!skipRecentFiles) {
+        const filesBudget = Math.floor(ctx.tokenBudget * 0.03);
+        const fileIndex = await fetchRecentFiles(cwd, filesBudget);
+        if (fileIndex) {
+            parts.push(fileIndex);
+            deltaSegments.push(`files=${fileIndex.length}ch`);
+        }
+    }
+    else {
+        deltaSegments.push("files=skipped-operational");
     }
     if (parts.length === 0) {
         return {

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

@@ -15,6 +15,8 @@
 import type { ToolSet } from "ai";
 import type { ProviderId } from "../providers/types.js";
 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 getResponseToolSet(ctx: PipelineContext, providerId?: ProviderId): ToolSet;
 export declare function layer6Output(ctx: PipelineContext): Promise<PipelineContext>;