pi-warden 0.38.3 → 0.40.2

package/dist/extension.js

@@ -1,11 +1,12 @@
-import { existsSync } from "node:fs";
+import { existsSync, readFileSync, statSync } from "node:fs";
 import { rm } from "node:fs/promises";
-import { join } from "node:path";
+import { join, resolve as pathResolve } from "node:path";
+import { homedir } from "node:os";
 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 { backendHost, disclosureFor, judgeOptions, keyEnvFor, resolveBackend } from "./backend.js";
 import { ActionGuard } from "./action-guard.js";
 import { ArmingTracker, unparseableArmingRules } from "./arming.js";
 import * as configModule from "./config.js";
@@ -19,7 +20,7 @@ import { evaluateProse, proseNudge, ProseTrend, RESTATE_MIN_SENTENCES, RESTATE_S
 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 { formatRules, pathNoteSteer, RulesGuard, rulesSteer, RULES_FILE, FALLBACK_FILES } from "./rules.js";
 import { checkPiWardenMissing } from "./rules-file.js";
 import { writeStarterRules, buildInitPrompt } from "./init.js";
 import { buildAuditPrompt, findProjects, snapshotReport, reportOutcome } from "./audit.js";
@@ -27,7 +28,9 @@ import { detectNotifier, sendNotification } from "./notify.js";
 import { formatRunaway, RunawayMonitor, runawayNudge } from "./runaway.js";
 import { AttemptWindow, evaluateStuck, formatStuck, makeAttempt, resultFailed, stuckDiff, stuckNudge } from "./stuck.js";
 import { assess } from "./conscience.js";
-import { loadSkillBody, buildLoadMessage, policyMatches, getActivePolicy, recordFileIdentity, clearFileIdentityCache } from "./load.js";
+import { loadSkillBody, buildLoadMessage, policyMatches, CONSCIENCE_BETA_POLICY, recordFileIdentity, clearFileIdentityCache } from "./load.js";
+import { buildIndexPrompt, readIndex, writeIndex, validateIndex, indexStats, indexPath, ensureIndexDir } from "./index-cmd.js";
+import { fileContentHash } from "./hashing.js";
 /** Classify a conscience assessment error into a safe category (spec §6: never exception bodies). */
 function classifyConscienceError(err) {
     if (err && typeof err === "object" && "code" in err) {
@@ -57,7 +60,7 @@ import { buildCompactSnapshot, compactAppendix } from "./compact.js";
 import { formatWake, newReports, reportLabel, triageReport, WakePolicy } from "./subagent.js";
 import { actionDetails, doneDetails, proseDetails, rulesDetails, runawayDetails, stuckDetails, Trace } from "./trace.js";
 import { actionTokens, 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); the resolved active rules file content (pi-warden.md, the configured files, or README/CLAUDE/AGENTS as fallback, token-aware truncated at ~4000 tokens) sent with every action request unless the rules guard is off (`rules.enabled: false`), which keeps that content on this machine; 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. For the conscience coach (recommend mode): your current request (2000 redacted characters), up to four recent user/assistant text messages (500 redacted characters each with roles), and sanitized candidate metadata (skill/tool name and description only; full skill instructions never go to Jev). 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, redacted command preview, outcomes) for held and judged-allowed calls, 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.";
+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); the resolved active rules file content (pi-warden.md, the configured files, or README/CLAUDE/AGENTS as fallback, token-aware truncated at ~4000 tokens) sent with every action request unless the rules guard is off (`rules.enabled: false`), which keeps that content on this machine; 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. For the conscience coach (recommend mode): your current request (2000 redacted characters), up to four recent user/assistant text messages (500 redacted characters each with roles), and sanitized candidate metadata (skill/tool name, role, lead, useWhen, examples when an index entry matches; bare description otherwise; full skill instructions never go to Jev). The index is built locally by the session model; only sanitized entries reach Jev; advertised locations never do. 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, redacted command preview, outcomes) for held and judged-allowed calls, 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 });
@@ -240,7 +243,18 @@ export function guardCurrentSections(result) {
     return { config, missing };
 }
 /** Native Pi registration; importing the root library does not load this module. */
