muonroi-cli 1.7.2 → 1.8.1

package/dist/src/pil/layer2_5-ponytail.js

@@ -0,0 +1,41 @@
+import { truncateToBudget } from "./budget.js";
+import { isPonytailModeEnabled } from "./config.js";
+const PONYTAIL_INSTRUCTION = `[LAZY SENIOR / PONYTAIL MODE ACTIVE]
+"The best code is the code you never wrote." You MUST adhere to the following Decision Ladder:
+1. Standard Library first.
+2. Native platform features next.
+3. 1-line solution next.
+4. YAGNI: Do not write it if not strictly necessary.
+5. Smallest correct change.
+
+DOCUMENTATION RULE: If you bypass a complex/scalable pattern in favor of a simple one to adhere to this rule, you MUST add a comment in the code starting exactly with "// Intentional simplification: [Reason]".`;
+export async function layer2_5Ponytail(ctx) {
+    // If task is not coding/action-related (e.g., chitchat), we might not need it, but pipeline.ts already skips layers if taskType is null.
+    if (!isPonytailModeEnabled()) {
+        return {
+            ...ctx,
+            layers: [
+                ...ctx.layers,
+                {
+                    name: "ponytail-mode",
+                    applied: false,
+                    delta: "skipped:disabled-by-config",
+                },
+            ],
+        };
+    }
+    const trimmed = truncateToBudget(PONYTAIL_INSTRUCTION, Math.floor(ctx.tokenBudget * 0.15));
+    return {
+        ...ctx,
+        enriched: `${ctx.enriched}\n\n${trimmed}`,
+        layers: [
+            ...ctx.layers,
+            {
+                name: "ponytail-mode",
+                applied: true,
+                delta: `chars=${trimmed.length}`,
+            },
+        ],
+    };
+}
+//# sourceMappingURL=layer2_5-ponytail.js.map

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

@@ -17,10 +17,18 @@
 import { createHash } from "node:crypto";
 import { searchByText } from "../ee/bridge.js";
 import { updateLastSurfacedState } from "../ee/intercept.js";
+import { formatPendingReminder, isRecallLedgerEnabled, sessionRecallLedger } from "../ee/recall-ledger.js";
 import { getRenderSink } from "../ee/render.js";
 import { logInteraction } from "../storage/interaction-log.js";
 import { classifyEeError, logEeFailure, readTimeoutEnv } from "../utils/ee-logger.js";
 import { truncateToBudget } from "./budget.js";
+/**
+ * Session-scoped cross-turn dedup: records which pending recall IDs have
+ * already been surfaced via the feedback nudge in a previous turn. Prevents
+ * the same unrated [id] list from consuming input tokens turn after turn.
+ * Cleared on session reset (process exit or ledger.reset()).
+ */
+const _surfacedPendingIds = new Map();
 // Budget for the HTTP/in-process search round-trip. 60ms (legacy) was tuned for
 // localhost Ollama and routinely tripped the abort on VPS thin-client setups
 // where embedding goes through SiliconFlow.
@@ -117,8 +125,13 @@ function isT1Proven(p) {
         return false;
     }
 }
