pi-warden 0.26.0 → 0.28.4

package/dist/panel.js

@@ -1,4 +1,5 @@
 import { Key, matchesKey, truncateToWidth, wrapTextWithAnsi } from "@earendil-works/pi-tui";
+import { applyUserOverrides, defaultConfig, readUserConfig, writeUserConfig } from "./config.js";
 import { LEVEL_COLOR, parseVerdictLine, renderSegment } from "./widget.js";
 /**
  * Sidebar listing the trace newest-first, live-updating while open. It opens without taking keyboard input: the editor
@@ -16,6 +17,8 @@ export class TracePanel {
     focused = false;
     scroll = 0;
     viewport = 20;
+    /** Compact mode: show 1-3 lines per entry. Toggle with `d` while focused. */
+    compact = true;
     unsubscribe;
     constructor(trace, theme, actions, requestRender, title = "pi-warden trace") {
         this.trace = trace;
@@ -31,10 +34,13 @@ export class TracePanel {
     /** Rendering is cheap and derived from the trace each time; nothing is cached. */
     invalidate() { }
     lines(width) {
-        const { theme } = this;
+        const { theme, compact } = this;
         const entries = this.trace.entries();
         const out = [];
-        const keys = this.focused ? "↑↓ PgUp PgDn scroll · c clear · esc back to editor · q close" : "click for keys · wheel scrolls · /warden trace closes";
+        const modeLabel = compact ? "compact" : "detailed";
+        const keys = this.focused
+            ? `↑↓ PgUp PgDn scroll · d ${modeLabel} · c clear · esc back · q close`
+            : `click for keys · wheel scrolls · /warden trace closes`;
         out.push(theme.bold(theme.fg("accent", `${this.title}`)) + theme.fg("muted", ` · ${entries.length} event${entries.length === 1 ? "" : "s"}`));
         out.push(theme.fg("muted", keys));
         out.push(theme.fg("borderMuted", "─".repeat(Math.max(0, width))));
@@ -43,8 +49,6 @@ export class TracePanel {
                 out.push(line);
             return out.map(line => truncateToWidth(line, width, ""));
         }
-        // Left rail: time and guard label. The verdict leads the right column as a bold chip, so a scan down the pane reads
-        // the decisions first and the evidence after.
         const RAIL = 16;
         for (let index = entries.length - 1; index >= 0; index--) {
             const entry = entries[index];
@@ -56,12 +60,20 @@ export class TracePanel {
             const rendered = body.map((segment, n) => renderSegment(segment, n === 0, theme)).join(theme.fg("dim", " · "));
             const wrapped = wrapTextWithAnsi(rendered, Math.max(10, width - indent));
             out.push(head + chip + (wrapped[0] ?? ""));
-            for (const continuation of wrapped.slice(1))
-                out.push(" ".repeat(indent) + continuation);
-            for (const detail of entry.details) {
-                const detailLines = wrapTextWithAnsi(detail, Math.max(10, width - RAIL - 2));
-                for (const [n, line] of detailLines.entries())
-                    out.push(" ".repeat(RAIL) + theme.fg("muted", n === 0 ? "· " : "  ") + theme.fg("dim", line));
+            if (!compact) {
+                for (const continuation of wrapped.slice(1))
+                    out.push(" ".repeat(indent) + continuation);
+                for (const detail of entry.details) {
+                    const detailLines = wrapTextWithAnsi(detail, Math.max(10, width - RAIL - 2));
+                    for (const [n, line] of detailLines.entries())
+                        out.push(" ".repeat(RAIL) + theme.fg("muted", n === 0 ? "· " : "  ") + theme.fg("dim", line));
+                }
+            }
+            else if (entry.details.length > 0) {
+                // Compact: show only the first detail line, truncated
+                const firstDetail = entry.details[0];
+                const truncated = firstDetail.length > width - indent - 4 ? firstDetail.slice(0, width - indent - 4) + "…" : firstDetail;
+                out.push(" ".repeat(indent) + theme.fg("dim", truncated));
             }
             out.push("");
         }
@@ -101,6 +113,11 @@ export class TracePanel {
             this.requestRender();
             return;
         }
+        if (data === "d") {
+            this.compact = !this.compact;
+            this.requestRender();
+            return;
+        }
         if (matchesKey(data, Key.up) || data === "k")
             this.scroll = Math.max(0, this.scroll - 1);
         else if (matchesKey(data, Key.down) || data === "j")
@@ -153,3 +170,233 @@ export function openTracePanel(ui, trace, options = {}) {
     });
     return { closed, close: () => close() };
 }
+function flattenConfig(obj, prefix = "") {
+    const entries = [];
+    const skip = new Set(["action", "stuck", "done", "slop", "security", "rules", "context", "runaway", "notify", "subagent"]);
+    for (const [key, value] of Object.entries(obj)) {
+        if (skip.has(key) && !prefix)
+            continue;
+        const path = prefix ? `${prefix}.${key}` : key;
+        if (typeof value === "boolean" || typeof value === "number" || typeof value === "string") {
+            entries.push({ path, label: key, level: prefix ? prefix.split(".").length : 0, value, type: typeof value, editable: true });
+        }
+        else if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+            entries.push({ path, label: key, level: prefix ? prefix.split(".").length : 0, value: "", type: "string", editable: false });
+            entries.push(...flattenConfig(value, path));
+        }
+    }
+    return entries;
+}
+export class ConfigPanel {
+    config;
+    theme;
+    actions;
+    requestRender;
+    focused = false;
+    cursor = 0;
+    scroll = 0;
+    viewport = 20;
+    editing = false;
+    editBuffer = "";
+    edits = new Map();
+    entries;
+    constructor(config, theme, actions, requestRender) {
+        this.config = config;
+        this.theme = theme;
+        this.actions = actions;
+        this.requestRender = requestRender;
+        this.entries = flattenConfig(config);
+    }
+    invalidate() { }
+    lines(width) {
+        const { theme, entries, cursor, scroll, editing, editBuffer, edits } = this;
+        const out = [];
+        const modeLabel = editing ? "editing" : "browsing";
+        const keys = this.focused
+            ? `↑↓ navigate · enter toggle/edit · esc ${editing ? "cancel" : "back"} · s save · ${modeLabel}`
+            : `click for keys · /warden config closes`;
+        out.push(theme.bold(theme.fg("accent", "pi-warden config")) + theme.fg("muted", ` · ${entries.length} keys`));
+        out.push(theme.fg("muted", keys));
+        out.push(theme.fg("borderMuted", "─".repeat(Math.max(0, width))));
+        for (let index = 0; index < entries.length; index++) {
+            const entry = entries[index];
+            const isSelected = index === cursor;
+            const indent = "  ".repeat(entry.level);
+            const changed = edits.has(entry.path);
+            const label = entry.label + (entry.editable ? "" : "/");
+            if (!entry.editable) {
+                out.push(indent + theme.fg("accent", theme.bold(label)));
+                continue;
+            }
+            let valueStr;
+            if (isSelected && editing && entry.type !== "boolean") {
+                valueStr = editBuffer + "\u2588";
+            }
+            else if (entry.type === "boolean") {
+                valueStr = entry.value ? "●" : "○";
+            }
+            else if (entry.type === "number") {
+                valueStr = String(entry.value);
+            }
+            else {
+                valueStr = typeof entry.value === "string" && entry.value.length > 40 ? entry.value.slice(0, 37) + "…" : String(entry.value);
+            }
+            const changedMark = changed ? theme.fg("warning", " *") : "";
+            const line = `${indent}${isSelected ? "> " : "  "}${theme.fg("muted", label)} ${theme.fg("text", valueStr)}${changedMark}`;
+            if (isSelected) {
+                out.push(theme.bold(line));
+            }
+            else {
+                out.push(line);
+            }
+        }
+        return out.map(line => truncateToWidth(line, width, ""));
+    }
+    render(width) {
+        const border = theme_fg(this.theme, "muted", "│ ");
+        const inner = Math.max(10, width - 2);
+        const all = this.lines(inner);
+        const maxScroll = Math.max(0, all.length - this.viewport);
+        if (this.scroll > maxScroll)
+            this.scroll = maxScroll;
+        const visible = all.slice(this.scroll, this.scroll + this.viewport);
+        if (all.length > this.viewport) {
+            const last = visible.length - 1;
+            const below = all.length - this.scroll - this.viewport;
+            const above = this.scroll;
+            const label = below > 0 ? `… ${below} more below${above ? ` · ${above} above` : ""}` : `… end${above ? ` · ${above} above` : ""}`;
+            visible[last] = truncateToWidth(theme_fg(this.theme, "dim", label), inner, "");
+        }
+        while (visible.length < this.viewport)
+            visible.push("");
+        return visible.map(line => border + line);
+    }
+    setViewport(rows) { this.viewport = Math.max(5, rows); }
+    handleInput(data) {
+        const { entries, editing } = this;
+        if (data === "q" || matchesKey(data, Key.ctrl("c"))) {
+            this.actions.close();
+            return;
+        }
+        if (matchesKey(data, Key.escape)) {
+            if (editing) {
+                this.editing = false;
+                this.requestRender();
+                return;
+            }
+            this.actions.unfocus();
+            this.requestRender();
+            return;
+        }
+        if (editing) {
+            const entry = entries[this.cursor];
+            if (matchesKey(data, Key.return)) {
+                this.edits.set(entry.path, this.parseValue(this.editBuffer, entry.type));
+                (entries[this.cursor]).value = this.parseValue(this.editBuffer, entry.type);
+                this.editing = false;
+                this.requestRender();
+                return;
+            }
+            if (matchesKey(data, Key.backspace)) {
+                this.editBuffer = this.editBuffer.slice(0, -1);
+                this.requestRender();
+                return;
+            }
+            if (data.length === 1 && data >= " ") {
+                this.editBuffer += data;
+                this.requestRender();
+                return;
+            }
+            return;
+        }
+        if (matchesKey(data, Key.up) || data === "k")
+            this.cursor = Math.max(0, this.cursor - 1);
+        else if (matchesKey(data, Key.down) || data === "j")
+            this.cursor = Math.min(entries.length - 1, this.cursor + 1);
+        else if (matchesKey(data, Key.pageUp))
+            this.cursor = Math.max(0, this.cursor - this.viewport);
+        else if (matchesKey(data, Key.pageDown))
+            this.cursor = Math.min(entries.length - 1, this.cursor + this.viewport);
+        else if (matchesKey(data, Key.home))
+            this.cursor = 0;
+        else if (matchesKey(data, Key.end))
+            this.cursor = entries.length - 1;
+        else if (data === "enter" || matchesKey(data, Key.return)) {
+            const entry = entries[this.cursor];
+            if (entry.type === "boolean") {
+                this.edits.set(entry.path, !entry.value);
+                entry.value = !entry.value;
+            }
+            else {
+                this.editing = true;
+                this.editBuffer = String(entry.value);
+            }
+        }
+        else if (data === "s") {
+            this.save();
+            return;
+        }
+        else
+            return;
+        // Keep cursor visible
+        if (this.cursor < this.scroll)
+            this.scroll = this.cursor;
+        else if (this.cursor >= this.scroll + this.viewport)
+            this.scroll = this.cursor - this.viewport + 1;
+        this.requestRender();
+    }
+    handleMouse(event) {
+        if (event.type === "wheel") {
+            this.scroll = Math.max(0, this.scroll + (event.wheelDelta ?? 0) * 3);
+            return { handled: true, render: true };
+        }
+        if (event.type === "press" && event.button === "left")
+            return { handled: true, focus: true, render: true };
+        return undefined;
+    }
+    parseValue(raw, type) {
+        if (type === "boolean")
+            return raw === "true" || raw === "1";
+        if (type === "number") {
+            const n = Number(raw);
+            return Number.isFinite(n) ? n : raw;
+        }
+        return raw;
+    }
+    save() {
+        if (this.edits.size === 0)
+            return;
+        const raw = readUserConfig();
+        const obj = (typeof raw === "object" && raw !== null && !Array.isArray(raw)) ? raw : {};
+        for (const [path, value] of this.edits) {
+            const keys = path.split(".");
+            let current = obj;
+            for (let i = 0; i < keys.length - 1; i++) {
+                const k = keys[i];
+                if (typeof current[k] !== "object" || current[k] === null)
+                    current[k] = {};
+                current = current[k];
+            }
+            current[keys.at(-1)] = value;
+        }
+        writeUserConfig(obj);
+        this.edits.clear();
+    }
+}
+export function openConfigPanel(ui, config, options = {}) {
+    let close = () => { };
+    let unfocus = () => { };
+    const closed = ui.custom((tui, theme, _keybindings, done) => {
+        close = () => done();
+        const panel = new ConfigPanel(config, theme, { close, unfocus: () => unfocus() }, () => tui.requestRender());
+        const rows = tui.terminal?.rows;
+        if (typeof rows === "number")
+            panel.setViewport(rows - 2);
+        return panel;
+    }, {
+        overlay: true,
+        overlayOptions: { anchor: "right-center", width: options.width ?? "40%", minWidth: 44, maxHeight: "100%", nonCapturing: true },
+        onHandle: (handle) => { unfocus = () => handle.unfocus(); },
+    });
+    return { closed, close: () => close() };
+}

package/dist/saver.d.ts

@@ -48,6 +48,8 @@ export declare class ContextLedger {
     /** Counts the first access to a compressed output; later accesses and duplicate-only copies are not new recalls. */
     noteAccess(text: string, kind?: RecallKind): string | undefined;
     snapshot(): ContextLedgerSnapshot;
+    /** Paths to temp files for cleanup at session start. Internal only — paths never leave the machine. */
+    storedPaths(): string[];
     reset(): void;
 }
 /** One line for /warden status. Says when there is nothing to report instead of printing zeros. */

package/dist/saver.js

@@ -69,6 +69,10 @@ export class ContextLedger {
     snapshot() {
         return { large: this.large, compressed: this.compressed, duplicates: this.duplicates, bytesSaved: this.bytesSaved, turns: this.turns, tokenTurnsSaved: this.tokenTurnsSaved, recalls: this.recalls, recallsFull: this.recallsFull };
     }
+    /** Paths to temp files for cleanup at session start. Internal only — paths never leave the machine. */
+    storedPaths() {
+        return [...this.stored.keys()];
+    }
     reset() {
         this.large = 0;
         this.compressed = 0;

package/dist/shape.js

@@ -40,7 +40,8 @@ export function completeConfig(loaded) {
         runaway: section("runaway", { ...off, repeats: Number.MAX_SAFE_INTEGER, thinkingRepeats: Number.MAX_SAFE_INTEGER, minChars: Number.MAX_SAFE_INTEGER, recover: false }),
         notify: section("notify", { ...off, cooldownMs: 0, command: [] }),
         subagent: section("subagent", { ...off, wake: false, threshold: 1, cooldownMs: 0 }),
-        widget: section("widget", { ...off, placement: "aboveEditor", shortcut: "", panelWidth: "40%", action: "", stuck: "", done: "", prose: "", security: "", context: "", runaway: "", rules: "", subagent: "" }),
+        widget: section("widget", { ...off, placement: "aboveEditor", barMode: "live", shortcut: "", panelWidth: "40%", action: "", stuck: "", done: "", prose: "", security: "", context: "", runaway: "", rules: "", subagent: "" }),
+        learning: section("learning", { adaptiveThresholds: true, patternAnalysis: true, minHoldsForAdaptive: 20, adaptationRate: 0.1, retentionDays: 365 }),
     };
     if (typeof config.slop.prose !== "object" || config.slop.prose === null) {
         missing.push("slop.prose");

package/dist/trace.d.ts

@@ -12,6 +12,8 @@ export interface TraceEntry {
     line: string;
     /** Redacted details: what was inspected, what Jev answered, what the agent was told. */
     details: string[];
+    /** Raw tokens for re-rendering in live mode with sentence templates. */
+    tokens?: Record<string, string | undefined> | undefined;
 }
 /** Session memory of guard decisions; the widget shows the latest line per guard, the panel shows the history. */
 export declare class Trace {

package/dist/widget.d.ts

@@ -5,6 +5,7 @@ import type { RulesVerdict } from "./rules.js";
 import type { RunawayVerdict } from "./runaway.js";
 import type { StuckVerdict } from "./stuck.js";
 export type WidgetPlacement = "aboveEditor" | "belowEditor";
+export type WidgetBarMode = "stack" | "live";
 /** Palette shared by the status line and the trace sidebar: one place decides what a verdict looks like. */
 export interface ThemeLike {
     fg(color: string, text: string): string;
@@ -14,6 +15,7 @@ export declare const LEVEL_COLOR: Record<string, string>;
 export interface WidgetConfig {
     enabled: boolean;
     placement: WidgetPlacement;
+    barMode: WidgetBarMode;
     /** Keyboard shortcut that toggles the trace sidebar; empty string disables it. */
     shortcut: string;
     /** Sidebar width: a percentage string such as "40%" or a column count. */
@@ -40,6 +42,100 @@ export declare const DEFAULT_TEMPLATES: {
     readonly rules: "warden · rules · {tool} {path} · {asked} rules · {violations} · {status}";
     readonly subagent: "warden · subagent · {agent} · {kind} · {wake} · {status}";
 };
+/** Sentence-style templates: natural language, no " · " separators between semantic groups. */
+export declare const SENTENCE_TEMPLATES: {
+    readonly action: {
+        readonly allow_default: "warden allowed {tool} action — {scope}";
+        readonly allow_safe: "warden allowed {tool} action — low risk";
+        readonly allow_read_only: "warden allowed {tool} action — read-only operation";
+        readonly allow_with_context: "warden allowed {tool} action — {scope}, irreversibility {irreversible}";
+        readonly allow_off_task: "warden allowed {tool} action — off-task but below threshold ({offTask})";
+        readonly allow_intent_mismatch: "warden allowed {tool} action — plan mismatch ({intent}) but not blocking";
+        readonly allow_slop: "warden allowed {tool} action — slop detected ({slop})";
+        readonly allow_patterns: "warden allowed {tool} action — patterns matched ({patterns})";
+        readonly allow_approved: "warden allowed {tool} action — approved by user";
+        readonly allow_typesafe_error: "warden allowed {tool} action — TypeSafe unavailable, pattern checks only";
+        readonly warn_off_task: "warden warned about {tool} action — off-task risk ({offTask})";
+        readonly warn_irreversible: "warden warned about {tool} action — high irreversibility ({irreversible})";
+        readonly warn_intent: "warden warned about {tool} action — differs from stated plan";
+        readonly warn_slop: "warden warned about {tool} action — code slop detected ({slop})";
+        readonly warn_patterns: "warden warned about {tool} action — security patterns matched ({patterns})";
+        readonly warn_visible: "warden warned about {tool} action — visible outside working tree";
+        readonly hold_irreversible: "warden held {tool} action — irreversibility {irreversible} exceeds threshold";
+        readonly hold_dangerous: "warden held {tool} action — destructive pattern detected ({patterns})";
+        readonly hold_deny: "warden blocked {tool} action — deny rule matched ({patterns})";
+        readonly default: "warden {level}ed {tool} action";
+    };
+    readonly stuck: {
+        readonly stuck_repeat: "warden detected stuck loop — {failures} failures, same strategy ({sameStrategy})";
+        readonly stuck_churn: "warden detected stuck loop — {failures} failures, churning approaches";
+        readonly stuck_no_progress: "warden detected stuck loop — {failures} failures, no progress ({progress})";
+        readonly stuck_repeat_successful: "warden detected repeated success — {failures} identical results, consider if the task is done";
+        readonly stuck_typesafe_error: "warden stuck check unavailable — TypeSafe error";
+        readonly stuck_recovering: "warden detected stuck loop — {failures} failures, now recovering";
+        readonly ok: "warden checked stuck — no loop detected ({failures} failures, approach change {approachChange})";
+        readonly default: "warden {status} — {failures} failures";
+    };
+    readonly done: {
+        readonly unverified: "warden flagged done claim — {checksPassed}/{checks} checks passed, {changes} changes, not verified";
+        readonly false_claim: "warden flagged false done claim — {checksPassed}/{checks} checks failed";
+        readonly ok: "warden confirmed done — {checksPassed}/{checks} checks passed, {changes} changes";
+        readonly ok_all_passed: "warden confirmed done — all {checks} checks passed";
+        readonly partial: "warden flagged done — {checksPassed}/{checks} checks passed, needs attention";
+        readonly no_checks: "warden flagged done claim — no verification checks run";
+        readonly typesafe_error: "warden done check unavailable — TypeSafe error";
+        readonly unverified_nudged: "warden flagged done claim — agent asked to verify ({checksPassed}/{checks} passed)";
+        readonly false_claim_nudged: "warden flagged false claim — agent asked to recheck";
+        readonly default: "warden done check — {outcome}";
+    };
+    readonly prose: {
+        readonly nudged: "warden nudged prose — {status} in recent replies";
+        readonly wordy: "warden flagged prose — wordy ({wordy})";
+        readonly cliches: "warden flagged prose — clichés detected ({cliches})";
+        readonly jargon: "warden flagged prose — jargon detected ({jargon})";
+        readonly multiple: "warden flagged prose — {status}";
+        readonly ok: "warden checked prose — all clear";
+        readonly typesafe_error: "warden prose check unavailable — TypeSafe error";
+        readonly default: "warden prose — {status}";
+    };
+    readonly security: {
+        readonly injection: "warden flagged security — injection risk in {tool} output";
+        readonly exfiltration: "warden flagged security — possible credentials in {tool} output";
+        readonly both: "warden flagged security — injection and exfiltration risk in {tool} output";
+        readonly suspicious: "warden flagged security — suspicious content in {tool} output";
+        readonly ok: "warden checked {tool} output — no security issues";
+        readonly default: "warden security — {tool}";
+    };
+    readonly context: {
+        readonly compressed: "warden compressed {tool} output — kept {retention}, saved {bytesSaved} bytes";
+        readonly recalled: "warden recalled full {tool} output — agent needed the original";
+        readonly kept: "warden kept {tool} output — {retention}";
+        readonly large: "warden compressed {tool} output — {bytesSaved} bytes saved";
+        readonly default: "warden context — {tool}, {retention}";
+    };
+    readonly runaway: {
+        readonly stopped: "warden stopped runaway {kind} — repeated {count}× ({chars} chars)";
+        readonly stopped_recovering: "warden stopped runaway {kind} — repeated {count}×, agent recovering";
+        readonly detected: "warden detected runaway {kind} — {count}× repetition";
+        readonly default: "warden runaway — {kind}";
+    };
+    readonly rules: {
+        readonly violations: "warden flagged rules — {violations} in {tool} {path}";
+        readonly violation_single: "warden flagged rule — {violations}";
+        readonly none: "warden checked rules — no violations in {tool} {path}";
+        readonly skipped: "warden rules — skipped ({reasons})";
+        readonly typesafe_error: "warden rules check unavailable — TypeSafe error";
+        readonly default: "warden rules — {tool}";
+    };
+    readonly subagent: {
+        readonly wake: "warden woke for subagent report — {agent}, {kind}";
+        readonly silent: "warden ignored subagent report — {agent}, {kind}";
+        readonly appended: "warden appended subagent report — {agent}";
+        readonly default: "warden subagent — {agent}";
+    };
+};
+/** Pick the best sentence template for a verdict. Falls back to the data-style template. */
+export declare function pickSentenceTemplate(guard: string, tokens: Tokens): string;
 export declare function defaultWidgetConfig(): WidgetConfig;
 export type Tokens = Record<string, string | undefined>;
 /**