pi-warden 0.64.1 → 0.71.0

package/dist/extension.js

@@ -8,6 +8,7 @@ import { authState, createTypeSafe, describeAuth } from "pi-typesafe";
 import { ensureApiKey } from "pi-typesafe/ui";
 import { backendHost, disclosureFor, judgeOptions, keyEnvFor, loginStoresKey, resolveBackend } from "./backend.js";
 import { ActionGuard } from "./action-guard.js";
+import { assistantView, formatMuted, NEVER_MUTED, STEER_KINDS, SteerStats, SteerWatch } from "./adaptive.js";
 import { ArmingTracker, unparseableArmingRules } from "./arming.js";
 import * as configModule from "./config.js";
 import { applyUserOverrides, defaultConfig, getNestedValue, isMode, loadConfig, PACKAGE_NAME, parseConfigValue, projectConfigPath, readUserConfig, setNestedValue, setUserSetting, userConfigPath, writeUserConfig } from "./config.js";
@@ -22,12 +23,16 @@ import { compressOutput, duplicateNote, evaluateOutput, mergeOutput, outputKey,
 import { classifyRecall, detectSearchTool, recallInstruction } from "./recall.js";
 import { maskSecrets, redact } from "./redact.js";
 import { formatRules, pathNoteSteer, projectPath, RulesGuard, rulesSteer, RULES_FILE, FALLBACK_FILES } from "./rules.js";
+import { checkRules, formatRulesCheck } from "./rules-lint.js";
+import { readRulesLog, RulesLog, rulesLogPath } from "./rules-log.js";
+import { buildRulesReport, formatRulesReport, REPORT_DEFAULT_DAYS } from "./rules-report.js";
 import { checkPiWardenMissing } from "./rules-file.js";
 import { writeStarterRules, buildInitPrompt } from "./init.js";
 import { buildAuditPrompt, findProjects, snapshotReport, reportOutcome } from "./audit.js";
 import { detectNotifier, sendNotification } from "./notify.js";
 import { formatRunaway, RunawayMonitor, runawayNudge } from "./runaway.js";
 import { AttemptWindow, evaluateStuck, formatStuck, makeAttempt, quickRepeatNudge, resultFailed, stuckDiff, stuckNudge } from "./stuck.js";
+import { WasteTracker, WASTE_TIP, withWasteTip } from "./waste.js";
 import { assess } from "./conscience.js";
 import { loadSkillBody, buildLoadMessage, policyMatches, CONSCIENCE_BETA_POLICY, recordFileIdentity, clearFileIdentityCache } from "./load.js";
 import { buildIndexPrompt, readIndex, writeIndex, validateIndex, indexStats, indexPath, ensureIndexDir } from "./index-cmd.js";
@@ -38,8 +43,8 @@ import { completeConfig, shapeWarning, taskSpine } from "./shape.js";
 import { ContextLedger, formatLedger } from "./saver.js";
 import { SeenText, collapseRuns, seenItem } from "./dedupe.js";
 import { buildCompactSnapshot, compactAppendix, recallText } from "./compact.js";
-import { applyLoopAction, formatLoopsForUser, formatOpenLoops, LOOP_ACTIONS, LOOP_CHARS, loopsFingerprint, loopsPath, openLoops, readLoops, writeLoops } from "./loops.js";
-import { emptyWordCounts, evaluatePrefs, forgetPref, formatPrefs, isCorrection, LESSON_CHARS, LESSON_TURNS, NO_LESSON_SIGNAL, prefsMessage, prefsStorePath, readPrefsStore, recordLesson, scanPreferences, writePrefsStore } from "./prefs.js";
+import { applyLoopAction, formatLoopsForUser, formatOpenLoops, LOOP_ACTIONS, LOOP_CHARS, loopsFingerprint, loopsPath, openLoops, readLoops, updateLoops } from "./loops.js";
+import { changePrefsStore, emptyWordCounts, evaluatePrefs, forgetPref, formatPrefs, isCorrection, LESSON_CHARS, LESSON_TURNS, NO_LESSON_SIGNAL, prefsMessage, prefsStorePath, readPrefsStore, recordLesson, scanPreferences } from "./prefs.js";
 import { formatWake, newReports, reportLabel, triageReport, WakePolicy } from "./subagent.js";
 import { actionDetails, doneDetails, proseDetails, rulesDetails, runawayDetails, stuckDetails, Trace } from "./trace.js";
 import { TraceFile, judgmentsState, traceDir, traceFilePath } from "./trace-file.js";
@@ -49,7 +54,7 @@ const WIDGET = PACKAGE_NAME;
 const CONFIRM_TEXT_LIMIT = 500;
 /** Rules requests one bash command may start; the other files it writes are recorded as skipped. */
 const SHELL_RULES_CHECKS = 5;
-const freshStats = () => ({ inspected: 0, judged: 0, warned: 0, held: 0, approved: 0, offPlan: 0, offPlanTraceOnly: 0, offTask: 0, slop: 0, ruleChecks: 0, ruleViolations: 0, pathNotes: 0, stuckChecks: 0, stuck: 0, doneChecks: 0, unverified: 0, proseChecks: 0, proseNudges: 0, runaway: 0, errors: 0, cooldownSkips: 0, steers: 0, steersSkipped: 0, steerGuards: {}, subagentReports: 0, subagentWoken: 0, restatements: 0 });
+const freshStats = () => ({ inspected: 0, judged: 0, warned: 0, held: 0, approved: 0, offPlan: 0, offPlanTraceOnly: 0, offTask: 0, slop: 0, ruleChecks: 0, ruleViolations: 0, pathNotes: 0, stuckChecks: 0, stuck: 0, doneChecks: 0, unverified: 0, proseChecks: 0, proseNudges: 0, runaway: 0, errors: 0, cooldownSkips: 0, steers: 0, steersSkipped: 0, steersMuted: 0, steerGuards: {}, subagentReports: 0, subagentWoken: 0, restatements: 0 });
 /**
  * One steer message can carry notes from more than one guard, so the per-guard numbers may add up to more than the
  * message count; the line says so instead of hiding it. Worst offender first: that is the number worth acting on.
@@ -272,7 +277,7 @@ export function guardCurrentSections(result) {
     if (typeof config.rules !== "object" || config.rules === null || !Array.isArray(config.rules.exclude)) {
         if (!missing.includes("rules"))
             missing.push("rules");
-        config.rules = { enabled: false, threshold: 1, files: [], fallback: false, maxChars: 500, exclude: [], skip: [], sensitivePaths: {} };
+        config.rules = { enabled: false, threshold: 1, softThreshold: 0, files: [], fallback: false, maxChars: 500, exclude: [], skip: [], sensitivePaths: {} };
     }
     if (typeof config.widget !== "object" || config.widget === null) {
         if (!missing.includes("widget"))
@@ -345,9 +350,14 @@ export default function wardenExtension(pi) {
     }
     const traceOf = new WeakMap();
     let holdLog;
+    // Local rules verdict log for this session; a write failure is silent to the agent and shown once in the trace.
+    let rulesLog;
     // Allowed calls of the turn the user just replied to; the regret question about them rides the next action request.
     let regretCandidates = [];
     let attempts = new AttemptWindow(defaultConfig().stuck.window);
+    // Call-waste notes for this session; the tip is offered once, the notes are rate limited per detector.
+    const waste = new WasteTracker();
+    let wasteTipOffered = false;
     /** Full output text and saved path keyed by attempt call key, for stuck-loop diffs. */
     let fullOutputs = new Map();
     let evidence = emptyEvidence();
@@ -746,6 +756,9 @@ export default function wardenExtension(pi) {
     /** Guards whose notices gate the run itself; they deliver even when the per-run steer budget is spent. */
     const CRITICAL_STEER_GUARDS = new Set(["stuck", "done", "runaway", "subagent"]);
     let steersThisRun = 0;
+    /** Follow and dispute counts per (model, steer kind), kept across sessions; and the sent steers still waiting for a reply. */
+    const steerStats = new SteerStats();
+    const steerWatch = new SteerWatch();
     /** Session generation counter for conscience invalidation. Incremented on steer, abort, reload, switch, or config change. */
     let conscienceGeneration = 0;
     /** Per-prompt error categories already warned about (one console.warn per category per prompt). */
@@ -807,6 +820,39 @@ export default function wardenExtension(pi) {
             wardenContinuation = true;
         return true;
     };
+    const modelKey = (ctx) => ctx.model ? `${ctx.model.provider}/${ctx.model.id}` : undefined;
+    const KIND_GUARD = { rules: "rules", "sensitive-path": "rules", "security-write": "security", stuck: "stuck", repeat: "stuck", prose: "prose", conscience: "conscience" };
+    /**
+     * False when steers of this kind are trace-only for the current model; the skipped note gets a trace line. Holds and
+     * judgments are not affected: only whether the note reaches the agent.
+     */
+    const adaptiveSend = (ctx, config, kind) => {
+        const model = modelKey(ctx);
+        if (!model)
+            return true;
+        const decision = steerStats.request(model, kind, config.steers);
+        if (decision !== "trace-only")
+            return true;
+        const pair = steerStats.pair(model, kind);
+        const rates = pair ? `${pair.sent} steers observed, ${Math.round((pair.followed / Math.max(1, pair.sent)) * 100)}% followed, ${Math.round((pair.disputed / Math.max(1, pair.sent)) * 100)}% disputed` : "no counts";
+        stats.steersMuted++;
+        record(ctx, config, KIND_GUARD[kind] ?? "action", `warden · steer trace-only · ${kind} · ${model}`, [
+            `${kind} steers are trace-only for ${model} (${rates}); 1 in ${config.steers.probeEvery} is still sent for the re-check`,
+            `/warden unmute ${kind} sends them again`,
+        ]);
+        return false;
+    };
+    /** A delivered steer waits for the agent's next two messages; its outcome is counted for the (model, kind) pair. */
+    const watchSteer = (ctx, config, kinds, subject = {}, nextTurn = false) => {
+        const model = modelKey(ctx);
+        if (!model || !config.steers.adaptive)
+            return;
+        steerWatch.add(model, kinds.filter(kind => !NEVER_MUTED.has(kind) || kind === "done"), subject, { nextTurn });
+    };
+    const settleSteers = (config, outcomes) => {
+        for (const outcome of outcomes)
+            steerStats.observe(outcome.model, outcome.kind, outcome, config.steers);
+    };
     /**
      * Desktop notification for a moment that needs the user back at the terminal. Interactive sessions only: a headless run
      * or a subagent has nobody to call, and several of them would flood the desktop. Fire-and-forget; failures are silent.
@@ -878,6 +924,7 @@ export default function wardenExtension(pi) {
         initRunning = false;
         await initSchema(loadConfig().learning.retentionDays);
         stats = freshStats();
+        steerWatch.clear();
         widget.clear();
         trace.clear();
         panel?.close();
@@ -888,6 +935,7 @@ export default function wardenExtension(pi) {
         regretCandidates = [];
         const sessionId = typeof ctx.sessionManager.getSessionId === "function" ? ctx.sessionManager.getSessionId() : String(process.pid);
         holdLog = new HoldLog(holdLogPath(sessionId));
+        rulesLog = new RulesLog(ctx.cwd, sessionId, { onFailure: message => record(ctx, loadConfig(), "rules", "rules log write failed", [message]) });
         unsubscribeTraceFile?.();
         unsubscribeTraceFile = undefined;
         traceFile = undefined;
@@ -910,6 +958,8 @@ export default function wardenExtension(pi) {
         }
         arming.reset();
         attempts.reset();
+        waste.reset();
+        wasteTipOffered = false;
         evidence = emptyEvidence();
         doneNudged = false;
         wardenContinuation = false;
@@ -991,6 +1041,22 @@ export default function wardenExtension(pi) {
         noticeUi = ctx.hasUI ? ctx.ui : undefined;
         const config = configFor(ctx);
         attempts = new AttemptWindow(config.stuck.window);
+        // ── Call waste: the session tip ──
+        // The tip is appended to the prompt, so every other part of the prompt stays where it was and the host records the
+        // change as a prompt-section delta. It is offered once per session; the trace line says so, and the next runs
+        // re-append the same text, which is what keeps it in the prompt instead of being diffed away.
+        const wasteOptions = event.systemPromptOptions;
+        if (config.enabled && config.waste.enabled && config.waste.tip && wasteOptions) {
+            wasteOptions.appendSystemPrompt = withWasteTip(wasteOptions.appendSystemPrompt);
+            if (!wasteTipOffered) {
+                wasteTipOffered = true;
+                record(ctx, config, "waste", "warden · waste · session tip · instructions_supplied", [
+                    "trigger: before_agent_start",
+                    "delivery: appended to the system prompt (appendSystemPrompt)",
+                    `tip: ${WASTE_TIP}`,
+                ]);
+            }
+        }
         fullOutputs = new Map();
         doneNudged = false;
         wardenContinuation = false;
@@ -1490,6 +1556,7 @@ export default function wardenExtension(pi) {
         // Notes for the agent about the content it just wrote: slop, rule violations, and sensitive paths arrive as one message.
         const notes = [];
         const noteGuards = new Set();
+        const noteKinds = [];
         /** Slop and rule findings say "just written", so they wait until the call proceeds. A held, denied, or declined write
          * never lands and drops them; an approved retry is judged again and brings its own. They go between the action notes
          * and the sensitive-path notes, the order of the combined message. */
@@ -1497,8 +1564,9 @@ export default function wardenExtension(pi) {
         const pathNotes = [];
         /** Sensitive-path notes ride with the combined steer for this call; their trace waits for the delivery result. */
         const pathNoteTraces = [];
-        if (verdict.judgment?.securityRisk !== undefined && verdict.judgment.securityRisk >= config.security.threshold) {
-            steer(config, "security", "pi-warden: the proposed write may introduce a security weakness. Check for embedded credentials, disabled TLS, unsafe command/SQL interpolation, broad permissions, or bypassed verification; use a safe implementation instead.");
+        if (verdict.judgment?.securityRisk !== undefined && verdict.judgment.securityRisk >= config.security.threshold && adaptiveSend(ctx, config, "security-write")) {
+            if (steer(config, "security", "pi-warden: the proposed write may introduce a security weakness. Check for embedded credentials, disabled TLS, unsafe command/SQL interpolation, broad permissions, or bypassed verification; use a safe implementation instead."))
+                watchSteer(ctx, config, ["security-write"], verdict.summary.path ? { path: verdict.summary.path } : {});
         }
         if (verdict.judgment)
             stats.judged++;
@@ -1547,25 +1615,29 @@ export default function wardenExtension(pi) {
             stats.offPlan++;
             if (verdict.intentTraceOnly)
                 stats.offPlanTraceOnly++;
-            else {
+            else if (adaptiveSend(ctx, config, "intent-mismatch")) {
                 noteGuards.add("action");
+                noteKinds.push("intent-mismatch");
                 notes.push(intentSteer(verdict));
             }
         }
         if (verdict.offTaskSteer) {
             stats.offTask++;
-            if (!verdict.offTaskTraceOnly) {
+            if (!verdict.offTaskTraceOnly && adaptiveSend(ctx, config, "off-task")) {
                 noteGuards.add("action");
+                noteKinds.push("off-task");
                 notes.push(offTaskSteer(verdict));
             }
         }
-        if (verdict.shouldProceedSteer && !verdict.shouldProceedTraceOnly) {
+        if (verdict.shouldProceedSteer && !verdict.shouldProceedTraceOnly && adaptiveSend(ctx, config, "should-proceed")) {
             noteGuards.add("action");
+            noteKinds.push("should-proceed");
             notes.push(shouldProceedMessage(verdict));
         }
         const largeOutput = largeOutputNotice(verdict, largeOutputSteered);
-        if (largeOutput) {
+        if (largeOutput && adaptiveSend(ctx, config, "large-output")) {
             noteGuards.add("action");
+            noteKinds.push("large-output");
             notes.push(largeOutput);
         }
         if (verdict.slopSymptoms?.length && verdict.slopReasons) {
@@ -1575,11 +1647,11 @@ export default function wardenExtension(pi) {
             if (ctx.hasUI && config.notices)
                 ctx.ui.notify(`warden · slop · ${where}: ${verdict.slopReasons.join("; ")}`, "warning");
             contentNotes.push(proceeds => {
-                if (!proceeds)
+                if (!proceeds || !adaptiveSend(ctx, config, "slop"))
                     return undefined;
                 for (const symptom of symptoms)
                     slopCounts[symptom]++;
-                return { guard: "action", text: slopSteer(where, symptoms, slopCounts) };
+                return { guard: "action", kind: "slop", text: slopSteer(where, symptoms, slopCounts) };
             });
         }
         for (const { check, shellWrite } of rulesChecks) {
@@ -1596,18 +1668,26 @@ export default function wardenExtension(pi) {
                 if (capNotice)
                     ctx.ui.notify(capNotice, "warning");
                 holds.recordRules({ source: rules.source, path: rules.path, findings: rules.findings.map(f => ({ name: f.name, violation: f.violation })), ...(rules.error ? { error: rules.error } : {}) });
+                // A later judgment below the threshold clears an earlier finding of the same rule on this path: one trace line, no steer.
+                if (rules.source === "typesafe") {
+                    for (const observation of rulesLog?.record(rules, config.rules.threshold, Date.now(), config.rules.softThreshold) ?? []) {
+                        if (observation.cleared)
+                            record(ctx, config, "rules", `rules: ${observation.name} now clear on ${rules.path}`, [`clear: a later ${rules.tool} on this path scored ${observation.violation.toFixed(2)}, below the ${config.rules.threshold} threshold`]);
+                    }
+                }
                 if (rules.findings.length) {
                     stats.ruleViolations++;
                     if (ctx.hasUI && config.notices)
                         ctx.ui.notify(`warden · rules · ${rules.path}: ${rules.findings.map(finding => `${finding.name} (${finding.violation.toFixed(2)})`).join("; ")}`, "warning");
                 }
                 contentNotes.push(proceeds => {
-                    const told = proceeds && rules.findings.length ? rulesSteer(rules, rulesGuard.count(rules)) : undefined;
+                    const hasRules = rules.findings.length > 0 || (rules.softFindings?.length ?? 0) > 0;
+                    const told = proceeds && hasRules && adaptiveSend(ctx, config, "rules") ? rulesSteer(rules, rulesGuard.count(rules)) : undefined;
                     const details = [...shellNote, ...rulesDetails(rules, told)];
                     if (!proceeds && rules.findings.length)
                         details.push("agent not told: the write was held");
                     record(ctx, config, "rules", rulesLine, details);
-                    return told ? { guard: "rules", text: told } : undefined;
+                    return told ? { guard: "rules", kind: "rules", text: told } : undefined;
                 });
             }
             else {
@@ -1620,7 +1700,7 @@ export default function wardenExtension(pi) {
         }
         if (config.rules.enabled && (event.toolName === "write" || event.toolName === "edit")) {
             const hits = rulesGuard.notesFor(verdict.summary.location === "inside_project" ? verdict.summary.path : undefined, config.rules.sensitivePaths);
-            if (hits.length && verdict.summary.path) {
+            if (hits.length && verdict.summary.path && adaptiveSend(ctx, config, "sensitive-path")) {
                 stats.pathNotes++;
                 const told = pathNoteSteer(verdict.summary.path, hits);
                 // A repeat or a spent steer budget records the note without the agent reading it again, so the trace waits
@@ -1631,6 +1711,7 @@ export default function wardenExtension(pi) {
                         ctx.ui.notify(`warden · sensitive path · ${verdict.summary.path} (${hits.map(hit => hit.glob).join(", ")}); the agent was given the note`, "warning");
                 });
                 noteGuards.add("rules");
+                noteKinds.push("sensitive-path");
                 pathNotes.push(told);
             }
         }
@@ -1641,17 +1722,28 @@ export default function wardenExtension(pi) {
                 if (!note)
                     continue;
                 noteGuards.add(note.guard);
+                noteKinds.push(note.kind);
                 notes.push(note.text);
             }
             notes.push(...pathNotes);
             if (notes.length) {
                 const delivered = steer(config, [...noteGuards], notes.join("\n\n"));
+                const notePath = verdict.summary.path ?? shell?.writes[0]?.path;
+                if (delivered)
+                    watchSteer(ctx, config, noteKinds, notePath ? { path: notePath } : {});
                 for (const traceNote of pathNoteTraces)
                     traceNote(delivered);
                 pathNoteTraces.length = 0;
             }
         };
-        const warnSteer = (reasons) => reasons.length > 0 && steer(config, "action", `pi-warden: this ${event.toolName} call ran with a warning (${reasons.join("; ")}). Nobody sees this in a headless run, so it is on you: if the flagged risk is expected, continue; otherwise fix it or ask the user before building on it.`);
+        const warnSteer = (reasons) => {
+            if (!reasons.length || !adaptiveSend(ctx, config, "warn-headless"))
+                return false;
+            const sent = steer(config, "action", `pi-warden: this ${event.toolName} call ran with a warning (${reasons.join("; ")}). Nobody sees this in a headless run, so it is on you: if the flagged risk is expected, continue; otherwise fix it or ask the user before building on it.`);
+            if (sent)
+                watchSteer(ctx, config, ["warn-headless"]);
+            return sent;
+        };
         if (verdict.level === "warn") {
             deliverNotes(true);
             stats.warned++;
@@ -1751,6 +1843,10 @@ export default function wardenExtension(pi) {
         pruneScratch(sessionScratch);
         // Repeat detection uses the original result, so its request goes out together with the output check.
         const failed = resultFailed(event.isError, event.details, event.content);
+        // ── Call waste ──
+        // Every finished call enters the window; a note, when one fires, is attached to this result below. Nothing here
+        // reads the call's fate, and the note never reaches a hold, the judge, or the steer budget.
+        const wasteNudge = waste.record({ tool: event.toolName, input: event.input, cwd: ctx.cwd, failed, result: text }, config.waste);
         // ── Conscience: track tool_result for the pending capability ──
         if (config.conscience.enabled && pendingCapability && !triggerConsumed) {
             if (pendingCapability.kind === "tool" && event.toolName === pendingCapability.id) {
@@ -2035,6 +2131,32 @@ export default function wardenExtension(pi) {
                 fullOutputs.set(currentKey, { text });
         }
         const patch = content === event.content ? undefined : { content };
+        /** The note rides the result the model is about to read; the call already ran, so this only adds text to it. */
+        const withWaste = (current) => {
+            if (!wasteNudge)
+                return current;
+            const base = current?.content ?? event.content;
+            const lastText = base.reduce((last, part, index) => part.type === "text" ? index : last, -1);
+            if (lastText < 0)
+                return current;
+            const next = base.map((part, index) => {
+                if (part.type !== "text" || index !== lastText)
+                    return part;
+                return { ...part, text: `${part.text}\n\n${wasteNudge.text}` };
+            });
+            // Redaction runs before the cut: a 200-character slice can leave half a credential the redactor no longer knows.
+            const triggerCommand = event.toolName === "bash" && typeof event.input.command === "string"
+                ? ` ${redact(event.input.command).replace(/\s+/g, " ").slice(0, 200)}`
+                : "";
+            record(ctx, config, "waste", `warden · waste · ${wasteNudge.detector} · ${wasteNudge.subject} · agent told`, [
+                `trigger: ${event.toolName}${triggerCommand}`,
+                `detector: ${wasteNudge.detector}`,
+                `subject: ${redact(wasteNudge.subject)}`,
+                `nudge: ${wasteNudge.text}`,
+                `rate limit: at most one ${wasteNudge.detector} note per ${config.waste.every} calls; no steer, no request`,
+            ]);
+            return { content: next };
+        };
         // Checks use the original result, not the excerpts or security banner.
         if (config.done.enabled)
             recordDoneOutcome(evidence, classifyToolResult(event.toolName, event.input, failed, text), event.input, event.toolName);
@@ -2047,34 +2169,38 @@ export default function wardenExtension(pi) {
         // A stuck verdict on the same call carries its own steer; the quick one would say the same thing twice.
         if (quickRepeat && !verdict?.stuck) {
             const nudge = quickRepeatNudge(quickRepeat);
-            const sent = steer(config, "repeat", nudge);
+            const sent = adaptiveSend(ctx, config, "repeat") && steer(config, "repeat", nudge);
+            if (sent)
+                watchSteer(ctx, config, ["repeat"], { call: { name: event.toolName, input: event.input } });
             record(ctx, config, "stuck", `warden · stuck · repeat · ${quickRepeat.attempt.tool} · ${quickRepeat.attempt.failed ? "same failure" : "same output"} · ${sent ? "agent nudged" : "recorded only"}`, [
-                `call: ${quickRepeat.attempt.call}`, `previous identical call: ${quickRepeat.callsAgo} calls ago, nothing changed between`, `agent told: ${sent ? nudge : "nothing (repeat of a recent steer or over the steer budget)"}`,
+                `call: ${quickRepeat.attempt.call}`, `previous identical call: ${quickRepeat.callsAgo} calls ago, nothing changed between`, `agent told: ${sent ? nudge : "nothing (repeat of a recent steer, over the steer budget, or trace-only for this model)"}`,
             ]);
             if (sent && ctx.hasUI && config.notices)
                 ctx.ui.notify(`warden \u00b7 repeat: ${quickRepeat.attempt.failed ? "same call failed the same way" : "same output re-read"} (agent nudged)`, "warning");
         }
         if (!verdict)
-            return patch;
+            return withWaste(patch);
         if (verdict.error)
             noteError(ctx, verdict.error, verdict.errorCode);
         if (verdict.source === "repeat" && !verdict.stuck)
-            return patch;
+            return withWaste(patch);
         const nudge = verdict.stuck && config.stuck.nudge ? stuckNudge(verdict) : undefined;
         record(ctx, config, "stuck", formatStuck(verdict, config.widget.stuck), stuckDetails(verdict, attempts.attempts, nudge));
         if (!verdict.stuck)
-            return patch;
+            return withWaste(patch);
         stats.stuck++;
         if (ctx.hasUI && config.notices)
             ctx.ui.notify(`warden \u00b7 stuck: ${verdict.reasons.join("; ")}${nudge ? " (agent nudged)" : ""}`, "warning");
-        if (nudge)
-            steer(config, "stuck", nudge);
-        return patch;
+        if (nudge && adaptiveSend(ctx, config, "stuck") && steer(config, "stuck", nudge))
+            watchSteer(ctx, config, ["stuck"], { call: { name: event.toolName, input: event.input } });
+        return withWaste(patch);
     });
     // Opt-in: a relayed report that pastes earlier turns again keeps only its new part. Pi persists the replaced message.
     pi.on("message_end", async (event, ctx) => {
         const config = configFor(ctx);
         const message = event.message;
+        if (message.role === "assistant")
+            settleSteers(config, steerWatch.assistant(assistantView(message.content)));
         if (!config.enabled || !config.context.enabled || !config.context.dedupeRuns || !config.context.dedupeMessages)
             return;
         if (message.role !== "user" && message.role !== "custom")
@@ -2151,6 +2277,7 @@ export default function wardenExtension(pi) {
         }
         // Operator input invalidates in-flight conscience assessments
         conscienceGeneration++;
+        settleSteers(configFor(ctx), steerWatch.user());
     });
     /**
      * One short reminder of the open loops when a run ends, for the next turn: it starts no turn of its own, counts against
@@ -2166,8 +2293,10 @@ export default function wardenExtension(pi) {
             if (!open.length || fingerprint === loopsReminded)
                 return;
             const notice = `pi-warden: ${open.length} open loop${open.length === 1 ? "" : "s"} you promised in this session:\n${formatOpenLoops(open)}\nClose each with warden_loops done or drop once it is finished or no longer needed.`;
-            if (steer(config, "loops", notice, { deliverAs: "nextTurn" }))
+            if (adaptiveSend(ctx, config, "loops") && steer(config, "loops", notice, { deliverAs: "nextTurn" })) {
                 loopsReminded = fingerprint;
+                watchSteer(ctx, config, ["loops"], {}, true);
+            }
         }
         catch (error) {
             record(ctx, config, "action", "loops reminder error", [`reading the loops file failed: ${error instanceof Error ? error.message : String(error)}`]);
@@ -2239,14 +2368,15 @@ export default function wardenExtension(pi) {
                 // Same activation gate as the first recommendation: selectedCapability is set before that gate, so without this a
                 // capability held for no_policy would be delivered here.
                 if (result.selected && result.selected.kind === selectedCapability.kind && result.selected.id === selectedCapability.id &&
-                    result.disposition !== "awaiting_user" && policyMatches(consciencePolicy, result.questionHash, judgeModel)) {
+                    result.disposition !== "awaiting_user" && policyMatches(consciencePolicy, result.questionHash, judgeModel) && adaptiveSend(ctx, config, "conscience")) {
                     reminderSent = true;
                     nudgesThisPrompt++;
                     spendBudgetUnit();
                     const msg = result.selected.kind === "skill"
                         ? `Reminder: consider using the \"${result.selected.id}\" skill. ${result.selected.description}`
                         : `Reminder: consider using the \"${result.selected.id}\" tool. ${result.selected.description}`;
-                    steer(config, "conscience", msg, { deliverAs: "followUp" });
+                    if (steer(config, "conscience", msg, { deliverAs: "followUp" }))
+                        watchSteer(ctx, config, ["conscience"], { capability: { kind: result.selected.kind === "skill" ? "skill" : "tool", id: result.selected.id } });
                 }
             }
             catch (err) {
@@ -2285,7 +2415,8 @@ export default function wardenExtension(pi) {
             if (nudge) {
                 if (ctx.hasUI && config.notices)
                     ctx.ui.notify(`warden · prose: ${due.join(", ")} in ${config.slop.prose.trend} of the last 3 replies (agent nudged for the next reply)`, "warning");
-                steer(config, "prose", nudge, { deliverAs: "nextTurn" });
+                if (adaptiveSend(ctx, config, "prose") && steer(config, "prose", nudge, { deliverAs: "nextTurn" }))
+                    watchSteer(ctx, config, ["prose"], {}, true);
             }
         }
         if (!doneCheck)
@@ -2304,7 +2435,8 @@ export default function wardenExtension(pi) {
             ctx.ui.notify(`warden · done-check: ${verdict.reasons.join("; ")}${nudge ? " (agent asked to verify)" : ""}`, "warning");
         if (nudge) {
             doneNudged = true;
-            steer(config, "done", nudge, { deliverAs: "followUp", triggerTurn: true });
+            if (steer(config, "done", nudge, { deliverAs: "followUp", triggerTurn: true }))
+                watchSteer(ctx, config, ["done"]);
         }
     });
     // Shortcuts are registered once at load; a shape check keeps a typo in the config file from being registered.
@@ -2337,10 +2469,11 @@ export default function wardenExtension(pi) {
             const session = typeof manager.getSessionId === "function" ? manager.getSessionId() : "unknown";
             const scan = await standingPrefs(ctx);
             const path = prefsStorePath(scan.project);
-            const result = recordLesson({ lesson, session, now: Date.now(), signal, scan, store: await readPrefsStore(path) });
-            if (result.store)
-                await writePrefsStore(path, result.store);
-            return toolReply(result.reply);
+            const reply = await changePrefsStore(path, store => {
+                const result = recordLesson({ lesson, session, now: Date.now(), signal, scan, store });
+                return { value: result.reply, ...(result.store ? { store: result.store } : {}) };
+            });
+            return toolReply(reply);
         },
     });
     pi.registerTool({
@@ -2360,10 +2493,8 @@ export default function wardenExtension(pi) {
             const file = loopsFile(ctx);
             if (!file)
                 return toolReply("not available: this session has no id to keep loops under");
-            const result = applyLoopAction(await readLoops(file), params, Date.now());
-            if (result.store)
-                await writeLoops(file, result.store);
-            return toolReply(result.reply);
+            const reply = await updateLoops(file, store => applyLoopAction(store, params, Date.now()));
+            return toolReply(reply);
         },
     });
     pi.registerTool({
@@ -2377,11 +2508,14 @@ export default function wardenExtension(pi) {
             return toolReply(recallText(evidenceSnapshot(ctx)));
         },
     });
-    const actions = ["status", "enable", "disable", "mode", "config", "test", "trace", "init", "audit", "index", "prefs", "loops", "recommend"];
+    const actions = ["status", "rules", "report", "enable", "disable", "mode", "config", "test", "trace", "init", "audit", "index", "prefs", "loops", "recommend", "unmute"];
     pi.registerCommand("warden", {
-        description: "pi-warden status, config (set/get/editor), TypeSafe consent, mode, trace panel, recommend, standing preferences, open loops, and a synthetic guard test",
+        description: "pi-warden status, active rules, config (set/get/editor), TypeSafe consent, mode, trace panel, recommend, standing preferences, open loops, and a synthetic guard test",
         getArgumentCompletions(prefix) {
             const matches = actions.filter(action => action.startsWith(prefix)).map(action => ({ value: action, label: action }));
+            // `rules check` is the one two-word action: `rules` on its own stays the local list.
+            if ("rules check".startsWith(prefix))
+                matches.push({ value: "rules check", label: "rules check", description: "which of the active rules the guard cannot judge well" });
             return matches.length ? matches : null;
         },
         async handler(args, ctx) {
@@ -2412,6 +2546,7 @@ export default function wardenExtension(pi) {
                         `pi-warden: ${config.enabled ? `guarding ${config.action.tools.join(", ")} (${guards})` : "off"}; mode ${activeMode(config, ctx.hasUI)}; TypeSafe judgments ${source ? `consented via ${source}` : "not consented (run /warden enable)"}${config.typesafeBackend !== "typesafe" ? ` (${config.typesafeBackend})` : ""}; ${auth.text}`,
                         `Session: ${stats.inspected} inspected, ${stats.judged} judged, ${stats.warned} warned, ${stats.held} held, ${stats.approved} approved on retry, ${stats.offPlan} off plan (${stats.offPlanTraceOnly} trace-only), ${stats.offTask} off task, ${stats.slop} slop notes, ${stats.ruleViolations}/${stats.ruleChecks} rule violations, ${stats.pathNotes} sensitive-path notes, ${stats.stuck}/${stats.stuckChecks} stuck, ${stats.unverified}/${stats.doneChecks} unverified done, ${stats.proseNudges}/${stats.proseChecks} prose nudges, ${stats.runaway} runaway stops, ${stats.subagentWoken}/${stats.subagentReports} subagent reports woken, ${stats.restatements} restatements, ${stats.errors} TypeSafe errors, ${stats.cooldownSkips} checks without Jev during a judge cooldown; ${usage?.requestsStarted ?? 0}/${config.maxRequests} requests. Steers are ${config.steerVisible ? "shown in the transcript" : "hidden from the transcript (trace panel shows them)"}. Steer budget: ${config.steerBudget === 0 ? "off" : `${config.steerBudget} per run`}.`,
                         formatSteers(stats),
+                        `${formatMuted(steerStats.muted(), config.steers)}${stats.steersMuted ? ` This session: ${stats.steersMuted} steer${stats.steersMuted === 1 ? "" : "s"} kept in the trace only.` : ""}`,
                         `Thresholds: irreversible warn ${config.action.irreversible.warn} / hold ${config.action.irreversible.confirm}; off-task warn ${config.action.offTask.warn} / steer ${config.action.offTask.steer} (never holds); intent mismatch ${config.action.intentMismatch} (${config.action.visibleMismatch} on a visible action, trace-only: ${config.action.intentTraceOnly}); stuck same-strategy ${config.stuck.sameStrategy} after ${config.stuck.minFailures} failures; done claims ${config.done.claimsDone}; slop ${config.slop.threshold}, rules ${config.rules.threshold}, prose ${config.slop.prose.threshold} in ${config.slop.prose.trend}/3 replies; runaway ${config.runaway.repeats} repeats (thinking ${config.runaway.thinkingRepeats}), recover ${config.runaway.recover}; failOpen ${config.action.failOpen}.`,
                         formatLedger(ledger.snapshot()),
                         ...(config.learning.patternAnalysis ? [`Learning: ${(await generateRecommendations(ctx.cwd)).length} recommendations, steer effectiveness ${Math.round((await analyzeSteerEffectivenessReport(ctx.cwd)).overall * 100)}% (use /warden recommend for details)`] : []),
@@ -2426,6 +2561,33 @@ export default function wardenExtension(pi) {
                     ].join(" "));
                     return;
                 }
+                if (action === "rules") {
+                    if (argument === "check") {
+                        const off = judgmentsOffReason(config);
+                        const result = await checkRules({ set: rulesGuard.store.load(ctx.cwd, config.rules), judge: judgeFor(config), timeoutMs: config.timeoutMs, signal: ctx.signal });
+                        if (result.source === "skipped") {
+                            // No key, no consent, or a spent budget: say why and send nothing.
+                            report(`Rules check sent nothing: Jev judgments are off${off === "budget" ? " (the request budget is used up)" : ""}.${off && off !== "budget" ? ` ${judgmentsOffText(off, config.typesafeBackend, !ctx.hasUI)}` : ""} /warden rules shows the rule set locally.`);
+                            return;
+                        }
+                        report(formatRulesCheck(result));
+                        return;
+                    }
+                    report(rulesGuard.details(ctx.cwd, config.rules));
+                    return;
+                }
+                if (action === "report") {
+                    const match = /--days\s+(\d+)/.exec(tail);
+                    const days = match ? Number(match[1]) : REPORT_DEFAULT_DAYS;
+                    if (match && days < 1) {
+                        report("Usage: /warden report [--days N], where N is at least 1. Default: 30 days.", "warning");
+                        return;
+                    }
+                    const records = await readRulesLog(rulesLogPath(ctx.cwd));
+                    const set = rulesGuard.store.load(ctx.cwd, config.rules);
+                    report(formatRulesReport(buildRulesReport(records, { days, currentRules: set?.rules.map(rule => ({ id: rule.id, name: rule.name })) ?? [] })));
+                    return;
+                }
                 if (action === "trace") {
                     if (!ctx.hasUI) {
                         report(traceText());
@@ -2441,6 +2603,17 @@ export default function wardenExtension(pi) {
                     void opened?.closed.then(fallback, fallback);
                     return;
                 }
+                if (action === "unmute") {
+                    const kind = STEER_KINDS.find(name => name === argument);
+                    if (!kind) {
+                        report(`Usage: /warden unmute <kind> [model]. Kinds: ${STEER_KINDS.filter(name => !NEVER_MUTED.has(name)).join(", ")}.`, "warning");
+                        return;
+                    }
+                    const models = tokens[2] ? [tokens[2]] : modelKey(ctx) ? [modelKey(ctx)] : steerStats.modelsWith(kind);
+                    const reset = models.filter(model => steerStats.unmute(model, kind));
+                    report(reset.length ? `Reset ${kind} for ${reset.join(", ")}: its steers are sent again and counted from zero.` : `No counts for ${kind} on ${models.join(", ") || "any model"}; nothing to reset.`);
+                    return;
+                }
                 if (action === "loops") {
                     const file = loopsFile(ctx);
                     report(file ? formatLoopsForUser(await readLoops(file)) : "No loops: this session has no id to keep them under.");
@@ -2459,7 +2632,7 @@ export default function wardenExtension(pi) {
                             report(`Usage: /warden prefs forget <n>, where n is an item number from /warden prefs (1 to ${items.length}).`, "warning");
                             return;
                         }
-                        await writePrefsStore(path, forgetPref(await readPrefsStore(path), item));
+                        await changePrefsStore(path, store => ({ value: undefined, store: forgetPref(store, item) }));
                         report(`Forgotten for this project: "${item.text}". It is not listed or injected again.`);
                         return;
                     }