pi-warden 0.60.0 → 0.71.0

package/dist/config.js

@@ -1,6 +1,7 @@
-import { chmodSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
+import { writeFileAtomicSync } from "./atomic.js";
 import { resolveBackend } from "./backend.js";
 import { COMMAND_TOOLS } from "./tools.js";
 import { defaultWidgetConfig } from "./widget.js";
@@ -23,7 +24,7 @@ export function isRecallTool(value) {
 }
 export 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 const CONFIG_SCHEMA = 8;
+export const CONFIG_SCHEMA = 10;
 export const PROJECT_CONFIG_FILE = `${PACKAGE_NAME}.json`;
 export function defaultConfig() {
     return {
@@ -42,6 +43,7 @@ export function defaultConfig() {
             offTask: { warn: 0.6, steer: 0.85 },
             intentMismatch: 0.9,
             visibleMismatch: 0.8,
+            intentTraceOnly: "invisible",
             shouldProceed: { hold: 0.6, steer: false },
             feedbackLog: true,
             commandRules: [],
@@ -52,12 +54,12 @@ export function defaultConfig() {
             escalationThreshold: 0.85,
             floor: "evidence",
         },
-        stuck: { enabled: true, window: 12, minFailures: 3, cooldown: 3, sameStrategy: 0.7, churnThreshold: 5, nudge: true, repeatSteer: true, diffLimit: 3000, tailLimit: 1000 },
+        stuck: { enabled: true, window: 12, minFailures: 3, cooldown: 3, sameStrategy: 0.7, churnThreshold: 5, nudge: true, repeatSteer: true, evidence: true, diffLimit: 3000, tailLimit: 1000 },
         done: { enabled: true, claimsDone: 0.7, nudge: true, uiProof: true, uiFiles: [...DEFAULT_UI_FILES], visualTools: defaultVisualTools() },
         slop: { enabled: true, threshold: 0.7, prose: { enabled: true, audience: "technical", threshold: 0.7, trend: 2, minChars: 200 } },
         security: { enabled: true, threshold: 0.7, maskOutput: true },
-        rules: { enabled: true, threshold: 0.7, files: [], fallback: true, maxChars: 8000, exclude: [], skip: [], sensitivePaths: {} },
-        context: { enabled: true, tailMinChars: 12000, confidence: 0.8, duplicateMinChars: 2000, recallTool: "auto", formatConfidence: 0.7, compactAppendix: true, largeOutput: { enabled: true, threshold: 0.85 } },
+        rules: { enabled: true, threshold: 0.7, softThreshold: 0, files: [], fallback: true, maxChars: 8000, exclude: [], skip: [], sensitivePaths: {} },
+        context: { enabled: true, tailMinChars: 12000, confidence: 0.8, duplicateMinChars: 2000, recallTool: "auto", formatConfidence: 0.7, compactAppendix: true, dedupeRuns: true, dedupeMessages: false, largeOutput: { enabled: true, threshold: 0.85 } },
         runaway: { enabled: true, repeats: 4, thinkingRepeats: 10, minChars: 400, recover: true },
         notify: { enabled: false, cooldownMs: 10000, command: [] },
         judge: { cooldownMs: 60000, failuresBeforeCooldown: 3 },
@@ -66,6 +68,7 @@ export function defaultConfig() {
         steerVisible: false,
         notices: false,
         steerBudget: 3,
+        steers: { adaptive: true, minSteers: 30, minFollowed: 0.2, maxDisputed: 0.4, recheckEvery: 30, probeEvery: 5 },
         learning: { adaptiveThresholds: true, patternAnalysis: true, minHoldsForAdaptive: 20, adaptationRate: 0.1, retentionDays: 365 },
         conscience: {
             enabled: false,
@@ -82,7 +85,8 @@ export function defaultConfig() {
             advanceThreshold: 0.70,
             loadThreshold: 1.0,
         },
-        prefs: { enabled: true, inject: false },
+        prefs: { enabled: true, inject: true },
+        waste: { enabled: true, tip: false, every: 20, sleep: true, paging: true, search: true, recheck: true },
     };
 }
 /** Mirrors Pi's agent directory rule so the file sits next to pi-typesafe's auth.json. */
@@ -284,6 +288,7 @@ function applyAction(base, raw, timeoutMs, source) {
         offTask: offTaskThreshold(raw.offTask, base.offTask),
         intentMismatch: probability(raw.intentMismatch, base.intentMismatch),
         visibleMismatch: Math.min(probability(raw.visibleMismatch, base.visibleMismatch), probability(raw.intentMismatch, base.intentMismatch)),
+        intentTraceOnly: raw.intentTraceOnly === "invisible" || raw.intentTraceOnly === "all" || raw.intentTraceOnly === "none" ? raw.intentTraceOnly : base.intentTraceOnly,
         shouldProceed: {
             hold: probability(raw.shouldProceed?.hold, base.shouldProceed.hold),
             steer: boolean(raw.shouldProceed?.steer, base.shouldProceed.steer),
@@ -315,6 +320,7 @@ function applyStuck(base, raw) {
         churnThreshold: Math.min(window, positiveInteger(raw.churnThreshold, base.churnThreshold)),
         nudge: boolean(raw.nudge, base.nudge),
         repeatSteer: boolean(raw.repeatSteer, base.repeatSteer),
+        evidence: boolean(raw.evidence, base.evidence),
         diffLimit: positiveInteger(raw.diffLimit, base.diffLimit),
         tailLimit: positiveInteger(raw.tailLimit, base.tailLimit),
     };
@@ -400,6 +406,7 @@ function applyRules(base, raw) {
     return {
         enabled: boolean(raw.enabled, base.enabled),
         threshold: probability(raw.threshold, base.threshold),
+        softThreshold: probability(raw.softThreshold, base.softThreshold),
         files: globList(raw.files, base.files),
         fallback: boolean(raw.fallback, base.fallback),
         maxChars: Math.max(500, positiveInteger(raw.maxChars, base.maxChars)),
@@ -440,6 +447,7 @@ function applyShared(base, raw) {
 }
 function applyGuards(base, raw, timeoutMs, source) {
     return {
+        waste: applyWaste(base.waste, raw.waste),
         rules: applyRules(base.rules, raw.rules),
         runaway: applyRunaway(base.runaway, raw.runaway),
         subagent: applySubagent(base.subagent, raw.subagent),
@@ -464,6 +472,8 @@ function applyGuards(base, raw, timeoutMs, source) {
             recallTool: isRecallTool(raw.context.recallTool) ? raw.context.recallTool : base.context.recallTool,
             formatConfidence: probability(raw.context.formatConfidence, base.context.formatConfidence),
             compactAppendix: boolean(raw.context.compactAppendix, base.context.compactAppendix),
+            dedupeRuns: boolean(raw.context.dedupeRuns, base.context.dedupeRuns),
+            dedupeMessages: boolean(raw.context.dedupeMessages, base.context.dedupeMessages),
             largeOutput: isObject(raw.context.largeOutput) ? {
                 enabled: boolean(raw.context.largeOutput.enabled, base.context.largeOutput.enabled),
                 threshold: probability(raw.context.largeOutput.threshold, base.context.largeOutput.threshold),
@@ -487,16 +497,42 @@ export function applyUserOverrides(base, raw) {
         steerVisible: boolean(raw.steerVisible, base.steerVisible),
         notices: boolean(raw.notices, base.notices),
         steerBudget: typeof raw.steerBudget === "number" && Number.isInteger(raw.steerBudget) && raw.steerBudget >= 0 ? raw.steerBudget : base.steerBudget,
+        steers: applySteers(base.steers, raw.steers),
         learning: applyLearning(base.learning, raw.learning),
         conscience: applyConscience(base.conscience, raw.conscience),
         prefs: applyPrefs(base.prefs, raw.prefs),
     };
 }
+function applyWaste(base, raw) {
+    if (!isObject(raw))
+        return base;
+    return {
+        enabled: boolean(raw.enabled, base.enabled),
+        tip: boolean(raw.tip, base.tip),
+        every: Math.max(2, positiveInteger(raw.every, base.every)),
+        sleep: boolean(raw.sleep, base.sleep),
+        paging: boolean(raw.paging, base.paging),
+        search: boolean(raw.search, base.search),
+        recheck: boolean(raw.recheck, base.recheck),
+    };
+}
 function applyPrefs(base, raw) {
     if (!isObject(raw))
         return base;
     return { enabled: boolean(raw.enabled, base.enabled), inject: boolean(raw.inject, base.inject) };
 }
+function applySteers(base, raw) {
+    if (!isObject(raw))
+        return base;
+    return {
+        adaptive: boolean(raw.adaptive, base.adaptive),
+        minSteers: positiveInteger(raw.minSteers, base.minSteers),
+        minFollowed: probability(raw.minFollowed, base.minFollowed),
+        maxDisputed: probability(raw.maxDisputed, base.maxDisputed),
+        recheckEvery: positiveInteger(raw.recheckEvery, base.recheckEvery),
+        probeEvery: positiveInteger(raw.probeEvery, base.probeEvery),
+    };
+}
 function applyLearning(base, raw) {
     if (!isObject(raw))
         return base;
@@ -553,11 +589,7 @@ export function readUserConfig() {
 }
 export function writeUserConfig(raw) {
     const path = userConfigPath();
-    mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
-    const temporary = `${path}.${process.pid}.tmp`;
-    writeFileSync(temporary, `${JSON.stringify(raw, null, 2)}\n`, { mode: 0o600, flag: "w" });
-    chmodSync(temporary, 0o600);
-    renameSync(temporary, path);
+    writeFileAtomicSync(path, `${JSON.stringify(raw, null, 2)}\n`);
     return path;
 }
 /** Persists one top-level user setting without disturbing the rest of the file. */

package/dist/dedupe.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Repeated-run detection: a new tool result or message that pastes again a long block the agent already has in context
+ * (a relayed report that quotes every earlier turn) keeps only its new part. Exact line matches only, after trimming
+ * trailing spaces; near-duplicates are never collapsed. Deterministic; no requests.
+ */
+/** A run shorter than this, in lines or characters, is kept: a short repeat costs less than the pointer that replaces it. */
+export declare const RUN_MIN_LINES = 20;
+export declare const RUN_MIN_CHARS = 1500;
+/** Errors and verdicts usually sit at the end of a result, so the last characters are never replaced. */
+export declare const TAIL_KEEP_CHARS = 2000;
+export interface RepeatedRun {
+    /** First line of the run in the new text, 0-based. */
+    start: number;
+    lines: number;
+    chars: number;
+    /** Where the earlier copy is, e.g. "an earlier bash result". */
+    where: string;
+}
+/** One text the agent has in context, with a stable identity so a sync adds it once. */
+export interface SeenItem {
+    key: unknown;
+    where: string;
+    texts: string[];
+}
+export declare class SeenText {
+    /** Interned normalized lines; ids start at 1 so 0 marks a line never seen. */
+    private readonly lineIds;
+    private readonly docs;
+    private readonly windows;
+    private readonly keys;
+    clear(): void;
+    /** Match the index to what is in context now: a compaction or a move to another branch drops texts, so it rebuilds. */
+    sync(items: SeenItem[]): void;
+    add(text: string, where: string): void;
+    /** Runs of `text` that repeat one earlier text exactly, longest match first at each position, outside the kept tail. */
+    find(text: string): RepeatedRun[];
+}
+/** Replaces each run with one pointer line; `path` holds the full original text. */
+export declare function collapseRuns(text: string, runs: RepeatedRun[], path: string): string;
+/** The texts a session entry puts in context and where the agent saw them. Thinking, images, and summaries are not indexed. */
+export declare function seenItem(entry: unknown): SeenItem | undefined;

package/dist/dedupe.js

@@ -0,0 +1,162 @@
+/**
+ * Repeated-run detection: a new tool result or message that pastes again a long block the agent already has in context
+ * (a relayed report that quotes every earlier turn) keeps only its new part. Exact line matches only, after trimming
+ * trailing spaces; near-duplicates are never collapsed. Deterministic; no requests.
+ */
+/** A run shorter than this, in lines or characters, is kept: a short repeat costs less than the pointer that replaces it. */
+export const RUN_MIN_LINES = 20;
+export const RUN_MIN_CHARS = 1500;
+/** Errors and verdicts usually sit at the end of a result, so the last characters are never replaced. */
+export const TAIL_KEEP_CHARS = 2000;
+const BASE = 1_000_003;
+/** BASE^(RUN_MIN_LINES - 1) mod 2^32, for the rolling window hash. */
+const TOP = (() => { let power = 1; for (let index = 1; index < RUN_MIN_LINES; index++)
+    power = Math.imul(power, BASE); return power; })();
+/** Several earlier copies of one window are enough to find the longest match; more only cost memory. */
+const MAX_POSITIONS = 4;
+/** Hash of every RUN_MIN_LINES-line window, by start line. */
+function windowHashes(ids) {
+    const hashes = [];
+    if (ids.length < RUN_MIN_LINES)
+        return hashes;
+    let hash = 0;
+    for (let index = 0; index < RUN_MIN_LINES; index++)
+        hash = (Math.imul(hash, BASE) + ids[index]) | 0;
+    hashes.push(hash);
+    for (let index = RUN_MIN_LINES; index < ids.length; index++) {
+        hash = (Math.imul((hash - Math.imul(ids[index - RUN_MIN_LINES], TOP)) | 0, BASE) + ids[index]) | 0;
+        hashes.push(hash);
+    }
+    return hashes;
+}
+export class SeenText {
+    /** Interned normalized lines; ids start at 1 so 0 marks a line never seen. */
+    lineIds = new Map();
+    docs = [];
+    windows = new Map();
+    keys = new Set();
+    clear() {
+        this.lineIds.clear();
+        this.docs.length = 0;
+        this.windows.clear();
+        this.keys.clear();
+    }
+    /** Match the index to what is in context now: a compaction or a move to another branch drops texts, so it rebuilds. */
+    sync(items) {
+        const current = new Set(items.map(item => item.key));
+        for (const key of this.keys)
+            if (!current.has(key)) {
+                this.clear();
+                break;
+            }
+        for (const item of items) {
+            if (this.keys.has(item.key))
+                continue;
+            this.keys.add(item.key);
+            for (const text of item.texts)
+                this.add(text, item.where);
+        }
+    }
+    add(text, where) {
+        const lines = text.split("\n");
+        if (lines.length < RUN_MIN_LINES)
+            return;
+        const ids = lines.map(line => {
+            const normalized = line.trimEnd();
+            let id = this.lineIds.get(normalized);
+            if (id === undefined) {
+                id = this.lineIds.size + 1;
+                this.lineIds.set(normalized, id);
+            }
+            return id;
+        });
+        const doc = this.docs.push({ where, ids }) - 1;
+        windowHashes(ids).forEach((hash, line) => {
+            const positions = this.windows.get(hash);
+            if (!positions)
+                this.windows.set(hash, [[doc, line]]);
+            else if (positions.length < MAX_POSITIONS)
+                positions.push([doc, line]);
+        });
+    }
+    /** Runs of `text` that repeat one earlier text exactly, longest match first at each position, outside the kept tail. */
+    find(text) {
+        const lines = text.split("\n");
+        const cutoff = text.length - TAIL_KEEP_CHARS;
+        let limit = 0;
+        for (let offset = 0; limit < lines.length; limit++) {
+            const end = offset + lines[limit].length + 1;
+            if (end > cutoff)
+                break;
+            offset = end;
+        }
+        if (limit < RUN_MIN_LINES)
+            return [];
+        const ids = lines.slice(0, limit).map(line => this.lineIds.get(line.trimEnd()) ?? 0);
+        const hashes = windowHashes(ids);
+        const runs = [];
+        let index = 0;
+        while (index + RUN_MIN_LINES <= limit) {
+            let best;
+            for (const [doc, line] of this.windows.get(hashes[index]) ?? []) {
+                const seen = this.docs[doc].ids;
+                let length = 0;
+                while (index + length < limit && line + length < seen.length && ids[index + length] !== 0 && ids[index + length] === seen[line + length])
+                    length++;
+                if (length >= RUN_MIN_LINES && (!best || length > best.length))
+                    best = { doc, length };
+            }
+            if (best) {
+                let chars = 0;
+                for (let line = index; line < index + best.length; line++)
+                    chars += lines[line].length + 1;
+                if (chars >= RUN_MIN_CHARS) {
+                    runs.push({ start: index, lines: best.length, chars, where: this.docs[best.doc].where });
+                    index += best.length;
+                    continue;
+                }
+            }
+            index++;
+        }
+        return runs;
+    }
+}
+/** Replaces each run with one pointer line; `path` holds the full original text. */
+export function collapseRuns(text, runs, path) {
+    if (!runs.length)
+        return text;
+    const lines = text.split("\n");
+    const kept = [];
+    let index = 0;
+    for (const run of runs) {
+        kept.push(...lines.slice(index, run.start), `[pi-warden: the next ${run.lines} lines repeat ${run.where} — omitted; full text: ${path}]`);
+        index = run.start + run.lines;
+    }
+    kept.push(...lines.slice(index));
+    return kept.join("\n");
+}
+function textsOf(content) {
+    if (typeof content === "string")
+        return [content];
+    if (!Array.isArray(content))
+        return [];
+    return content.filter(part => part?.type === "text" && typeof part.text === "string").map(part => part.text);
+}
+/** The texts a session entry puts in context and where the agent saw them. Thinking, images, and summaries are not indexed. */
+export function seenItem(entry) {
+    if (!entry || typeof entry !== "object")
+        return undefined;
+    const record = entry;
+    const key = typeof record.id === "string" ? record.id : entry;
+    if (record.type === "custom_message")
+        return { key, where: `an earlier ${String(record.customType ?? "custom")} message`, texts: textsOf(record.content) };
+    if (record.type !== "message" || !record.message)
+        return undefined;
+    const { role } = record.message;
+    const where = role === "toolResult" ? `an earlier ${String(record.message.toolName ?? "tool")} result`
+        : role === "user" ? "an earlier user message"
+            : role === "assistant" ? "an earlier assistant reply"
+                : role === "custom" ? `an earlier ${String(record.message.customType ?? "custom")} message`
+                    : undefined;
+    return where ? { key, where, texts: textsOf(record.message.content) } : undefined;
+}

package/dist/evidence.d.ts

@@ -0,0 +1,93 @@
+import type { Attempt } from "./stuck.js";
+/** Byte cap for the whole `evidence` object; over it, the oldest runs go first, then the oldest edits. */
+export declare const EVIDENCE_LIMIT = 4096;
+/** A failed or check output parsed into failing tests, error lines, a location, a summary and an exit code. */
+export type ParsedFailure = {
+    format: string;
+    failing: string[];
+    failing_more?: number;
+    errors: string[];
+    location?: string;
+    summary?: string;
+    exit?: number;
+};
+/** Parses a failed or check output into failing tests, error lines, a location, a summary and an exit code. */
+export declare function parseFailure(text: string): ParsedFailure;
+/**
+ * Normalises what changes between identical runs: durations, clock times and dates, addresses, long numbers, thread
+ * ids, temp paths, and line:column positions. Other digits stay, so "expected 3" and "expected 4" still differ.
+ */
+export declare function normaliseFailureText(value: string | undefined): string;
+/**
+ * Order-free signature of a failure: which tests failed and with which errors, both normalised. Pass counts are left
+ * out, so a run narrowed by a flag (`-x`, a test filter) still matches the full run that failed the same way.
+ */
+export declare function failureSignature(parsed: ParsedFailure, raw?: string): string;
+/** The edit pairs of an `edit` input, as `[oldText, newText]`: the `edits` array, or one top-level pair. */
+export declare function editPairs(input: Record<string, unknown>): Array<[string, string]>;
+/** Removed and added lines of one edit, as a multiset difference, so unchanged context lines drop out. */
+export declare function lineDelta(oldText: string, newText: string): {
+    removed: string[];
+    added: string[];
+};
+/** What an `edit` or `write` changed: the path, the line counts, and a diff capped at `DIFF_CAP` characters. */
+export type EditDiff = {
+    path: string;
+    added: number;
+    removed: number;
+    removedLines: string[];
+    addedLines: string[];
+    diff: string;
+};
+/**
+ * The change an `edit` or `write` made. Every string is as the agent wrote it: the caller redacts what leaves the
+ * machine. The diff is the whole added and removed text, not a line-by-line patch, because the judge compares one
+ * change against the next.
+ */
+export declare function editDiff(tool: string, input: Record<string, unknown>): EditDiff;
+/** One run in the evidence: a failed call, or a call that ran a test, build or lint command and passed. */
+export type EvidenceRun = {
+    n: number;
+    outcome: "failed" | "ok";
+    parser?: string;
+    failing_tests?: string[];
+    failing_tests_more?: number;
+    errors?: string[];
+    location?: string;
+    summary?: string;
+    output_tail?: string;
+    output_head_tail?: string;
+    /** The run number of the earlier run whose failure matches, after normalising times, temp paths and line numbers. */
+    same_failure_as_run?: number | null;
+    exit_code?: number;
+};
+/** One `edit`/`write` call in the evidence. */
+export type EvidenceEdit = {
+    n: number;
+    path: string;
+    added_lines: number;
+    removed_lines: number;
+    diff: string;
+};
+/** The counts a judge can weigh without reading every run. */
+export type EvidenceDigest = {
+    failed_runs: number;
+    distinct_failures: number;
+    /** Runs whose command repeats an earlier run's command, whatever the outcome. */
+    same_command_runs: number[];
+    latest_failure_seen_before: boolean;
+    edits_between_failed_runs: number;
+    information_calls_between_failed_runs: number;
+};
+export type StuckEvidence = {
+    runs: EvidenceRun[];
+    edits: EvidenceEdit[];
+    digest: EvidenceDigest;
+};
+/**
+ * Builds the evidence for one stuck window: a run per failed call and per passing check command, an edit per
+ * `edit`/`write`, and a digest. The oldest runs are dropped first when the whole object is over `EVIDENCE_LIMIT`
+ * bytes, then the oldest edits; the digest is then recomputed over what is left, and a run that pointed at a dropped
+ * run points at nothing. The floor is one run plus the digest, which is far under the cap.
+ */
+export declare function buildStuckEvidence(attempts: readonly Attempt[], limit?: number): StuckEvidence;