pi-warden 0.38.3 → 0.40.1

package/CHANGELOG.md

@@ -8,6 +8,51 @@ How to keep this current: add the entry in the same pull request as the change,
 
 <!-- Empty. Next release starts here. -->
 
+## 0.40.1
+
+### Fixed
+
+- An `rm` in a compound command (`rm -rf build && npm test`) no longer makes every word after it a separate target. Target extraction now runs per shell segment, so a compound command stops producing one Jev question per trailing token and no longer trips TypeSafe's 32-question limit on long command lines. A single `rm` naming more targets than the request budget still can; chunking is separate.
+- An `rm` followed by a newline and another command produced no targets at all, so it was never scoped; it now yields the targets of its own line.
+
+## 0.40.0
+
+### Fixed
+
+- `/warden status` and `/warden enable` now describe the key of the configured `typesafeBackend`. With `"openrouter"`, status said "TypeSafe key: missing" on the same line that counted judgments, and enable opened the TypeSafe login prompt, so consent could not be saved. Both call pi-typesafe's backend-aware `authState` and `ensureApiKey`; with no OpenRouter key, enable reports the variable to set instead of prompting (#57).
+- The headless hint and the enable confirmation name the backend's own environment variable.
+
+### Changed
+
+- `src/backend.ts` reads hosts and key variables from pi-typesafe's `DECISIONS_BACKENDS` instead of keeping its own copy; `keyAvailable` is replaced by `authState({ backend }).usable`, which also honours a rejected key. Requires pi-typesafe 0.7.0.
+
+## 0.39.1
+
+### Changed
+- Bump `pi-typesafe` from `^0.6.1` to `^0.6.2`. Programmatic API is unchanged; the 0.6.2 tool schema now documents its own payload fields, and no pi-warden text duplicated it.
+
+## 0.39.0
+
+### Docs
+- README quick start now carries the four setup commands (`/warden enable`, `/warden init`, `/warden index`, `/warden test`) and the beta note; `docs/commands.md` gains rows for `/warden init --force` and `/warden index`.
+- Conscience policy measurement on the per-project corpus with the split disposition gate: beta candidate policy record (89% pooled precision, 74/83; 95% gate not met), comparison against the first measurement and the remeasure, labelled-subset reproduction of the live-run gate numbers.
+- Conscience recommendation remeasurement after index + question changes: before-and-after table, labelled-subset comparison, research-role tool rate, candidate policy update.
+
+### Added
+- `/warden index` command: builds a local capability index with the session model. Entries carry `lead`, `useWhen`, `examples`, and `role` instead of bare names and descriptions. The conscience uses index entries when the source hash matches; bare descriptions are the fallback. Index files live at `~/.pi/agent/pi-warden/index/global.json` and `projects/<hash>.json`. Once-per-session nudge when the index is missing or stale.
+- `conscience.advanceThreshold` config key (default `0.70`): separate gate for the disposition question's P(advance), independent of the usefulness threshold.
+- `CONSCIENCE_BETA_POLICY` in `src/load.ts` (questionHash `fb2d35042f667b3c`, model `jev-1.13.0`, usefulness 0.80, advance 0.70), held in the extension's closure and passed to the activation gate; a test pins the question wording to the policy hash, and `questionHash` is computed over the disposition question plus one canonical candidate question so it no longer moves with batch shape.
+- Capability roles (`research`, `evidence`, `execution`, `delegation`, `review`, `conversation`) in index entries and candidate state; role-based guidance in Score questions.
+
+### Changed
+- Conscience defaults: `recommendThreshold` 1.0 → 0.80 (beta policy thresholds); still off by default — `conscience.enabled: true` is the one switch.
+- The replay script omits prompt excerpts from the selected-candidates table unless `PI_WARDEN_OWNER_REPORTS=1`, so committed reports carry no Linear ids or branch names; scrub greps include `CON-[0-9]+`.
+- Replay script `scripts/conscience-replay.mjs` gates delivery on `advanceThreshold` (default 0.70) and reports pi-warden status rows below the gate.
+- Conscience question wording reverted to baseline after four calibration iterations; the disposition gate, not wording, was the lever.
+
+### Fixed
+- The conscience activation gate now fails closed: with no active policy, or a policy whose hash or model does not match the request, no recommendation is delivered (traced `no_policy`). Previously an absent policy let delivery through, contradicting `docs/configuration.md`. The gate also compares the policy's model against the model that actually answered instead of the literal `"jev-latest"`.
+
 ## 0.38.3
 
 ### Fixed

