pi-warden 0.73.0 → 0.74.0

package/CHANGELOG.md

@@ -8,6 +8,23 @@ How to keep this current: add the entry in the same pull request as the change,
 
 <!-- Empty. Next release starts here. -->
 
+## 0.74.0
+
+### Added
+
+- `typesafeBackend` accepts `"commandcode"`: judgments go to api.commandcode.ai under `/provider/v1/systemone`, with the key from `COMMANDCODE_API_KEY` and the model `typesafe/jev`.
+- `typesafeBackend` accepts a caller-supplied endpoint object (`{ "label", "host", "path", "keyEnv", "defaultModel" }`, plus optional model-list fields) for a gateway that serves the same decisions protocol (pi-typesafe 0.8.0). The object is passed to the judge as written and validated on every call. It reads only its own `keyEnv` variable: the TypeSafe key and the `/typesafe login` store are never sent to it. `/warden status`, the `/warden enable` dialog, and the `/warden test` confirmation name the label, host, and model sent for any non-TypeSafe backend, and the consent disclosure names the real destination host.
+
+### Changed
+
+- An unknown `typesafeBackend` name, or an endpoint object the judge refuses, no longer silently falls back to `"typesafe"`: judgments turn off, the refusal message is shown once and in `/warden status`, and nothing is sent to api.typesafe.ai because a value was mistyped.
+
+## 0.73.1
+
+### Tests
+
+- `tests/host-compat.test.ts`: the fake host's per-handler timeout stays referenced while a dispatch runs and is cleared before `emit()` returns, so an awaited `emit()` always has a loop wakeup. The timer was unref'd, so on Node 22 the event loop could drain mid-dispatch and node:test cancelled the rest of the file with `Promise resolution is still pending but the event loop has already resolved`.
+
 ## 0.73.0
 
 ### Fixed

package/dist/backend.d.ts

@@ -1,16 +1,37 @@
-import type { TypeSafeOptions } from "pi-typesafe";
-/** The judgment backend that receives pi-warden's Jev requests. */
-export type JudgmentBackend = "typesafe" | "openrouter";
-/** Why no judge is available: consent not given, no key for the backend, a saved 401 or 403, or the request budget spent. */
-export type JudgmentsOffReason = "no_consent" | "no_key" | "key_rejected" | "budget";
-/** The host the consent disclosure names as the destination, without scheme: `api.typesafe.ai`, `openrouter.ai`. */
-export declare function backendHost(backend: JudgmentBackend): string;
-/** The environment variable that carries the backend's key, for messages that tell the user what to set. */
-export declare function keyEnvFor(backend: JudgmentBackend): string;
-/** Whether the backend takes the TypeSafe key, the only one `/typesafe login` stores; pi-typesafe's `usesTypesafeKey`, which its package does not export. */
-export declare function loginStoresKey(backend: JudgmentBackend): boolean;
+import type { BackendSpec, TypeSafeOptions } from "pi-typesafe";
+/** The judgment backend: a registry name ("typesafe", "openrouter", "commandcode") or a caller-supplied endpoint object. */
+export type JudgmentBackend = BackendSpec;
+/** The judgment destination as the config carries it, plus the refusal that turns judgments off when the configured value was refused. */
+export interface BackendSetting {
+    /** The spec judgments go to; undefined only when the configured value was refused. */
+    readonly typesafeBackend: JudgmentBackend | undefined;
+    /** Why the configured value was refused: the once-per-session notice and `/warden status` quote it. */
+    readonly backendRefusal: string | undefined;
+}
+/** What a raw `typesafeBackend` value resolves to: the spec judgments go to, or the refusal that turns them off. Exactly one is set. */
+export type BackendResolution = {
+    readonly typesafeBackend: JudgmentBackend;
+    readonly backendRefusal?: undefined;
+} | {
+    readonly typesafeBackend?: undefined;
+    readonly backendRefusal: string;
+};
+/** Why no judge is available: consent not given, the backend refused, no key for the backend, a saved 401 or 403, or the request budget spent. */
+export type JudgmentsOffReason = "no_consent" | "bad_backend" | "no_key" | "key_rejected" | "budget";
+/**
+ * Resolve a raw config value to the spec judgments go to, kept as written, or to the refusal that turns judgments off.
+ * pi-typesafe validates the spec again on every call. An unknown name or an object it refuses is never silently mapped
+ * to the default backend: a mistyped value must not send judgments to api.typesafe.ai.
+ */
+export declare function resolveJudgmentBackend(raw: unknown): BackendResolution;
+/** The name messages show for a backend: the registry name, or an endpoint's validated label. */
+export declare function backendName(backend: JudgmentBackend | undefined): string;
+/** Whether the backend takes the TypeSafe key, the only one `/typesafe login` stores; true only for "typesafe". */
+export declare function loginStoresKey(backend: JudgmentBackend | undefined): boolean;
+/** One phrase naming where judgments go — the label, the host, and the model sent — for consent text and status lines. */
+export declare function describeBackend(backend: JudgmentBackend | undefined): string;
 /** Adapt the consent text to the active backend by substituting the destination host. */
