pi-warden 0.36.0 → 0.40.1

package/dist/conscience.js

@@ -0,0 +1,437 @@
+import { choice, noul, score } from "pi-typesafe";
+import { createHash } from "node:crypto";
+import { redact } from "./redact.js";
+import { fileContentHash, toolSourceHash } from "./hashing.js";
+/** Score levels for the usefulness question. Levels are ordered from least to most useful. */
+export const SCORE_LEVELS = [
+    "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.",
+];
+/* ─── Envelope limits (spec §3 "Bounded assessment envelope") ──────── */
+/** Max eligible entries per category. */
+const MAX_ELIGIBLE = 256;
+/** Max UTF-8 bytes per candidate description. */
+const MAX_DESC_BYTES = 8192;
+/** Max questions per single judge request (including the shared disposition question). */
+const MAX_QUESTIONS_PER_REQUEST = 32;
+/* ─── Path/URL sanitizer (spec §6) ─────────────────────────────────── */
+/** Strip absolute paths, URLs, and credentials from a description. */
+export function sanitizeDescription(text) {
+    // Remove credentials: tokens, keys, secrets
+    let result = text.replace(/\b(?:ghp|gho|ghu|ghs|ghr)_[A-Za-z0-9]{20,}/g, "[credential]");
+    result = result.replace(/\bsk-[A-Za-z0-9_-]{16,}/g, "[credential]");
+    result = result.replace(/\bAKIA[0-9A-Z]{16}\b/g, "[credential]");
+    result = result.replace(/\bxox[abprs]-[A-Za-z0-9-]{10,}/g, "[credential]");
+    result = result.replace(/\bAIza[0-9A-Za-z_-]{30,}/g, "[credential]");
+    result = result.replace(/\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}/g, "[credential]");
+    result = result.replace(/(?:TOKEN|SECRET|KEY|PASSWORD)\s*[=:]\s*['"]?[\w\-./]{8,}/gi, "[credential]");
+    // Remove absolute paths: /foo/bar, ~/foo, ~user/foo
+    result = result.replace(/(?:^|\s)\/[\w.~\-/]+(?:\s|$)/g, " ");
+    result = result.replace(/~\/[\w.~\-/]+/g, "[path]");
+    result = result.replace(/~\w+\/[\w.~\-/]+/g, "[path]");
+    // Remove URLs
+    result = result.replace(/https?:\/\/[\w.~\-/]+/g, "[url]");
+    return result.trim();
+}
+/* ─── Opaque ID mapping ─────────────────────────────────────────────── */
+/** Opaque IDs: c1, c2, ... in stable order. */
+export function opaqueId(index) {
+    return `c${index + 1}`;
+}
+/** Map candidates to opaque IDs, returning a stable ordered list. */
+export function assignOpaqueIds(candidates) {
+    return candidates.map((c, i) => ({ opaqueId: opaqueId(i), candidate: c }));
+}
+/* ─── Question builder ──────────────────────────────────────────────── */
+/**
+ * Build assessment questions for a batch of candidates.
+ * State carries structured data; each question names its candidate field.
+ * Returns questions, the disposition key, and the opaqueId→candidate map.
+ */
+export function buildBatchQuestions(batch, task, recentContext, activeSkills, suppliedSkills) {
+    const questions = {};
+    const idMap = new Map();
+    // Shared disposition question
+    const dispositionKey = "conscience_disposition";
+    questions[dispositionKey] = choice(`Disposition of the current request. A message that reports status, shares context, or narrates what the user is doing elsewhere, without asking the agent to do anything, is no_gap; select nothing on it.`, {
+        advance: "A useful next step can be taken now.",
+        awaiting_user: "The assistant has already asked for information and must wait.",
+        no_gap: "The request is satisfied with no useful missing step.",
+        unclear: "Insufficient evidence to determine the next step.",
+    });
+    // Per-candidate Score questions
+    for (const { opaqueId, candidate } of batch) {
+        idMap.set(opaqueId, candidate);
+        questions[opaqueId] = score(`Judge candidates.${opaqueId} against what the user is asking the agent to do now in task, not against the subjects the prompt mentions in passing; a candidate that matches words in the prompt but does not serve the actual request belongs at the lowest level. When the request needs information the repository cannot supply, a research-role candidate serves the request; when the request is about the repository's own code or behaviour, an evidence-role candidate does.`, [...SCORE_LEVELS]);
+    }
+    return { questions, dispositionKey, idMap };
+}
+/**
+ * Build the full state object for the judge request (spec §3 state contract).
+ */
+export function buildState(task, recentContext, activeSkills, suppliedSkills, batch) {
+    const candidates = {};
+    for (const { opaqueId, candidate } of batch) {
+        const entry = candidate.indexEntry;
+        candidates[opaqueId] = entry
+            ? { kind: candidate.kind, name: candidate.id, lead: entry.lead, useWhen: entry.useWhen, examples: entry.examples }
+            : { kind: candidate.kind, name: candidate.id, description: candidate.description, unindexed: true };
+    }
+    return {
+        task: sanitizeDescription(redact(task)),
+        context: sanitizeDescription(redact(recentContext)),
+        active_skills: activeSkills,
+        supplied_skills: suppliedSkills,
+        candidates,
+    };
+}
+/**
+ * Compute a deterministic hash of the assessment questions for deduplication.
+ * Recursively sorts all object keys for canonical form.
+ *
+ * Opaque candidate ids (c1, c2, …) are positional, not semantic: which batch a prompt happens to
+ * produce must not change the hash the activation gate compares. A conscience question set
+ * (recognised by the `conscience_disposition` key) is therefore hashed as the disposition question
+ * plus one canonical candidate question, keyed `c1` — every candidate question carries the same
+ * wording by design (per-candidate state lives in the request state, not the question text), so any
+ * one of them is the canonical representative.
+ *
+ * Why the hash was constant before this change: each assessment issues several requests (one per
+ * batch), each with its own question keys, and `assess` kept only the hash of whichever batch wrote
+ * `state_.hash` last. Every recorded replay row showed `fb2d35042f667b3c` only because those final
+ * batches happened to serialize identically — an accident of batch order, not a guarantee.
+ */
+export function questionHash(questions) {
+    if (questions.conscience_disposition) {
+        const firstCandidate = Object.entries(questions).find(([key]) => /^c\d+$/.test(key));
+        questions = {
+            conscience_disposition: questions.conscience_disposition,
+            ...(firstCandidate ? { [firstCandidate[0]]: firstCandidate[1] } : {}),
+        };
+    }
+    const sorted = JSON.parse(JSON.stringify(questions, (_key, value) => {
+        if (value && typeof value === "object" && !Array.isArray(value)) {
+            return Object.fromEntries(Object.entries(value).sort(([a], [b]) => a.localeCompare(b)));
+        }
+        return value;
+    }));
+    return createHash("sha256").update(JSON.stringify(sorted)).digest("hex").slice(0, 16);
+}
+/* ─── Candidate eligibility ─────────────────────────────────────────── */
+/** Check if a candidate is excluded by the config's exclude list. */
+function isExcluded(id, exclude) {
+    for (const pattern of exclude) {
+        if (pattern === "*")
+            return true;
+        if (pattern.endsWith("*") && id.startsWith(pattern.slice(0, -1)))
+            return true;
+        if (pattern === id)
+            return true;
+    }
+    return false;
+}
+/** Filter candidates by eligibility rules, capped at MAX_ELIGIBLE per category. Attaches index entries when available. */
+export function eligibleCandidates(skills, tools, config, activeSkills, suppliedSkills, globalIndex, projectIndex) {
+    const candidates = [];
+    let skillOverflow = false;
+    let toolOverflow = false;
+    const findEntry = (name, sourceHash) => {
+        const search = (index) => {
+            if (!index)
+                return undefined;
+            return index.entries.find(e => e.name === name && e.sourceHash === sourceHash);
+        };
+        return search(projectIndex) ?? search(globalIndex);
+    };
+    if (config.skills.mode !== "off") {
+        let count = 0;
+        for (const skill of skills) {
+            if (isExcluded(skill.name, config.skills.exclude))
+                continue;
+            // disableModelInvocation skills are never automatic candidates (spec §3 rule 4)
+            if (skill.disableModelInvocation)
+                continue;
+            // Already supplied: skip
+            if (suppliedSkills.includes(skill.name))
+                continue;
+            if (count >= MAX_ELIGIBLE) {
+                skillOverflow = true;
+                break;
+            }
+            const sourceHash = skill.filePath ? fileContentHash(skill.filePath) : "missing";
+            const entry = findEntry(skill.name, sourceHash);
+            candidates.push({
+                kind: "skill",
+                id: skill.name,
+                description: sanitizeDescription(skill.description),
+                skill,
+                ...(entry ? { role: entry.role, indexEntry: entry } : {}),
+            });
+            count++;
+        }
+    }
+    if (config.tools.enabled) {
+        let count = 0;
+        for (const tool of tools) {
+            if (isExcluded(tool.name, config.tools.exclude))
+                continue;
+            if (count >= MAX_ELIGIBLE) {
+                toolOverflow = true;
+                break;
+            }
+            const sourceHash = toolSourceHash(tool.name, tool.description);
+            const entry = findEntry(tool.name, sourceHash);
+            candidates.push({
+                kind: "tool",
+                id: tool.name,
+                description: sanitizeDescription(tool.description),
+                ...(entry ? { role: entry.role, indexEntry: entry } : {}),
+            });
+            count++;
+        }
+    }
+    return { candidates, skillOverflow, toolOverflow };
+}
+/* ─── Description cap ───────────────────────────────────────────────── */
+/** Cap a candidate description to MAX_DESC_BYTES UTF-8. Returns the candidate with overflow flag. */
+function capDescription(candidate) {
+    const bytes = new TextEncoder().encode(candidate.description).byteLength;
+    if (bytes <= MAX_DESC_BYTES)
+        return { candidate, overLimit: false };
+    // Truncate by UTF-8 characters, not bytes, to avoid splitting multi-byte chars
+    const chars = [...candidate.description];
+    let truncated = "";
+    let byteCount = 0;
+    for (const ch of chars) {
+        const chBytes = new TextEncoder().encode(ch).byteLength;
+        if (byteCount + chBytes > MAX_DESC_BYTES - 3)
+            break;
+        truncated += ch;
+        byteCount += chBytes;
+    }
+    return { candidate: { ...candidate, description: truncated + "..." }, overLimit: true };
+}
+/* ─── Error classification ──────────────────────────────────────────── */
+/** Classify an assessment error into a safe category (spec §6: never exception bodies). */
+function classifyError(err) {
+    if (err && typeof err === "object" && "code" in err) {
+        const code = String(err.code);
+        if (code === "timeout")
+            return "timeout";
+        if (code === "http" || code === "connection" || code === "response" || code === "network")
+            return "network";
+        if (code === "configuration" || code === "validation")
+            return "configuration";
+    }
+    const msg = err instanceof Error ? err.message : String(err);
+    if (/timeout|timed out/i.test(msg))
+        return "timeout";
+    if (/auth|key|credential|401|403/i.test(msg))
+        return "auth";
+    if (/network|fetch|connect|ECONNREFUSED|ENOTFOUND/i.test(msg))
+        return "network";
+    return "other";
+}
+/**
+ * Parse a Choice answer from pi-typesafe.
+ * Shape: { choice: string, confidence: number, probabilities: Record<string, number> }
+ */
+function parseChoiceAnswer(answer) {
+    if (!answer || typeof answer !== "object")
+        return undefined;
+    const a = answer;
+    if (typeof a.choice !== "string")
+        return undefined;
+    const probs = a.probabilities;
+    return {
+        label: a.choice,
+        pAdvance: typeof probs?.advance === "number" ? probs.advance : 0,
+    };
+}
+/**
+ * Parse a Score answer from pi-typesafe.
+ * Shape: { score: number, confidence: number, legend: Record<number, string>, probabilities: Record<number, number> }
+ * Probabilities are keyed by numeric index (0, 1, 2, 3).
+ */
+function parseScoreAnswer(answer) {
+    if (!answer || typeof answer !== "object")
+        return undefined;
+    const a = answer;
+    if (typeof a.score !== "number")
+        return undefined;
+    const probs = a.probabilities;
+    if (!probs)
+        return undefined;
+    // Build an array of probabilities keyed by index
+    const p = [];
+    for (let i = 0; i < SCORE_LEVELS.length; i++) {
+        p.push(typeof probs[String(i)] === "number" ? probs[String(i)] : 0);
+    }
+    return { level: Math.round(a.score), probabilities: p };
+}
+/**
+ * Run assessment for the given prompt revision.
+ * Pre-measurement: returns trace-only results. No steers, no auto-loading.
+ * Issues concurrent requests (up to four in flight), skills first, shared deadline.
+ */
+export async function assess(prompt, recentContext, skills, tools, activeSkills, suppliedSkills, deps) {
+    const start = deps.now?.() ?? Date.now();
+    const { config, judge, sharedTimeoutMs } = deps;
+    if (!config.enabled) {
+        return { disposition: "no_gap", selected: null, usefulness: 0, pAdvance: 0, questionHash: "", elapsedMs: 0, requestCount: 0, skipReason: "disabled" };
+    }
+    if (!judge) {
+        return { disposition: "no_gap", selected: null, usefulness: 0, pAdvance: 0, questionHash: "", elapsedMs: 0, requestCount: 0, skipReason: "no_consent" };
+    }
+    const { candidates, skillOverflow, toolOverflow } = eligibleCandidates(skills, tools, config, activeSkills, suppliedSkills, deps.globalIndex, deps.projectIndex);
+    if (candidates.length === 0) {
+        return { disposition: "no_gap", selected: null, usefulness: 0, pAdvance: 0, questionHash: "", elapsedMs: 0, requestCount: 0, skipReason: "no_match" };
+    }
+    const effectiveTimeout = Math.min(config.timeoutMs, sharedTimeoutMs);
+    const deadline = start + effectiveTimeout;
+    const MAX_IN_FLIGHT = 4;
+    const categoryMeta = [
+        { category: "skill", overflow: skillOverflow },
+        { category: "tool", overflow: toolOverflow },
+    ];
+    const cappedByCategory = {
+        skill: candidates.filter(c => c.kind === "skill").map(c => ({ candidate: c, capped: capDescription(c) })),
+        tool: candidates.filter(c => c.kind === "tool").map(c => ({ candidate: c, capped: capDescription(c) })),
+    };
+    const maxCandidatesPerRequest = MAX_QUESTIONS_PER_REQUEST - 1; // -1 for disposition
+    const workQueue = [];
+    for (const meta of categoryMeta) {
+        const items = cappedByCategory[meta.category];
+        if (items.length === 0 && !meta.overflow)
+            continue;
+        for (let i = 0; i < items.length; i += maxCandidatesPerRequest) {
+            workQueue.push({ category: meta.category, items: items.slice(i, i + maxCandidatesPerRequest), overflow: false });
+        }
+        if (items.length === 0 && meta.overflow) {
+            workQueue.push({ category: meta.category, items: [], overflow: true });
+        }
+    }
+    // Per-category tracking: a category whose every batch fails or times out is discarded.
+    const categoryCompleted = { skill: false, tool: false };
+    const categoryFailed = { skill: false, tool: false };
+    const judgeError = { value: null };
+    const state_ = { disposition: "unclear", pAdvance: 0, hash: "", requestCount: 0, bestScored: null };
+    // Execute chunks with at most MAX_IN_FLIGHT concurrent judge calls.
+    // Each chunk races its own evaluate against the shared deadline.
+    // A settled chunk (success or error) frees its slot for the next waiting chunk.
+    let nextIdx = 0;
+    const inFlight = [];
+    function launchNext() {
+        while (inFlight.length < MAX_IN_FLIGHT && nextIdx < workQueue.length) {
+            const work = workQueue[nextIdx];
+            nextIdx++;
+            const p = runChunk(work).finally(() => {
+                const pos = inFlight.indexOf(p);
+                if (pos !== -1)
+                    inFlight.splice(pos, 1);
+                launchNext();
+            });
+            inFlight.push(p);
+        }
+    }
+    async function runChunk(work) {
+        if (work.items.length === 0) {
+            if (work.overflow)
+                categoryCompleted[work.category] = true;
+            return;
+        }
+        const opaqueBatch = assignOpaqueIds(work.items.map(e => e.capped.candidate));
+        const { questions, dispositionKey } = buildBatchQuestions(opaqueBatch, prompt, recentContext, activeSkills, suppliedSkills);
+        state_.hash = questionHash(questions);
+        const state = buildState(prompt, recentContext, activeSkills, suppliedSkills, opaqueBatch);
+        const remaining = deadline - (deps.now?.() ?? Date.now());
+        if (remaining <= 0) {
+            categoryFailed[work.category] = true;
+            return;
+        }
+        let answers;
+        const j = judge;
+        try {
+            const result = await Promise.race([
+                j.evaluate({ state, questions }),
+                new Promise((_, reject) => setTimeout(() => reject(new Error("timeout")), remaining)),
+            ]);
+            answers = result.answers;
+            state_.requestCount++;
+        }
+        catch (err) {
+            categoryFailed[work.category] = true;
+            judgeError.value = { message: err instanceof Error ? err.message : String(err), category: classifyError(err) };
+            return;
+        }
+        categoryCompleted[work.category] = true;
+        if (state_.disposition === "unclear") {
+            const dispRaw = parseChoiceAnswer(answers[dispositionKey]);
+            if (dispRaw) {
+                state_.disposition = dispRaw.label;
+                state_.pAdvance = dispRaw.pAdvance;
+            }
+        }
+        if (state_.disposition !== "advance")
+            return;
+        for (const { opaqueId, candidate } of opaqueBatch) {
+            const answer = parseScoreAnswer(answers[opaqueId]);
+            if (!answer)
+                continue;
+            const pUseful = (answer.probabilities[2] ?? 0) + (answer.probabilities[3] ?? 0);
+            if (!state_.bestScored || pUseful > state_.bestScored.usefulness ||
+                (pUseful === state_.bestScored.usefulness && answer.level > state_.bestScored.level) ||
+                (pUseful === state_.bestScored.usefulness && answer.level === state_.bestScored.level &&
+                    (candidate.kind === "skill" && state_.bestScored.candidate.kind !== "skill" ||
+                        (candidate.kind === state_.bestScored.candidate.kind && candidate.id < state_.bestScored.candidate.id)))) {
+                state_.bestScored = { candidate, usefulness: pUseful, level: answer.level };
+            }
+        }
+    }
+    launchNext();
+    await Promise.all(inFlight);
+    const elapsedMs = (deps.now?.() ?? Date.now()) - start;
+    const { disposition, pAdvance, hash, requestCount, bestScored } = state_;
+    const skillUsable = categoryCompleted.skill && !categoryFailed.skill;
+    const toolUsable = categoryCompleted.tool && !categoryFailed.tool;
+    // When every category failed, the judge is broken — surface the error, not no_match.
+    if (!skillUsable && !toolUsable && judgeError.value) {
+        return { disposition: "unclear", selected: null, usefulness: 0, pAdvance: 0, questionHash: state_.hash, elapsedMs, requestCount: state_.requestCount, skipReason: "error", errorCategory: judgeError.value.category };
+    }
+    if (disposition !== "advance") {
+        const skipReason = disposition === "awaiting_user" ? "awaiting_user" : undefined;
+        const result = { disposition, selected: null, usefulness: 0, pAdvance, questionHash: hash, elapsedMs, requestCount };
+        if (skipReason)
+            result.skipReason = skipReason;
+        return result;
+    }
+    if (!bestScored) {
+        const skipReason = skillOverflow ? "catalog_limit" : "no_match";
+        return { disposition, selected: null, usefulness: 0, pAdvance, questionHash: hash, elapsedMs, requestCount, skipReason };
+    }
+    if (bestScored.candidate.kind === "skill" && !skillUsable) {
+        return { disposition, selected: null, usefulness: 0, pAdvance, questionHash: hash, elapsedMs, requestCount, skipReason: "no_match" };
+    }
+    if (bestScored.candidate.kind === "tool" && !toolUsable) {
+        return { disposition, selected: null, usefulness: 0, pAdvance, questionHash: hash, elapsedMs, requestCount, skipReason: "no_match" };
+    }
+    const passesUsefulness = bestScored.usefulness >= config.recommendThreshold;
+    const passesAdvance = pAdvance >= config.advanceThreshold;
+    if (!passesUsefulness || !passesAdvance) {
+        return { disposition, selected: null, usefulness: bestScored.usefulness, pAdvance, questionHash: hash, elapsedMs, requestCount, skipReason: "below_threshold" };
+    }
+    if (bestScored.candidate.kind === "skill" && skillOverflow) {
+        return { disposition, selected: null, usefulness: bestScored.usefulness, pAdvance, questionHash: hash, elapsedMs, requestCount, skipReason: "catalog_limit" };
+    }
+    return {
+        disposition,
+        selected: bestScored.candidate,
+        usefulness: bestScored.usefulness,
+        pAdvance,
+        questionHash: hash,
+        elapsedMs,
+        requestCount,
+    };
+}

package/dist/extension.d.ts

@@ -2,9 +2,9 @@ import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-a
 import type { ToolCallRef } from "./action-guard.js";
 import type { SlopSymptom, Verdict } from "./guard.js";
 import type { ShapeResult } from "./shape.js";
-export declare 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. 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 declare 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.";
 /** Which guard spent the user's attention. The status line reports one count per guard. */
-export type SteerGuard = "action" | "rules" | "security" | "stuck" | "done" | "prose" | "runaway" | "subagent";
+export type SteerGuard = "action" | "rules" | "security" | "stuck" | "done" | "prose" | "runaway" | "subagent" | "conscience";
 /**
  * One steer message can carry notes from more than one guard, so the per-guard numbers may add up to more than the
  * message count; the line says so instead of hiding it. Worst offender first: that is the number worth acting on.
@@ -33,5 +33,6 @@ export declare function slopSteer(where: string, symptoms: readonly SlopSymptom[
  * failed until Pi was restarted. The sections this build reads are therefore checked here as well, in the module that reads them.
  */
 export declare function guardCurrentSections(result: ShapeResult): ShapeResult;
-/** Native Pi registration; importing the root library does not load this module. */
+/** Test-only: set the index-running state and write paths for the action guard bypass. */
+export declare function _testSetIndexRunning(running: boolean, paths?: string[]): void;
 export default function wardenExtension(pi: ExtensionAPI): void;