pi-warden 0.5.0 → 0.5.1

package/README.md

@@ -112,11 +112,15 @@ The action guard receives the latest user message plus up to eight previous user
 | `/warden mode steer\|confirm\|advise` | Choose how holds are handled; without an argument, show the current mode |
 | `/warden config` | Edit the user config JSON in Pi's editor and save it |
 | `/warden test` | Evaluate one synthetic destructive action and show the verdict and what the agent would be told |
-| `/warden trace` | Open the trace panel (or print the last 20 events without a UI) |
+| `/warden trace` | Toggle the trace sidebar (or print the last 20 events without a UI) |
 
-## Status line and trace panel
+## Status line and trace sidebar
 
-The line above the editor shows the latest verdict per guard, for example `warden · bash · irreversible 0.84 · off-task 0.86 · unrelated · confirm`. Every verdict is also kept in a session trace with what was inspected (redacted command or path), the pattern hits, Jev's scores with model and latency, the reasons, and the exact text the agent was told. Open the panel with `/warden trace`, `ctrl+shift+w`, or by clicking the status line (clicks need Pi's fullscreen mode: `tuiMode: "fullscreen"` in settings, because regular mode leaves the mouse to the terminal). The panel is a right-hand overlay, newest first, live-updating while the agent works; ↑↓/PgUp/PgDn scroll, `c` clears, Esc closes.
+The line above the editor shows the latest verdict per guard, for example `warden · bash · irreversible 0.84 · off-task 0.86 · unrelated · confirm`. Every verdict is also kept in a session trace with what was inspected (redacted command or path), the pattern hits, Jev's scores with model and latency, the reasons, and the exact text the agent was told.
+
+`/warden trace`, `ctrl+shift+w`, and a click on the status line each **toggle a right-hand sidebar** with that trace, newest first, live-updating while the agent works. The sidebar does not take the keyboard: you keep typing in the editor while it is open. Click inside it to give it the keys (↑↓/PgUp/PgDn scroll, `c` clears, Esc hands input back to the editor, `q` closes); the wheel scrolls it without focus. `widget.panelWidth` sets its width (`"40%"` or a column count).
+
+Clicks and the wheel need Pi's fullscreen mode (`tuiMode: "fullscreen"` in `/settings`); regular mode leaves the mouse to the terminal for scrollback. If the mouse does nothing in fullscreen, the terminal is not reporting it: in macOS Terminal.app enable View → Allow Mouse Reporting (⌘R). Pi's extension API offers floating overlays but no side dock that narrows the transcript, so the sidebar covers the right part of the screen instead of pushing the transcript aside.
 
 Templates in `config.widget` control the text. Segments are separated by ` · `; a segment whose token has no value for that verdict is dropped, so optional information disappears together with its label:
 
@@ -125,6 +129,7 @@ Templates in `config.widget` control the text. Segments are separated by ` · `;
   "enabled": true,
   "placement": "aboveEditor",
   "shortcut": "ctrl+shift+w",
+  "panelWidth": "40%",
   "action": "warden · {tool} · irreversible {irreversible} · off-task {offTask} · {scope} · slop: {slop} · patterns: {patterns} · {flags} · {level}",
   "stuck": "warden · stuck · {failures} failures · same strategy {sameStrategy} · change {approachChange} · progress {progress} · {flags} · {status}",
   "done": "warden · done-check · {changes} changes · {checksPassed}/{checks} checks passed · claims done {claimsDone} · claims verified {claimsVerified} · checks apply {checksApply} · {outcome} · {status}",
@@ -163,7 +168,7 @@ User file `~/.pi/agent/pi-warden/config.json` (owner-only). Missing keys use the
     "threshold": 0.7,
     "prose": { "enabled": true, "audience": "technical", "threshold": 0.7, "trend": 2, "minChars": 200 }
   },
