pi-warden 0.25.0 → 0.28.4

package/dist/extension.js

@@ -1,30 +1,33 @@
-import { MouseRegion } from "@earendil-works/pi-tui";
+import { rm } from "node:fs/promises";
+import * as tuiModule from "@earendil-works/pi-tui";
+const MouseRegion = tuiModule.MouseRegion;
 import { authState, createTypeSafe, describeAuth } from "pi-typesafe";
 import { ensureApiKey } from "pi-typesafe/ui";
+import { backendHost, disclosureFor, judgeOptions, keyAvailable, resolveBackend } from "./backend.js";
 import { ActionGuard } from "./action-guard.js";
 import { ArmingTracker, unparseableArmingRules } from "./arming.js";
 import * as configModule from "./config.js";
-import { applyUserOverrides, defaultConfig, isMode, loadConfig, PACKAGE_NAME, projectConfigPath, readUserConfig, setUserSetting, userConfigPath, writeUserConfig } from "./config.js";
+import { applyUserOverrides, defaultConfig, getNestedValue, isMode, loadConfig, PACKAGE_NAME, parseConfigValue, projectConfigPath, readUserConfig, setNestedValue, setUserSetting, userConfigPath, writeUserConfig } from "./config.js";
 import { classifyToolResult, doneNudge, emptyEvidence, evaluateDone, finalAssistantText, formatDone, needsDoneCheck, recordOutcome as recordDoneOutcome } from "./done.js";
-import { evaluateAction, formatVerdict, higher, inertPathRules, intentSteer, offTaskSteer, SLOP_LABELS, SteerRepeatWindow, steerReason, stripDataText, unknownExemptIds, writeSinkTargets } from "./guard.js";
+import { evaluateAction, formatVerdict, formatVerdictTokens, higher, inertPathRules, intentSteer, offTaskSteer, SLOP_LABELS, SteerRepeatWindow, steerReason, stripDataText, unknownExemptIds, writeSinkTargets } from "./guard.js";
 import { commandOf } from "./tools.js";
 import { formatHolds, HoldLedger, HoldLog, holdLogPath, outcomeNote, regretsAt, textRegrets } from "./holds.js";
-import { initSchema, recordHold, recordOutcome, toHoldRecord } from "./learning.js";
+import { initSchema, recordHold, recordOutcome, toHoldRecord, generateRecommendations, analyzeSteerEffectivenessReport } from "./learning.js";
 import { evaluateProse, proseNudge, ProseTrend, RESTATE_MIN_SENTENCES, RESTATE_SHARE, RestatementWindow, substantiveSentences } from "./prose.js";
-import { compressOutput, duplicateNote, evaluateOutput, mergeOutput, outputKey, saveOutput, securityNotice } from "./output.js";
+import { compressOutput, duplicateNote, evaluateOutput, mergeOutput, outputKey, saveOutput, securityNotice, CompressionLearner } from "./output.js";
 import { classifyRecall, detectSearchTool, recallInstruction } from "./recall.js";
 import { redact } from "./redact.js";
 import { formatRules, pathNoteSteer, RulesGuard, rulesSteer } from "./rules.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 { openTracePanel } from "./panel.js";
+import { openConfigPanel, openTracePanel } from "./panel.js";
 import { completeConfig, shapeWarning } from "./shape.js";
 import { ContextLedger, formatLedger } from "./saver.js";
 import { formatWake, newReports, reportLabel, triageReport, WakePolicy } from "./subagent.js";
 import { actionDetails, doneDetails, proseDetails, rulesDetails, runawayDetails, stuckDetails, Trace } from "./trace.js";
