pi-warden 0.34.1 → 0.35.0

package/CHANGELOG.md

@@ -6,7 +6,10 @@ How to keep this current: add the entry in the same pull request as the change,
 
 ## Unreleased
 
-<!-- Empty. Next release starts here. -->
+## 0.35.0
+
+### Added
+- Stuck-loop diff: when the stuck detector marks a repeated failed attempt, the agent sees a short unified line diff against the previous output instead of the full repeated output again. Byte-identical outputs get a one-line note. The diff note never grows the result. Config keys `stuck.diffLimit` (3000) and `stuck.tailLimit` (1000) control the diff and tail caps.
 
 ## 0.34.1
 

package/dist/config.d.ts

@@ -127,6 +127,10 @@ export interface StuckGuardConfig {
     churnThreshold: number;
     /** Also steer the agent with a short message, not only the user. */
     nudge: 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. */
+    tailLimit: number;
 }
 export interface DoneGuardConfig {
     enabled: boolean;

package/dist/config.js

@@ -39,7 +39,7 @@ export function defaultConfig() {
             escalationThreshold: 0.85,
             floor: "evidence",
         },
-        stuck: { enabled: true, window: 12, minFailures: 3, cooldown: 3, sameStrategy: 0.7, churnThreshold: 5, nudge: true },
+        stuck: { enabled: true, window: 12, minFailures: 3, cooldown: 3, sameStrategy: 0.7, churnThreshold: 5, nudge: true, diffLimit: 3000, tailLimit: 1000 },
         done: { enabled: true, claimsDone: 0.7, nudge: true },
         slop: { enabled: true, threshold: 0.7, prose: { enabled: true, audience: "technical", threshold: 0.7, trend: 2, minChars: 200 } },
         security: { enabled: true, threshold: 0.7 },
@@ -284,6 +284,8 @@ function applyStuck(base, raw) {
         sameStrategy: probability(raw.sameStrategy, base.sameStrategy),
         churnThreshold: Math.min(window, positiveInteger(raw.churnThreshold, base.churnThreshold)),
         nudge: boolean(raw.nudge, base.nudge),
+        diffLimit: positiveInteger(raw.diffLimit, base.diffLimit),
+        tailLimit: positiveInteger(raw.tailLimit, base.tailLimit),
     };
 }
 function applyRunaway(base, raw) {

package/dist/extension.js

@@ -25,7 +25,7 @@ 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, resultFailed, stuckNudge } from "./stuck.js";
+import { AttemptWindow, evaluateStuck, formatStuck, makeAttempt, resultFailed, stuckDiff, stuckNudge } from "./stuck.js";
 import { openConfigPanel, openTracePanel } from "./panel.js";
 import { completeConfig, shapeWarning } from "./shape.js";
 import { ContextLedger, formatLedger } from "./saver.js";
@@ -250,6 +250,8 @@ export default function wardenExtension(pi) {
     // 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);
+    /** Full output text and saved path keyed by attempt call key, for stuck-loop diffs. */
+    let fullOutputs = new Map();
     let evidence = emptyEvidence();
     let doneNudged = false;
     let warnedFallback = false;
@@ -595,6 +597,7 @@ export default function wardenExtension(pi) {
             lastUi = ctx.ui;
         const config = configFor(ctx);
         attempts = new AttemptWindow(config.stuck.window);
+        fullOutputs = new Map();
         doneNudged = false;
         steersThisRun = 0;
         finals.reset();
@@ -1129,11 +1132,53 @@ export default function wardenExtension(pi) {
                 `output sample: ${redact(text).slice(0, 300)}`, delivered ? `agent told: ${notice}` : `steer recorded, not delivered (a repeat or the per-run budget): ${notice}`,
             ]);
         }