+let indexRunning = false;
+let indexWritePaths = [];
+/** Test-only: set the index-running state and write paths for the action guard bypass. */
+export function _testSetIndexRunning(running, paths = []) {
+    indexRunning = running;
+    indexWritePaths = paths;
+}
 export default function wardenExtension(pi) {
+    // The beta policy is held in this closure and passed to the activation gate on every delivery
+    // check; there is no module state. A question-wording change breaks the hash test and the gate
+    // fail-closes (no delivery) until the policy is re-measured.
+    const consciencePolicy = CONSCIENCE_BETA_POLICY;
     let client;
     let budgetExhausted = false;
     let stats = freshStats();
@@ -359,7 +373,7 @@ export default function wardenExtension(pi) {
     const judgeFor = (config) => {
         if (!consentGiven(config) || budgetExhausted)
             return undefined;
-        if (!keyAvailable(config.typesafeBackend, process.env, () => authState().usable))
+        if (!authState({ backend: config.typesafeBackend }).usable)
             return undefined;
         return client ??= createTypeSafe(judgeOptions(config));
     };
@@ -506,6 +520,10 @@ export default function wardenExtension(pi) {
     let queuedRevision = 0;
     let beforeAgentStartFired = false;
     let needsReassessment = false;
+    // Index state: loaded once per session, nudged once when stale.
+    let globalIndexFile;
+    let projectIndexFile;
+    let indexNudged = false;
     /** The final messages of the current run, for restatement measurement. */
     const finals = new RestatementWindow();
     /** Returns true when the message was delivered; false means it was recorded in the trace only. */
@@ -646,6 +664,11 @@ export default function wardenExtension(pi) {
         searchTool = undefined;
         notifier = undefined;
         lastNotifiedAt = 0;
+        // Load capability indexes (once per session, overwritten on every /warden index run).
+        globalIndexFile = readIndex(indexPath("global")) ?? undefined;
+        projectIndexFile = readIndex(indexPath("project", ctx.cwd)) ?? undefined;
+        indexNudged = false;
+        indexRunning = false;
         for (const symptom of Object.keys(slopCounts))
             slopCounts[symptom] = 0;
         if (ctx.hasUI)
@@ -740,6 +763,31 @@ export default function wardenExtension(pi) {
                 // Active and supplied skills
                 const activeSkills = skills.map(s => s.name);
                 const suppliedSkills = [];
+                // ── Index nudge: once per session when index is missing or stale ──
+                if (!indexNudged && (globalIndexFile === undefined || projectIndexFile === undefined)) {
+                    indexNudged = true;
+                    if (ctx.hasUI)
+                        ctx.ui.notify("pi-warden: run /warden index so the conscience recommends skills and tools from real descriptions.", "info");
+                    else
+                        record(ctx, config, "conscience", "nudge: index missing", ["trigger: before_agent_start", "nudgeReason: missing_index"]);
+                }
+                else if (!indexNudged && skills.length > 0) {
+                    // Check if any cached skill has no matching index entry
+                    const missing = skills.filter(s => {
+                        if (s.disableModelInvocation)
+                            return false;
+                        const hash = s.filePath ? fileContentHash(s.filePath) : "missing";
+                        const search = (index) => index?.entries.some(e => e.name === s.name && e.sourceHash === hash) ?? false;
+                        return !search(projectIndexFile) && !search(globalIndexFile);
+                    });
+                    if (missing.length > 0) {
+                        indexNudged = true;
+                        if (ctx.hasUI)
+                            ctx.ui.notify("pi-warden: run /warden index so the conscience recommends skills and tools from real descriptions.", "info");
+                        else
+                            record(ctx, config, "conscience", `nudge: ${missing.length} skill(s) unindexed`, ["trigger: before_agent_start", "nudgeReason: stale_index", ...missing.map(s => `unindexed: ${s.name}`)]);
+                    }
+                }
                 // Deadline: smaller of conscience.timeoutMs and shared timeoutMs
                 const effectiveTimeout = Math.min(config.conscience.timeoutMs, config.timeoutMs);
                 const start = Date.now();
@@ -752,8 +800,11 @@ export default function wardenExtension(pi) {
                     hostSignal.addEventListener("abort", () => ac.abort(), { once: true });
                 }
                 try {
-                    const judgeAdapter = judge ? { evaluate: async (req) => { const r = await judge.evaluate(req); return { answers: r.answers }; } } : undefined;
-                    const result = await assess(redactedPrompt, recentContext, skills, toolInfos, activeSkills, suppliedSkills, { judge: judgeAdapter, config: config.conscience, sharedTimeoutMs: config.timeoutMs, now: () => Date.now() });
+                    // The evaluate result carries the model that answered; the activation gate compares the policy's model against
+                    // it. Empty until the first evaluate call, and an empty model never matches a policy, so the gate fails closed.
+                    let judgeModel = "";
+                    const judgeAdapter = judge ? { evaluate: async (req) => { const r = await judge.evaluate(req); judgeModel = r.model; return { answers: r.answers }; } } : undefined;
+                    const result = await assess(redactedPrompt, recentContext, skills, toolInfos, activeSkills, suppliedSkills, { judge: judgeAdapter, config: config.conscience, sharedTimeoutMs: config.timeoutMs, now: () => Date.now(), globalIndex: globalIndexFile, projectIndex: projectIndexFile });
                     // Check generation after await
                     if (conscienceGeneration !== myGeneration) {
                         record(ctx, config, "conscience", "stale: generation changed during assessment", ["trigger: before_agent_start", `generation: ${myGeneration} → ${conscienceGeneration}`, `skipReason: stale`]);
@@ -769,7 +820,8 @@ export default function wardenExtension(pi) {
                             console.warn(`pi-warden: conscience ${result.errorCategory}`);
                         }
                     }
-                    record(ctx, config, "conscience", `assessed ${skills.length} skills + ${toolInfos.length} tools → ${selectedName} (P(useful)=${result.usefulness.toFixed(2)}, P(advance)=${result.pAdvance.toFixed(2)}, ${result.elapsedMs}ms)`, ["trigger: before_agent_start", `eligible: ${skills.length} skills, ${toolInfos.length} tools`, `requests: ${result.requestCount}`, `questionHash: ${result.questionHash}`, ...skipInfo, ...truncInfo]);
+                    const skipTag = result.skipReason ? `, ${result.skipReason}` : "";
+                    record(ctx, config, "conscience", `assessed ${skills.length} skills + ${toolInfos.length} tools → ${selectedName} (P(useful)=${result.usefulness.toFixed(2)}, P(advance)=${result.pAdvance.toFixed(2)}, ${result.elapsedMs}ms${skipTag})`, ["trigger: before_agent_start", `eligible: ${skills.length} skills, ${toolInfos.length} tools`, `requests: ${result.requestCount}`, `questionHash: ${result.questionHash}`, ...skipInfo, ...truncInfo]);
                     // Track state for turn-end triggers and reminders
                     assessmentsThisPrompt++;
                     lastAssessmentHash = result.questionHash;
@@ -786,10 +838,10 @@ export default function wardenExtension(pi) {
                     }
                     // Delivery: only when selected, thresholds pass, and activation gate clears
                     if (result.selected && budgetAvailable(config)) {
-                        // Activation gate (spec §7): policy must match hash and model when a policy exists
-                        const policyActive = getActivePolicy() !== null;
-                        if (policyActive && !policyMatches(result.questionHash, "jev-latest")) {
-                            record(ctx, config, "conscience", "no policy for current hash/model", ["trigger: before_agent_start", "skipReason: no_policy"]);
+                        // Activation gate (spec §7): no policy means no delivery; a policy that does not match the current hash or
+                        // the model that actually answered also means no delivery. Fail closed either way.
+                        if (!policyMatches(consciencePolicy, result.questionHash, judgeModel)) {
+                            record(ctx, config, "conscience", "no policy for current hash/model", ["trigger: before_agent_start", "skipReason: no_policy", `hash: ${result.questionHash}`, `model: ${judgeModel || "none"}`]);
                         }
                         else {
                             spendBudgetUnit();
@@ -884,10 +936,10 @@ export default function wardenExtension(pi) {
                     const activeSkills = cachedSkills.map(s => s.name);
                     const judgeAdapter = judge ? { evaluate: async (req) => { const r = await judge.evaluate(req); return { answers: r.answers }; } } : undefined;
                     try {
-                        const result = await assess(redactedText, "", cachedSkills, toolInfos, activeSkills, [], { judge: judgeAdapter, config: config.conscience, sharedTimeoutMs: config.timeoutMs, now: () => Date.now() });
+                        const result = await assess(redactedText, "", cachedSkills, toolInfos, activeSkills, [], { judge: judgeAdapter, config: config.conscience, sharedTimeoutMs: config.timeoutMs, now: () => Date.now(), globalIndex: globalIndexFile, projectIndex: projectIndexFile });
                         if (conscienceGeneration !== myGeneration)
                             return;
-                        record(ctx, config, "conscience", `queued prompt assessed → ${result.selected ? `${result.selected.kind}:${result.selected.id}` : "none"}`, ["trigger: message_start", `origin: queued`, `skipReason: ${result.skipReason ?? "none"}`]);
+                        record(ctx, config, "conscience", `queued prompt assessed → ${result.selected ? `${result.selected.kind}:${result.selected.id}` : "none"} (${result.skipReason ?? "none"})`, ["trigger: message_start", `origin: queued`, `skipReason: ${result.skipReason ?? "none"}`]);
                     }
                     catch (err) {
                         const cat = classifyConscienceError(err);
@@ -954,7 +1006,7 @@ export default function wardenExtension(pi) {
                 const activeSkills = cachedSkills.map(s => s.name);
                 const judgeAdapter = judge ? { evaluate: async (req) => { const r = await judge.evaluate(req); return { answers: r.answers }; } } : undefined;
                 try {
-                    const result = await assess(redactedPrompt, "", cachedSkills, toolInfos, activeSkills, [], { judge: judgeAdapter, config: config.conscience, sharedTimeoutMs: config.timeoutMs, now: () => Date.now() });
+                    const result = await assess(redactedPrompt, "", cachedSkills, toolInfos, activeSkills, [], { judge: judgeAdapter, config: config.conscience, sharedTimeoutMs: config.timeoutMs, now: () => Date.now(), globalIndex: globalIndexFile, projectIndex: projectIndexFile });
                     if (conscienceGeneration !== myGeneration)
                         return;
                     assessmentsThisPrompt++;
@@ -963,7 +1015,7 @@ export default function wardenExtension(pi) {
                         selectedCapability = { kind: result.selected.kind, id: result.selected.id };
                         lastAssessmentHash = result.questionHash;
                     }
-                    record(ctx, config, "conscience", `turn_end reassessment → ${result.selected ? `${result.selected.kind}:${result.selected.id}` : "none"} (${result.elapsedMs}ms)`, ["trigger: turn_end", `assessments: ${assessmentsThisPrompt}/${config.conscience.maxAssessments}`, `skipReason: ${result.skipReason ?? "none"}`]);
+                    record(ctx, config, "conscience", `turn_end reassessment → ${result.selected ? `${result.selected.kind}:${result.selected.id}` : "none"} (${result.elapsedMs}ms, ${result.skipReason ?? "none"})`, ["trigger: turn_end", `assessments: ${assessmentsThisPrompt}/${config.conscience.maxAssessments}`, `skipReason: ${result.skipReason ?? "none"}`]);
                 }
                 catch (err) {
                     const cat = err instanceof Error ? (/(timeout|timed out)/i.test(err.message) ? "timeout" : /(auth|key|credential|401|403)/i.test(err.message) ? "auth" : /(network|fetch|connect)/i.test(err.message) ? "network" : "other") : "other";
@@ -1008,14 +1060,17 @@ export default function wardenExtension(pi) {
         if (!config.action.enabled || !config.action.tools.includes(event.toolName))
             return;
         stats.inspected++;
-        // First-run warning: pi-warden.md missing, one time per session.
+        // First-run warning: no project rules file resolved, one time per session.
         if (!warnedMissingRules && config.rules.enabled) {
-            const { missing, fallbackSource } = checkPiWardenMissing(ctx.cwd);
+            const { missing, fallbackSource } = checkPiWardenMissing(ctx.cwd, config.rules);
             if (missing && ctx.hasUI) {
                 warnedMissingRules = true;
+                // The tiers still in play, in resolution order: naming README/CLAUDE/AGENTS to someone who
+                // turned the fallback off would send them to a document pi-warden will not read.
+                const tiers = [RULES_FILE, "rules.files", ...(config.rules.fallback ? FALLBACK_FILES : [])].join(", ");
                 const msg = fallbackSource
-                    ? `No pi-warden.md detected. Using ${fallbackSource} as active fallback rules. Run /warden init to create project-specific rules.`
-                    : `No rules file detected (pi-warden.md, README.md, CLAUDE.md, or AGENTS.md). Run /warden init to create project-specific rules.`;
+                    ? `No pi-warden.md or rules.files entry here. Using ${fallbackSource} as active fallback rules. Run /warden init to create project-specific rules.`
+                    : `No rules file detected (${tiers}). Run /warden init to create project-specific rules.`;
                 ctx.ui.notify(msg, "warning");
             }
         }
@@ -1035,6 +1090,17 @@ export default function wardenExtension(pi) {
         const judge = judgeFor(config);
         const siblings = siblingToolCalls(ctx);
         const call = { id: event.toolCallId, tool: event.toolName, input: event.input };
+        // Index command writes its own output files — exempt them from the action guard.
+        if (indexRunning && event.toolName === "write") {
+            const rawPath = typeof event.input.path === "string" ? event.input.path : "";
+            if (rawPath) {
+                const resolved = rawPath.startsWith("~") ? pathResolve(rawPath.replace(/^~/, homedir())) : pathResolve(rawPath);
+                if (indexWritePaths.includes(resolved)) {
+                    record(ctx, config, "action", "index write, expected", ["trigger: before_tool_use", `path: ${redact(rawPath)}`]);
+                    return;
+                }
+            }
+        }
         // The rules request carries the written content and the rule text, so it goes out beside the action request, not inside it.
         const rulesCheck = config.rules.enabled && (event.toolName === "write" || event.toolName === "edit")
             ? rulesGuard.inspect(call, siblings, { cwd: ctx.cwd, config: config.rules, judge, timeoutMs: config.timeoutMs, signal: ctx.signal })
@@ -1622,6 +1688,10 @@ export default function wardenExtension(pi) {
             ctx.ui.notify("pi-warden is running an audit. Please wait...", "warning");
             return { action: "handled" };
         }
+        if (indexRunning) {
+            ctx.ui.notify("pi-warden is building the capability index. Please wait...", "warning");
+            return { action: "handled" };
+        }
         // Operator input invalidates in-flight conscience assessments
         conscienceGeneration++;
     });
@@ -1679,7 +1749,7 @@ export default function wardenExtension(pi) {
             const activeSkills = cachedSkills.map(s => s.name);
             const judgeAdapter = judge ? { evaluate: async (req) => { const r = await judge.evaluate(req); return { answers: r.answers }; } } : undefined;
             try {
-                const result = await assess(redactedPrompt, "", cachedSkills, toolInfos, activeSkills, [], { judge: judgeAdapter, config: config.conscience, sharedTimeoutMs: config.timeoutMs, now: () => Date.now() });
+                const result = await assess(redactedPrompt, "", cachedSkills, toolInfos, activeSkills, [], { judge: judgeAdapter, config: config.conscience, sharedTimeoutMs: config.timeoutMs, now: () => Date.now(), globalIndex: globalIndexFile, projectIndex: projectIndexFile });
                 if (conscienceGeneration !== myGeneration)
                     return;
                 assessmentsThisPrompt++;
@@ -1760,7 +1830,7 @@ export default function wardenExtension(pi) {
                 togglePanel(ctx.ui, configFor(ctx)); },
         });
     }
-    const actions = ["status", "enable", "disable", "mode", "config", "test", "trace", "init", "audit"];
+    const actions = ["status", "enable", "disable", "mode", "config", "test", "trace", "init", "audit", "index"];
     pi.registerCommand("warden", {
         description: "pi-warden status, config (set/get/editor), TypeSafe consent, mode, trace panel, recommend, and a synthetic guard test",
         getArgumentCompletions(prefix) {
@@ -1783,7 +1853,7 @@ export default function wardenExtension(pi) {
             try {
                 const config = configFor(ctx);
                 if (action === "status") {
-                    const auth = describeAuth();
+                    const auth = describeAuth(authState({ backend: config.typesafeBackend }));
                     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(", ");
@@ -1863,13 +1933,14 @@ export default function wardenExtension(pi) {
                 }
                 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");
+                        report(`Consent needs an interactive session. For headless runs set PI_WARDEN_ENABLED=1 and ${keyEnvFor(config.typesafeBackend)} explicitly.`, "warning");
                         return;
                     }
                     if (!await ctx.ui.confirm("Enable TypeSafe judgments for pi-warden?", disclosure))
                         return;
-                    // One flow: consent, then a key if none is configured yet (hidden input, verified, stored for every pi-typesafe consumer).
-                    const key = await ensureApiKey(ctx);
+                    // 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 });
                     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;
@@ -1877,7 +1948,7 @@ export default function wardenExtension(pi) {
                     const path = setUserSetting("typesafe", true);
                     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 TYPESAFE_API_KEY"}`}. 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 ${keyEnvFor(config.typesafeBackend)}`}`}. This stays on in new sessions until /warden disable.`);
                     return;
                 }
                 if (action === "disable") {
@@ -2045,6 +2116,190 @@ export default function wardenExtension(pi) {
                     }
                     return;
                 }
+                if (action === "index") {
+                    if (!ctx.hasUI) {
+                        report("Index needs an interactive session to run.", "warning");
+                        return;
+                    }
+                    // The snapshot from Pi is authoritative; cachedSkills is only filled by before_agent_start.
+                    let skillsForIndex = [];
+                    try {
+                        const snapshot = ctx.getSystemPromptOptions().skills;
+                        if (snapshot && snapshot.length > 0) {
+                            skillsForIndex = snapshot.filter(s => !s.disableModelInvocation).map(s => ({ name: s.name, description: s.description, filePath: s.filePath ?? "" }));
+                        }
+                    }
+                    catch (err) {
+                        record(ctx, config, "conscience", `snapshot unavailable: ${err instanceof Error ? err.message : String(err)}`, ["trigger: warden_index"]);
+                    }
+                    if (skillsForIndex.length === 0 && cachedSkills.length > 0) {
+                        skillsForIndex = cachedSkills.filter(s => !s.disableModelInvocation).map(s => ({ name: s.name, description: s.description, filePath: s.filePath ?? "" }));
+                    }
+                    if (skillsForIndex.length === 0) {
+                        report("No skills available. Run a prompt first so Pi discovers installed skills, then retry /warden index.", "warning");
+                        return;
+                    }
+                    let toolCount = 0;
+                    try {
+                        toolCount = pi.getAllTools().length;
+                    }
+                    catch {
+                        toolCount = 0;
+                    }
+                    const roughBytes = skillsForIndex.length * 200 + toolCount * 100;
+                    if (!await ctx.ui.confirm("Build capability index?", `This reads every installed skill file (${skillsForIndex.length} skills) and tool description (${toolCount} tools, ~${roughBytes} bytes total) and runs the session model to produce index entries. It may take a minute and use real tokens.`))
+                        return;
+                    let toolInfosForIndex = [];
+                    try {
+                        toolInfosForIndex = pi.getAllTools().map((t) => ({ name: t.name, description: t.description }));
+                    }
+                    catch {
+                        toolInfosForIndex = [];
+                    }
+                    const globalPath = indexPath("global");
+                    const projectPath = indexPath("project", ctx.cwd);
+                    ensureIndexDir("global");
+                    ensureIndexDir("project");
+                    const prompt = buildIndexPrompt(ctx.cwd, skillsForIndex, toolInfosForIndex, { global: globalPath, project: projectPath });
+                    // Snapshot files before the model runs so we can detect whether it wrote anything.
+                    const snap = (p) => { try {
+                        const s = statSync(p);
+                        return { exists: true, mtimeMs: s.mtimeMs };
+                    }
+                    catch {
+                        return { exists: false, mtimeMs: 0 };
+                    } };
+                    const preGlobal = snap(globalPath);
+                    const preProject = snap(projectPath);
+                    indexRunning = true;
+                    indexWritePaths = [pathResolve(globalPath), pathResolve(projectPath)];
+                    if (ctx.hasUI)
+                        ctx.ui.notify("pi-warden: Building capability index...", "info");
+                    try {
+                        for (let attempt = 0; attempt < 40; attempt++) {
+                            if (ctx.isIdle())
+                                break;
+                            await new Promise(resolve => setTimeout(resolve, 250));
+                        }
+                        pi.sendUserMessage(prompt);
+                        await ctx.waitForIdle();
+                    }
+                    catch (err) {
+                        const detail = err instanceof Error ? err.message : String(err);
+                        report(`pi-warden index failed: ${detail}.`, "error");
+                        indexRunning = false;
+                        indexWritePaths = [];
+                        return;
+                    }
+                    finally {
+                        indexRunning = false;
+                        indexWritePaths = [];
+                    }
+                    const postGlobal = snap(globalPath);
+                    const postProject = snap(projectPath);
+                    const globalChanged = !preGlobal.exists || postGlobal.mtimeMs > preGlobal.mtimeMs;
+                    const projectChanged = !preProject.exists || postProject.mtimeMs > preProject.mtimeMs;
+                    if (!globalChanged && !projectChanged) {
+                        report("The model did not write the index; nothing was changed.", "warning");
+                        return;
+                    }
+                    const rawGlobal = readIndex(globalPath);
+                    const rawProject = readIndex(projectPath);
+                    // Accept both the full format and entries-only; warden always writes the final metadata.
+                    let globalResult = rawGlobal ? validateIndex(rawGlobal) : { file: undefined, rejections: [] };
+                    let projectResult = rawProject ? validateIndex(rawProject) : { file: undefined, rejections: [] };
+                    // Entries-only fallback: read raw JSON and extract entries array
+                    if (!globalResult.file && rawGlobal) {
+                        try {
+                            const parsed = JSON.parse(readFileSync(globalPath, "utf8"));
+                            if (parsed && typeof parsed === "object" && Array.isArray(parsed.entries)) {
+                                globalResult = validateIndex({ formatVersion: 1, builtAt: "", model: "", entries: parsed.entries });
+                            }
+                        }
+                        catch (err) {
+                            const msg = err instanceof Error ? err.message : String(err);
+                            if (!msg.includes("ENOENT"))
+                                record(ctx, config, "conscience", `global entries-only parse: ${msg}`, ["trigger: warden_index"]);
+                        }
+                    }
+                    if (!projectResult.file && rawProject) {
+                        try {
+                            const parsed = JSON.parse(readFileSync(projectPath, "utf8"));
+                            if (parsed && typeof parsed === "object" && Array.isArray(parsed.entries)) {
+                                projectResult = validateIndex({ formatVersion: 1, builtAt: "", model: "", entries: parsed.entries });
+                            }
+                        }
+                        catch (err) {
+                            const msg = err instanceof Error ? err.message : String(err);
+                            // ENOENT is normal (no project index yet); only trace actual parse errors
+                            if (!msg.includes("ENOENT"))
+                                record(ctx, config, "conscience", `project entries-only parse: ${msg}`, ["trigger: warden_index"]);
+                        }
+                    }
+                    // Collect rejections from both files
+                    const allRejections = [];
+                    if (rawGlobal && !globalResult.file)
+                        allRejections.push(...globalResult.rejections.map(r => `global index: entry ${r}`));
+                    if (rawProject && !projectResult.file)
+                        allRejections.push(...projectResult.rejections.map(r => `project index: entry ${r}`));
+                    if (allRejections.length > 0) {
+                        report(`Index rejected:\n${allRejections.map(r => `  ${r}`).join("\n")}\nOld files kept.`, "warning");
+                        return;
+                    }
+                    const validatedGlobal = globalResult.file;
+                    const validatedProject = projectResult.file;
+                    // Recompute sourceHash from actual skill files; the model's hash is untrusted.
+                    const recomputeHashes = (file) => {
+                        for (const entry of file.entries) {
+                            if (entry.kind === "skill") {
+                                const skill = skillsForIndex.find(s => s.name === entry.name);
+                                if (skill?.filePath)
+                                    entry.sourceHash = fileContentHash(skill.filePath);
+                            }
+                        }
+                    };
+                    if (validatedGlobal)
+                        recomputeHashes(validatedGlobal);
+                    if (validatedProject)
+                        recomputeHashes(validatedProject);
+                    const realModel = ctx.model ? `${ctx.model.provider}/${ctx.model.id}` : "unknown";
+                    const builtAt = new Date().toISOString();
+                    const buildFile = (file) => ({ formatVersion: 1, builtAt, model: realModel, entries: file.entries });
+                    if (validatedGlobal)
+                        writeIndex(globalPath, buildFile(validatedGlobal));
+                    if (validatedProject)
+                        writeIndex(projectPath, buildFile(validatedProject));
+                    globalIndexFile = validatedGlobal;
+                    projectIndexFile = validatedProject;
+                    // Report
+                    const globalStats = validatedGlobal ? indexStats(validatedGlobal) : { globalEntries: 0, projectEntries: 0, thinSources: [], truncatedCount: 0, sourceQualityReport: [] };
+                    const projectStats = validatedProject ? indexStats(validatedProject) : { globalEntries: 0, projectEntries: 0, thinSources: [], truncatedCount: 0, sourceQualityReport: [] };
+                    const totalEntries = globalStats.globalEntries + projectStats.projectEntries;
+                    const allThin = [...globalStats.thinSources, ...projectStats.thinSources];
+                    const totalTruncated = globalStats.truncatedCount + projectStats.truncatedCount;
+                    const lines = [
+                        `Index built: ${totalEntries} entries (${globalStats.globalEntries} global, ${projectStats.projectEntries} project).`,
+                        allThin.length ? `Thin sources: ${allThin.join(", ")}.` : undefined,
+                        totalTruncated ? `${totalTruncated} truncated at bullet boundary.` : undefined,
+                    ].filter(Boolean);
+                    const qualityReport = [...globalStats.sourceQualityReport, ...projectStats.sourceQualityReport]
+                        .sort((a, b) => (a.sourceQuality === "thin" ? 0 : 1) - (b.sourceQuality === "thin" ? 0 : 1));
+                    if (qualityReport.length === 0) {
+                        lines.push("", "Every description states when to use it.");
+                    }
+                    else {
+                        lines.push("", "These descriptions would recommend better with a rewrite:");
+                        const shown = qualityReport.slice(0, 25);
+                        for (const q of shown) {
+                            lines.push(`  ${q.name} (${q.kind}): ${q.improve}`);
+                        }
+                        if (qualityReport.length > 25) {
+                            lines.push(`  ... and ${qualityReport.length - 25} more.`);
+                        }
+                    }
+                    report(lines.join("\n"));
+                    return;
+                }
                 report(`Unknown action "${action}". Use: ${actions.join(", ")}.`, "warning");
             }
             catch (error) {