-export declare function disclosureFor(backend: JudgmentBackend, disclosure: string): string;
+export declare function disclosureFor(backend: JudgmentBackend | undefined, disclosure: string): string;
 /**
  * Build the options forwarded to `createTypeSafe`.
  * The caller must gate on `authState({ backend }).usable` before calling `createTypeSafe`.
@@ -20,5 +41,3 @@ export declare function judgeOptions(config: {
     timeoutMs: number;
     typesafeBackend: JudgmentBackend;
 }): TypeSafeOptions;
-/** Resolve the effective backend from a raw config value; invalid values fall back to "typesafe". */
-export declare function resolveBackend(raw: unknown): JudgmentBackend;

package/dist/backend.js

@@ -1,19 +1,36 @@
-import { DECISIONS_BACKENDS, DEFAULT_BACKEND } from "pi-typesafe";
-/** The host the consent disclosure names as the destination, without scheme: `api.typesafe.ai`, `openrouter.ai`. */
-export function backendHost(backend) {
-    return new URL(DECISIONS_BACKENDS[backend].host).host;
+import { DEFAULT_BACKEND, backendHost, resolveBackend } from "pi-typesafe";
+/**
+ * Resolve a raw config value to the spec judgments go to, kept as written, or to the refusal that turns judgments off.
+ * pi-typesafe validates the spec again on every call. An unknown name or an object it refuses is never silently mapped
+ * to the default backend: a mistyped value must not send judgments to api.typesafe.ai.
+ */
+export function resolveJudgmentBackend(raw) {
+    if (raw === undefined || raw === null)
+        return { typesafeBackend: DEFAULT_BACKEND };
+    try {
+        resolveBackend(raw);
+    }
+    catch (error) {
+        return { backendRefusal: error instanceof Error ? error.message : String(error) };
+    }
+    return { typesafeBackend: raw };
 }
-/** The environment variable that carries the backend's key, for messages that tell the user what to set. */
-export function keyEnvFor(backend) {
-    return DECISIONS_BACKENDS[backend].keyEnv ?? DECISIONS_BACKENDS[DEFAULT_BACKEND].keyEnv ?? "TYPESAFE_API_KEY";
+/** The name messages show for a backend: the registry name, or an endpoint's validated label. */
+export function backendName(backend) {
+    return backend === undefined ? DEFAULT_BACKEND : typeof backend === "string" ? backend : resolveBackend(backend).label;
 }
-/** Whether the backend takes the TypeSafe key, the only one `/typesafe login` stores; pi-typesafe's `usesTypesafeKey`, which its package does not export. */
+/** Whether the backend takes the TypeSafe key, the only one `/typesafe login` stores; true only for "typesafe". */
 export function loginStoresKey(backend) {
-    return keyEnvFor(backend) === keyEnvFor(DEFAULT_BACKEND);
+    return backend === DEFAULT_BACKEND;
+}
+/** One phrase naming where judgments go — the label, the host, and the model sent — for consent text and status lines. */
+export function describeBackend(backend) {
+    const resolved = resolveBackend(backend);
+    return `${resolved.label} at ${backendHost(backend)}, model ${resolved.defaultModel ?? "none configured"}`;
 }
 /** Adapt the consent text to the active backend by substituting the destination host. */
 export function disclosureFor(backend, disclosure) {
-    return backend === DEFAULT_BACKEND ? disclosure : disclosure.replace(backendHost(DEFAULT_BACKEND), backendHost(backend));
+    return backend === undefined || backend === DEFAULT_BACKEND ? disclosure : disclosure.replace(backendHost(DEFAULT_BACKEND), backendHost(backend));
 }
 /**
  * Build the options forwarded to `createTypeSafe`.
@@ -26,7 +43,3 @@ export function judgeOptions(config) {
         ...(config.typesafeBackend === DEFAULT_BACKEND ? {} : { backend: config.typesafeBackend }),
     };
 }
-/** Resolve the effective backend from a raw config value; invalid values fall back to "typesafe". */
-export function resolveBackend(raw) {
-    return raw === "typesafe" || raw === "openrouter" ? raw : DEFAULT_BACKEND;
-}

package/dist/config.d.ts

@@ -368,8 +368,10 @@ export interface WardenConfig {
     enabled: boolean;
     /** Consent to send task and action summaries to api.typesafe.ai. Set by /warden enable; never by a project file. */
     typesafe: boolean;
-    /** The decisions service the judgments go to. User file only: a project must not redirect judgments to another vendor. */
-    typesafeBackend: JudgmentBackend;
+    /** The decisions service the judgments go to: a name ("typesafe", "openrouter", "commandcode") or a caller-supplied endpoint object. User file only: a project must not redirect judgments to another vendor. Undefined when the configured value was refused. */
+    typesafeBackend: JudgmentBackend | undefined;
+    /** Why the configured typesafeBackend was refused: judgments stay off, and the once-per-session notice and /warden status quote this. */
+    backendRefusal: string | undefined;
     /**
      * steer (default): a confirm-level call is held and the agent receives the judgment as its tool result, so it re-plans or asks
      * the user in chat. confirm: open a dialog and let the user decide (falls back to steer without a UI). advise: never hold; report only.

package/dist/config.js

@@ -1,7 +1,7 @@
 import { readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { writeFileAtomicSync } from "./atomic.js";
-import { resolveBackend } from "./backend.js";
+import { resolveJudgmentBackend } from "./backend.js";
 import { defaultHostDirs } from "./host-dirs.js";
 import { COMMAND_TOOLS } from "./tools.js";
 import { defaultWidgetConfig } from "./widget.js";
@@ -31,6 +31,7 @@ export function defaultConfig() {
         enabled: true,
         typesafe: false,
         typesafeBackend: "typesafe",
+        backendRefusal: undefined,
         mode: "steer",
         timeoutMs: 5000,
         maxRequests: 500,
@@ -482,10 +483,12 @@ export function applyUserOverrides(base, raw) {
     if (!isObject(raw))
         return base;
     const shared = applyShared(base, raw);
+    const backend = resolveJudgmentBackend(raw.typesafeBackend);
     return {
         enabled: boolean(raw.enabled, base.enabled),
         typesafe: boolean(raw.typesafe, base.typesafe),
-        typesafeBackend: resolveBackend(raw.typesafeBackend),
+        typesafeBackend: backend.typesafeBackend,
+        backendRefusal: backend.backendRefusal,
         mode: isMode(raw.mode) ? raw.mode : base.mode,
         ...shared,
         ...applyGuards(base, raw, shared.timeoutMs, "user"),

package/dist/conscience.d.ts

@@ -66,7 +66,7 @@ export interface AssessmentResult {
     /** Number of judge requests issued for this assessment. */
     requestCount: number;
 }
-export type SkipReason = "disabled" | "no_consent" | "no_key" | "key_rejected" | "no_match" | "already_supplied" | "awaiting_user" | "timeout" | "error" | "stale" | "catalog_unavailable" | "catalog_limit" | "metadata_unsafe" | "budget" | "explicit_skill" | "origin_unknown" | "below_threshold";
+export type SkipReason = "disabled" | "no_consent" | "bad_backend" | "no_key" | "key_rejected" | "no_match" | "already_supplied" | "awaiting_user" | "timeout" | "error" | "stale" | "catalog_unavailable" | "catalog_limit" | "metadata_unsafe" | "budget" | "explicit_skill" | "origin_unknown" | "below_threshold";
 /** Score levels for the usefulness question. Levels are ordered from least to most useful. */
 export declare const SCORE_LEVELS: readonly ["No useful contribution to the current request, or conflicts with the supplied constraints.", "Related to the subject, but already covered, premature, or unable to resolve the current need.", "Addresses a concrete unmet need at the current step without displacing the active workflow.", "Supplies a missing prerequisite or directly applicable documented method needed for the current step."];
 /** Strip absolute paths, URLs, and credentials from a description. */

package/dist/extension.d.ts

@@ -1,6 +1,6 @@
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import type { HostDirs } from "./host-dirs.js";
-import type { JudgmentBackend, JudgmentsOffReason } from "./backend.js";
+import type { BackendSetting, JudgmentsOffReason } from "./backend.js";
 import type { ToolCallRef } from "./action-guard.js";
 import type { SlopSymptom, Verdict } from "./guard.js";
 import type { ShapeResult } from "./shape.js";
@@ -37,7 +37,7 @@ export declare function assistantPlan(ctx: ExtensionContext, visibleAction?: boo
  * variable that holds a rejected key, or undefined when the rejected key is the one `/typesafe login` saved. Never
  * names a key value or a path.
  */
-export declare function judgmentsOffText(reason: Exclude<JudgmentsOffReason, "budget">, backend: JudgmentBackend, headless: boolean, rejectedEnv?: string): string;
+export declare function judgmentsOffText(reason: Exclude<JudgmentsOffReason, "budget">, setting: BackendSetting, headless: boolean, rejectedEnv?: string): string;
 export declare function confirmMessage(verdict: Verdict): string;
 /** Names each symptom and its fix; repeats in the session turn the note into a standing rule. */
 export declare function slopSteer(where: string, symptoms: readonly SlopSymptom[], counts: Record<SlopSymptom, number>): string;

package/dist/extension.js

@@ -6,9 +6,9 @@ import { CONFIG_DIR_NAME, getAgentDir } from "@earendil-works/pi-coding-agent";
 import { defaultHostDirs } from "./host-dirs.js";
 import * as tuiModule from "@earendil-works/pi-tui";
 const MouseRegion = tuiModule.MouseRegion;
-import { authState, createTypeSafe, describeAuth } from "pi-typesafe";
+import { authState, backendHost, createTypeSafe, describeAuth, resolveBackend } from "pi-typesafe";
 import { ensureApiKey } from "pi-typesafe/ui";
-import { backendHost, disclosureFor, judgeOptions, keyEnvFor, loginStoresKey, resolveBackend } from "./backend.js";
+import { backendName, describeBackend, disclosureFor, judgeOptions, loginStoresKey } from "./backend.js";
 import { ActionGuard } from "./action-guard.js";
 import { adaptHost } from "./host-compat.js";
 import { assistantView, formatMuted, NEVER_MUTED, STEER_KINDS, SteerStats, SteerWatch, steerStatsPath } from "./adaptive.js";
@@ -201,10 +201,11 @@ function planForCall(entries) {
  * variable that holds a rejected key, or undefined when the rejected key is the one `/typesafe login` saved. Never
  * names a key value or a path.
  */
-export function judgmentsOffText(reason, backend, headless, rejectedEnv) {
+export function judgmentsOffText(reason, setting, headless, rejectedEnv) {
     switch (reason) {
         case "no_consent": return `warden: Jev judgments are off (no consent). ${headless ? "Set PI_WARDEN_ENABLED=1." : "Run /warden enable."}`;
-        case "no_key": return `warden: Jev judgments are off (no key for ${backend}). Set ${keyEnvFor(backend)}${loginStoresKey(backend) ? " or run /typesafe login" : ""}.`;
+        case "bad_backend": return `warden: Jev judgments are off (typesafeBackend refused: ${setting.backendRefusal ?? "the configured value is not usable"})`;
+        case "no_key": return `warden: Jev judgments are off (no key for ${backendName(setting.typesafeBackend)}). Set ${resolveBackend(setting.typesafeBackend).keyEnv}${loginStoresKey(setting.typesafeBackend) ? " or run /typesafe login" : ""}.`;
         case "key_rejected": return rejectedEnv
             ? `warden: Jev judgments are off (the key in ${rejectedEnv} was rejected). Check the key, then run /warden status.`
             : "warden: Jev judgments are off (the key saved by /typesafe login was rejected). Run /typesafe login.";
@@ -557,11 +558,15 @@ export default function wardenExtension(host) {
     const consentGiven = (config) => config.typesafe || process.env.PI_WARDEN_ENABLED === "1";
     /** Why no judge is available, or undefined when one is. The notice, the trace file, and the conscience all use it. */
     const judgmentsOffReason = (config) => {
+        // A refused backend is a config error the user must see even before consent or keys matter.
+        const backend = config.typesafeBackend;
+        if (config.backendRefusal !== undefined || backend === undefined)
+            return "bad_backend";
         if (!consentGiven(config))
             return "no_consent";
         if (budgetExhausted)
             return "budget";
-        const auth = authState({ backend: config.typesafeBackend });
+        const auth = authState({ backend });
         if (auth.usable)
             return undefined;
         // No key in effect, or one whose last request came back 401 or 403.
@@ -578,8 +583,8 @@ export default function wardenExtension(host) {
         if (reason === undefined || reason === "budget" || judgmentsReported.has(reason))
             return;
         judgmentsReported.add(reason);
-        const auth = reason === "key_rejected" ? authState({ backend: config.typesafeBackend }) : undefined;
-        judgmentsNotify?.(judgmentsOffText(reason, config.typesafeBackend, judgmentsHeadless, auth?.kind === "environment" ? auth.keyName : undefined));
+        const auth = reason === "key_rejected" && config.typesafeBackend !== undefined ? authState({ backend: config.typesafeBackend }) : undefined;
+        judgmentsNotify?.(judgmentsOffText(reason, config, judgmentsHeadless, auth?.kind === "environment" ? auth.keyName : undefined));
     };
     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; check the key state for the chosen backend. */
@@ -594,7 +599,26 @@ export default function wardenExtension(host) {
             stats.cooldownSkips++;
             return undefined;
         }
-        return client ??= watched(createTypeSafe(judgeOptions(config)));
+        if (client)
+            return client;
+        const backend = config.typesafeBackend;
+        // Reached only if a config ever sets no backend and no refusal at once; treating it as off keeps the invariant.
+        if (backend === undefined)
+            return undefined;
+        try {
+            client = watched(createTypeSafe(judgeOptions({ maxRequests: config.maxRequests, timeoutMs: config.timeoutMs, typesafeBackend: backend })));
+        }
+        catch (error) {
+            // An endpoint the config accepts can still be unusable (one that names no defaultModel); a hook must never crash.
+            const message = error instanceof Error ? error.message : String(error);
+            if (!judgmentsReported.has("bad_backend")) {
+                judgmentsReported.add("bad_backend");
+                traceFile?.judgments(judgmentsState("bad_backend"));
+                judgmentsNotify?.(`warden: Jev judgments are off (typesafeBackend refused: ${message})`);
+            }
+            return undefined;
+        }
+        return client;
     };
     /** Every guard reaches the backend through `evaluate`, so this one seam sees each failure and each success. */
     const watched = (typesafe) => new Proxy(typesafe, {
@@ -625,7 +649,7 @@ export default function wardenExtension(host) {
         }
         const seconds = Math.round(event.ms / 1000);
         const remedy = event.kind === "auth"
-            ? ` Set ${keyEnvFor(judgeConfig?.typesafeBackend ?? "typesafe")} or run /warden enable.`
+            ? ` Set ${resolveBackend(judgeConfig?.typesafeBackend).keyEnv} or run /warden enable.`
             : event.kind === "configuration" ? " /warden status shows the backend setup." : "";
         noticeUi.notify(`warden: judgments paused for ${seconds}s after a ${event.kind} failure; pattern checks run alone until then.${remedy}`, "warning");
     };
@@ -2686,7 +2710,9 @@ export default function wardenExtension(host) {
             try {
                 const config = configFor(ctx);
                 if (action === "status") {
-                    const auth = describeAuth(authState({ backend: config.typesafeBackend }));
+                    // A refused backend has no key to describe; the refusal itself is the status line.
+                    const backend = config.typesafeBackend;
+                    const auth = config.backendRefusal !== undefined || backend === undefined ? undefined : describeAuth(authState({ backend }));
                     const source = consentSource(config);
                     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(", ");
@@ -2695,7 +2721,7 @@ export default function wardenExtension(host) {
                         ? `Lifetime here: ${ls.held} hold${ls.held === 1 ? "" : "s"}, not yet measurable (${ls.allowed} allowed).`
                         : `Lifetime here: ${ls.held} hold${ls.held === 1 ? "" : "s"}, ${ls.labeled} labeled, ${ls.declined + ls.replanned} stood (${ls.declined + ls.replanned}/${ls.labeled}), ${ls.allowed} allowed (${ls.accepted} accepted, ${ls.regretted} regretted).`;
                     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)"}${config.typesafeBackend !== "typesafe" ? ` (${config.typesafeBackend})` : ""}; ${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.backendRefusal !== undefined || backend === undefined || backend === "typesafe" ? "" : ` (${describeBackend(backend)})`}; ${config.backendRefusal !== undefined ? `judgments are off: typesafeBackend refused: ${config.backendRefusal}` : 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.offPlanTraceOnly} trace-only), ${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, ${stats.cooldownSkips} checks without Jev during a judge cooldown; ${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),
                         `${formatMuted(steerStats.muted(), config.steers)}${stats.steersMuted ? ` This session: ${stats.steersMuted} steer${stats.steersMuted === 1 ? "" : "s"} kept in the trace only.` : ""}`,
@@ -2730,7 +2756,7 @@ export default function wardenExtension(host) {
                     switch (result.status) {
                         // No key, no consent, or a spent budget: say why and send nothing.
                         case "no-judge":
-                            report(`Rules audit sent nothing: Jev judgments are off${off === "budget" ? " (the request budget is used up)" : ""}.${off && off !== "budget" ? ` ${judgmentsOffText(off, config.typesafeBackend, !ctx.hasUI)}` : ""}`);
+                            report(`Rules audit sent nothing: Jev judgments are off${off === "budget" ? " (the request budget is used up)" : ""}.${off && off !== "budget" ? ` ${judgmentsOffText(off, config, !ctx.hasUI)}` : ""}`);
                             return;
                         case "no-files":
                             report(`Rules audit sent nothing: ${result.reason}.`);
@@ -2759,7 +2785,7 @@ export default function wardenExtension(host) {
                     switch (result.status) {
                         // No key, no consent, or a spent budget: say why and send nothing.
                         case "no-judge":
-                            report(`Bench sent nothing: Jev judgments are off${off === "budget" ? " (the request budget is used up)" : ""}.${off && off !== "budget" ? ` ${judgmentsOffText(off, config.typesafeBackend, !ctx.hasUI)}` : ""}`);
+                            report(`Bench sent nothing: Jev judgments are off${off === "budget" ? " (the request budget is used up)" : ""}.${off && off !== "budget" ? ` ${judgmentsOffText(off, config, !ctx.hasUI)}` : ""}`);
                             return;
                         case "skipped":
                             report(`Bench sent nothing: ${result.reason}.`);
@@ -2776,7 +2802,7 @@ export default function wardenExtension(host) {
                         const result = await checkRules({ set: rulesGuard.store.load(ctx.cwd, config.rules), judge: judgeFor(config), timeoutMs: config.timeoutMs, signal: ctx.signal });
                         if (result.source === "skipped") {
                             // No key, no consent, or a spent budget: say why and send nothing.
-                            report(`Rules check sent nothing: Jev judgments are off${off === "budget" ? " (the request budget is used up)" : ""}.${off && off !== "budget" ? ` ${judgmentsOffText(off, config.typesafeBackend, !ctx.hasUI)}` : ""} /warden rules shows the rule set locally.`);
+                            report(`Rules check sent nothing: Jev judgments are off${off === "budget" ? " (the request budget is used up)" : ""}.${off && off !== "budget" ? ` ${judgmentsOffText(off, config, !ctx.hasUI)}` : ""} /warden rules shows the rule set locally.`);
                             return;
                         }
                         if (result.source === "typesafe")
@@ -2811,7 +2837,7 @@ export default function wardenExtension(host) {
                         const off = judgmentsOffReason(config);
                         const judge = judgeFor(config);
                         if (!judge) {
-                            report(`Rules calibrate sent nothing: Jev judgments are off${off === "budget" ? " (the request budget is used up)" : ""}.${off && off !== "budget" ? ` ${judgmentsOffText(off, config.typesafeBackend, !ctx.hasUI)}` : ""} /warden rules shows the rule set locally.`);
+                            report(`Rules calibrate sent nothing: Jev judgments are off${off === "budget" ? " (the request budget is used up)" : ""}.${off && off !== "budget" ? ` ${judgmentsOffText(off, config, !ctx.hasUI)}` : ""} /warden rules shows the rule set locally.`);
                             return;
                         }
                         let history;
@@ -2991,15 +3017,24 @@ export default function wardenExtension(host) {
                     return;
                 }
                 if (action === "enable") {
+                    if (config.backendRefusal !== undefined) {
+                        report(`Cannot enable judgments: typesafeBackend refused: ${config.backendRefusal} Fix the value in ${userConfigPath(dirs)}, then run /warden enable again.`, "warning");
+                        return;
+                    }
+                    const backend = config.typesafeBackend;
                     if (!ctx.hasUI) {
-                        report(`Consent needs an interactive session. For headless runs set PI_WARDEN_ENABLED=1 and ${keyEnvFor(config.typesafeBackend)} explicitly.`, "warning");
+                        report(`Consent needs an interactive session. For headless runs set PI_WARDEN_ENABLED=1 and ${resolveBackend(backend).keyEnv} explicitly.`, "warning");
                         return;
                     }
-                    if (!await ctx.ui.confirm("Enable TypeSafe judgments for pi-warden?", disclosure))
+                    // For a non-TypeSafe backend the dialog names who answers: the label, host, and model sent.
+                    const consentText = backend === undefined || backend === "typesafe"
+                        ? disclosure
+                        : `Judgments go to ${describeBackend(backend)}. ${disclosureFor(backend, disclosure)}`;
+                    if (!await ctx.ui.confirm("Enable TypeSafe judgments for pi-warden?", consentText))
                         return;
                     // One flow: consent, then a key if none is configured yet. TypeSafe prompts, verifies, and stores the key for every
                     // pi-typesafe consumer; any other backend has no login, so a missing key is reported with the variable to set.
-                    const key = await ensureApiKey(ctx, { backend: config.typesafeBackend });
+                    const key = await ensureApiKey(ctx, backend === undefined ? {} : { backend });
                     if (!key) {
                         report("No key entered; pi-warden stays on pattern checks only. Run /warden enable again when you have a key from console.typesafe.ai.", "warning");
                         return;
@@ -3007,7 +3042,7 @@ export default function wardenExtension(host) {
                     const path = setUserSetting("typesafe", true, dirs);
                     client = undefined;
                     budgetExhausted = false;
-                    report(`TypeSafe judgments enabled and saved to ${path}${key.login ? `; key verified (${key.login.models} model${key.login.models === 1 ? "" : "s"}) and stored at ${key.login.path}` : ` using the ${key.source === "stored" ? "stored key" : `key from ${keyEnvFor(config.typesafeBackend)}`}`}. This stays on in new sessions until /warden disable.`);
+                    report(`TypeSafe judgments enabled and saved to ${path}${key.login ? `; key verified (${key.login.models} model${key.login.models === 1 ? "" : "s"}) and stored at ${key.login.path}` : ` using the ${key.source === "stored" ? "stored key" : `key from ${resolveBackend(config.typesafeBackend).keyEnv}`}`}. This stays on in new sessions until /warden disable.`);
                     return;
                 }
                 if (action === "disable") {
@@ -3149,7 +3184,10 @@ export default function wardenExtension(host) {
                 }
                 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 "Prepare the demo environment") goes to ${backendHost(config.typesafeBackend)} and may incur charges. ${disclosureFor(config.typesafeBackend, disclosure)}`))
+                    // For a non-TypeSafe backend the confirmation names who answers: the label, host, and model sent.
+                    const backend = config.typesafeBackend;
+                    const destination = backend === undefined || backend === "typesafe" ? backendHost(backend) : describeBackend(backend);
+                    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 "Prepare the demo environment") goes to ${destination} 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: "Prepare the demo environment" }, { config: { ...config.action, enabled: true, tools: ["bash"] }, judge, rules: config.rules });
                     const deliveryVerdict = ctx.hasUI ? verdict : agentDeliveryVerdict(verdict);

package/dist/shape.js

@@ -1,5 +1,5 @@
 import { isMode } from "./config.js";
-import { resolveBackend } from "./backend.js";
+import { resolveJudgmentBackend } from "./backend.js";
 import { redact } from "./redact.js";
 import { DEFAULT_TEMPLATES } from "./widget.js";
 /** The config layout this extension build expects; compared with the loaded config module's CONFIG_SCHEMA. */
@@ -8,6 +8,10 @@ const off = { enabled: false };
 // Duplicated from defaultConfig(): this file must work when the config module is stale and lacks the key.
 const coreTools = () => ["read", "bash", "edit", "write", "grep", "find", "ls"];
 const proseOff = () => ({ ...off, audience: "technical", threshold: 1, trend: 3, minChars: 1 });
+// A stale config module hands back either its own resolution or a raw value; both end up resolved here.
+const resolveSetting = (source) => source.backendRefusal !== undefined
+    ? { typesafeBackend: source.typesafeBackend, backendRefusal: source.backendRefusal }
+    : resolveJudgmentBackend(source.typesafeBackend);
 /**
  * `loadConfig()` always returns a complete object, yet live sessions crashed at `config.slop.prose.enabled` after a package
  * update. A partially updated module graph (extension from one version, config from another) is the only known way to get
@@ -23,10 +27,12 @@ export function completeConfig(loaded) {
         missing.push(key);
         return fallback;
     };
+    const backend = resolveSetting(source);
     const config = {
         enabled: source.enabled ?? true,
         typesafe: source.typesafe ?? false,
-        typesafeBackend: resolveBackend(source.typesafeBackend),
+        typesafeBackend: backend.typesafeBackend,
+        backendRefusal: backend.backendRefusal,
         mode: isMode(source.mode) ? source.mode : "steer",
         timeoutMs: source.timeoutMs ?? 5000,
         maxRequests: source.maxRequests ?? 500,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-warden",
-  "version": "0.73.0",
+  "version": "0.74.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",
@@ -63,8 +63,8 @@
     "eval:judge": "node scripts/judge-bench.mjs",
     "eval:replay": "node scripts/rules-replay.mjs",
     "eval:rules": "node scripts/rules-bench.mjs",
-    "eval:replay": "node scripts/rules-replay.mjs",
-    "eval:rules-turn": "node scripts/rules-turn-bench.mjs"  },
+    "eval:rules-turn": "node scripts/rules-turn-bench.mjs"
+  },
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": ">=0.85.1 <1",
     "@earendil-works/pi-tui": ">=0.85.1 <1"
@@ -85,6 +85,6 @@
     "typescript": "^6.0.0"
   },
   "dependencies": {
-    "pi-typesafe": "^0.7.0"
+    "pi-typesafe": "^0.8.0"
   }
 }