-import { DEFAULT_TEMPLATES, proseTokens, renderTemplate, statusWidget, TOKEN_NAMES } from "./widget.js";
-export const disclosure = "With TypeSafe judgments enabled, pi-warden sends to api.typesafe.ai: your latest request and up to eight redacted prior user/assistant text messages for task context, plus a redacted, truncated summary of each guarded bash, write, or edit call before it runs, with the agent's own words from the message that makes the call (its stated plan); for a write or edit in a project with a rules file (pi-warden.md, the configured files, or README/CLAUDE/AGENTS as fallback), a larger redacted sample of the written content with the current file around each edit and the rule text; the last few tool calls and output tails when the agent keeps failing; the agent's final message when it reports completion without running checks; redacted tool-output samples for security and context saving (retention and output format); a redacted sample of an async subagent report that names a failure, a stop, or a question, with your latest request, when warden decides whether that report should wake the agent; and, on the first guarded call after your reply, the redacted summaries of the calls allowed in the previous turn, so Jev can say whether your reply regrets one of them. Compression and duplicate notes store an exact, owner-only copy in a temporary file on this machine; the hold feedback log stores tool names, pattern ids, scores, and outcomes (never commands) in an owner-only file under Pi's agent directory. Requests may incur charges. Secret redaction is best-effort. Results are model judgments, not proof or authorization; offline pattern checks stay active either way.";
+import { DEFAULT_TEMPLATES, LEVEL_COLOR, pickSentenceTemplate, proseTokens, renderTemplate, SENTENCE_TEMPLATES, statusWidget, TOKEN_NAMES } from "./widget.js";
+export const disclosure = "With TypeSafe judgments enabled, pi-warden sends to api.typesafe.ai: your latest request and up to eight redacted prior user/assistant text messages for task context, plus a redacted, truncated summary of each guarded bash, write, or edit call before it runs, with the agent's own words from the message that makes the call (its stated plan); for a write or edit in a project with a rules file (pi-warden.md, the configured files, or README/CLAUDE/AGENTS as fallback), a larger redacted sample of the written content with the current file around each edit and the rule text; the last few tool calls and output tails when the agent keeps failing; the agent's final message when it reports completion without running checks; redacted tool-output samples for security and context saving (retention and output format); a redacted sample of an async subagent report that names a failure, a stop, or a question, with your latest request, when warden decides whether that report should wake the agent; and, on the first guarded call after your reply, the redacted summaries of the calls allowed in the previous turn, so Jev can say whether your reply regrets one of them. Compression and duplicate notes store an exact, owner-only copy in a temporary file on this machine; the hold feedback log stores tool names, pattern ids, scores, and outcomes (never commands) in an owner-only file under Pi's agent directory; an owner-only SQLite database under Pi's agent directory stores redacted hold context (plan, summary, reason) for learning and retention (configurable, default 365 days). Requests may incur charges. Secret redaction is best-effort. Results are model judgments, not proof or authorization; offline pattern checks stay active either way.";
 const WIDGET = PACKAGE_NAME;
 const CONFIRM_TEXT_LIMIT = 500;
 const freshStats = () => ({ inspected: 0, judged: 0, warned: 0, held: 0, approved: 0, offPlan: 0, offTask: 0, slop: 0, ruleChecks: 0, ruleViolations: 0, pathNotes: 0, stuckChecks: 0, stuck: 0, doneChecks: 0, unverified: 0, proseChecks: 0, proseNudges: 0, runaway: 0, errors: 0, steers: 0, steersSkipped: 0, steerGuards: {}, subagentReports: 0, subagentWoken: 0, restatements: 0 });
