pi-warden 0.38.3 → 0.40.2

package/dist/conscience.js

@@ -1,6 +1,7 @@
 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.",
@@ -54,7 +55,7 @@ export function buildBatchQuestions(batch, task, recentContext, activeSkills, su
     const idMap = new Map();
     // Shared disposition question
     const dispositionKey = "conscience_disposition";
-    questions[dispositionKey] = choice("Disposition of the current request.", {
+    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.",
@@ -63,7 +64,7 @@ export function buildBatchQuestions(batch, task, recentContext, activeSkills, su
     // Per-candidate Score questions
     for (const { opaqueId, candidate } of batch) {
         idMap.set(opaqueId, candidate);
-        questions[opaqueId] = score(`Judge candidates.${opaqueId} against task and context.`, [...SCORE_LEVELS]);
+        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 };
 }
@@ -73,11 +74,10 @@ export function buildBatchQuestions(batch, task, recentContext, activeSkills, su
 export function buildState(task, recentContext, activeSkills, suppliedSkills, batch) {
     const candidates = {};
     for (const { opaqueId, candidate } of batch) {
-        candidates[opaqueId] = {
-            kind: candidate.kind,
-            name: candidate.id,
-            description: candidate.description,
-        };
+        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)),
@@ -90,8 +90,27 @@ export function buildState(task, recentContext, activeSkills, suppliedSkills, ba
 /**
  * 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)));
@@ -113,11 +132,19 @@ function isExcluded(id, exclude) {
     }
     return false;
 }
-/** Filter candidates by eligibility rules, capped at MAX_ELIGIBLE per category. */
-export function eligibleCandidates(skills, tools, config, activeSkills, suppliedSkills) {
+/** 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) {
@@ -133,11 +160,14 @@ export function eligibleCandidates(skills, tools, config, activeSkills, supplied
                 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++;
         }
@@ -151,10 +181,13 @@ export function eligibleCandidates(skills, tools, config, activeSkills, supplied
                 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++;
         }
@@ -241,7 +274,7 @@ function parseScoreAnswer(answer) {
 /**
  * Run assessment for the given prompt revision.
  * Pre-measurement: returns trace-only results. No steers, no auto-loading.
- * Issues sequential requests: skills first, then tools in the remaining envelope.
+ * 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();
@@ -252,120 +285,145 @@ export async function assess(prompt, recentContext, skills, tools, activeSkills,
     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);
+    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" };
     }
-    // Split into skills and tools for sequential assessment
-    const skillCandidates = candidates.filter(c => c.kind === "skill");
-    const toolCandidates = candidates.filter(c => c.kind === "tool");
-    // Cap descriptions
-    const cappedSkills = skillCandidates.map(c => capDescription(c));
-    const cappedTools = toolCandidates.map(c => capDescription(c));
     const effectiveTimeout = Math.min(config.timeoutMs, sharedTimeoutMs);
     const deadline = start + effectiveTimeout;
-    let requestCount = 0;
-    // Disposition result (shared across batches)
-    let disposition = "unclear";
-    let pAdvance = 0;
-    let hash = "";
-    let bestScored = null;
-    // Process skills first, then tools
-    const batches = [
-        { items: cappedSkills, overflow: skillOverflow, categoryOverflowReason: "catalog_limit" },
-        { items: cappedTools, overflow: toolOverflow, categoryOverflowReason: "catalog_limit" },
+    const MAX_IN_FLIGHT = 4;
+    const categoryMeta = [
+        { category: "skill", overflow: skillOverflow },
+        { category: "tool", overflow: toolOverflow },
     ];
-    // Track if we have a complete skill assessment (for tool catalog to proceed)
-    let skillAssessmentComplete = false;
-    for (const batch of batches) {
-        if (batch.items.length === 0 && !batch.overflow)
+    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;
-        // Pack into requests of at most MAX_QUESTIONS_PER_REQUEST (including disposition)
-        const maxCandidatesPerRequest = MAX_QUESTIONS_PER_REQUEST - 1; // -1 for disposition
-        const chunks = [];
-        for (let i = 0; i < batch.items.length; i += maxCandidatesPerRequest) {
-            chunks.push(batch.items.slice(i, i + maxCandidatesPerRequest));
+        for (let i = 0; i < items.length; i += maxCandidatesPerRequest) {
+            workQueue.push({ category: meta.category, items: items.slice(i, i + maxCandidatesPerRequest), overflow: false });
         }
-        for (const chunk of chunks) {
-            const opaqueBatch = assignOpaqueIds(chunk.map(e => e.candidate));
-            const { questions, dispositionKey, idMap } = buildBatchQuestions(opaqueBatch, prompt, recentContext, activeSkills, suppliedSkills);
-            hash = questionHash(questions);
-            const state = buildState(prompt, recentContext, activeSkills, suppliedSkills, opaqueBatch);
-            const remaining = deadline - (deps.now?.() ?? Date.now());
-            if (remaining <= 0) {
-                return { disposition: "unclear", selected: null, usefulness: 0, pAdvance: 0, questionHash: hash, elapsedMs: (deps.now?.() ?? Date.now()) - start, requestCount, skipReason: "timeout" };
-            }
-            let answers;
-            try {
-                const result = await Promise.race([
-                    judge.evaluate({ state, questions }),
-                    new Promise((_, reject) => setTimeout(() => reject(new Error("timeout")), remaining)),
-                ]);
-                answers = result.answers;
-                requestCount++;
-            }
-            catch (err) {
-                return { disposition: "unclear", selected: null, usefulness: 0, pAdvance: 0, questionHash: hash, elapsedMs: (deps.now?.() ?? Date.now()) - start, requestCount, skipReason: "error", errorCategory: classifyError(err) };
-            }
-            // Parse disposition (only from first batch that returns it)
-            if (disposition === "unclear") {
-                const dispRaw = parseChoiceAnswer(answers[dispositionKey]);
-                if (dispRaw) {
-                    disposition = dispRaw.label;
-                    pAdvance = dispRaw.pAdvance;
-                }
+        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 disposition is not advance, stop assessing
-            if (disposition !== "advance")
+        }
+        if (state_.disposition !== "advance")
+            return;
+        for (const { opaqueId, candidate } of opaqueBatch) {
+            const answer = parseScoreAnswer(answers[opaqueId]);
+            if (!answer)
                 continue;
-            // Score each candidate in this chunk
-            for (const { opaqueId, candidate } of opaqueBatch) {
-                const answer = parseScoreAnswer(answers[opaqueId]);
-                if (!answer)
-                    continue;
-                // P(useful now) = P(level 2: directly_useful) + P(level 3: prerequisite)
-                const pUseful = (answer.probabilities[2] ?? 0) + (answer.probabilities[3] ?? 0);
-                if (!bestScored || pUseful > bestScored.usefulness ||
-                    (pUseful === bestScored.usefulness && answer.level > bestScored.level) ||
-                    (pUseful === bestScored.usefulness && answer.level === bestScored.level &&
-                        (candidate.kind === "skill" && bestScored.candidate.kind !== "skill" ||
-                            (candidate.kind === bestScored.candidate.kind && candidate.id < bestScored.candidate.id)))) {
-                    bestScored = { candidate, usefulness: pUseful, level: answer.level };
-                }
+            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 };
             }
         }
-        if (batch.items.length > 0 || batch.overflow) {
-            skillAssessmentComplete = true;
-        }
-        // If skills had catalog_limit, do not proceed to tools with partial results
-        if (batch.overflow && batch.categoryOverflowReason === "catalog_limit") {
-            // Per spec: "if a required batch for a category fails or times out, discard that category's selection"
-            // But catalog_limit means the category is incomplete, not failed. Selection may use the other category.
-            // Record catalog_limit but continue to tools.
-        }
     }
-    // Return disposition result
+    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: (deps.now?.() ?? Date.now()) - start, requestCount };
+        const result = { disposition, selected: null, usefulness: 0, pAdvance, questionHash: hash, elapsedMs, requestCount };
         if (skipReason)
             result.skipReason = skipReason;
         return result;
     }
-    // No candidate scored
     if (!bestScored) {
         const skipReason = skillOverflow ? "catalog_limit" : "no_match";
-        return { disposition, selected: null, usefulness: 0, pAdvance, questionHash: hash, elapsedMs: (deps.now?.() ?? Date.now()) - start, requestCount, skipReason };
+        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" };
     }
-    // Threshold gate: both P(useful now) and P(advance) must pass
     const passesUsefulness = bestScored.usefulness >= config.recommendThreshold;
-    const passesAdvance = pAdvance >= config.recommendThreshold;
+    const passesAdvance = pAdvance >= config.advanceThreshold;
     if (!passesUsefulness || !passesAdvance) {
-        return { disposition, selected: null, usefulness: bestScored.usefulness, pAdvance, questionHash: hash, elapsedMs: (deps.now?.() ?? Date.now()) - start, requestCount, skipReason: "below_threshold" };
+        return { disposition, selected: null, usefulness: bestScored.usefulness, pAdvance, questionHash: hash, elapsedMs, requestCount, skipReason: "below_threshold" };
     }
-    // Catalog completeness gate: do not select from an incomplete category
     if (bestScored.candidate.kind === "skill" && skillOverflow) {
-        return { disposition, selected: null, usefulness: bestScored.usefulness, pAdvance, questionHash: hash, elapsedMs: (deps.now?.() ?? Date.now()) - start, requestCount, skipReason: "catalog_limit" };
+        return { disposition, selected: null, usefulness: bestScored.usefulness, pAdvance, questionHash: hash, elapsedMs, requestCount, skipReason: "catalog_limit" };
     }
     return {
         disposition,
@@ -373,7 +431,7 @@ export async function assess(prompt, recentContext, skills, tools, activeSkills,
         usefulness: bestScored.usefulness,
         pAdvance,
         questionHash: hash,
-        elapsedMs: (deps.now?.() ?? Date.now()) - start,
+        elapsedMs,
         requestCount,
     };
 }

package/dist/extension.d.ts

@@ -2,7 +2,7 @@ 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. 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 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" | "conscience";
 /**
@@ -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;