pi-warden 0.60.0 → 0.71.0

package/dist/adaptive.js

@@ -0,0 +1,274 @@
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { writeFileAtomicSync } from "./atomic.js";
+import { userConfigPath } from "./config.js";
+export const STEER_KINDS = [
+    "intent-mismatch", "off-task", "should-proceed", "warn-headless", "large-output", "slop", "rules", "sensitive-path",
+    "security-write", "stuck", "repeat", "done", "prose", "conscience", "loops", "runaway", "subagent",
+    "hold", "confirm", "deny", "masking", "credential-notice",
+];
+/**
+ * Never trace-only, whatever a model does with them: holds, confirm and deny verdicts, security masking, the credential
+ * notice on masked output, and the done-check. Runaway recovery and subagent wakes start a turn of their own; muting
+ * them would change what the run does, not only what the agent is told.
+ */
+export const NEVER_MUTED = new Set([
+    "hold", "confirm", "deny", "masking", "credential-notice", "done", "runaway", "subagent",
+]);
+/** Where the counts live: next to the user config, in pi-warden's data folder. */
+export function steerStatsPath() {
+    return process.env.PI_WARDEN_STEER_STATS ?? join(dirname(userConfigPath()), "steer-stats.json");
+}
+export const DEFAULT_STEERS = { adaptive: true, minSteers: 30, minFollowed: 0.2, maxDisputed: 0.4, recheckEvery: 30, probeEvery: 5 };
+const zero = () => ({ sent: 0, followed: 0, disputed: 0 });
+const fresh = () => ({ ...zero(), muted: false, asked: 0, probe: zero() });
+/** Kinds whose "followed" can be read from the next calls or text; the rest are judged by disputes alone. */
+const FOLLOW_MEASURED = new Set([
+    "intent-mismatch", "off-task", "should-proceed", "warn-headless", "large-output", "slop", "rules", "security-write",
+    "stuck", "repeat", "done", "conscience", "loops",
+]);
+/** True when the counts put the pair under the follow floor or over the dispute ceiling. */
+export function failing(kind, counts, config) {
+    if (!counts.sent)
+        return false;
+    return (FOLLOW_MEASURED.has(kind) && counts.followed / counts.sent < config.minFollowed) || counts.disputed / counts.sent > config.maxDisputed;
+}
+/** The counts per (model, kind) pair, read once and written after every change. */
+export class SteerStats {
+    path;
+    data;
+    constructor(path = steerStatsPath()) {
+        this.path = path;
+    }
+    load() {
+        if (this.data)
+            return this.data;
+        try {
+            const raw = JSON.parse(readFileSync(this.path, "utf8"));
+            this.data = raw?.version === 1 && typeof raw.models === "object" && raw.models ? raw : { version: 1, models: {} };
+        }
+        catch {
+            this.data = { version: 1, models: {} };
+        }
+        return this.data;
+    }
+    save() {
+        try {
+            writeFileAtomicSync(this.path, `${JSON.stringify(this.data)}\n`);
+        }
+        catch (error) {
+            console.warn("pi-warden: steer stats write failed:", error instanceof Error ? error.message : String(error));
+        }
+    }
+    pair(model, kind) {
+        return this.load().models[model]?.[kind];
+    }
+    ensure(model, kind) {
+        const models = this.load().models;
+        const kinds = models[model] ??= {};
+        return kinds[kind] ??= fresh();
+    }
+    /**
+     * Called before a steer of this kind goes out. A trace-only pair still sends the first of every `probeEvery` steers;
+     * after `recheckEvery` steers the probes decide: rates within the thresholds end trace-only, and the probe counts
+     * become the pair's new counts, so a fresh `minSteers` must pass before it can be muted again.
+     */
+    request(model, kind, config) {
+        if (!config.adaptive || NEVER_MUTED.has(kind))
+            return "send";
+        const pair = this.pair(model, kind);
+        if (!pair?.muted)
+            return "send";
+        const probe = pair.asked % Math.max(1, config.probeEvery) === 0;
+        pair.asked++;
+        if (pair.asked >= config.recheckEvery) {
+            if (pair.probe.sent > 0 && !failing(kind, pair.probe, config))
+                Object.assign(pair, { ...pair.probe, muted: false, asked: 0, probe: zero() });
+            else
+                Object.assign(pair, { asked: 0, probe: zero() });
+        }
+        this.save();
+        return probe ? "probe" : "trace-only";
+    }
+    /**
+     * The outcome of one sent steer. Crossing the thresholds at `minSteers` or later makes the pair trace-only. Kinds in
+     * NEVER_MUTED are counted, for the status, and never muted.
+     */
+    observe(model, kind, outcome, config) {
+        if (!config.adaptive)
+            return;
+        const pair = this.ensure(model, kind);
+        const add = (counts) => {
+            counts.sent++;
+            if (outcome.followed)
+                counts.followed++;
+            if (outcome.disputed)
+                counts.disputed++;
+        };
+        add(pair);
+        if (pair.muted)
+            add(pair.probe);
+        else if (!NEVER_MUTED.has(kind) && pair.sent >= config.minSteers && failing(kind, pair, config))
+            Object.assign(pair, { muted: true, asked: 0, probe: zero() });
+        this.save();
+    }
+    /** Drops the pair's counts; its steers are sent again. True when there was something to reset. */
+    unmute(model, kind) {
+        const kinds = this.load().models[model];
+        if (!kinds?.[kind])
+            return false;
+        delete kinds[kind];
+        if (!Object.keys(kinds).length)
+            delete this.load().models[model];
+        this.save();
+        return true;
+    }
+    /** Every trace-only pair, per model. */
+    muted() {
+        const out = [];
+        for (const [model, kinds] of Object.entries(this.load().models)) {
+            for (const [kind, pair] of Object.entries(kinds)) {
+                if (pair.muted)
+                    out.push({ model, kind, sent: pair.sent, followed: pair.followed, disputed: pair.disputed });
+            }
+        }
+        return out.sort((a, b) => a.model.localeCompare(b.model) || a.kind.localeCompare(b.kind));
+    }
+    /** Models with a pair of this kind, for `/warden unmute` without a model. */
+    modelsWith(kind) {
+        return Object.entries(this.load().models).filter(([, kinds]) => kinds[kind]).map(([model]) => model);
+    }
+}
+const percent = (part, whole) => `${whole ? Math.round((part / whole) * 100) : 0}%`;
+export function formatMuted(pairs, config) {
+    if (!config.adaptive)
+        return "Adaptive steers: off.";
+    if (!pairs.length)
+        return "Adaptive steers: no steer kind is trace-only for any model.";
+    const byModel = new Map();
+    for (const pair of pairs)
+        byModel.set(pair.model, [...(byModel.get(pair.model) ?? []), pair]);
+    const models = [...byModel].map(([model, list]) => `${model}: ${list.map(pair => `${pair.kind} (${pair.sent} steers, ${percent(pair.followed, pair.sent)} followed, ${percent(pair.disputed, pair.sent)} disputed)`).join(", ")}`);
+    return `Adaptive steers, trace-only per model: ${models.join("; ")}. /warden unmute <kind> resets a pair.`;
+}
+/** Agent replies that argue with a note instead of acting on it. The same pattern the field replays used. */
+export const DISPUTE = /false positive|false alarm|no (real )?(credentials|secrets)|not (a |real )?(secret|credential|token)s?|(only|just) (placeholder|fixture|test|dummy|fake)|as (I )?(said|planned|stated)|matches (what I said|the plan)|this is expected|warden (is wrong|misfired|misread)|misfire|spurious|harmless|benign|nothing sensitive|not sensitive|was intended|intended/i;
+const CHECK = /\b(test|tests|vitest|jest|pytest|build|lint|tsc|check|make|cargo|go test|flutter (test|analyze)|npm run|eslint|typecheck)\b/i;
+const UNVERIFIED = /not (yet )?(verified|tested)|unverified|did not run|didn't run/i;
+const REPLAN = /\b(instead|re-?plan(ned|ning)?|ask(ing)? (you|the user|first|before)|should I|do you want)\b/i;
+const commandText = (input) => typeof input.command === "string" ? input.command : typeof input.path === "string" ? input.path : JSON.stringify(input);
+/**
+ * Whether the next assistant messages (at most two) changed course after a steer of this kind, and whether they
+ * disputed it. A port of the heuristic the field replays used; it is a proxy and does not prove the note caused the change.
+ */
+export function steerOutcome(kind, subject, views) {
+    const text = views.map(view => view.text).join("\n");
+    const calls = views.flatMap(view => view.calls);
+    const disputed = DISPUTE.test(text);
+    let followed = false;
+    switch (kind) {
+        case "done":
+            followed = calls.some(call => call.name === "bash" && CHECK.test(commandText(call.input))) || UNVERIFIED.test(text);
+            break;
+        case "rules":
+        case "slop":
+        case "security-write": {
+            const path = subject.path;
+            followed = !!path && calls.some(call => /edit|write/i.test(call.name) ? commandText(call.input).endsWith(path) : call.name === "bash" && commandText(call.input).includes(path));
+            break;
+        }
+        case "stuck":
+        case "repeat": {
+            const next = calls[0];
+            followed = !!next && (!subject.call || next.name !== subject.call.name || commandText(next.input) !== commandText(subject.call.input));
+            break;
+        }
+        case "intent-mismatch":
+        case "off-task":
+        case "should-proceed":
+        case "warn-headless":
+        case "large-output":
+            followed = (!calls.length && /\?\s*$/.test(views[0]?.text ?? "")) || REPLAN.test(text);
+            break;
+        case "conscience": {
+            const target = subject.capability;
+            followed = !!target && calls.some(call => target.kind === "tool" ? call.name === target.id || call.name.endsWith(target.id) : commandText(call.input).includes(`/${target.id}/`));
+            break;
+        }
+        case "loops":
+            followed = calls.some(call => call.name === "warden_loops");
+            break;
+        default:
+            followed = false;
+    }
+    return { followed, disputed };
+}
+/**
+ * Sent steers waiting for the agent's next two messages. A steer queued for the next turn waits past the next user
+ * message; any other steer that meets a user message first is settled on what it saw, or dropped when it saw nothing.
+ */
+export class SteerWatch {
+    pending = [];
+    add(model, kinds, subject = {}, options = {}) {
+        if (!kinds.length)
+            return;
+        this.pending.push({ model, kinds: [...kinds], subject, views: [], waitUser: options.nextTurn === true });
+        if (this.pending.length > 50)
+            this.pending.shift();
+    }
+    /** Feeds one assistant message; returns the steers it settled. */
+    assistant(view) {
+        const settled = [];
+        const keep = [];
+        for (const item of this.pending) {
+            if (item.waitUser) {
+                keep.push(item);
+                continue;
+            }
+            item.views.push(view);
+            const outcomes = item.kinds.map(kind => ({ kind, ...steerOutcome(kind, item.subject, item.views) }));
+            if (item.views.length >= 2 || outcomes.every(outcome => outcome.followed || outcome.disputed)) {
+                for (const outcome of outcomes)
+                    settled.push({ model: item.model, ...outcome });
+            }
+            else
+                keep.push(item);
+        }
+        this.pending = keep;
+        return settled;
+    }
+    /** A user message arrived. */
+    user() {
+        const settled = [];
+        const keep = [];
+        for (const item of this.pending) {
+            if (item.waitUser) {
+                item.waitUser = false;
+                keep.push(item);
+                continue;
+            }
+            if (item.views.length)
+                for (const kind of item.kinds)
+                    settled.push({ model: item.model, kind, ...steerOutcome(kind, item.subject, item.views) });
+        }
+        this.pending = keep;
+        return settled;
+    }
+    clear() { this.pending = []; }
+}
+/** The text and tool calls of an assistant message as Pi stores it. */
+export function assistantView(content) {
+    if (typeof content === "string")
+        return { text: content, calls: [] };
+    if (!Array.isArray(content))
+        return { text: "", calls: [] };
+    const text = [];
+    const calls = [];
+    for (const part of content) {
+        if (part?.type === "text" && typeof part.text === "string")
+            text.push(part.text);
+        else if (part?.type === "toolCall" && typeof part.name === "string")
+            calls.push({ name: part.name, input: (part.arguments && typeof part.arguments === "object" ? part.arguments : {}) });
+    }
+    return { text: text.join("\n"), calls };
+}