@@ -199,7 +202,6 @@ export default function wardenExtension(pi) {
     const rulesGuard = new RulesGuard();
     // Hold feedback: what the user did after each judged call, the trace entry each label lands on, and the per-session log.
     const holds = new HoldLedger();
-    initSchema();
     const learningIds = new Map(); // holds.id -> learning.id
     // Prune learningIds when it grows large to prevent memory leaks
     function pruneLearningIds() {
@@ -223,9 +225,12 @@ export default function wardenExtension(pi) {
     let attempts = new AttemptWindow(defaultConfig().stuck.window);
     let evidence = emptyEvidence();
     let doneNudged = false;
+    let warnedFallback = false;
     const prose = new ProseTrend();
     const slopCounts = { stub: 0, comments: 0, dead: 0, hedging: 0 };
     const ledger = new ContextLedger();
+    // Learns which compression strategies work best per tool, so the next call skips the judge when confident.
+    const compressionLearner = new CompressionLearner();
     // Secrets already announced this session, by fingerprint: the same key read twice earns one banner and one steer.
     const secretsSeen = new Set();
     // Subagent report entries already triaged, by session entry id; the wake window outlives one scan.
@@ -290,11 +295,13 @@ export default function wardenExtension(pi) {
     };
     const consentGiven = (config) => config.typesafe || process.env.PI_WARDEN_ENABLED === "1";
     const consentSource = (config) => config.typesafe ? "/warden enable" : process.env.PI_WARDEN_ENABLED === "1" ? "PI_WARDEN_ENABLED" : undefined;
-    /** A consent flag is not proof that judgments happen; ask pi-typesafe for the real key state. */
+    /** A consent flag is not proof that judgments happen; check the key state for the chosen backend. */
     const judgeFor = (config) => {
-        if (!consentGiven(config) || budgetExhausted || !authState().usable)
+        if (!consentGiven(config) || budgetExhausted)
             return undefined;
-        return client ??= createTypeSafe({ maxRequests: config.maxRequests, timeoutMs: config.timeoutMs });
+        if (!keyAvailable(config.typesafeBackend, process.env, () => authState().usable))
+            return undefined;
+        return client ??= createTypeSafe(judgeOptions(config));
     };
     const noteError = (ctx, message, code) => {
         stats.errors++;
@@ -324,18 +331,47 @@ export default function wardenExtension(pi) {
             ctx.ui.setWidget(WIDGET, undefined);
             return;
         }
-        const entries = [...widget].map(([guard, line]) => ({ guard, line }));
+        let entries = [...widget].map(([guard, line]) => ({ guard, line }));
+        // In live mode: only show the most recent guard, re-rendered with sentence templates.
+        if (config.widget.barMode === "live" && entries.length > 0) {
+            const lastEntry = trace.entries().at(-1);
+            if (lastEntry?.tokens) {
+                const template = pickSentenceTemplate(lastEntry.guard, lastEntry.tokens);
+                const sentence = renderTemplate(template, lastEntry.tokens);
+                const chip = lastEntry.tokens.level ?? lastEntry.tokens.status;
+                ctx.ui.setWidget(WIDGET, (_tui, theme) => {
+                    const color = LEVEL_COLOR[chip ?? ""] ?? "text";
+                    const chipText = chip ? `${theme.bold(theme.fg(color, chip.toUpperCase()))}  ` : "";
+                    const guardText = theme.fg("muted", lastEntry.guard + " ");
+                    const body = { render: (width) => [chipText + guardText + sentence], invalidate: () => { } };
+                    return MouseRegion ? new MouseRegion(body, event => {
+                        if (event.type !== "click" || event.button !== "left")
+                            return undefined;
+                        togglePanel(lastUi, config);
+                        return { handled: true };
+                    }) : body;
+                }, { placement: config.widget.placement });
+                return;
+            }
+            entries = [entries.at(-1)];
+        }
         // A custom component so the lines wrap to the pane and a click (fullscreen mode) opens the trace panel.
-        ctx.ui.setWidget(WIDGET, (_tui, theme) => new MouseRegion(statusWidget(entries, theme), event => {
-            if (event.type !== "click" || event.button !== "left")
-                return undefined;
-            togglePanel(lastUi, config);
-            return { handled: true };
-        }), { placement: config.widget.placement });
+        // When the host TUI lacks MouseRegion (e.g. omp 18.2.5), the extension still loads — the widget
+        // renders the same text, but a click does nothing. A missing named import is a link-time error
+        // that kills the entire extension silently; a missing namespace property is undefined.
+        ctx.ui.setWidget(WIDGET, (_tui, theme) => {
+            const body = statusWidget(entries, theme);
+            return MouseRegion ? new MouseRegion(body, event => {
+                if (event.type !== "click" || event.button !== "left")
+                    return undefined;
+                togglePanel(lastUi, config);
+                return { handled: true };
+            }) : body;
+        }, { placement: config.widget.placement });
     };
-    const record = (ctx, config, guard, line, details) => {
+    const record = (ctx, config, guard, line, details, tokens) => {
         widget.set(guard, line);
-        const entry = { at: Date.now(), guard, line, details };
+        const entry = { at: Date.now(), guard, line, details, tokens };
         trace.push(entry);
         paint(ctx, config);
         return entry;
@@ -443,8 +479,12 @@ export default function wardenExtension(pi) {
         }
     };
     pi.on("session_start", async (_event, ctx) => {
+        if (ctx.hasUI)
+            lastUi = ctx.ui;
         client = undefined;
         budgetExhausted = false;
+        warnedFallback = false;
+        await initSchema(loadConfig().learning.retentionDays);
         stats = freshStats();
         widget.clear();
         trace.clear();
@@ -459,7 +499,17 @@ export default function wardenExtension(pi) {
         evidence = emptyEvidence();
         doneNudged = false;
         prose.reset();
+        // Clean up temp output dirs from the previous session.
+        for (const dir of ledger.storedPaths()) {
+            try {
+                await rm(dir, { recursive: true, force: true });
+            }
+            catch (err) {
+                console.warn("pi-warden: temp cleanup failed:", err);
+            }
+        }
         ledger.reset();
+        compressionLearner.reset();
         secretsSeen.clear();
         subagentSeen.clear();
         wakePolicy.reset();
@@ -476,10 +526,21 @@ export default function wardenExtension(pi) {
             slopCounts[symptom] = 0;
         if (ctx.hasUI)
             ctx.ui.setWidget(WIDGET, undefined);
+        // One-time notice when confirm mode falls back to steer (headless).
+        if (!warnedFallback && loadConfig().mode === "confirm" && !ctx.hasUI) {
+            warnedFallback = true;
+            const msg = "warden: confirm mode requires a UI; falling back to steer mode for this session.";
+            if (ctx.hasUI)
+                ctx.ui.notify(msg, "warning");
+            else
+                pi.sendMessage({ customType: `${PACKAGE_NAME}-status`, content: msg, display: true });
+        }
     });
     // A new user prompt starts a new attempt history, a new steer budget, and a new restatement window; answering the
     // user is never a restatement.
     pi.on("before_agent_start", async (event, ctx) => {
+        if (ctx.hasUI)
+            lastUi = ctx.ui;
         const config = configFor(ctx);
         attempts = new AttemptWindow(config.stuck.window);
         doneNudged = false;
@@ -545,8 +606,10 @@ export default function wardenExtension(pi) {
         if (storedPath) {
             const kind = classifyRecall(event.toolName, event.input, storedPath);
             const recalled = ledger.noteAccess(serializedInput, kind);
-            if (recalled)
+            if (recalled) {
+                compressionLearner.noteRecall(event.toolName);
                 record(ctx, config, "context", renderTemplate(config.widget.context, { tool: event.toolName, retention: `full output recalled (${kind})` }), [`the agent went back to ${recalled} (${kind === "full" ? "whole-file read" : "scoped access"})`, formatLedger(ledger.snapshot())]);
+            }
         }
         if (!config.action.enabled || !config.action.tools.includes(event.toolName))
             return;
@@ -643,13 +706,14 @@ export default function wardenExtension(pi) {
                 noteOutcomes(config, [released]);
                 const learningId = learningIds.get(released.id);
                 if (learningId)
-                    recordOutcome(learningId, "approved");
+                    recordOutcome(learningId, "approved").catch(err => console.warn("pi-warden: recordOutcome failed:", err));
             }
         }
         const told = verdict.level === "confirm" && mode === "steer" ? steerReason(verdict, { canApprove: judge !== undefined }) : undefined;
         // SAFETY: verdict.source is a string union; the read-only → pattern rewrite above may have narrowed it in TS's view,
         // but the field is still one of the source values at runtime when no armed hits fired.
-        const entry = verdict.source !== "read-only" ? record(ctx, config, "action", formatVerdict(verdict, config.widget.action), actionDetails(verdict, { mode, ...(told ? { told } : {}) })) : undefined;
+        const actionFmt = formatVerdictTokens(verdict, config.widget.action);
+        const entry = verdict.source !== "read-only" ? record(ctx, config, "action", actionFmt.line, actionDetails(verdict, { mode, ...(told ? { told } : {}) }), actionFmt.tokens) : undefined;
         // What happens to this call is the label for its scores; a decision made in the dialog lands at once, a steer-mode hold waits for the user.
         const track = (held, outcome, via) => {
             if (!entry)
@@ -669,10 +733,11 @@ export default function wardenExtension(pi) {
             noteOutcomes(config, outcome ? [item] : []);
             // Record to SQLite for learning
             if (held) {
-                const id = recordHold(toHoldRecord({ at: item.at, tool: item.tool, level: item.level, reasons: item.reasons, scores: item.scores }, ctx.cwd, { task, plan: verdict.plan, contextSummary: ctxSummary, agentReason: steerReason(verdict, { canApprove: judge !== undefined }) }));
-                learningIds.set(item.id, id);
-                if (outcome)
-                    recordOutcome(id, outcome);
+                recordHold(toHoldRecord({ at: item.at, tool: item.tool, level: item.level, reasons: item.reasons, scores: item.scores }, ctx.cwd, { task: task ? redact(task) : task, plan: verdict.plan, contextSummary: ctxSummary, agentReason: steerReason(verdict, { canApprove: judge !== undefined }) })).then(id => {
+                    learningIds.set(item.id, id);
+                    if (outcome)
+                        recordOutcome(id, outcome).catch(err => console.warn("pi-warden: recordOutcome failed:", err));
+                }).catch(err => console.warn("pi-warden: recordHold failed:", err));
                 pruneLearningIds();
             }
         };
@@ -839,7 +904,7 @@ export default function wardenExtension(pi) {
                 blockVerdicts.push(await evaluateOutput(event.toolName, blockText, latestUserPrompt(ctx), {
                     security: config.security, context: config.context, judge: judgeFor(config), timeoutMs: config.timeoutMs,
                     signal: ctx.signal, compressible: true, taskContext: recentTaskContext(ctx),
-                }));
+                }, compressionLearner));
             }
             output = mergeOutput(blockVerdicts);
         }
@@ -847,7 +912,7 @@ export default function wardenExtension(pi) {
             output = await evaluateOutput(event.toolName, text, latestUserPrompt(ctx), {
                 security: config.security, context: config.context, judge: judgeFor(config), timeoutMs: config.timeoutMs,
                 signal: ctx.signal, compressible: true, taskContext: recentTaskContext(ctx),
-            });
+            }, compressionLearner);
         }
         if (ctx.signal?.aborted)
             return;
@@ -933,6 +998,7 @@ export default function wardenExtension(pi) {
                             replacement = body;
                             ledger.record(path, bytesSaved);
                             storedPath = path;
+                            compressionLearner.record(event.toolName, verdict.retention, verdict.format, false);
                             record(ctx, config, "context", renderTemplate(config.widget.context, { tool: event.toolName, retention: verdict.retention, bytesSaved: String(bytesSaved) }), [
                                 `text block ${textIndex} of ${blockVerdicts.length}: retention ${verdict.retention}; confidence ${verdict.confidence?.toFixed(2)}; format ${verdict.format ?? "generic"}${verdict.formatConfidence === undefined ? "" : ` (${verdict.formatConfidence.toFixed(2)})`}; saved ${bytesSaved} bytes; full output: ${path}`,
                                 formatLedger(ledger.snapshot()),
@@ -960,6 +1026,7 @@ export default function wardenExtension(pi) {
                         content = content.map(part => part.type === "text" ? { ...part, text: replacement } : part);
                         ledger.record(path, bytesSaved);
                         storedPath = path;
+                        compressionLearner.record(event.toolName, output.retention, output.format, false);
                         record(ctx, config, "context", renderTemplate(config.widget.context, { tool: event.toolName, retention: output.retention, bytesSaved: String(bytesSaved) }), [
                             `retention: ${output.retention}; confidence ${output.confidence?.toFixed(2)}; format ${output.format ?? "generic"}${output.formatConfidence === undefined ? "" : ` (${output.formatConfidence.toFixed(2)})`}; ${output.model}; ${output.elapsedMs} ms`,
                             `saved ${bytesSaved} bytes; full output: ${path}`,
@@ -1117,7 +1184,7 @@ export default function wardenExtension(pi) {
     }
     const actions = ["status", "enable", "disable", "mode", "config", "test", "trace"];
     pi.registerCommand("warden", {
-        description: "pi-warden status, TypeSafe consent, steer/confirm/advise mode, config editor, trace panel, and a synthetic guard test",
+        description: "pi-warden status, config (set/get/editor), TypeSafe consent, mode, trace panel, recommend, and a synthetic guard test",
         getArgumentCompletions(prefix) {
             const matches = actions.filter(action => action.startsWith(prefix)).map(action => ({ value: action, label: action }));
             return matches.length ? matches : null;
@@ -1138,11 +1205,12 @@ export default function wardenExtension(pi) {
                     const usage = client?.getUsage();
                     const guards = [config.action.enabled && "action", config.stuck.enabled && "stuck", config.done.enabled && "done-check", config.slop.enabled && "slop", config.slop.enabled && config.slop.prose.enabled && `prose (${config.slop.prose.audience})`, config.security.enabled && "security", config.rules.enabled && "rules", config.context.enabled && "context", config.runaway.enabled && "runaway", config.subagent.enabled && "subagent triage", config.notify.enabled && "desktop notifications"].filter(Boolean).join(", ");
                     report([
-                        `pi-warden: ${config.enabled ? `guarding ${config.action.tools.join(", ")} (${guards})` : "off"}; mode ${activeMode(config, ctx.hasUI)}; TypeSafe judgments ${source ? `consented via ${source}` : "not consented (run /warden enable)"}; ${auth.text}`,
+                        `pi-warden: ${config.enabled ? `guarding ${config.action.tools.join(", ")} (${guards})` : "off"}; mode ${activeMode(config, ctx.hasUI)}; TypeSafe judgments ${source ? `consented via ${source}` : "not consented (run /warden enable)"}${config.typesafeBackend !== "typesafe" ? ` (${config.typesafeBackend})` : ""}; ${auth.text}`,
                         `Session: ${stats.inspected} inspected, ${stats.judged} judged, ${stats.warned} warned, ${stats.held} held, ${stats.approved} approved on retry, ${stats.offPlan} off plan, ${stats.offTask} off task, ${stats.slop} slop notes, ${stats.ruleViolations}/${stats.ruleChecks} rule violations, ${stats.pathNotes} sensitive-path notes, ${stats.stuck}/${stats.stuckChecks} stuck, ${stats.unverified}/${stats.doneChecks} unverified done, ${stats.proseNudges}/${stats.proseChecks} prose nudges, ${stats.runaway} runaway stops, ${stats.subagentWoken}/${stats.subagentReports} subagent reports woken, ${stats.restatements} restatements, ${stats.errors} TypeSafe errors; ${usage?.requestsStarted ?? 0}/${config.maxRequests} requests. Steers are ${config.steerVisible ? "shown in the transcript" : "hidden from the transcript (trace panel shows them)"}. Steer budget: ${config.steerBudget === 0 ? "off" : `${config.steerBudget} per run`}.`,
                         formatSteers(stats),
                         `Thresholds: irreversible warn ${config.action.irreversible.warn} / hold ${config.action.irreversible.confirm}; off-task warn ${config.action.offTask.warn} / steer ${config.action.offTask.steer} (never holds); intent mismatch ${config.action.intentMismatch} (${config.action.visibleMismatch} on a visible action); stuck same-strategy ${config.stuck.sameStrategy} after ${config.stuck.minFailures} failures; done claims ${config.done.claimsDone}; slop ${config.slop.threshold}, rules ${config.rules.threshold}, prose ${config.slop.prose.threshold} in ${config.slop.prose.trend}/3 replies; runaway ${config.runaway.repeats} repeats (thinking ${config.runaway.thinkingRepeats}), recover ${config.runaway.recover}; failOpen ${config.action.failOpen}.`,
                         formatLedger(ledger.snapshot()),
+                        ...(config.learning.patternAnalysis ? [`Learning: ${(await generateRecommendations(ctx.cwd)).length} recommendations, steer effectiveness ${Math.round((await analyzeSteerEffectivenessReport(ctx.cwd)).overall * 100)}% (use /warden recommend for details)`] : []),
                         `${formatHolds(holds.snapshot(), config.action.feedbackLog ? holdLog?.path : undefined)}${holdLog?.lastFailure ? ` Log write failed: ${holdLog.lastFailure}.` : ""}`,
                         `Rules: ${config.rules.enabled ? `${rulesGuard.describe(ctx.cwd, config.rules)}${Object.keys(config.rules.sensitivePaths).length ? `; ${Object.keys(config.rules.sensitivePaths).length} sensitive path${Object.keys(config.rules.sensitivePaths).length === 1 ? "" : "s"}` : ""}` : "off"}.`,
                         ...(config.action.armingRules.length > 0 ? [`Arming: ${arming.statusLine() || "no rules armed"}.`] : []),
@@ -1162,6 +1230,49 @@ export default function wardenExtension(pi) {
                     togglePanel(ctx.ui, config);
                     return;
                 }
+                if (action === "recommend") {
+                    // Learning-driven recommendations based on hold history
+                    const recommendations = await generateRecommendations(ctx.cwd);
+                    const steerReport = await analyzeSteerEffectivenessReport(ctx.cwd);
+                    const lines = [];
+                    lines.push("pi-warden learning recommendations:");
+                    if (recommendations.length === 0 && steerReport.suggestions.length === 0) {
+                        lines.push(`No recommendations yet. Need more hold data (current: ${holds.snapshot().holds} holds).`);
+                    }
+                    else {
+                        if (recommendations.length > 0) {
+                            lines.push("");
+                            lines.push("Threshold & pattern recommendations:");
+                            for (const rec of recommendations.slice(0, 5)) {
+                                lines.push(`  [${rec.priority}] ${rec.message}`);
+                            }
+                        }
+                        if (steerReport.suggestions.length > 0) {
+                            lines.push("");
+                            lines.push("Steer effectiveness:");
+                            lines.push(`  Overall effectiveness: ${(steerReport.overall * 100).toFixed(0)}%`);
+                            for (const suggestion of steerReport.suggestions.slice(0, 3)) {
+                                lines.push(`  ${suggestion}`);
+                            }
+                        }
+                        if (Object.keys(steerReport.byType).length > 0) {
+                            lines.push("");
+                            lines.push("Effectiveness by type:");
+                            for (const [type, stats] of Object.entries(steerReport.byType)) {
+                                lines.push(`  ${type}: ${(stats.rate * 100).toFixed(0)}% (${stats.effective}/${stats.total})`);
+                            }
+                        }
+                        if (steerReport.topPatterns.length > 0) {
+                            lines.push("");
+                            lines.push("Top performing patterns:");
+                            for (const pattern of steerReport.topPatterns.slice(0, 3)) {
+                                lines.push(`  ${pattern.pattern}: ${(pattern.effectiveness * 100).toFixed(0)}% effectiveness (${pattern.sampleSize} samples)`);
+                            }
+                        }
+                    }
+                    report(lines.join("\n"));
+                    return;
+                }
                 if (action === "enable") {
                     if (!ctx.hasUI) {
                         report("Consent needs an interactive session. For headless runs set PI_WARDEN_ENABLED=1 and TYPESAFE_API_KEY explicitly.", "warning");
@@ -1196,39 +1307,45 @@ export default function wardenExtension(pi) {
                     return;
                 }
                 if (action === "config") {
-                    if (!ctx.hasUI) {
-                        report(`Edit ${userConfigPath()} directly. Defaults: ${JSON.stringify(defaultConfig())}`);
+                    if (argument && argument.startsWith("set ")) {
+                        const rest = argument.slice(4).trim();
+                        const spaceIndex = rest.indexOf(" ");
+                        if (spaceIndex === -1) {
+                            report("Usage: /warden config set <key> <value>", "warning");
+                            return;
+                        }
+                        const keyPath = rest.slice(0, spaceIndex).trim();
+                        const rawValue = rest.slice(spaceIndex + 1).trim();
+                        const value = parseConfigValue(rawValue);
+                        const current = readUserConfig();
+                        const updated = setNestedValue(current, keyPath, value);
+                        const savedPath = writeUserConfig(updated);
+                        client = undefined;
+                        report(`Saved ${keyPath} = ${JSON.stringify(value)}.`);
                         return;
                     }
-                    const current = readUserConfig();
-                    const seed = Object.keys(current).length ? current : { ...defaultConfig(), typesafe: config.typesafe };
-                    const text = await ctx.ui.editor(`pi-warden config · ${userConfigPath()}`, JSON.stringify(seed, null, 2));
-                    if (text === undefined)
+                    if (argument && argument.startsWith("get ")) {
+                        const keyPath = argument.slice(4).trim();
+                        const current = readUserConfig();
+                        const value = getNestedValue(current, keyPath);
+                        const defaultValue = getNestedValue(defaultConfig(), keyPath);
+                        report(value === undefined ? `${keyPath} not set (default: ${JSON.stringify(defaultValue)})` : `${keyPath} = ${JSON.stringify(value)}`);
                         return;
-                    let parsed;
-                    try {
-                        parsed = JSON.parse(text);
                     }
-                    catch {
-                        report("Invalid JSON; nothing was saved.", "error");
+                    if (!ctx.hasUI || !lastUi) {
+                        report(`Edit ${userConfigPath()} directly. Use /warden config set <key> <value> for quick changes.`);
                         return;
                     }
-                    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
-                        report("The config must be a JSON object; nothing was saved.", "error");
-                        return;
-                    }
-                    const path = writeUserConfig(parsed);
-                    const effective = applyUserOverrides(defaultConfig(), parsed);
-                    client = undefined;
-                    report(`Saved ${path}. Effective: guard ${effective.enabled && effective.action.enabled ? "on" : "off"}, mode ${effective.mode}, TypeSafe ${effective.typesafe ? "on" : "off"}, tools ${effective.action.tools.join(", ")}, irreversible hold ≥ ${effective.action.irreversible.confirm}, off-task steer ≥ ${effective.action.offTask.steer}, stuck ${effective.stuck.enabled ? "on" : "off"}, done-check ${effective.done.enabled ? "on" : "off"}, slop ${effective.slop.enabled ? "on" : "off"}.`);
+                    openConfigPanel(lastUi, config, { width: config.widget.panelWidth });
                     return;
                 }
                 if (action === "test") {
                     const judge = judgeFor(config);
-                    if (judge && ctx.hasUI && !await ctx.ui.confirm("Send one synthetic pi-warden test request?", `A synthetic action ("rm -rf /tmp/pi-warden-demo" for the task "Clean up the demo directory") goes to api.typesafe.ai and may incur charges. ${disclosure}`))
+                    if (judge && ctx.hasUI && !await ctx.ui.confirm("Send one synthetic pi-warden test request?", `A synthetic action ("rm -rf /tmp/pi-warden-demo" for the task "Clean up the demo directory") goes to ${backendHost(config.typesafeBackend)} and may incur charges. ${disclosureFor(config.typesafeBackend, disclosure)}`))
                         return;
                     const verdict = await evaluateAction({ tool: "bash", input: { command: "rm -rf /tmp/pi-warden-demo" }, cwd: ctx.cwd, task: "Clean up the demo directory" }, { config: { ...config.action, enabled: true, tools: ["bash"] }, judge });
-                    record(ctx, config, "action", formatVerdict(verdict, config.widget.action), actionDetails(verdict, { mode: activeMode(config, ctx.hasUI) }));
+                    const fmt = formatVerdictTokens(verdict, config.widget.action);
+                    record(ctx, config, "action", fmt.line, actionDetails(verdict, { mode: activeMode(config, ctx.hasUI) }), fmt.tokens);
                     report(`${formatVerdict(verdict)}${verdict.reasons.length ? ` — ${verdict.reasons.join("; ")}` : ""}${judge ? "" : " (pattern checks only: TypeSafe judgments are not enabled or no key is configured)"}${verdict.error ? ` — ${verdict.error}` : ""}`);
                     if (verdict.level === "confirm") {
                         const mode = activeMode(config, ctx.hasUI);