-  "widget": { "enabled": true, "placement": "aboveEditor", "shortcut": "ctrl+shift+w" },
+  "widget": { "enabled": true, "placement": "aboveEditor", "shortcut": "ctrl+shift+w", "panelWidth": "40%" },
   "steerVisible": false
 }
 ```

package/dist/config.js

@@ -128,6 +128,8 @@ function applyWidget(base, raw) {
         enabled: boolean(raw.enabled, base.enabled),
         placement: raw.placement === "belowEditor" || raw.placement === "aboveEditor" ? raw.placement : base.placement,
         shortcut: typeof raw.shortcut === "string" ? raw.shortcut.trim() : base.shortcut,
+        panelWidth: typeof raw.panelWidth === "number" && Number.isSafeInteger(raw.panelWidth) && raw.panelWidth >= 20 ? raw.panelWidth
+            : typeof raw.panelWidth === "string" && /^[1-9]\d?%$/.test(raw.panelWidth.trim()) ? raw.panelWidth.trim() : base.panelWidth,
         action: template(raw.action, base.action),
         stuck: template(raw.stuck, base.stuck),
         done: template(raw.done, base.done),

package/dist/extension.js

@@ -94,7 +94,7 @@ export default function wardenExtension(pi) {
     let stats = freshStats();
     const widget = new Map();
     const trace = new Trace();
-    let panelOpen = false;
+    let panel;
     let lastUi;
     /** Calls held in steer mode, with the user prompt current at that time; a retry after the user replies asks Jev about approval. */
     const held = new Map();
@@ -118,11 +118,18 @@ export default function wardenExtension(pi) {
         if (ctx.hasUI)
             ctx.ui.notify(`warden: ${message}${budgetExhausted ? " Pattern checks continue without TypeSafe for the rest of this session." : ""}`, "warning");
     };
-    const openPanel = (ui) => {
-        if (!ui || panelOpen)
+    /** Click, shortcut, and /warden trace all toggle the same sidebar. */
+    const togglePanel = (ui, config) => {
+        if (!ui)
             return;
-        panelOpen = true;
-        openTracePanel(ui, trace).catch(() => undefined).finally(() => { panelOpen = false; });
+        if (panel) {
+            panel.close();
+            return;
+        }
+        const opened = openTracePanel(ui, trace, { width: config.widget.panelWidth });
+        panel = opened;
+        opened.closed.catch(() => undefined).finally(() => { if (panel === opened)
+            panel = undefined; });
     };
     const paint = (ctx, config) => {
         if (!ctx.hasUI)
@@ -137,7 +144,7 @@ export default function wardenExtension(pi) {
         ctx.ui.setWidget(WIDGET, (_tui, theme) => new MouseRegion(new Text(lines.map(line => theme.fg("muted", line)).join("\n"), 0, 0), event => {
             if (event.type !== "click" || event.button !== "left")
                 return undefined;
-            openPanel(lastUi);
+            togglePanel(lastUi, config);
             return { handled: true };
         }), { placement: config.widget.placement });
     };
@@ -153,6 +160,7 @@ export default function wardenExtension(pi) {
         stats = freshStats();
         widget.clear();
         trace.clear();
+        panel?.close();
         held.clear();
         attempts.reset();
         evidence = emptyEvidence();
@@ -372,9 +380,9 @@ export default function wardenExtension(pi) {
     const shortcut = loadConfig().widget.shortcut;
     if (/^(?:(?:ctrl|shift|alt|super)\+)+[a-z0-9]+$|^f\d{1,2}$/i.test(shortcut)) {
         pi.registerShortcut(shortcut, {
-            description: "Open the pi-warden trace panel",
+            description: "Toggle the pi-warden trace sidebar",
             handler: async (ctx) => { if (ctx.hasUI)
-                openPanel(ctx.ui); },
+                togglePanel(ctx.ui, configFor(ctx)); },
         });
     }
     const actions = ["status", "enable", "disable", "mode", "config", "test", "trace"];
@@ -405,7 +413,7 @@ export default function wardenExtension(pi) {
                         `Thresholds: irreversible warn ${config.action.irreversible.warn} / hold ${config.action.irreversible.confirm}; off-task warn ${config.action.offTask.warn} / hold ${config.action.offTask.confirm}; stuck same-strategy ${config.stuck.sameStrategy} after ${config.stuck.minFailures} failures; done claims ${config.done.claimsDone}; slop ${config.slop.threshold}, prose ${config.slop.prose.threshold} in ${config.slop.prose.trend}/3 replies; failOpen ${config.action.failOpen}.`,
                         `Config: ${userConfigPath()}${ctx.isProjectTrusted() ? ` and ${projectConfigPath(ctx.cwd)}` : ""}.`,
                         widget.size ? `Last: ${[...widget.values()].join(" | ")}` : "No guarded activity yet this session.",
-                        `Trace: ${trace.entries().length} events (/warden trace${shortcut ? `, ${shortcut}` : ""}, or click the status line in fullscreen mode). Widget templates in config.widget: action tokens ${TOKEN_NAMES.action.map(name => `{${name}}`).join(" ")}.`,
+                        `Trace: ${trace.entries().length} events (/warden trace${shortcut ? `, ${shortcut}` : ""}, or click the status line in fullscreen mode; each toggles the sidebar). Widget templates in config.widget: action tokens ${TOKEN_NAMES.action.map(name => `{${name}}`).join(" ")}.`,
                     ].join(" "));
                     return;
                 }
@@ -415,7 +423,7 @@ export default function wardenExtension(pi) {
                         report(entries.length ? entries.slice(-20).map(entry => `${new Date(entry.at).toTimeString().slice(0, 8)} ${entry.guard}: ${entry.line}${entry.details.length ? `\n  ${entry.details.join("\n  ")}` : ""}`).join("\n") : "No guarded activity yet this session.");
                         return;
                     }
-                    openPanel(ctx.ui);
+                    togglePanel(ctx.ui, config);
                     return;
                 }
                 if (action === "enable") {

package/dist/panel.d.ts

@@ -4,25 +4,35 @@ interface ThemeLike {
     fg(color: string, text: string): string;
     bold(text: string): string;
 }
+export interface PanelActions {
+    /** Remove the sidebar. */
+    close(): void;
+    /** Keep the sidebar visible but give keyboard input back to the editor. */
+    unfocus(): void;
+}
 /**
- * Side panel listing the trace newest-first, live-updating while open. Keys: ↑/↓/j/k scroll a line, PgUp/PgDn a page,
- * Home/End jump, c clears the trace, Esc or q closes. Wheel scrolling works in fullscreen mode.
+ * Sidebar listing the trace newest-first, live-updating while open. It opens without taking keyboard input: the editor
+ * keeps working while it is visible. A click inside it (fullscreen mode) focuses it; then ↑/↓/j/k scroll a line,
+ * PgUp/PgDn a page, Home/End jump, c clears the trace, Esc returns input to the editor, and q closes. Wheel scrolling
+ * works without focus.
  */
 export declare class TracePanel implements Component {
     private readonly trace;
     private readonly theme;
-    private readonly close;
+    private readonly actions;
     private readonly requestRender;
     private readonly title;
+    /** Set by the TUI when keyboard focus changes. */
     focused: boolean;
     private scroll;
     private viewport;
     private readonly unsubscribe;
-    constructor(trace: Trace, theme: ThemeLike, close: () => void, requestRender: () => void, title?: string);
+    constructor(trace: Trace, theme: ThemeLike, actions: PanelActions, requestRender: () => void, title?: string);
     dispose(): void;
     /** Rendering is cheap and derived from the trace each time; nothing is cached. */
     invalidate(): void;
     private lines;
+    /** A left border makes the overlay read as a pane; the content column is two cells narrower. */
     render(width: number): string[];
     /** The overlay tells us how tall we may be through the layout; fall back to a fixed viewport otherwise. */
     setViewport(rows: number): void;
@@ -39,6 +49,16 @@ export interface PanelUi {
         dispose?(): void;
     }, options?: Record<string, unknown>): Promise<T>;
 }
-/** Open the trace as a right-hand overlay. Resolves when the user closes it. */
-export declare function openTracePanel(ui: PanelUi, trace: Trace): Promise<void>;
+export interface PanelController {
+    /** Resolves when the sidebar has been removed, by the user or by close(). */
+    closed: Promise<void>;
+    close(): void;
+}
+/**
+ * Open the trace as a right-hand sidebar. Pi's public UI API offers floating overlays but no side dock that narrows the
+ * transcript, so the sidebar covers the right part of the screen; `nonCapturing` keeps the editor focused.
+ */
+export declare function openTracePanel(ui: PanelUi, trace: Trace, options?: {
+    width?: string | number;
+}): PanelController;
 export {};

package/dist/panel.js

@@ -1,23 +1,26 @@
 import { Key, matchesKey, truncateToWidth, wrapTextWithAnsi } from "@earendil-works/pi-tui";
 const LEVEL_COLOR = { allow: "success", ok: "success", warn: "warning", unverified: "warning", nudged: "warning", confirm: "error", stuck: "error", "false claim": "error" };
 /**
- * Side panel listing the trace newest-first, live-updating while open. Keys: ↑/↓/j/k scroll a line, PgUp/PgDn a page,
- * Home/End jump, c clears the trace, Esc or q closes. Wheel scrolling works in fullscreen mode.
+ * Sidebar listing the trace newest-first, live-updating while open. It opens without taking keyboard input: the editor
+ * keeps working while it is visible. A click inside it (fullscreen mode) focuses it; then ↑/↓/j/k scroll a line,
+ * PgUp/PgDn a page, Home/End jump, c clears the trace, Esc returns input to the editor, and q closes. Wheel scrolling
+ * works without focus.
  */
 export class TracePanel {
     trace;
     theme;
-    close;
+    actions;
     requestRender;
     title;
-    focused = true;
+    /** Set by the TUI when keyboard focus changes. */
+    focused = false;
     scroll = 0;
     viewport = 20;
     unsubscribe;
-    constructor(trace, theme, close, requestRender, title = "pi-warden trace") {
+    constructor(trace, theme, actions, requestRender, title = "pi-warden trace") {
         this.trace = trace;
         this.theme = theme;
-        this.close = close;
+        this.actions = actions;
         this.requestRender = requestRender;
         this.title = title;
         this.unsubscribe = trace.subscribe(() => this.requestRender());
@@ -31,10 +34,13 @@ export class TracePanel {
         const { theme } = this;
         const entries = this.trace.entries();
         const out = [];
-        out.push(theme.bold(theme.fg("accent", ` ${this.title}`)) + theme.fg("muted", ` · ${entries.length} event${entries.length === 1 ? "" : "s"} · ↑↓ PgUp PgDn scroll · c clear · esc close`));
+        const keys = this.focused ? "↑↓ PgUp PgDn scroll · c clear · esc back to editor · 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("muted", "─".repeat(Math.max(0, width))));
         if (!entries.length) {
-            out.push(theme.fg("muted", " No guarded activity yet this session. Verdicts, Jev scores, and what the agent was told will appear here."));
+            for (const line of wrapTextWithAnsi(theme.fg("muted", "No guarded activity yet this session. Verdicts, Jev scores, and what the agent was told will appear here."), Math.max(10, width)))
+                out.push(line);
             return out.map(line => truncateToWidth(line, width, ""));
         }
         for (let index = entries.length - 1; index >= 0; index--) {
@@ -56,25 +62,35 @@ export class TracePanel {
         }
         return out.map(line => truncateToWidth(line, width, ""));
     }
+    /** A left border makes the overlay read as a pane; the content column is two cells narrower. */
     render(width) {
-        const all = this.lines(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;
-            visible[last] = truncateToWidth(theme_fg(this.theme, "muted", ` … ${all.length - this.scroll - this.viewport > 0 ? `${all.length - this.scroll - this.viewport} more lines below` : "end"} · ${this.scroll} above`), width, "");
+            visible[last] = truncateToWidth(theme_fg(this.theme, "muted", `… ${all.length - this.scroll - this.viewport > 0 ? `${all.length - this.scroll - this.viewport} more lines below` : "end"} · ${this.scroll} above`), inner, "");
         }
-        return visible;
+        while (visible.length < this.viewport)
+            visible.push("");
+        return visible.map(line => border + line);
     }
     /** The overlay tells us how tall we may be through the layout; fall back to a fixed viewport otherwise. */
     setViewport(rows) {
         this.viewport = Math.max(5, rows);
     }
     handleInput(data) {
-        if (matchesKey(data, Key.escape) || data === "q" || matchesKey(data, Key.ctrl("c"))) {
-            this.close();
+        if (data === "q" || matchesKey(data, Key.ctrl("c"))) {
+            this.actions.close();
+            return;
+        }
+        if (matchesKey(data, Key.escape)) {
+            this.actions.unfocus();
+            this.requestRender();
             return;
         }
         if (matchesKey(data, Key.up) || data === "k")
@@ -100,22 +116,32 @@ export class TracePanel {
             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;
     }
 }
 function theme_fg(theme, color, text) {
     return theme.fg(color, text);
 }
-/** Open the trace as a right-hand overlay. Resolves when the user closes it. */
-export function openTracePanel(ui, trace) {
-    return ui.custom((tui, theme, _keybindings, done) => {
-        const panel = new TracePanel(trace, theme, () => done(), () => tui.requestRender());
+/**
+ * Open the trace as a right-hand sidebar. Pi's public UI API offers floating overlays but no side dock that narrows the
+ * transcript, so the sidebar covers the right part of the screen; `nonCapturing` keeps the editor focused.
+ */
+export function openTracePanel(ui, trace, options = {}) {
+    let close = () => { };
+    let unfocus = () => { };
+    const closed = ui.custom((tui, theme, _keybindings, done) => {
+        close = () => done();
+        const panel = new TracePanel(trace, theme, { close, unfocus: () => unfocus() }, () => tui.requestRender());
         const rows = tui.terminal?.rows;
         if (typeof rows === "number")
-            panel.setViewport(Math.floor(rows * 0.9) - 2);
+            panel.setViewport(rows - 2);
         return panel;
     }, {
         overlay: true,
-        overlayOptions: { anchor: "right-center", width: "48%", minWidth: 56, maxHeight: "90%", margin: { right: 1 } },
+        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/widget.d.ts

@@ -6,8 +6,10 @@ export type WidgetPlacement = "aboveEditor" | "belowEditor";
 export interface WidgetConfig {
     enabled: boolean;
     placement: WidgetPlacement;
-    /** Keyboard shortcut that opens the trace panel; empty string disables it. */
+    /** 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. */
+    panelWidth: string | number;
     /** Templates per guard. Segments are separated by " · "; a segment whose token has no value is dropped. */
     action: string;
     stuck: string;

package/dist/widget.js

@@ -7,7 +7,7 @@ export const DEFAULT_TEMPLATES = {
     context: "warden · context · {tool} · {retention} · saved {bytesSaved} bytes",
 };
 export function defaultWidgetConfig() {
-    return { enabled: true, placement: "aboveEditor", shortcut: "ctrl+shift+w", ...DEFAULT_TEMPLATES };
+    return { enabled: true, placement: "aboveEditor", shortcut: "ctrl+shift+w", panelWidth: "40%", ...DEFAULT_TEMPLATES };
 }
 const SEPARATOR = " · ";
 const TOKEN = /\{([a-zA-Z]+)\}/g;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-warden",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "description": "Guardrails for Pi built on pi-typesafe that steer the agent instead of interrupting you: Jev judges irreversible and off-task tool calls before they run, detects stuck loops, checks unverified done claims, and flags slop.",
   "type": "module",
   "license": "MIT",