+        // Stuck-loop diff: when the verdict is stuck on a failed result and a previous failed output
+        // for the same call is available, replace the tool result with a short diff note. Compute
+        // bytesSaved against the current content (after duplicate detection and compression), so the
+        // diff never grows the result.
+        const verdict = await stuckCheck;
+        if (verdict && verdict.stuck && failed && !verdict.successRepeat && !verdict.churn && text.length > 0) {
+            const currentKey = attempts.attempts.at(-1)?.key;
+            const prevEntry = currentKey ? fullOutputs.get(currentKey) : undefined;
+            if (currentKey && prevEntry && prevEntry.text !== text) {
+                // Differing outputs: save the current output and diff against the previous one.
+                try {
+                    const saved = await saveOutput(text);
+                    const diffNote = stuckDiff(prevEntry.text, text, { diffLimit: config.stuck.diffLimit, tailLimit: config.stuck.tailLimit, fullPath: saved });
+                    const currentLen = Buffer.byteLength(content.map(part => part.type === "text" ? part.text : "").join("\n"));
+                    if (Buffer.byteLength(diffNote) < currentLen) {
+                        content = [{ type: "text", text: diffNote }, ...content.filter(part => part.type !== "text")];
+                    }
+                    fullOutputs.set(currentKey, { text, path: saved });
+                }
+                catch {
+                    noteError(ctx, "Could not store full output for stuck diff; keeping it unchanged.", undefined);
+                    fullOutputs.set(currentKey, { text });
+                }
+            }
+            else if (currentKey && prevEntry && prevEntry.text === text && prevEntry.path) {
+                // Byte-identical outputs: one-line note reusing the existing saved path.
+                const diffNote = stuckDiff(text, text, { diffLimit: config.stuck.diffLimit, tailLimit: config.stuck.tailLimit, fullPath: prevEntry.path });
+                const currentLen = Buffer.byteLength(content.map(part => part.type === "text" ? part.text : "").join("\n"));
+                if (Buffer.byteLength(diffNote) < currentLen) {
+                    content = [{ type: "text", text: diffNote }, ...content.filter(part => part.type !== "text")];
+                }
+            }
+            else if (currentKey) {
+                // First failed output for this call, or no previous entry yet: store for future diffs.
+                fullOutputs.set(currentKey, { text });
+            }
+        }
+        else if (failed && text.length > 0) {
+            // Not stuck (or no verdict yet): store the output so a future repeat can diff against it.
+            const currentKey = attempts.attempts.at(-1)?.key;
+            if (currentKey)
+                fullOutputs.set(currentKey, { text });
+        }
         const patch = content === event.content ? undefined : { content };
         // 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);
-        const verdict = await stuckCheck;
         if (!verdict)
             return patch;
         if (verdict.error)