-async function queryEeBridge(raw) {
+async function queryEeBridge(raw, taskType) {
     try {
+        // Enrich query with task context so EE embedding is more precise.
+        // e.g. "analyze: vậy ở...fix?" vs generic "vậy ở...fix?" — the prefix
+        // shifts the embedding toward task-relevant entries and away from generic
+        // action-oriented behavioral patterns that score highly on any NL query.
+        const queryWithTask = taskType ? `[${taskType}] ${raw}` : 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.
@@ -126,8 +139,8 @@ async function queryEeBridge(raw) {
         // prior "Progress ✔ DONE / elided" without the agent having to ask "task finished?".
         const signal = AbortSignal.timeout(PIL_SEARCH_TIMEOUT_MS);
         const [principleRaw, behavioralRaw, checkpointRaw] = await Promise.all([
-            searchByText(raw, ["experience-principles"], 3, signal),
-            searchByText(raw, ["experience-behavioral"], 4, signal),
+            searchByText(queryWithTask, ["experience-principles"], 3, signal),
+            searchByText(queryWithTask, ["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);
@@ -192,23 +205,113 @@ export async function layer3EeInjection(ctx) {
         const behavioralBudget = Math.floor(ctx.tokenBudget * 0.15);
         const parts = [];
         const deltas = [];
-        if (ctx._brainData.t0_principles.length > 0) {
-            const lines = ctx._brainData.t0_principles.map((p) => `- ${p.text.slice(0, 120)}`);
+        // Collection fallback by array position mirrors the legacy path's arm→collection
+        // mapping (t0 = principles, t2 = behavioral). The server (PIL schema_version
+        // 1.1+) may override per-point — e.g. a selfqa hit merged into the behavioral
+        // bucket carries collection="experience-selfqa" so ee_feedback resolves it.
+        let principleItems = ctx._brainData.t0_principles.map((p) => ({
+            ...p,
+            collection: p.collection ?? "experience-principles",
+        }));
+        let behavioralItems = ctx._brainData.t2_patterns.map((p) => ({
+            ...p,
+            collection: p.collection ?? "experience-behavioral",
+        }));
+        // Suppress already-fedback entries so they don't re-inject as noise.
+        if (isRecallLedgerEnabled()) {
+            principleItems = principleItems.filter((p) => !sessionRecallLedger.wasCleared(String(p.id)));
+            behavioralItems = behavioralItems.filter((p) => !sessionRecallLedger.wasCleared(String(p.id)));
+        }
+        // Render the [id:..] handle inline (mirrors formatPrincipleRules/Hints) so the
+        // [id collection] reminder below refers to handles the agent can actually see.
+        const renderLine = (p) => p.id ? `- ${p.text.slice(0, 120)} [id:${p.id}]` : `- ${p.text.slice(0, 120)}`;
+        if (principleItems.length > 0) {
+            const lines = principleItems.map(renderLine);
             const block = truncateToBudget(`[principles: Generalized principles from past work]\n${lines.join("\n")}`, principlesBudget);
             parts.push(block);
-            deltas.push(`principles=${ctx._brainData.t0_principles.length}`);
+            deltas.push(`principles=${principleItems.length}`);
         }
-        if (ctx._brainData.t2_patterns.length > 0) {
-            const lines = ctx._brainData.t2_patterns.map((p) => `- ${p.text.slice(0, 120)}`);
+        if (behavioralItems.length > 0) {
+            const lines = behavioralItems.map(renderLine);
             const block = truncateToBudget(`[experience: Relevant patterns from past work]\n${lines.join("\n")}`, behavioralBudget);
             parts.push(block);
-            deltas.push(`behavioral=${ctx._brainData.t2_patterns.length}`);
+            deltas.push(`behavioral=${behavioralItems.length}`);
         }
         deltas.push(`t1=${ctx._brainData.t1_rules.length}`);
         deltas.push(`src=unified`);
+        // Close BOTH arms of the recall loop on the unified path, symmetric with the
+        // legacy path below (previously this formatter rendered text only — invisible
+        // to both arms). NEGATIVE arm: register surfaced ids for prompt-stale decay.
+        // POSITIVE arm: record the rateable points (those carrying an id from
+        // schema_version 1.1+) into the SAME session ledger the native ee_feedback
+        // builtin clears, then surface a dynamic [id collection] reminder so an
+        // explicit ee_feedback(followed) can credit the injection. No auto verdict is
+        // emitted (that would pollute Gate-4 precision). Points without an id (older
+        // server) fall through to the static nudge — rendered, but unrateable.
+        const ledgerEnabled = isRecallLedgerEnabled();
+        let ledgerRecorded = 0;
+        const rateable = [...principleItems, ...behavioralItems].filter((p) => p.id);
+        if (rateable.length > 0) {
+            updateLastSurfacedState(rateable.map((p) => String(p.id)));
+            if (ledgerEnabled) {
+                sessionRecallLedger.record(rateable.map((p) => ({ id: String(p.id), collection: p.collection })), `passive-injection (unified): ${ctx.raw.slice(0, 80)}`);
+                ledgerRecorded = rateable.length;
+            }
+        }
+        if (parts.length > 0 && principleItems.length + behavioralItems.length > 0) {
+            const pending = ledgerEnabled ? sessionRecallLedger.pending() : [];
+            if (pending.length > 0) {
+                // Cross-turn dedup: only surface pending IDs NOT already shown in a prior
+                // turn. Once the agent has seen the [id collection] handle, re-listing it
+                // every turn is pure input noise.
+                const sid = ctx.sessionId ?? "_anon";
+                let surfaced = _surfacedPendingIds.get(sid);
+                if (!surfaced) {
+                    surfaced = new Set();
+                    _surfacedPendingIds.set(sid, surfaced);
+                }
+                const newPending = pending.filter((p) => !surfaced.has(p.id));
+                if (newPending.length > 0) {
+                    for (const p of newPending)
+                        surfaced.add(p.id);
+                    parts.push(formatPendingReminder(newPending, { max: 5 }));
+                }
+                // else: all pending IDs were already surfaced — skip the nudge.
+            }
+            else {
+                parts.push(RECALL_FEEDBACK_NUDGE);
+            }
+        }
+        const injected = parts.join("\n");
+        try {
+            if (ctx.sessionId && parts.length > 0) {
+                logInteraction(ctx.sessionId, "ee_injection", {
+                    eventSubtype: "injected",
+                    data: {
+                        phase: "pil_enrichment",
+                        role: "knowledge_retriever",
+                        source: "unified",
+                        principleCount: principleItems.length,
+                        behavioralCount: behavioralItems.length,
+                        t1RuleCount: ctx._brainData.t1_rules.length,
+                        pointIds: rateable.map((p) => String(p.id)),
+                        injectedChars: injected.length,
+                        // Recall-loop closure observability (harness verification reads these):
+                        // rateable points recorded as pending debt this turn + total unrated.
+                        ledgerRecorded,
+                        ledgerPending: sessionRecallLedger.pendingCount(),
+                        taskType: ctx.taskType ?? null,
+                        domain: ctx.domain ?? null,
+                    },
+                });
+            }
+        }
+        catch {
+            /* fail-open — never break injection path */
+        }
         return {
             ...ctx,
-            enriched: parts.length > 0 ? `${ctx.enriched}\n${parts.join("\n")}` : ctx.enriched,
+            enriched: parts.length > 0 ? `${ctx.enriched}\n${injected}` : ctx.enriched,
             t1Rules: ctx._brainData.t1_rules,
             layers: [
                 ...ctx.layers,
@@ -221,7 +324,7 @@ export async function layer3EeInjection(ctx) {
         };
     }
     // Legacy path: existing logic continues below — unchanged.
-    const result = await queryEeBridge(ctx.raw);
+    const result = await queryEeBridge(ctx.raw, ctx.taskType);
     const { principlePoints, behavioralPoints, t1Rules } = result;
     const totalPoints = principlePoints.length + behavioralPoints.length;
     if (result.error) {
@@ -294,9 +397,39 @@ export async function layer3EeInjection(ctx) {
             return text.length === 0 || !checkpointMarkerShas.has(payloadSha16(text));
         })
         : result.checkpointPoints || [];
-    const allPoints = [...deduplicatedPrinciples, ...deduplicatedBehavioral, ...deduplicatedCheckpoints];
+    // Feedback-cleared suppression: skip points that were already rated via ee_feedback in an earlier turn.
+    // This prevents already-judged entries from being re-injected as noise.
+    const ledgerEnabled = isRecallLedgerEnabled();
+    const clearedFilteredPrinciples = deduplicatedPrinciples.filter((p) => !(ledgerEnabled && sessionRecallLedger.wasCleared(String(p.id))));
+    const clearedFilteredBehavioral = deduplicatedBehavioral.filter((p) => !(ledgerEnabled && sessionRecallLedger.wasCleared(String(p.id))));
+    const clearedFilteredCheckpoints = deduplicatedCheckpoints.filter((p) => !(ledgerEnabled && sessionRecallLedger.wasCleared(String(p.id))));
+    const allPoints = [...clearedFilteredPrinciples, ...clearedFilteredBehavioral, ...clearedFilteredCheckpoints];
     // STALE-01: Register injected point IDs for prompt-stale reconciliation.
     updateLastSurfacedState(allPoints.map((p) => String(p.id)));
+    // Close the POSITIVE arm of the recall loop in-process. Record the RATEABLE
+    // injected points (principles + behavioral; checkpoints are artifacts, not
+    // recall verdicts) into the SAME session ledger the native ee_feedback builtin
+    // clears. Before this, the ledger was only ever populated by the external MCP
+    // ee.query, so in-CLI ee_feedback.clear() was a guaranteed no-op and nothing
+    // surfaced pending debt to the agent — leaving passive injections with an
+    // automatic NEGATIVE signal (prompt-stale decay every turn) but no positive
+    // one. Recording here makes a passive injection real, rateable debt that the
+    // dynamic reminder below names and an explicit ee_feedback(followed) resolves —
+    // the signal the brain needs to learn which injections were gold. No auto
+    // verdict is emitted (that would pollute Gate-4 precision); the agent rates
+    // deliberately. Collection is the search arm (deterministic), which is what
+    // ee_feedback requires.
+    let ledgerRecorded = 0;
+    if (ledgerEnabled) {
+        const rateableEntries = [
+            ...deduplicatedPrinciples.map((p) => ({ id: String(p.id), collection: "experience-principles" })),
+            ...deduplicatedBehavioral.map((p) => ({ id: String(p.id), collection: "experience-behavioral" })),
+        ].filter((e) => e.id);
+        if (rateableEntries.length > 0) {
+            sessionRecallLedger.record(rateableEntries, `passive-injection: ${ctx.raw.slice(0, 80)}`);
+            ledgerRecorded = rateableEntries.length;
+        }
+    }
     // CQ-16b: Emit experience_injected StreamChunk so TUI can show collapsible block.
     // Carry per-point {id, title, tier} so the TUI can show WHAT was injected, not
     // just how many (the data already exists here; previously only the count + ids
@@ -341,7 +474,7 @@ export async function layer3EeInjection(ctx) {
     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)));
+        parts.push(truncateToBudget(`${cpText}\n${marker}`, Math.floor(ctx.tokenBudget * 0.12)));
     }
     // Close the recall feedback loop at the injection site: passively-injected
     // experience (the agent did not ee_query for it) otherwise carries no feedback
@@ -350,8 +483,36 @@ export async function layer3EeInjection(ctx) {
     // on long sessions; this nudge rides next to the [id:..] handles it refers to.
     // Gated on rateable experience (principles/behavioral) — checkpoints are task
     // artifacts, not recall verdicts.
+    // Dynamic, token-bounded reminder of accumulated unrated debt (this turn's
+    // fresh injections + any earlier still-unrated ones), naming the actual
+    // [id collection] so ee_feedback is actionable — the static nudge named no ids,
+    // so the model could not complete a rating even when willing. Falls back to the
+    // static nudge when the ledger is disabled. Gated on rateable experience.
+    // Cross-turn dedup: only surface pending IDs NOT already shown in a prior
+    // turn. Once surfaced, the agent has seen the [id collection] handle and can
+    // act on it (ee_feedback) or ignore it — re-listing the same IDs every turn
+    // is pure input noise with no new signal. If nothing is new, skip the nudge.
     if (deduplicatedPrinciples.length + deduplicatedBehavioral.length > 0) {
-        parts.push(RECALL_FEEDBACK_NUDGE);
+        const pending = ledgerEnabled ? sessionRecallLedger.pending() : [];
+        if (pending.length > 0) {
+            const sid = ctx.sessionId ?? "_anon";
+            let surfaced = _surfacedPendingIds.get(sid);
+            if (!surfaced) {
+                surfaced = new Set();
+                _surfacedPendingIds.set(sid, surfaced);
+            }
+            const newPending = pending.filter((p) => !surfaced.has(p.id));
+            if (newPending.length > 0) {
+                for (const p of newPending)
+                    surfaced.add(p.id);
+                parts.push(formatPendingReminder(newPending, { max: 5 }));
+            }
+            // else: all pending IDs were already surfaced — skip the nudge entirely.
+        }
+        else {
+            // No pending debt at all; fall back to the generic static nudge.
+            parts.push(RECALL_FEEDBACK_NUDGE);
+        }
     }
     const injected = parts.join("\n");
     try {
@@ -367,6 +528,11 @@ export async function layer3EeInjection(ctx) {
                     t1RuleCount: t1Rules.length,
                     pointIds: allPoints.map((p) => String(p.id)),
                     injectedChars: injected.length,
+                    // Recall-loop closure observability (harness verification reads these
+                    // from the interaction log): how many rateable points were recorded as
+                    // pending debt this turn, and the total still-unrated debt afterwards.
+                    ledgerRecorded,
+                    ledgerPending: sessionRecallLedger.pendingCount(),
                     taskType: ctx.taskType ?? null,
                     domain: ctx.domain ?? null,
                 },

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

@@ -16,7 +16,7 @@
  * (questions surfaced via AskUserQuestion) is localised — at render time, by
  * the agent, into the user's language.
  */
-import { routeTask } from "../ee/bridge.js";
+import { getWhoAmIProfile, routeTask } from "../ee/bridge.js";
 import { buildDirective } from "../playbook/directives.js";
 import { classifyEeError, logEeFailure } from "../utils/ee-logger.js";
 import { truncateToBudget } from "./budget.js";
@@ -43,13 +43,16 @@ const DIRECTIVE_BUDGET_FRACTION = 0.25;
 // value that fits it whole (truncateToBudget multiplies by CHARS_PER_TOKEN=4 →
 // 700 tokens ≈ 2.8K chars). The fraction still wins when tokenBudget is large.
 const DIRECTIVE_MIN_TOKENS = 700;
-// TODO(WhoAmI-L4): when EE v4.0 Who Am I profile is available:
-//   - work_patterns.delegation_style="autonomous" → bias routeTask toward "direct",
-//     skip qc-flow discussion phase for familiar task types
-//   - decision_speed="fast-intuitive" → trim heavy-tier directive text,
-//     remove "consider alternatives" section
-//   - Cache routeTask result per (taskType, domain) in the profile so the
-//     EE brain round-trip is skipped for patterns the user has confirmed before
+// WhoAmI v4.0 (wired): work_patterns.delegation_style="autonomous" biases the route
+// toward "direct" — a resolved 'discuss' phase is dropped so the agent isn't funnelled
+// into a clarify round the user didn't want (see the phase-resolution block below).
+// Fail-open: absent dim → no change; only 'discuss' is affected (execute is untouched —
+// autonomy is about skipping clarification, not skipping execution).
+// TODO(WhoAmI-L4): still deferred — decision_speed="fast-intuitive" → trim heavy-tier
+// directive: decision_speed IS available via getWhoAmIProfile, but trimming the HEAVY
+// directive is risky (see DIRECTIVE_MIN_TOKENS below — past truncation dropped the
+// rubric), so it stays manual pending a measured approach. Also: cache routeTask result
+// per (taskType, domain) — unblocked by the provider, future.
 export async function layer4Gsd(ctx) {
     // Short-circuit: chitchat / pure-greeting inputs (detected by layer1) should
     // NOT be wrapped in a GSD directive. Injecting "STANDARD task — apply
@@ -86,6 +89,17 @@ export async function layer4Gsd(ctx) {
         // the directive reads cleanly without a phase hint.
         routeSource = "none";
     }
+    else if (phase === "discuss") {
+        // WhoAmI v4.0: an autonomous delegator ("cứ làm / just do it / don't ask") does
+        // not want to be funnelled into a clarify-first 'discuss' round. Drop the hint so
+        // the directive reads neutrally (bias toward the 'direct' path). getWhoAmIProfile
+        // is cached + fail-open → absent dim leaves the discuss phase exactly as-is.
+        const delegation = getWhoAmIProfile()?.dims["work_patterns.delegation_style"]?.value;
+        if (delegation === "autonomous") {
+            phase = null;
+            routeSource = `${routeSource}+autonomous:skip-discuss`;
+        }
+    }
     // Work depth is decided by the model in layer1's classify call (the 5th
     // word → ctx.modelDepthTier). The regex `scoreComplexity` scorer has been
     // removed from this decision path: depth must reflect what the task actually

package/dist/src/pil/layer5-context.d.ts

@@ -1,2 +1,3 @@
 import type { PipelineContext } from "./types.js";
+export declare function staleThresholdMsForSessionLength(value: string | undefined | null): number;
 export declare function layer5Context(ctx: PipelineContext): Promise<PipelineContext>;

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

@@ -1,15 +1,26 @@
 import { promises as fs } from "node:fs";
 import * as path from "node:path";
-import { searchByText } from "../ee/bridge.js";
+import { getWhoAmIProfile, searchByText } from "../ee/bridge.js";
 import { truncateToBudget } from "./budget.js";
-// TODO(WhoAmI-L5): when EE v4.0 Who Am I profile is available, replace the
-// hardcoded threshold with profile-derived value:
-//   work_patterns.session_length="medium-long (1-3h)" → 120 min stale threshold
-//   work_patterns.multitasking="sequential-deep"      → extend to 2h
-//   (task-switchers with short sessions → keep 15 min)
-// Also: deduplicate with L3 — if L3 already injected experience-principles,
-// skip that collection here to avoid double-injection.
+// WhoAmI v4.0 (wired): `work_patterns.session_length` (short|medium|long), reachable
+// via ../ee/bridge.js → who-am-i.ts, tunes the resume-digest staleness window below.
+// TODO(WhoAmI-L5): `work_patterns.multitasking` (sequential-deep | task-switcher) IS
+// also emitted and could tune recall freshness similarly — deferred until measured.
+// Also: deduplicate with L3 — if L3 already injected experience-principles, skip that
+// collection here to avoid double-injection.
 const STALE_THRESHOLD_MS = 30 * 60 * 1000;
+// session_length → resume-digest staleness window. Long deep-work sessions keep a
+// resume digest relevant longer (relax to 60m); short bursts go stale sooner (tighten
+// to 15m). medium / absent → the 30m default, so a machine with no committed
+// session_length dim (the common case — needs N>=10 sessions) behaves byte-identically
+// to pre-v4.0: zero regression. Pure + exported for deterministic unit testing.
+export function staleThresholdMsForSessionLength(value) {
+    if (value === "long")
+        return 60 * 60 * 1000;
+    if (value === "short")
+        return 15 * 60 * 1000;
+    return STALE_THRESHOLD_MS;
+}
 // Single round-trip for both collections via /api/search; topK=5 yields
 // up to 2 principles + 3 behavioral after server-side scoring.
 const LAYER5_SEARCH_TIMEOUT_MS = 1500;
@@ -105,15 +116,19 @@ export async function layer5Context(ctx) {
     else {
         deltaSegments.push("principles=skipped-l1-unified");
     }
-    // 2. Resume digest (5% budget)
+    // 2. Resume digest (5% budget). Staleness window is profile-tuned by session_length
+    //    (fail-open: absent dim → 30m default, identical to pre-v4.0). getWhoAmIProfile
+    //    is cached + fail-open, so this never adds latency or a failure path here.
     const digest = ctx.resumeDigest;
     if (digest?.trim()) {
-        const isStale = typeof ctx.digestAgeMs === "number" && ctx.digestAgeMs > STALE_THRESHOLD_MS;
+        const staleMs = staleThresholdMsForSessionLength(getWhoAmIProfile()?.dims["work_patterns.session_length"]?.value);
+        const isStale = typeof ctx.digestAgeMs === "number" && ctx.digestAgeMs > staleMs;
         const stalePrefix = isStale ? "(stale — verify before relying)\n" : "";
         const hint = `[flow-context: Resume]\n${stalePrefix}${digest.trim()}`;
         const trimmed = truncateToBudget(hint, Math.floor(ctx.tokenBudget * 0.05));
         parts.push(trimmed);
-        deltaSegments.push(`digest=${trimmed.length}ch${isStale ? ",stale" : ""}`);
+        const windowTag = staleMs !== STALE_THRESHOLD_MS ? `,window=${staleMs / 60000}m` : "";
+        deltaSegments.push(`digest=${trimmed.length}ch${isStale ? ",stale" : ""}${windowTag}`);
     }
     // 3. Flow state (5% budget)
     const flowBudget = Math.floor(ctx.tokenBudget * 0.05);

package/dist/src/pil/layer6-output.js

@@ -12,7 +12,7 @@
  * Resolved style is propagated back onto ctx.outputStyle so the orchestrator
  * picks it up via applyPilSuffix without falling back to the hard "concise" default.
  */
-import { classifyViaBrain } from "../ee/bridge.js";
+import { classifyViaBrain, getWhoAmIProfile } from "../ee/bridge.js";
 import { getProviderCapabilities } from "../providers/capabilities.js";
 import { buildResponseTools } from "./response-tools.js";
 const VALID_STYLES = ["concise", "balanced", "detailed"];
@@ -120,6 +120,12 @@ const NO_PREAMBLE_RULE = `\nFORBIDDEN OPENERS: do not start with "I'll", "I will
 // noise. Applied only to non-question turns — question turns already get the same
 // guidance from the Layer 4 QUESTION directive (buildQuestion).
 const NO_BOOKKEEPING_NOTE = `\nWRITE FOR THE READER: the answer is for the human who asked. Do NOT append a provenance / compliance footer (e.g. "evidence only from this turn", "did not infer unopened files", token-budget notes) and do NOT restate internal rule / contract / layer / tool names as compliance — those are your operating rules, invisible to the reader. End on the answer's last substantive point.`;
+// WhoAmI v4.0: a precise-correction feedback style means the user corrects with
+// surgical edits, not rewrites. Bias code-producing tasks toward an AUDITABLE
+// presentation so a follow-up correction can target one line. This is orthogonal to
+// brevity (answer length) and delegation_style (clarify rounds) — it shapes the FORMAT
+// of changes, not their length or whether to ask first.
+const CORRECTION_AFFORDANCE_RULE = `\nAUDITABLE CHANGES: show exactly what changed — a unified diff or before/after for each edit, file:line anchored — and keep edits small and individually reviewable so a precise correction can target a single change.`;
 const SUFFIXES = {
     refactor: {
         concise: `\nOUTPUT RULES (refactor): Show only changed code. Prefer unified diff or replacement function. No prose unless architecture changes. One sentence max if explanation needed. No preamble.`,
@@ -164,10 +170,13 @@ const SUFFIXES = {
         detailed: `\nAnswer thoroughly. Use rich markdown structure (headings, lists, bold text, code blocks) to organize complex information so it is easy to scan and read.`,
     },
 };
-// TODO(WhoAmI-L6): when EE v4.0 Who Am I profile is available, skip
-// NO_PREAMBLE_RULE for users with feedback_style="explicit" who prefer
-// preamble. Also source TASK_TYPE_DEFAULT_STYLE from profile communication.brevity
-// instead of the hardcoded heuristic map above.
+// WhoAmI v4.0 (wired): brevity → ctx.outputStyle (layer1-intent.ts) drives answer
+// length; feedback_style="precise-correction" → CORRECTION_AFFORDANCE_RULE on code
+// tasks (auditable diffs, see applyPilSuffix below). The originally-assumed
+// feedback_style="explicit" → gate-NO_PREAMBLE arm was dropped on purpose: EE emits
+// implicit | precise-correction (no "explicit"), and gating preamble on it would
+// double-count brevity's verbosity axis. The "implicit" value is likewise left
+// unwired — its signal is already carried by brevity + delegation_style.
 export function applyPilSuffix(systemPrompt, ctx, responseToolsActive = false) {
     // Chitchat: layer6Output already skipped suffix work; mirror that here so
     // direct callers (e.g. orchestrator) don't accidentally re-inject rules.
@@ -237,6 +246,15 @@ export function applyPilSuffix(systemPrompt, ctx, responseToolsActive = false) {
     if (!isQuestionTurn) {
         result += NO_BOOKKEEPING_NOTE;
     }
+    // WhoAmI v4.0: precise-correctors get an auditable-changes nudge on code tasks.
+    // Fail-open: getWhoAmIProfile is cached + returns null when absent → unchanged.
+    // We intentionally do NOT wire feedback_style="implicit" — its signal (terseness /
+    // proceed-without-confirm) is already carried by brevity + delegation_style, so a
+    // second knob would double-count. Only the precise-correction arm is non-redundant.
+    if (ACTION_TASKS.has(ctx.taskType) &&
+        getWhoAmIProfile()?.dims["communication.feedback_style"]?.value === "precise-correction") {
+        result += CORRECTION_AFFORDANCE_RULE;
+    }
     // T1 behavioral rules (proven-tier EE points set by Layer 3). These are
     // project-specific reflexes the model MUST follow — injected as instructions,
     // not as context hints, so they carry imperative weight rather than suggestion weight.

package/dist/src/pil/llm-classify.d.ts

@@ -76,3 +76,14 @@ export type LlmClassifyFn = (prompt: string, signal?: AbortSignal) => Promise<Ll
  * fail-open (keep prior taskType, do not block the turn).
  */
 export declare function createLlmClassifier(factory: ProviderFactory, modelId: string): LlmClassifyFn;
+export type SubSessionAction = "DIRECT_ANSWER" | "ROTATE_SESSION" | "SPAWN_SUB_SESSION";
+export interface SubSessionRouteResult {
+    action: SubSessionAction;
+    confidence: number;
+    reason: string;
+}
+export declare function classifySubSessionActionHeuristic(prompt: string): SubSessionRouteResult | null;
+export declare function classifySubSessionAction(factory: ProviderFactory, modelId: string, prompt: string, contextInfo?: {
+    currentChars: number;
+    threshold: number;
+}, signal?: AbortSignal): Promise<SubSessionRouteResult | null>;