package/dist/atomic.d.ts

@@ -0,0 +1,10 @@
+/** Writes `text` to `path` through a temporary file and a rename, so a crash or a reader never sees half a file. */
+export declare function writeFileAtomic(path: string, text: string): Promise<void>;
+/** `writeFileAtomic` for the synchronous stores, which cannot interleave with each other inside one process. */
+export declare function writeFileAtomicSync(path: string, text: string): void;
+/**
+ * Runs `task` after every earlier task for `key`, so the read-modify-write sequences that share a store file run one
+ * after another instead of all reading the same old store and then writing over each other's change. A task's rejection
+ * reaches its own caller and does not stop the queue.
+ */
+export declare function serialize<T>(key: string, task: () => Promise<T> | T): Promise<T>;

package/dist/atomic.js

@@ -0,0 +1,51 @@
+/**
+ * Whole-file writes and per-file queues for pi-warden's small JSON stores. Two operations on one store in one process
+ * share no temporary name and do not interleave: every write goes to a temporary file that belongs to this process and
+ * this write, then a rename puts it in place, and every read-modify-write of one file runs through a queue keyed by that
+ * path. Cross-process locking is out of scope: a second process writing the same store can still lose this process's
+ * update, and nothing here stops it.
+ */
+import { chmodSync, mkdirSync, renameSync, writeFileSync } from "node:fs";
+import { chmod, mkdir, rename, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+let writes = 0;
+/** The temporary file one write lands in: the pid keeps two processes apart, the counter two writes within one process. */
+function temporaryPath(path) {
+    writes += 1;
+    return `${path}.${process.pid}.${writes}.tmp`;
+}
+/** Writes `text` to `path` through a temporary file and a rename, so a crash or a reader never sees half a file. */
+export async function writeFileAtomic(path, text) {
+    await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+    const temporary = temporaryPath(path);
+    await writeFile(temporary, text, { mode: 0o600 });
+    // The mode applies only when the temporary file is created; force it so a leftover file cannot change the store's permissions.
+    await chmod(temporary, 0o600);
+    await rename(temporary, path);
+}
+/** `writeFileAtomic` for the synchronous stores, which cannot interleave with each other inside one process. */
+export function writeFileAtomicSync(path, text) {
+    mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+    const temporary = temporaryPath(path);
+    writeFileSync(temporary, text, { mode: 0o600 });
+    chmodSync(temporary, 0o600);
+    renameSync(temporary, path);
+}
+/** The tail of each path's queue: a task starts once the previous task for the same path has settled. */
+const queues = new Map();
+/**
+ * Runs `task` after every earlier task for `key`, so the read-modify-write sequences that share a store file run one
+ * after another instead of all reading the same old store and then writing over each other's change. A task's rejection
+ * reaches its own caller and does not stop the queue.
+ */
+export function serialize(key, task) {
+    const previous = queues.get(key) ?? Promise.resolve();
+    const run = previous.then(task);
+    const settled = run.then(() => undefined, () => undefined);
+    queues.set(key, settled);
+    void settled.then(() => {
+        if (queues.get(key) === settled)
+            queues.delete(key);
+    });
+    return run;
+}

package/dist/compact.d.ts

@@ -56,9 +56,17 @@ export interface CompactSnapshot {
     verification: Verification | undefined;
     stuck: StuckState | undefined;
     activeTask: string | undefined;
+    /** The session's open loops, already formatted and capped by `formatOpenLoops`; absent or empty when none is open. */
+    openLoops?: string;
 }
 /** Returns empty string for an empty snapshot. Capped at 2 000 chars. */
 export declare function compactAppendix(snapshot: CompactSnapshot): string;
+/**
+ * `warden_recall`: what was already tried in this session, from the same snapshot and the same section text as the
+ * compaction appendix: the failed attempts with their error lines, the last passing check with whether the code
+ * changed since, and the saved-output paths. Capped like the appendix.
+ */
+export declare function recallText(snapshot: CompactSnapshot): string;
 /** The line of a failed output most likely to name the error: the last specific error line, else the last line. */
 export declare function errorLine(output: string): string;
 /** Distinct failed calls, the latest occurrence of each, oldest first; at most `MAX_FAILED`. */
@@ -101,4 +109,5 @@ export declare function buildCompactSnapshot(options: {
     evidence?: Pick<RunEvidence, "mutations" | "checks" | "checksBeforeMutation">;
     activeTask: string | undefined;
     runs: number;
+    openLoops?: string;
 }): CompactSnapshot;

package/dist/compact.js

@@ -8,8 +8,10 @@ const TASK_CHARS_WHEN_OVER = 300;
 function clip(text, limit) {
     return text.length <= limit ? text : `${text.slice(0, Math.max(0, limit - 1))}…`;
 }
-function render(snapshot) {
+/** Every section in appendix order; `warden_recall` prints some of the same strings, so the two never disagree. */
+function renderSections(snapshot) {
     const sections = [];
+    const push = (name, text) => sections.push([name, text]);
     if (snapshot.failedAttempts.length) {
         const items = snapshot.failedAttempts.map(attempt => {
             const call = clip(redact(attempt.call), FAILED_CALL_CHARS);
@@ -17,39 +19,46 @@ function render(snapshot) {
             const entry = error ? `${call} → ${clip(error, FAILED_ENTRY_CHARS - call.length - 3)}` : call;
             return `- ${entry}`;
         }).join("\n");
-        sections.push(`### Tried and failed\nDo not retry these unchanged.\n${items}`);
+        push("failed", `### Tried and failed\nDo not retry these unchanged.\n${items}`);
     }
     if (snapshot.verification) {
         const v = snapshot.verification;
         const line = v.kind === "passed"
             ? `- last passing check: ${redact(v.command)}; code changed since last passing check: ${v.changedSince ? "yes" : "no"}`
             : "- no check has passed yet; code was changed";
-        sections.push(`### Verification\n${line}`);
+        push("verification", `### Verification\n${line}`);
+    }
+    if (snapshot.openLoops) {
+        push("loops", `### Open loops\nPromised earlier in this session and not done yet; close each with warden_loops done or drop.\n${snapshot.openLoops}`);
     }
     if (snapshot.checks.length) {
         const items = snapshot.checks
             .map(c => `- ${c.passed ? "✓" : "✗"} ${c.when}: ${redact(c.command)}`)
             .join("\n");
-        sections.push(`### Last checks\n${items}`);
+        push("checks", `### Last checks\n${items}`);
     }
     if (snapshot.stuck) {
-        sections.push(`### Stuck state\n- failures: ${snapshot.stuck.failures} of the last ${snapshot.stuck.window} tool results`);
+        push("stuck", `### Stuck state\n- failures: ${snapshot.stuck.failures} of the last ${snapshot.stuck.window} tool results`);
     }
     if (snapshot.holds.length) {
         const items = snapshot.holds
             .map(h => `- ${redact(h.tool)}: ${redact(h.outcome)}${h.preview ? ` (${redact(h.preview)})` : ""}`)
             .join("\n");
-        sections.push(`### Held actions\n${items}`);
+        push("holds", `### Held actions\n${items}`);
     }
     if (snapshot.savedOutputs.length) {
         const items = snapshot.savedOutputs
             .map(item => `- ${item.tool ? `${redact(item.tool)} → ` : ""}${redact(item.path)}${item.bytes === undefined ? "" : ` (${item.bytes} bytes)`}`)
             .join("\n");
-        sections.push(`### Saved full outputs\n${items}`);
+        push("saved", `### Saved full outputs\n${items}`);
     }
     if (snapshot.activeTask) {
-        sections.push(`### Active task\n${redact(snapshot.activeTask)}`);
+        push("task", `### Active task\n${redact(snapshot.activeTask)}`);
     }
+    return sections;
+}
+function render(snapshot) {
+    const sections = renderSections(snapshot).map(([, text]) => text);
     if (sections.length === 0)
         return "";
     return [
@@ -61,8 +70,9 @@ function render(snapshot) {
     ].join("\n");
 }
 /**
- * Lower-value content goes first when the appendix is over the cap. Failed attempts and the verification line are
- * never reduced here; they come first in the text, so the final cut reaches them last.
+ * Lower-value content goes first when the appendix is over the cap. Failed attempts, the verification line, and the
+ * open loops (at most 600 characters) are never reduced here; they come first in the text, so the final cut reaches
+ * them last.
  */
 const REDUCERS = [
     s => ({ ...s, savedOutputs: s.savedOutputs.slice(-SAVED_KEEP_WHEN_OVER) }),
@@ -88,6 +98,19 @@ export function compactAppendix(snapshot) {
     const marker = "\n… [truncated]";
     return appendix.slice(0, MAX_CHARS - marker.length) + marker;
 }
+/**
+ * `warden_recall`: what was already tried in this session, from the same snapshot and the same section text as the
+ * compaction appendix: the failed attempts with their error lines, the last passing check with whether the code
+ * changed since, and the saved-output paths. Capped like the appendix.
+ */
+export function recallText(snapshot) {
+    const kept = renderSections(snapshot).filter(([name]) => name === "failed" || name === "verification" || name === "saved").map(([, text]) => text);
+    const text = kept.length ? kept.join("\n\n") : "Nothing recorded yet in this session: no failed attempt, no check, and no saved output.";
+    if (text.length <= MAX_CHARS)
+        return text;
+    const marker = "\n… [truncated]";
+    return text.slice(0, MAX_CHARS - marker.length) + marker;
+}
 const ERROR_LINE = /\b(?:error|errors|fail(?:ed|ure|s)?|exception|cannot|can't|could not|not found|no such|denied|refused|invalid|unexpected|missing|undefined|timed? ?out|abort(?:ed)?|panic|fatal|traceback)\b|✗|✖|✘/i;
 /** Runner tallies ("Found 1 error.", "3 failing") say that something failed, not what; an earlier line says what. */
 const SUMMARY_LINE = /^(?:found \d+ errors?\b|\d+ (?:failing|failed|errors?)\b|tests?:\s|ℹ fail \d+|npm (?:err!|error) (?:code|errno|a complete log|command failed|lifecycle)|error: command failed|command failed with exit code)/i;
@@ -159,5 +182,6 @@ export function buildCompactSnapshot(options) {
         verification: options.evidence ? verificationOf(options.evidence) : undefined,
         stuck,
         activeTask,
+        ...(options.openLoops ? { openLoops: options.openLoops } : {}),
     };
 }

package/dist/config.d.ts

@@ -41,6 +41,8 @@ export interface ActionGuardConfig {
     intentMismatch: number;
     /** The same, for a command whose effect is visible outside the working tree (commit, push, merge, publish, launch): less mismatch is enough. */
     visibleMismatch: number;
+    /** Which intent mismatches stay in the trace without a steer: "invisible" (default) a call with no visible effect (neither a commit, push, merge, tag, reset, pull request, release, or publish by `isVisibleCommand`, nor judged `visible` at 0.8 or more), "all" every one, "none" none. The steer arrives after the call ran: 275 of 275 recorded steers did. */
+    intentTraceOnly: "invisible" | "all" | "none";
     /** Low P(should_proceed) is trace-only unless steer is enabled; hold is the inclusive threshold, not a blocking decision. Calibration: AUC 0.26 against regret, 44% flagged at 0.6 (100 targeted sessions, 2026-09-20). */
     shouldProceed: {
         hold: number;
@@ -129,6 +131,8 @@ export interface StuckGuardConfig {
     nudge: boolean;
     /** Steer on the 2nd identical call when nothing changed between and it failed the same way or re-read the same output. Code only. */
     repeatSteer: boolean;
+    /** Send the judge a compact structured `evidence` section: the parsed failure per run, the edit diffs, and a digest. */
+    evidence: boolean;
     /** Maximum characters of the unified line diff in a stuck-loop diff note. */
     diffLimit: number;
     /** Characters of the current output tail shown after the diff in a stuck-loop diff note. */
@@ -188,6 +192,8 @@ export interface RulesConfig {
     enabled: boolean;
     /** P(violation) at or above this names the rule to the agent. */
     threshold: number;
+    /** A score from here up to the rule's cutoff becomes a soft "please double-check" steer; `0` turns the tier off. */
+    softThreshold: number;
     /** Project-relative Markdown rule files, used when the root pi-warden.md is absent. All are sent in one request. */
     files: string[];
     /** With no rules file, README.md, CLAUDE.md, or AGENTS.md (first found) is judged as one document. */
@@ -215,6 +221,10 @@ export interface ContextConfig {
     formatConfidence: number;
     /** Append a compact evidence appendix to the summary during compaction. */
     compactAppendix: boolean;
+    /** A run of at least 20 lines and 1500 characters in a new tool result that repeats text already in context becomes one pointer line (code only). */
+    dedupeRuns: boolean;
+    /** The same for user and custom messages, when `dedupeRuns` is also on. Off by default: a repeat the user sends can itself carry meaning ("here it is again, still failing"). */
+    dedupeMessages: boolean;
     /** Prevention before the call: a bash action request asks whether the command will print far more than the agent needs. Never holds. */
     largeOutput: LargeOutputConfig;
 }
@@ -264,12 +274,43 @@ export interface SubagentConfig {
 export type RecallTool = "auto" | "rg" | "ag" | "ugrep" | "git-grep" | "grep" | "select-string" | "findstr" | "none";
 export declare function isRecallTool(value: unknown): value is RecallTool;
 export type WardenMode = "steer" | "confirm" | "advise";
+export interface WasteConfig {
+    /** Master switch for the call-waste notes and the session tip. */
+    enabled: boolean;
+    /** Append the session tip to the prompt once per session. */
+    tip: boolean;
+    /** Tool calls between two notes from the same detector. */
+    every: number;
+    /** Note on repeated poll calls (`sleep`). */
+    sleep: boolean;
+    /** Note on adjacent range reads of one file. */
+    paging: boolean;
+    /** Note on repeated searches of one file with an overlapping pattern. */
+    search: boolean;
+    /** Note on a filtered check re-run. */
+    recheck: boolean;
+}
 export interface PrefsConfig {
     /** Read this project's earlier session files for preferences the user repeated (`/warden prefs`). Local, code only. */
     enabled: boolean;
-    /** At session start, send the standing preferences to the agent as one context message. Off by default. */
+    /** At session start, send the standing preferences that pass every injection rule to the agent as one context message. */
     inject: boolean;
 }
+/** Per-model steer adaptation: a steer kind a model rarely follows or often disputes becomes trace-only for it. */
+export interface SteersConfig {
+    /** Make a steer kind trace-only for a model that rarely follows or often disputes it. */
+    adaptive: boolean;
+    /** Steers observed for a (model, kind) pair before it can become trace-only. */
+    minSteers: number;
+    /** Trace-only when the followed share is under this. Kinds with no follow measure are judged by disputes alone. */
+    minFollowed: number;
+    /** Trace-only when the disputed share is over this. */
+    maxDisputed: number;
+    /** A trace-only pair is re-checked after this many further steers. */
+    recheckEvery: number;
+    /** While trace-only, 1 in this many steers is still sent, so the re-check has fresh data. */
+    probeEvery: number;
+}
 export interface LearningConfig {
     /** Enable adaptive thresholds based on learning data. */
     adaptiveThresholds: boolean;
@@ -360,16 +401,20 @@ export interface WardenConfig {
      * steer costs at least one LLM turn, and a closing run that collects six notices collects six restatements of the final
      * status. 0 disables the budget. Critical guards (stuck, done, runaway, subagent wake) always deliver. */
     steerBudget: number;
+    /** Per-model steer adaptation. */
+    steers: SteersConfig;
     /** Learning and adaptation settings. */
     learning: LearningConfig;
     /** Broad-consideration coach: recommends or loads skills and tools before the agent acts. */
     conscience: ConscienceConfig;
     /** Standing preferences: corrections the user repeated in earlier sessions of this project. */
     prefs: PrefsConfig;
+    /** Call-waste notes: advisory sentences attached to the tool result that triggers them. */
+    waste: WasteConfig;
 }
 export declare const PACKAGE_NAME = "pi-warden";
 /** Bumped when WardenConfig gains a section; extension.ts checks it so a half-updated module graph is reported, not crashed on. */
-export declare const CONFIG_SCHEMA = 8;
+export declare const CONFIG_SCHEMA = 10;
 export declare const PROJECT_CONFIG_FILE = "pi-warden.json";
 export declare function defaultConfig(): WardenConfig;
 /** Mirrors Pi's agent directory rule so the file sits next to pi-typesafe's auth.json. */