pi-warden 1.4.0 → 1.5.0

package/CHANGELOG.md

@@ -6,6 +6,12 @@ How to keep this current: add the entry in the same pull request as the change,
 
 ## Unreleased
 
+## 1.5.0
+
+### Added
+
+- The config panel has selectors for mode, judgment backend, widget placement and bar mode, conscience skill mode, and recall tool. Left/right wraps through supported values; Enter saves the chosen field and Esc cancels. Invalid values and custom backends remain intact until a choice is made, and other staged edits keep their existing `s` save behavior. ([Configuration](docs/configuration.md#user-config))
+
 ## 1.4.0
 
 ### Added

package/dist/config.d.ts

@@ -321,9 +321,11 @@ export interface SubagentConfig {
     /** At most one wake per this window, so several children finishing together cost one interruption. */
     cooldownMs: number;
 }
-export type RecallTool = "auto" | "rg" | "ag" | "ugrep" | "git-grep" | "grep" | "select-string" | "findstr" | "none";
+export declare const RECALL_TOOLS: readonly ["auto", "rg", "ag", "ugrep", "git-grep", "grep", "select-string", "findstr", "none"];
+export type RecallTool = typeof RECALL_TOOLS[number];
 export declare function isRecallTool(value: unknown): value is RecallTool;
-export type WardenMode = "steer" | "confirm" | "advise";
+export declare const WARDEN_MODES: readonly ["steer", "confirm", "advise"];
+export type WardenMode = typeof WARDEN_MODES[number];
 export interface WasteConfig {
     /** Master switch for the call-waste notes and the session tip. */
     enabled: boolean;
@@ -369,7 +371,8 @@ export interface LearningConfig {
     /** Days to keep records of calls that were not held; they repeat their task text across a turn and are the bulk of the file. 0 disables this pruning. */
     allowedRetentionDays: number;
 }
-export type ConscienceSkillMode = "off" | "recommend" | "load";
+export declare const CONSCIENCE_SKILL_MODES: readonly ["off", "recommend", "load"];
+export type ConscienceSkillMode = typeof CONSCIENCE_SKILL_MODES[number];
 export interface ConscienceSkillConfig {
     /** off: no automatic skill selection; recommend: name a skill and ask the agent to load it; load: supply instructions directly. */
     mode: ConscienceSkillMode;

package/dist/config.js

@@ -4,7 +4,7 @@ import { writeFileAtomicSync } from "./atomic.js";
 import { resolveJudgmentBackend } from "./backend.js";
 import { defaultHostDirs } from "./host-dirs.js";
 import { COMMAND_TOOLS } from "./tools.js";
-import { defaultWidgetConfig } from "./widget.js";
+import { WIDGET_BAR_MODES, WIDGET_PLACEMENTS, defaultWidgetConfig } from "./widget.js";
 // Tests of UI code are proven by running them, not by looking at them.
 export const DEFAULT_UI_FILES = [
     "**/*.{css,scss,sass,less,html,htm,vue,svelte,jsx,tsx,astro,dart}", "**/web/**/*.js", "**/public/**/*.js",
@@ -21,10 +21,15 @@ export function defaultVisualTools() {
         images: ["png", "jpg", "jpeg", "webp"],
     };
 }
-const RECALL_TOOLS = ["auto", "rg", "ag", "ugrep", "git-grep", "grep", "select-string", "findstr", "none"];
+export const RECALL_TOOLS = ["auto", "rg", "ag", "ugrep", "git-grep", "grep", "select-string", "findstr", "none"];
+function isOption(value, options) {
+    return typeof value === "string" && options.includes(value);
+}
 export function isRecallTool(value) {
-    return typeof value === "string" && RECALL_TOOLS.includes(value);
+    return isOption(value, RECALL_TOOLS);
 }
+export const WARDEN_MODES = ["steer", "confirm", "advise"];
+export const CONSCIENCE_SKILL_MODES = ["off", "recommend", "load"];
 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 = 13;
@@ -147,7 +152,7 @@ function positiveInteger(value, fallback) {
     return typeof value === "number" && Number.isSafeInteger(value) && value > 0 ? value : fallback;
 }
 export function isMode(value) {
-    return value === "steer" || value === "confirm" || value === "advise";
+    return isOption(value, WARDEN_MODES);
 }
 /** One config warning for a rule value no kind accepts; the rule still applies, at the level named. */
 function unknownRuleValue(kind, id, key, value, valid, applied) {
@@ -529,8 +534,8 @@ function applyWidget(base, raw) {
     const template = (value, fallback) => (typeof value === "string" && value.trim() ? value : fallback);
     return {
         enabled: boolean(raw.enabled, base.enabled),
-        placement: raw.placement === "belowEditor" || raw.placement === "aboveEditor" ? raw.placement : base.placement,
-        barMode: raw.barMode === "live" || raw.barMode === "stack" ? raw.barMode : base.barMode,
+        placement: isOption(raw.placement, WIDGET_PLACEMENTS) ? raw.placement : base.placement,
+        barMode: isOption(raw.barMode, WIDGET_BAR_MODES) ? raw.barMode : base.barMode,
         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,
@@ -713,7 +718,7 @@ function applyConscience(base, raw) {
         return base;
     const skillsRaw = isObject(raw.skills) ? raw.skills : undefined;
     const toolsRaw = isObject(raw.tools) ? raw.tools : undefined;
-    const mode = typeof skillsRaw?.mode === "string" && ["off", "recommend", "load"].includes(skillsRaw.mode) ? skillsRaw.mode : base.skills.mode;
+    const mode = isOption(skillsRaw?.mode, CONSCIENCE_SKILL_MODES) ? skillsRaw.mode : base.skills.mode;
     return {
         enabled: boolean(raw.enabled, base.enabled),
         skills: {

package/dist/panel.d.ts

@@ -75,8 +75,9 @@ export declare class ConfigPanel implements Component {
     private cursor;
     private scroll;
     private viewport;
-    private editing;
-    private editBuffer;
+    private keepCursorVisible;
+    private draft;
+    private notice;
     private readonly edits;
     private readonly entries;
     constructor(config: WardenConfig, theme: ThemeLike, actions: PanelActions, requestRender: () => void, dirs?: HostDirs);
@@ -88,6 +89,7 @@ export declare class ConfigPanel implements Component {
     handleMouse(event: TuiMouseEvent): TuiMouseEventResult | undefined;
     private parseValue;
     save(): void;
+    private saveChanges;
 }
 export declare function openConfigPanel(ui: PanelUi, config: WardenConfig, options?: {
     width?: string | number;

package/dist/panel.js

@@ -1,7 +1,9 @@
 import { Key, matchesKey, truncateToWidth, wrapTextWithAnsi } from "@earendil-works/pi-tui";
-import { applyUserOverrides, defaultConfig, readUserConfig, writeUserConfig } from "./config.js";
+import { DECISIONS_BACKENDS } from "pi-typesafe";
+import { resolveJudgmentBackend } from "./backend.js";
+import { CONSCIENCE_SKILL_MODES, RECALL_TOOLS, WARDEN_MODES, applyUserOverrides, defaultConfig, getNestedValue, readUserConfig, setNestedValue, writeUserConfig } from "./config.js";
 import { defaultHostDirs } from "./host-dirs.js";
-import { LEVEL_COLOR, parseVerdictLine, renderSegment } from "./widget.js";
+import { LEVEL_COLOR, WIDGET_BAR_MODES, WIDGET_PLACEMENTS, parseVerdictLine, renderSegment } from "./widget.js";
 /**
  * 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,
@@ -175,13 +177,41 @@ export function openTracePanel(ui, trace, options = {}) {
     });
     return { closed, close: () => close(), built: () => built };
 }
+const SELECTOR_OPTIONS = {
+    mode: WARDEN_MODES,
+    typesafeBackend: Object.keys(DECISIONS_BACKENDS),
+    "widget.placement": WIDGET_PLACEMENTS,
+    "widget.barMode": WIDGET_BAR_MODES,
+    "conscience.skills.mode": CONSCIENCE_SKILL_MODES,
+    "context.recallTool": RECALL_TOOLS,
+};
+function isCustomBackend(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value)
+        && resolveJudgmentBackend(value).backendRefusal === undefined;
+}
+function selectorValue(entry, value) {
+    if (typeof value === "string" && entry.options.includes(value))
+        return value;
+    if (entry.path === "typesafeBackend" && isCustomBackend(value))
+        return "custom";
+    const raw = typeof value === "string" ? value : JSON.stringify(value) ?? String(value);
+    return raw + " (invalid)";
+}
 function flattenConfig(obj, prefix = "") {
     const entries = [];
-    const skip = new Set(["action", "stuck", "done", "slop", "security", "rules", "context", "runaway", "notify", "subagent"]);
+    const skip = new Set(["action", "stuck", "done", "slop", "security", "rules", "runaway", "notify", "subagent", "backendRefusal"]);
     for (const [key, value] of Object.entries(obj)) {
         if (skip.has(key) && !prefix)
             continue;
         const path = prefix ? `${prefix}.${key}` : key;
+        const level = prefix ? prefix.split(".").length : 0;
+        const options = SELECTOR_OPTIONS[path];
+        if (options) {
+            entries.push({ path, label: key, level, value, type: "select", options, editable: true });
+            if (path === "typesafeBackend" && isCustomBackend(value))
+                entries.push(...flattenConfig(value, path));
+            continue;
+        }
         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 });
         }
@@ -202,8 +232,9 @@ export class ConfigPanel {
     cursor = 0;
     scroll = 0;
     viewport = 20;
-    editing = false;
-    editBuffer = "";
+    keepCursorVisible = true;
+    draft;
+    notice = "";
     edits = new Map();
     entries;
     constructor(config, theme, actions, requestRender, dirs = defaultHostDirs()) {
@@ -212,15 +243,26 @@ export class ConfigPanel {
         this.actions = actions;
         this.requestRender = requestRender;
         this.dirs = dirs;
-        this.entries = flattenConfig(config);
+        const raw = readUserConfig(dirs);
+        const user = applyUserOverrides(defaultConfig(), raw);
+        let visible = { ...config, context: { recallTool: user.context.recallTool } };
+        // Only selector rows use the user layer; never persist a trusted project's recall override here.
+        for (const path of Object.keys(SELECTOR_OPTIONS)) {
+            const value = getNestedValue(raw, path);
+            visible = setNestedValue(visible, path, value === undefined ? getNestedValue(user, path) : value);
+        }
+        this.entries = flattenConfig(visible);
     }
     invalidate() { }
     lines(width) {
-        const { theme, entries, cursor, scroll, editing, editBuffer, edits } = this;
+        const { theme, entries, cursor, draft, edits } = this;
         const out = [];
-        const modeLabel = editing ? "editing" : "browsing";
+        const modeLabel = draft?.type === "select" ? "selecting" : draft ? "editing" : "browsing";
+        const editingKeys = draft?.type === "select" ? "←→ choose · enter save · esc cancel"
+            : draft ? "enter stage · esc cancel · s saves after editing"
+                : "↑↓ navigate · enter toggle/edit · esc back · s save";
         const keys = this.focused
-            ? `↑↓ navigate · enter toggle/edit · esc ${editing ? "cancel" : "back"} · s save · ${modeLabel}`
+            ? editingKeys + " · " + 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));
@@ -236,8 +278,12 @@ export class ConfigPanel {
                 continue;
             }
             let valueStr;
-            if (isSelected && editing && entry.type !== "boolean") {
-                valueStr = editBuffer + "\u2588";
+            if (entry.type === "select") {
+                const value = isSelected && draft?.type === "select" ? draft.value : entry.value;
+                valueStr = "‹ " + selectorValue(entry, value) + " ›";
+            }
+            else if (isSelected && draft?.type === "text") {
+                valueStr = draft.buffer + "\u2588";
             }
             else if (entry.type === "boolean") {
                 valueStr = entry.value ? "●" : "○";
@@ -263,31 +309,48 @@ export class ConfigPanel {
         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);
+        const fixed = all.splice(0, 3);
+        if (this.notice) {
+            const notice = wrapTextWithAnsi(this.theme.fg("warning", this.notice), inner);
+            // Keep the notice outside the scrolling list, with room for at least one selected row.
+            fixed.push(...notice.slice(0, Math.max(1, this.viewport - fixed.length - 2)));
+        }
+        const available = Math.max(1, this.viewport - fixed.length);
+        const showFooter = all.length > available && available > 1;
+        const listRows = available - (showFooter ? 1 : 0);
+        const maxScroll = Math.max(0, all.length - listRows);
         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;
+        if (this.keepCursorVisible) {
+            if (this.cursor < this.scroll)
+                this.scroll = this.cursor;
+            else if (this.cursor >= this.scroll + listRows)
+                this.scroll = this.cursor - listRows + 1;
+            this.keepCursorVisible = false;
+        }
+        const visible = [...fixed, ...all.slice(this.scroll, this.scroll + listRows)];
+        if (showFooter) {
+            const below = all.length - this.scroll - listRows;
             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, "");
+            visible.push(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); }
+    setViewport(rows) { this.viewport = Math.max(5, rows); this.keepCursorVisible = true; }
     handleInput(data) {
-        const { entries, editing } = this;
+        const { entries, draft } = this;
         if (data === "q" || matchesKey(data, Key.ctrl("c"))) {
             this.actions.close();
             return;
         }
+        this.keepCursorVisible = true;
         if (matchesKey(data, Key.escape)) {
-            if (editing) {
-                this.editing = false;
+            if (draft) {
+                this.draft = undefined;
+                this.notice = "";
                 this.requestRender();
                 return;
             }
@@ -295,22 +358,58 @@ export class ConfigPanel {
             this.requestRender();
             return;
         }
-        if (editing) {
+        if (draft) {
             const entry = entries[this.cursor];
+            if (draft.type === "select" && entry.type === "select") {
+                if (matchesKey(data, Key.left) || matchesKey(data, Key.right)) {
+                    const step = matchesKey(data, Key.right) ? 1 : -1;
+                    const index = typeof draft.value === "string" ? entry.options.indexOf(draft.value) : -1;
+                    const next = index < 0 ? (step > 0 ? 0 : entry.options.length - 1)
+                        : (index + step + entry.options.length) % entry.options.length;
+                    draft.value = entry.options[next];
+                    draft.cycled = true;
+                    this.notice = "";
+                }
+                else if (data === "enter" || matchesKey(data, Key.return)) {
+                    if (!draft.cycled)
+                        this.draft = undefined;
+                    else if (entry.path === "typesafeBackend" && [...this.edits.keys()].some(path => path.startsWith("typesafeBackend."))) {
+                        this.notice = "Backend fields have pending edits. Press Esc, then s to save them before choosing a named backend.";
+                    }
+                    else if (this.saveChanges(new Map([[entry.path, draft.value]]))) {
+                        entry.value = draft.value;
+                        this.draft = undefined;
+                        if (entry.path === "typesafeBackend") {
+                            // Replace only this subtree; rebuilding all rows would discard unrelated staged values.
+                            let end = this.cursor + 1;
+                            while (entries[end]?.path.startsWith("typesafeBackend."))
+                                end++;
+                            entries.splice(this.cursor + 1, end - this.cursor - 1);
+                        }
+                    }
+                }
+                else
+                    return;
+                this.requestRender();
+                return;
+            }
+            if (draft.type !== "text")
+                return;
             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;
+                const value = this.parseValue(draft.buffer, entry.type);
+                this.edits.set(entry.path, value);
+                entry.value = value;
+                this.draft = undefined;
                 this.requestRender();
                 return;
             }
             if (matchesKey(data, Key.backspace)) {
-                this.editBuffer = this.editBuffer.slice(0, -1);
+                draft.buffer = draft.buffer.slice(0, -1);
                 this.requestRender();
                 return;
             }
             if (data.length === 1 && data >= " ") {
-                this.editBuffer += data;
+                draft.buffer += data;
                 this.requestRender();
                 return;
             }
@@ -330,13 +429,18 @@ export class ConfigPanel {
             this.cursor = entries.length - 1;
         else if (data === "enter" || matchesKey(data, Key.return)) {
             const entry = entries[this.cursor];
-            if (entry.type === "boolean") {
+            if (!entry.editable)
+                return;
+            this.notice = "";
+            if (entry.type === "select") {
+                this.draft = { type: "select", value: entry.value, cycled: false };
+            }
+            else if (entry.type === "boolean") {
                 this.edits.set(entry.path, !entry.value);
                 entry.value = !entry.value;
             }
             else {
-                this.editing = true;
-                this.editBuffer = String(entry.value);
+                this.draft = { type: "text", buffer: String(entry.value) };
             }
         }
         else if (data === "s") {
@@ -345,16 +449,12 @@ export class ConfigPanel {
         }
         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);
+            this.keepCursorVisible = false;
             return { handled: true, render: true };
         }
         if (event.type === "press" && event.button === "left")
@@ -373,21 +473,34 @@ export class ConfigPanel {
     save() {
         if (this.edits.size === 0)
             return;
-        const raw = readUserConfig(this.dirs);
-        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];
+        this.keepCursorVisible = true;
+        if (this.saveChanges(this.edits))
+            this.edits.clear();
+        this.requestRender();
+    }
+    saveChanges(changes) {
+        try {
+            const obj = readUserConfig(this.dirs);
+            for (const [path, value] of changes) {
+                const keys = path.split(".");
+                let current = obj;
+                for (let i = 0; i < keys.length - 1; i++) {
+                    const key = keys[i];
+                    if (typeof current[key] !== "object" || current[key] === null || Array.isArray(current[key]))
+                        current[key] = {};
+                    current = current[key];
+                }
+                current[keys.at(-1)] = value;
             }
-            current[keys.at(-1)] = value;
+            writeUserConfig(obj, this.dirs);
+            this.notice = "";
+            return true;
+        }
+        catch (error) {
+            const retry = this.draft?.type === "select" ? "Enter" : "s";
+            this.notice = `Save failed. Retry ${retry}. ` + (error instanceof Error ? error.message : String(error));
+            return false;
         }
-        writeUserConfig(obj, this.dirs);
-        this.edits.clear();
     }
 }
 export function openConfigPanel(ui, config, options = {}) {

package/dist/widget.d.ts

@@ -5,8 +5,10 @@ import type { ProseVerdict } from "./prose.js";
 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";
+export declare const WIDGET_PLACEMENTS: readonly ["aboveEditor", "belowEditor"];
+export type WidgetPlacement = typeof WIDGET_PLACEMENTS[number];
+export declare const WIDGET_BAR_MODES: readonly ["stack", "live"];
+export type WidgetBarMode = typeof WIDGET_BAR_MODES[number];
 /** 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;

package/dist/widget.js

@@ -1,4 +1,6 @@
 import { freshChecks } from "./done.js";
+export const WIDGET_PLACEMENTS = ["aboveEditor", "belowEditor"];
+export const WIDGET_BAR_MODES = ["stack", "live"];
 export const LEVEL_COLOR = { allow: "success", ok: "success", warn: "warning", unverified: "warning", nudged: "warning", confirm: "error", deny: "error", stuck: "error", "false claim": "error", stopped: "error", "stopped, recovering": "error", violation: "warning", skipped: "muted", wake: "warning", silent: "muted", "appended silently": "muted", "possible credentials": "warning", error: "error" };
 /** Verdicts that need no eye: the guard ran and found nothing. The rest keep a line of their own. */
 export const QUIET_COLORS = new Set(["success", "muted"]);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-warden",
-  "version": "1.4.0",
+  "version": "1.5.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",