@@ -1146,7 +1191,7 @@ export default function wardenExtension(pi) {
             return patch;
         stats.stuck++;
         if (ctx.hasUI && config.notices)
-            ctx.ui.notify(`warden · stuck: ${verdict.reasons.join("; ")}${nudge ? " (agent nudged)" : ""}`, "warning");
+            ctx.ui.notify(`warden \u00b7 stuck: ${verdict.reasons.join("; ")}${nudge ? " (agent nudged)" : ""}`, "warning");
         if (nudge)
             steer(config, "stuck", nudge);
         return patch;

package/dist/shape.js

@@ -31,7 +31,7 @@ export function completeConfig(loaded) {
         notices: source.notices ?? false,
         steerBudget: typeof source.steerBudget === "number" && source.steerBudget >= 0 ? source.steerBudget : 3,
         action: section("action", { ...off, tools: [], failOpen: true, timeoutMs: 5000, irreversible: { warn: 1, confirm: 1 }, offTask: { warn: 1, steer: 1 }, intentMismatch: 1, visibleMismatch: 1, shouldProceed: { hold: 0.6, steer: false }, feedbackLog: false, commandRules: [], commandDenyRules: [], exemptRules: [], pathRules: [], armingRules: [], escalationThreshold: 0.85, floor: "evidence" }),
-        stuck: section("stuck", { ...off, window: 12, minFailures: 3, cooldown: 3, sameStrategy: 1, churnThreshold: 5, nudge: false }),
+        stuck: section("stuck", { ...off, window: 12, minFailures: 3, cooldown: 3, sameStrategy: 1, churnThreshold: 5, nudge: false, diffLimit: 3000, tailLimit: 1000 }),
         done: section("done", { ...off, claimsDone: 1, nudge: false }),
         slop: section("slop", { ...off, threshold: 1, prose: proseOff() }),
         security: section("security", { ...off, threshold: 1 }),

package/dist/stuck.d.ts

@@ -102,4 +102,13 @@ export declare function evaluateStuck(window: AttemptWindow, task: string | unde
 /** Steering text for the agent. Names the pattern and asks for a change of method, not another retry. A successful
  * repeat is a different disease than a failure loop: the model already has the answer, so it should use it. */
 export declare function stuckNudge(verdict: StuckVerdict): string;
+/**
+ * Short note for a stuck-loop repeated failure: header, capped unified diff against the previous output,
+ * tail of the current output, and the path of the full copy. All inputs must be pre-redacted.
+ */
+export declare function stuckDiff(previous: string, current: string, options: {
+    diffLimit: number;
+    tailLimit: number;
+    fullPath: string;
+}): string;
 export declare function formatStuck(verdict: StuckVerdict, template?: string): string;

package/dist/stuck.js

@@ -177,6 +177,107 @@ export function stuckNudge(verdict) {
     }
     return `pi-warden: ${verdict.reasons.join("; ")}. Stop retrying. Re-read the last error output carefully, state a new hypothesis about the cause, and either gather the missing information (read the relevant file, check versions or paths) or try a different method. If two different methods have failed, report the blocker to the user with the exact error instead of trying again.`;
 }
+/** LCS-based line diff between two outputs, capped at diffLimit characters. Both inputs must be pre-redacted. */
+function lineDiff(previous, current, diffLimit) {
+    const prevLines = previous.split("\n");
+    const currLines = current.split("\n");
+    const m = prevLines.length;
+    const n = currLines.length;
+    // Longest common subsequence.
+    const dp = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0));
+    for (let i = 1; i <= m; i++) {
+        for (let j = 1; j <= n; j++) {
+            dp[i][j] = prevLines[i - 1] === currLines[j - 1] ? dp[i - 1][j - 1] + 1 : Math.max(dp[i - 1][j], dp[i][j - 1]);
+        }
+    }
+    // Backtrack to build unified diff.
+    let i = m;
+    let j = n;
+    const ops = [];
+    while (i > 0 || j > 0) {
+        if (i > 0 && j > 0 && prevLines[i - 1] === currLines[j - 1]) {
+            ops.push([" ", prevLines[i - 1]]);
+            i--;
+            j--;
+        }
+        else if (j > 0 && (i === 0 || dp[i][j - 1] >= dp[i - 1][j])) {
+            ops.push(["+", currLines[j - 1]]);
+            j--;
+        }
+        else {
+            ops.push(["-", prevLines[i - 1]]);
+            i--;
+        }
+    }
+    ops.reverse();
+    // Identify indices of changed ops (+ or -).
+    const changedIndices = [];
+    for (let k = 0; k < ops.length; k++) {
+        if (ops[k][0] !== " ")
+            changedIndices.push(k);
+    }
+    if (changedIndices.length === 0)
+        return "";
+    // Merge nearby changes: expand each changed index by 3 lines of context on each side,
+    // then merge overlapping ranges.
+    const CONTEXT = 3;
+    const ranges = [];
+    for (const idx of changedIndices) {
+        const start = Math.max(0, idx - CONTEXT);
+        const end = Math.min(ops.length - 1, idx + CONTEXT);
+        if (ranges.length > 0 && start <= ranges[ranges.length - 1][1] + 1) {
+            ranges[ranges.length - 1][1] = end;
+        }
+        else {
+            ranges.push([start, end]);
+        }
+    }
+    // Emit hunks.
+    const hunks = [];
+    for (const [rangeStart, rangeEnd] of ranges) {
+        let prevPos = 0;
+        for (let k = 0; k < rangeStart; k++) {
+            const op = ops[k][0];
+            if (op === " " || op === "-")
+                prevPos++;
+        }
+        // Count lines in the range for each file.
+        let prevCount = 0;
+        let currCount = 0;
+        const lines = [];
+        for (let k = rangeStart; k <= rangeEnd; k++) {
+            const [op, line] = ops[k];
+            lines.push(`${op} ${line}`);
+            if (op === " ") {
+                prevCount++;
+                currCount++;
+            }
+            else if (op === "-") {
+                prevCount++;
+            }
+            else {
+                currCount++;
+            }
+        }
+        hunks.push(`@@ -${prevPos + 1},${prevCount} +${prevPos + 1},${currCount} @@`);
+        hunks.push(...lines);
+    }
+    const text = hunks.join("\n");
+    return text.length <= diffLimit ? text : `${text.slice(0, diffLimit)}\n… [diff truncated]`;
+}
+/**
+ * Short note for a stuck-loop repeated failure: header, capped unified diff against the previous output,
+ * tail of the current output, and the path of the full copy. All inputs must be pre-redacted.
+ */
+export function stuckDiff(previous, current, options) {
+    const header = `pi-warden: stuck-loop diff; this output repeated a failure (previous: ${previous.length} chars, current: ${current.length} chars).`;
+    if (previous === current) {
+        return `${header}\nOutputs are byte-identical; see the full output at ${options.fullPath}.`;
+    }
+    const diff = lineDiff(previous, current, options.diffLimit);
+    const tail = current.length <= options.tailLimit ? current : `… [${current.length - options.tailLimit} earlier chars omitted]\n${current.slice(-options.tailLimit)}`;
+    return `${header}\n${diff}\n${tail}\n\nFull output: ${options.fullPath}`;
+}
 export function formatStuck(verdict, template = DEFAULT_TEMPLATES.stuck) {
     return renderTemplate(template, stuckTokens(verdict));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-warden",
-  "version": "0.34.1",
+  "version": "0.35.0",
   "description": "Makes the Pi agent follow your project's rules. Jev judges every write against your pi-warden.md and quotes the broken rule back to the agent, names slop, breaks stuck loops, calls out unverified done claims, compresses large tool output, and holds the rare destructive command. Built on pi-typesafe.",
   "type": "module",
   "license": "MIT",