package/README.md

@@ -14,9 +14,12 @@ Instead of interrupting you for every problem, Warden usually feeds the issue ba
 pi install npm:pi-warden
 ```
 
-1. `/warden enable` to activate. Paste a key from [console.typesafe.ai](https://console.typesafe.ai) if you have one (hidden input, saved owner-only), or skip for offline-only mode.
-2. `/warden test` to see one synthetic verdict.
-3. Work as usual. Status line shows verdicts; `ctrl+shift+w` opens the trace sidebar.
+1. `/warden enable` to turn judgments on. Paste a key from [console.typesafe.ai](https://console.typesafe.ai) (hidden input, saved owner-only), or skip for offline-only mode.
+2. `/warden init` to write a starter `pi-warden.md`. The rules guard enforces what you put there.
+3. `/warden index` (recommended) so the conscience knows your skills and tools from their real descriptions.
+4. `/warden test` to see one synthetic verdict, then work as usual. The status line shows verdicts; `ctrl+shift+w` opens the trace sidebar.
+
+The conscience is beta and off by default. Turn it on with `conscience.enabled: true` in the user config.
 
 Works without any key (offline guards: pattern list, runaway stop, sensitive-path notes, credential warnings). Requires Pi 0.85+, Node 22.19+.
 
@@ -32,6 +35,7 @@ Works without any key (offline guards: pattern list, runaway stop, sensitive-pat
 | **Security** | code and output | Hardcoded secrets, injection risks |
 | **Runaway** | reply stream | Stops replies that begin repeating themselves |
 | **Subagent triage** | async child reports | Keeps noisy background work from waking the parent |
+| **Conscience** (beta, off) | each operator prompt | Recommends a skill or tool from the capability index before the agent acts; enable with `conscience.enabled: true` |
 
 ## How intervention works
 

package/dist/backend.d.ts

@@ -1,18 +1,15 @@
 import type { TypeSafeOptions } from "pi-typesafe";
 /** The judgment backend that receives pi-warden's Jev requests. */
 export type JudgmentBackend = "typesafe" | "openrouter";
-/** The host the consent disclosure names as the destination. */
+/** The host the consent disclosure names as the destination, without scheme: `api.typesafe.ai`, `openrouter.ai`. */
 export declare function backendHost(backend: JudgmentBackend): string;
+/** The environment variable that carries the backend's key, for messages that tell the user what to set. */
+export declare function keyEnvFor(backend: JudgmentBackend): string;
 /** Adapt the consent text to the active backend by substituting the destination host. */
 export declare function disclosureFor(backend: JudgmentBackend, disclosure: string): string;
-/**
- * Whether the right credential exists for the chosen backend.
- * TypeSafe uses the pi-typesafe keystore; other backends use an environment variable.
- */
-export declare function keyAvailable(backend: JudgmentBackend, env: Record<string, string | undefined>, keystoreUsable: () => boolean): boolean;
 /**
  * Build the options forwarded to `createTypeSafe`.
- * The caller must gate on `keyAvailable` before calling `createTypeSafe`.
+ * The caller must gate on `authState({ backend }).usable` before calling `createTypeSafe`.
  */
 export declare function judgeOptions(config: {
     maxRequests: number;

package/dist/backend.js

@@ -1,36 +1,28 @@
-import { authState } from "pi-typesafe";
-const BACKENDS = {
-    typesafe: { host: "api.typesafe.ai" },
-    openrouter: { host: "openrouter.ai", keyEnv: "OPENROUTER_API_KEY" },
-};
-/** The host the consent disclosure names as the destination. */
+import { DECISIONS_BACKENDS, DEFAULT_BACKEND } from "pi-typesafe";
+/** The host the consent disclosure names as the destination, without scheme: `api.typesafe.ai`, `openrouter.ai`. */
 export function backendHost(backend) {
-    return BACKENDS[backend].host;
+    return new URL(DECISIONS_BACKENDS[backend].host).host;
+}
+/** The environment variable that carries the backend's key, for messages that tell the user what to set. */
+export function keyEnvFor(backend) {
+    return DECISIONS_BACKENDS[backend].keyEnv ?? DECISIONS_BACKENDS[DEFAULT_BACKEND].keyEnv ?? "TYPESAFE_API_KEY";
 }
 /** Adapt the consent text to the active backend by substituting the destination host. */
 export function disclosureFor(backend, disclosure) {
-    return backend === "typesafe" ? disclosure : disclosure.replace(BACKENDS.typesafe.host, BACKENDS[backend].host);
-}
-/**
- * Whether the right credential exists for the chosen backend.
- * TypeSafe uses the pi-typesafe keystore; other backends use an environment variable.
- */
-export function keyAvailable(backend, env, keystoreUsable) {
-    const keyEnv = BACKENDS[backend].keyEnv;
-    return keyEnv ? (env[keyEnv]?.trim() ?? "") !== "" : keystoreUsable();
+    return backend === DEFAULT_BACKEND ? disclosure : disclosure.replace(backendHost(DEFAULT_BACKEND), backendHost(backend));
 }
 /**
  * Build the options forwarded to `createTypeSafe`.
- * The caller must gate on `keyAvailable` before calling `createTypeSafe`.
+ * The caller must gate on `authState({ backend }).usable` before calling `createTypeSafe`.
  */
 export function judgeOptions(config) {
     return {
         maxRequests: config.maxRequests,
         timeoutMs: config.timeoutMs,
-        ...(config.typesafeBackend === "typesafe" ? {} : { backend: config.typesafeBackend }),
+        ...(config.typesafeBackend === DEFAULT_BACKEND ? {} : { backend: config.typesafeBackend }),
     };
 }
 /** Resolve the effective backend from a raw config value; invalid values fall back to "typesafe". */
 export function resolveBackend(raw) {
-    return raw === "typesafe" || raw === "openrouter" ? raw : "typesafe";
+    return raw === "typesafe" || raw === "openrouter" ? raw : DEFAULT_BACKEND;
 }

package/dist/config.d.ts

@@ -273,6 +273,8 @@ export interface ConscienceConfig {
     maxLoadedBytes: number;
     /** P(useful now) must reach this to select a candidate for recommendation. Default 1.0 (trace-only until calibrated per spec §7). */
     recommendThreshold: number;
+    /** P(advance) from the disposition question must reach this before a candidate is considered. Default 0.70. */
+    advanceThreshold: number;
     /** P(useful now) must reach this to auto-load. Must be >= recommendThreshold. Default 1.0 (trace-only until calibrated). */
     loadThreshold: number;
 }

package/dist/config.js

@@ -57,13 +57,14 @@ export function defaultConfig() {
             enabled: false,
             skills: { mode: "recommend", exclude: [] },
             tools: { enabled: true, exclude: [] },
-            timeoutMs: 1500,
+            timeoutMs: 3000,
             maxAssessments: 3,
             maxNudges: 2,
             maxSkillBytes: 32768,
             maxLoadedBytes: 65536,
-            // Calibration targets from spec §7. Until measured, 1.0 keeps production trace-only.
-            recommendThreshold: 1.0,
+            // Beta policy thresholds (measured 2026-09-22); disabled by default, conscience.enabled is the switch.
+            recommendThreshold: 0.80,
+            advanceThreshold: 0.70,
             loadThreshold: 1.0,
         },
     };
@@ -478,6 +479,7 @@ function applyConscience(base, raw) {
         maxSkillBytes: Math.max(1024, Math.min(131072, typeof raw.maxSkillBytes === "number" ? raw.maxSkillBytes : base.maxSkillBytes)),
         maxLoadedBytes: Math.max(1024, Math.min(262144, typeof raw.maxLoadedBytes === "number" ? raw.maxLoadedBytes : base.maxLoadedBytes)),
         recommendThreshold: Math.max(0, Math.min(1, typeof raw.recommendThreshold === "number" ? raw.recommendThreshold : base.recommendThreshold)),
+        advanceThreshold: Math.max(0, Math.min(1, typeof raw.advanceThreshold === "number" ? raw.advanceThreshold : base.advanceThreshold)),
         loadThreshold: Math.max(0, Math.min(1, typeof raw.loadThreshold === "number" ? raw.loadThreshold : base.loadThreshold)),
     };
 }

package/dist/conscience.d.ts

@@ -8,6 +8,24 @@ import type { Skill } from "@earendil-works/pi-coding-agent";
 import type { Questions } from "pi-typesafe";
 import type { ConscienceConfig } from "./config.js";
 export type Disposition = "advance" | "awaiting_user" | "no_gap" | "unclear";
+/** Capability roles the session model assigns to index entries. */
+export type CapabilityRole = "research" | "evidence" | "execution" | "delegation" | "review" | "conversation";
+/** Minimal index entry shape used by the conscience; full validation lives in index-cmd. */
+export interface IndexEntry {
+    kind: "skill" | "tool";
+    name: string;
+    scope: "global" | "project";
+    sourceHash: string;
+    role: CapabilityRole;
+    lead: string;
+    useWhen: string[];
+    notWhen: string[];
+    inputs: string;
+    examples: string[];
+    thin: boolean;
+    truncated?: boolean;
+    _location?: string;
+}
 /** One candidate for assessment: a skill or a tool. */
 export interface Candidate {
     /** "skill" or "tool". */
@@ -20,6 +38,10 @@ export interface Candidate {
     incomplete?: boolean;
     /** Full skill metadata, present for kind=skill. */
     skill?: Skill;
+    /** Capability role, present when the candidate has an index entry. */
+    role?: CapabilityRole;
+    /** Index entry when the candidate has a matching entry; bare description is the fallback. */
+    indexEntry?: IndexEntry;
 }
 /** The result of one assessment. */
 export interface AssessmentResult {
@@ -77,13 +99,29 @@ export declare function buildState(task: string, recentContext: string, activeSk
 /**
  * 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 declare function questionHash(questions: Questions): string;
-/** Filter candidates by eligibility rules, capped at MAX_ELIGIBLE per category. */
+/** Filter candidates by eligibility rules, capped at MAX_ELIGIBLE per category. Attaches index entries when available. */
 export declare function eligibleCandidates(skills: Skill[], tools: {
     name: string;
     description: string;
-}[], config: ConscienceConfig, activeSkills: string[], suppliedSkills: string[]): {
+}[], config: ConscienceConfig, activeSkills: string[], suppliedSkills: string[], globalIndex?: {
+    entries: IndexEntry[];
+} | undefined, projectIndex?: {
+    entries: IndexEntry[];
+} | undefined): {
     candidates: Candidate[];
     skillOverflow: boolean;
     toolOverflow: boolean;
@@ -105,11 +143,19 @@ export interface ConscienceDeps {
     sharedTimeoutMs: number;
     /** Current wall-clock time (ms). Injected for testability. */
     now?: () => number;
+    /** Pre-loaded global index, if any. */
+    globalIndex?: {
+        entries: IndexEntry[];
+    } | undefined;
+    /** Pre-loaded project index, if any. */
+    projectIndex?: {
+        entries: IndexEntry[];
+    } | undefined;
 }
 /**
  * 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 declare function assess(prompt: string, recentContext: string, skills: Skill[], tools: {
     name: string;