pi-warden 0.26.0 → 0.34.1

package/dist/audit.js

@@ -0,0 +1,110 @@
+import { existsSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { redact } from "./redact.js";
+import { discoverSourceFiles, findProjects } from "./discover.js";
+export { discoverSourceFiles, findProjects } from "./discover.js";
+// ─── Prompt builder ─────────────────────────────────────────────────────────
+/**
+ * Build the user message that sends the workspace to the session model for an
+ * agent-driven audit.  The model reads source, finds Jev opportunities, produces
+ * measurable evidence, and writes an HTML report.
+ *
+ * `projects` comes from {@link findProjects}.  `cwd` is the workspace root.
+ */
+export function buildAuditPrompt(cwd, projects) {
+    const projectName = cwd.split("/").pop() ?? "workspace";
+    // Collect project summaries so the model knows the workspace shape.
+    const summaries = [];
+    for (const projectPath of projects) {
+        const name = projectPath.split("/").pop() ?? projectPath;
+        let files;
+        try {
+            files = discoverSourceFiles(projectPath);
+        }
+        catch (err) {
+            console.warn(`audit: could not discover files in ${redact(projectPath)}: ${err instanceof Error ? err.message : err}`);
+            files = [];
+        }
+        const manifests = ["package.json", "Cargo.toml", "pyproject.toml", "go.mod"];
+        let manifest = "";
+        for (const m of manifests) {
+            const p = join(projectPath, m);
+            if (existsSync(p)) {
+                manifest = m;
+                break;
+            }
+        }
+        summaries.push(`- ${name} (${files.length} source files${manifest ? `, manifest: ${manifest}` : ""})`);
+    }
+    const reportPath = join(cwd, ".pi-warden", "audit-report.html");
+    return [
+        `# Workspace Audit — ${projectName}`,
+        "",
+        "You are auditing this workspace to find concrete places where hand-written heuristics can be replaced by typed Jev (TypeSafe) questions.",
+        "",
+        "## Workspace inventory",
+        summaries.join("\n"),
+        "",
+        "## What to do",
+        "",
+        "1. **Read the actual source** of each project. Do not rely on README or manifest alone. Open the files listed above (and any others you discover) and read the code.",
+        "",
+        "2. **Find concrete replacement candidates.** Look for:",
+        "   - if/else or switch chains that classify, route, or decide",
+        "   - regex classifiers or keyword lists that label text",
+        "   - threshold tables or scoring heuristics",
+        "   - ranking or sorting by hand-built criteria",
+        "   - validation logic that checks correctness of free-form output",
+        "   - routing decisions based on intent or content",
+        "",
+        "   For each candidate, cite the exact **file:line** location.",
+        "",
+        "3. **Produce measurable data for every finding.** For each candidate, gather evidence such as:",
+        "   - Count the branches, keyword entries, or cases the current code handles",
+        "   - Count cases it misses (e.g. grep for keywords it does not cover, list known false positives from comments or issues)",
+        "   - Run the existing test suite and count pass/fail relevant to this code path",
+        "   - Write a throwaway script under the OS temp directory that feeds sample inputs through both the current code and a Jev question (using `typesafe_evaluate` when available in the session; this tool requires the operator to run `/typesafe enable` once per session — if a call fails with \"TypeSafe is disabled\", ask the operator once, and if it remains disabled, continue with the other evidence and mark those findings unmeasured)",
+        "",
+        "   A finding without measurable comparison data must be marked **\"unmeasured\"** — do not dress it up.",
+        "",
+        "4. **Rank findings** by expected improvement (high/medium/low) and setup effort (low/medium/high).",
+        "",
+        `5. **Write a self-contained HTML report** to \`${reportPath}\` (create the \`.pi-warden\` directory if it does not exist).`,
+        "   - Plain HTML + inline CSS, no external assets, no scripts that fetch anything.",
+        "   - Sections: summary, findings table, one section per finding with evidence, methodology, and what was not measured.",
+        "   - One short chat line at the end naming the file path and the finding count.",
+        "",
+        "## Constraints",
+        "",
+        "- Read-only: do not modify any project source while auditing. The only files you may write are the report and throwaway scripts under the OS temp directory.",
+        "- Be specific. Every finding must name a file:line in this workspace.",
+        "- Prefer fewer, well-evidenced findings over many thin ones.",
+        "- If no replacement opportunities exist in a project, say so briefly and move on.",
+    ].join("\n");
+}
+/**
+ * Take a point-in-time snapshot of the audit report file.  Call before
+ * sending the prompt and again after the agent finishes.
+ */
+export function snapshotReport(reportPath) {
+    if (!existsSync(reportPath))
+        return { exists: false, mtimeMs: 0 };
+    try {
+        const s = statSync(reportPath);
+        return { exists: true, mtimeMs: s.mtimeMs };
+    }
+    catch (err) {
+        console.warn(`audit: could not stat report: ${err instanceof Error ? err.message : err}`);
+        return { exists: false, mtimeMs: 0 };
+    }
+}
+/**
+ * Determine whether the audit produced a new or updated report.
+ */
+export function reportOutcome(before, after) {
+    if (!after.exists)
+        return "missing";
+    if (!before.exists || after.mtimeMs > before.mtimeMs)
+        return "written";
+    return "stale";
+}

package/dist/config.d.ts

@@ -41,6 +41,11 @@ export interface ActionGuardConfig {
     intentMismatch: number;
     /** The same, for a command whose effect is visible outside the working tree (commit, push, merge, publish, launch): less mismatch is enough. */
     visibleMismatch: number;
+    /** Low P(should_proceed) is trace-only unless steer is enabled; hold is the inclusive threshold, not a blocking decision. Calibration: AUC 0.26 against regret, 44% flagged at 0.6 (100 targeted sessions, 2026-09-20). */
+    shouldProceed: {
+        hold: number;
+        steer: boolean;
+    };
     /** Write each judged call and what the user did next (approved, declined, re-planned, regretted) to an owner-only per-session file under the agent directory; redacted, never the command. */
     feedbackLog: boolean;
     /** User-defined command rules (user file only; project files cannot set severity above warn). */
@@ -53,6 +58,11 @@ export interface ActionGuardConfig {
     pathRules: PathRule[];
     /** User-defined arming rules: editing files matching globs arms a command pattern for a window (user file only). */
     armingRules: ArmingRule[];
+    /** Jev confidence at or above this escalates a violation's severity in the blast-radius and rules-guard escalation paths. */
+    escalationThreshold: number;
+    /** When a judge answers: "evidence" (default) lets the judge decide the level from irreversible score alone, using built-in pattern hits as context; "level" restores the legacy behaviour where the floor sets the level before the judge.
+     *  User-declared rules keep their declared action in both modes. */
+    floor: "evidence" | "level";
 }
 /** A user-defined path rule: which paths, which side of the access is held, which tools, what happens on a hit. */
 export interface PathRule {
@@ -213,6 +223,18 @@ export interface SubagentConfig {
 export type RecallTool = "auto" | "rg" | "ag" | "ugrep" | "git-grep" | "grep" | "select-string" | "findstr" | "none";
 export declare function isRecallTool(value: unknown): value is RecallTool;
 export type WardenMode = "steer" | "confirm" | "advise";
+export interface LearningConfig {
+    /** Enable adaptive thresholds based on learning data. */
+    adaptiveThresholds: boolean;
+    /** Enable pattern analysis and recommendations. */
+    patternAnalysis: boolean;
+    /** Minimum number of holds before adaptive thresholds kick in. */
+    minHoldsForAdaptive: number;
+    /** How aggressively to adjust thresholds (0-1). Higher values mean faster adaptation. */
+    adaptationRate: number;
+    /** Days to keep hold records in SQLite before pruning. 0 disables pruning. */
+    retentionDays: number;
+}
 export interface WardenConfig {
     /** Master switch. false disables every guard, including offline pattern checks. */
     enabled: boolean;
@@ -251,6 +273,8 @@ export interface WardenConfig {
      * steer costs at least one LLM turn, and a closing run that collects six notices collects six restatements of the final
      * status. 0 disables the budget. Critical guards (stuck, done, runaway, subagent wake) always deliver. */
     steerBudget: number;
+    /** Learning and adaptation settings. */
+    learning: LearningConfig;
 }
 export declare const PACKAGE_NAME = "pi-warden";
 /** Bumped when WardenConfig gains a section; extension.ts checks it so a half-updated module graph is reported, not crashed on. */
@@ -277,4 +301,8 @@ export declare function readUserConfig(): Json;
 export declare function writeUserConfig(raw: Json): string;
 /** Persists one top-level user setting without disturbing the rest of the file. */
 export declare function setUserSetting(key: "typesafe" | "enabled" | "mode", value: boolean | WardenMode): string;
+export declare function setNestedValue(obj: Record<string, unknown>, path: string, value: unknown): Record<string, unknown>;
+export declare function getNestedValue(obj: Record<string, unknown>, path: string): unknown;
+/** Coerce a CLI string into a JSON primitive so `/warden config set` stays ergonomic. */
+export declare function parseConfigValue(value: string): unknown;
 export {};

package/dist/config.js

@@ -29,12 +29,15 @@ export function defaultConfig() {
             offTask: { warn: 0.6, steer: 0.85 },
             intentMismatch: 0.9,
             visibleMismatch: 0.8,
+            shouldProceed: { hold: 0.6, steer: false },
             feedbackLog: true,
             commandRules: [],
             commandDenyRules: [],
             exemptRules: [],
             pathRules: [],
             armingRules: [],
+            escalationThreshold: 0.85,
+            floor: "evidence",
         },
         stuck: { enabled: true, window: 12, minFailures: 3, cooldown: 3, sameStrategy: 0.7, churnThreshold: 5, nudge: true },
         done: { enabled: true, claimsDone: 0.7, nudge: true },
@@ -49,6 +52,7 @@ export function defaultConfig() {
         steerVisible: false,
         notices: false,
         steerBudget: 3,
+        learning: { adaptiveThresholds: true, patternAnalysis: true, minHoldsForAdaptive: 20, adaptationRate: 0.1, retentionDays: 365 },
     };
 }
 /** Mirrors Pi's agent directory rule so the file sits next to pi-typesafe's auth.json. */
@@ -250,6 +254,10 @@ function applyAction(base, raw, timeoutMs, source) {
         offTask: offTaskThreshold(raw.offTask, base.offTask),
         intentMismatch: probability(raw.intentMismatch, base.intentMismatch),
         visibleMismatch: Math.min(probability(raw.visibleMismatch, base.visibleMismatch), probability(raw.intentMismatch, base.intentMismatch)),
+        shouldProceed: {
+            hold: probability(raw.shouldProceed?.hold, base.shouldProceed.hold),
+            steer: boolean(raw.shouldProceed?.steer, base.shouldProceed.steer),
+        },
         feedbackLog: boolean(raw.feedbackLog, base.feedbackLog),
         // Only the user file declares these; a project file cannot add, edit, or remove them. The base (already the
         // user's rules when a project file layers on top) is carried through, so a project "action" block cannot wipe them.
@@ -260,6 +268,8 @@ function applyAction(base, raw, timeoutMs, source) {
         pathRules: source === "user" ? parsePathRules(raw.pathRules) : base.pathRules,
         // Arming rules are user-declared security policy: same gate.
         armingRules: source === "user" ? parseArmingRules(raw.armingRules) : base.armingRules,
+        escalationThreshold: probability(raw.escalationThreshold, base.escalationThreshold),
+        floor: source === "user" && (raw.floor === "level" || raw.floor === "evidence") ? raw.floor : base.floor,
     };
 }
 function applyStuck(base, raw) {
@@ -351,6 +361,7 @@ function applyWidget(base, raw) {
     return {
         enabled: boolean(raw.enabled, base.enabled),
         placement: raw.placement === "belowEditor" || raw.placement === "aboveEditor" ? raw.placement : base.placement,
+        barMode: raw.barMode === "live" || raw.barMode === "stack" ? raw.barMode : base.barMode,
         shortcut: typeof raw.shortcut === "string" ? raw.shortcut.trim() : base.shortcut,
         panelWidth: typeof raw.panelWidth === "number" && Number.isSafeInteger(raw.panelWidth) && raw.panelWidth >= 20 ? raw.panelWidth
             : typeof raw.panelWidth === "string" && /^[1-9]\d?%$/.test(raw.panelWidth.trim()) ? raw.panelWidth.trim() : base.panelWidth,
@@ -414,6 +425,18 @@ export function applyUserOverrides(base, raw) {
         steerVisible: boolean(raw.steerVisible, base.steerVisible),
         notices: boolean(raw.notices, base.notices),
         steerBudget: typeof raw.steerBudget === "number" && Number.isInteger(raw.steerBudget) && raw.steerBudget >= 0 ? raw.steerBudget : base.steerBudget,
+        learning: applyLearning(base.learning, raw.learning),
+    };
+}
+function applyLearning(base, raw) {
+    if (!isObject(raw))
+        return base;
+    return {
+        adaptiveThresholds: boolean(raw.adaptiveThresholds, base.adaptiveThresholds),
+        patternAnalysis: boolean(raw.patternAnalysis, base.patternAnalysis),
+        minHoldsForAdaptive: Math.max(5, positiveInteger(raw.minHoldsForAdaptive, base.minHoldsForAdaptive)),
+        adaptationRate: Math.max(0, Math.min(1, probability(raw.adaptationRate, base.adaptationRate))),
+        retentionDays: Math.max(0, positiveInteger(raw.retentionDays, base.retentionDays)),
     };
 }
 /** Project files may tune the guards but cannot grant TypeSafe consent, change the mode, or raise budgets. */
@@ -445,3 +468,37 @@ export function writeUserConfig(raw) {
 export function setUserSetting(key, value) {
     return writeUserConfig({ ...readUserConfig(), [key]: value });
 }
+export function setNestedValue(obj, path, value) {
+    const keys = path.split(".");
+    const result = { ...obj };
+    let current = result;
+    for (let i = 0; i < keys.length - 1; i++) {
+        const key = keys[i];
+        current[key] = { ...(current[key] ?? {}) };
+        current = current[key];
+    }
+    current[keys.at(-1)] = value;
+    return result;
+}
+export function getNestedValue(obj, path) {
+    const keys = path.split(".");
+    let current = obj;
+    for (const key of keys) {
+        if (typeof current !== "object" || current === null)
+            return undefined;
+        current = current[key];
+    }
+    return current;
+}
+/** Coerce a CLI string into a JSON primitive so `/warden config set` stays ergonomic. */
+export function parseConfigValue(value) {
+    if (value === "true")
+        return true;
+    if (value === "false")
+        return false;
+    if (value === "null")
+        return null;
+    if (/^-?\d+(\.\d+)?$/.test(value))
+        return Number(value);
+    return value;
+}

package/dist/conscience-config.d.ts

@@ -0,0 +1,21 @@
+export interface ConscienceConfig {
+    enabled: boolean;
+    skills: {
+        mode: "off" | "recommend" | "load";
+        exclude: string[];
+    };
+    tools: {
+        enabled: boolean;
+        exclude: string[];
+    };
+    timeoutMs: number;
+    maxAssessments: number;
+    maxNudges: number;
+    maxSkillBytes: number;
+    maxLoadedBytes: number;
+}
+export declare const conscienceWarnings: (config: ConscienceConfig) => readonly string[];
+export declare function disabledConscience(): ConscienceConfig;
+export declare function validConscience(value: unknown): value is ConscienceConfig;
+/** Normalize each raw layer before defaults lose the distinction between absent and explicit opt-outs. */
+export declare function mergeConscience(base: ConscienceConfig, layer: Record<string, unknown>, project: boolean): ConscienceConfig;

package/dist/conscience-config.js

@@ -0,0 +1,82 @@
+const ranges = { timeoutMs: [100, 10000], maxAssessments: [1, 10], maxNudges: [1, 5], maxSkillBytes: [1024, 131072], maxLoadedBytes: [1024, 262144] };
+const modes = ["off", "recommend", "load"];
+const warnings = new WeakMap();
+const object = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const exclusions = (value) => Array.isArray(value) && value.every(item => typeof item === "string" && /^[A-Za-z0-9_.:*\-]+$/.test(item));
+export const conscienceWarnings = (config) => warnings.get(config) ?? [];
+export function disabledConscience() {
+    return { enabled: false, skills: { mode: "off", exclude: [] }, tools: { enabled: false, exclude: [] }, timeoutMs: 1500, maxAssessments: 3, maxNudges: 2, maxSkillBytes: 32768, maxLoadedBytes: 65536 };
+}
+export function validConscience(value) {
+    if (!object(value) || typeof value.enabled !== "boolean" || !object(value.skills) || !object(value.tools))
+        return false;
+    if (!modes.includes(value.skills.mode) || !exclusions(value.skills.exclude) || typeof value.tools.enabled !== "boolean" || !exclusions(value.tools.exclude))
+        return false;
+    return Object.entries(ranges).every(([key, [min, max]]) => typeof value[key] === "number" && Number.isInteger(value[key]) && value[key] >= min && value[key] <= max);
+}
+/** Normalize each raw layer before defaults lose the distinction between absent and explicit opt-outs. */
+export function mergeConscience(base, layer, project) {
+    const notes = [...conscienceWarnings(base)];
+    const warn = (key) => notes.push(`Invalid conscience configuration: ${key}; prior policy retained or capability disabled.`);
+    const raw = object(layer.conscience) ? layer.conscience : {};
+    if (layer.conscience !== undefined && !object(layer.conscience))
+        warn("conscience");
+    const next = { ...base, skills: { ...base.skills, exclude: [...base.skills.exclude] }, tools: { ...base.tools, exclude: [...base.tools.exclude] } };
+    const action = object(layer.action) ? layer.action : {};
+    const legacyOff = action.enabled === false || action.toolRecommendation === false;
+    if (raw.enabled !== undefined && typeof raw.enabled !== "boolean")
+        warn("conscience.enabled");
+    const explicit = typeof raw.enabled === "boolean";
+    const enabled = explicit ? raw.enabled : legacyOff ? false : base.enabled;
+    next.enabled = project ? base.enabled && enabled : enabled;
+    if (layer.enabled === false)
+        next.enabled = false;
+    if (explicit && (legacyOff || layer.enabled === false))
+        notes.push("Conscience migration: conscience.enabled supersedes action.enabled/action.toolRecommendation; enabled remains the master opt-out.");
+    for (const category of ["skills", "tools"]) {
+        const value = raw[category];
+        if (value === undefined)
+            continue;
+        if (!object(value)) {
+            warn(`conscience.${category}`);
+            continue;
+        }
+        if (category === "skills" && value.mode !== undefined) {
+            if (modes.includes(value.mode)) {
+                const index = modes.indexOf(value.mode);
+                next.skills.mode = modes[project ? Math.min(index, modes.indexOf(base.skills.mode)) : index];
+            }
+            else
+                warn("conscience.skills.mode");
+        }
+        if (category === "tools" && value.enabled !== undefined) {
+            if (typeof value.enabled === "boolean")
+                next.tools.enabled = project ? base.tools.enabled && value.enabled : value.enabled;
+            else
+                warn("conscience.tools.enabled");
+        }
+        if (value.exclude !== undefined) {
+            if (exclusions(value.exclude))
+                next[category].exclude = [...new Set([...(project ? base[category].exclude : []), ...value.exclude])];
+            else {
+                warn(`conscience.${category}.exclude`);
+                if (category === "skills")
+                    next.skills.mode = "off";
+                else
+                    next.tools.enabled = false;
+            }
+        }
+    }
+    for (const key of Object.keys(ranges)) {
+        const value = raw[key];
+        if (value === undefined)
+            continue;
+        const [min, max] = ranges[key];
+        if (typeof value === "number" && Number.isInteger(value) && value >= min && value <= max)
+            next[key] = project ? Math.min(base[key], value) : value;
+        else
+            warn(`conscience.${key}`);
+    }
+    warnings.set(next, [...new Set(notes)]);
+    return next;
+}

package/dist/conscience-loader.d.ts

@@ -0,0 +1,26 @@
+import type { Skill } from "@earendil-works/pi-coding-agent";
+import type { ActionGuardConfig } from "./config.js";
+export interface SkillReadRequest {
+    skill: Skill;
+    cwd: string;
+    action: ActionGuardConfig;
+    maxBytes: number;
+    signal: AbortSignal;
+    disclosed: string;
+}
+export type SkillReadResult = {
+    ok: true;
+    body: string;
+    bytes: number;
+    digest: string;
+    notice: boolean;
+} | {
+    ok: false;
+    reason: "load_denied" | "load_too_large" | "load_changed" | "load_failed" | "metadata_unsafe" | "timeout";
+};
+export declare function skillPathPolicy(skill: Skill, cwd: string, action: ActionGuardConfig, resolved?: string): {
+    allowed: boolean;
+    notice: boolean;
+};
+/** Narrow catalog read, not an agent tool call and not a filesystem sandbox. */
+export declare function readTrustedSkill(request: SkillReadRequest): Promise<SkillReadResult>;

package/dist/conscience-loader.js

@@ -0,0 +1,82 @@
+import { constants } from "node:fs";
+import { open, realpath, stat } from "node:fs/promises";
+import { basename, resolve } from "node:path";
+import { parseFrontmatter, stripFrontmatter } from "@earendil-works/pi-coding-agent";
+import { matchPathRules } from "./guard.js";
+import { digest } from "./conscience-policy.js";
+import { safeConscienceText } from "./conscience-privacy.js";
+export function skillPathPolicy(skill, cwd, action, resolved) {
+    const hits = [skill.filePath, ...(resolved ? [resolved] : [])].flatMap(path => matchPathRules("read", { path }, cwd, action.pathRules, new Set(action.exemptRules)));
+    return { allowed: !hits.some(hit => hit.severity === "deny" || hit.severity === "destructive"), notice: hits.length > 0 };
+}
+/** Narrow catalog read, not an agent tool call and not a filesystem sandbox. */
+export async function readTrustedSkill(request) {
+    const { skill, cwd, action, signal, maxBytes } = request;
+    const check = () => signal.throwIfAborted();
+    const fingerprint = (value) => [value.dev, value.ino, value.size, value.mtimeMs, value.ctimeMs].join(":");
+    try {
+        check();
+        if (!skillPathPolicy(skill, cwd, action).allowed)
+            return { ok: false, reason: "load_denied" };
+        const advertised = resolve(cwd, skill.filePath);
+        const target = await realpath(advertised);
+        check();
+        const base = await realpath(resolve(cwd, skill.baseDir));
+        check();
+        const policy = skillPathPolicy(skill, cwd, action, target);
+        if (!policy.allowed)
+            return { ok: false, reason: "load_denied" };
+        const before = await stat(target);
+        check();
+        if (!before.isFile())
+            return { ok: false, reason: "load_failed" };
+        if (before.size > maxBytes)
+            return { ok: false, reason: "load_too_large" };
+        const handle = await open(target, constants.O_RDONLY | constants.O_NONBLOCK);
+        try {
+            check();
+            const opened = await handle.stat();
+            check();
+            if (!opened.isFile() || fingerprint(before) !== fingerprint(opened))
+                return { ok: false, reason: "load_changed" };
+            const buffer = Buffer.alloc(maxBytes + 1);
+            let count = 0;
+            while (count < buffer.length) {
+                const result = await handle.read(buffer, count, buffer.length - count, count);
+                check();
+                if (!result.bytesRead)
+                    break;
+                count += result.bytesRead;
+            }
+            if (count > maxBytes)
+                return { ok: false, reason: "load_too_large" };
+            const after = await handle.stat();
+            check();
+            const currentTarget = await realpath(advertised);
+            check();
+            const currentBase = await realpath(resolve(cwd, skill.baseDir));
+            check();
+            const current = await stat(target);
+            check();
+            if (currentTarget !== target || currentBase !== base || fingerprint(opened) !== fingerprint(after) || fingerprint(after) !== fingerprint(current) || count !== after.size)
+                return { ok: false, reason: "load_changed" };
+            const text = new TextDecoder("utf-8", { fatal: true }).decode(buffer.subarray(0, count));
+            if (/[\x00-\x08\x0b\x0c\x0e-\x1f]/.test(text))
+                return { ok: false, reason: "load_failed" };
+            const { frontmatter } = parseFrontmatter(text);
+            if ((frontmatter.name ?? basename(skill.baseDir)) !== skill.name || frontmatter.description !== skill.description || frontmatter["disable-model-invocation"] === true)
+                return { ok: false, reason: "load_changed" };
+            const body = stripFrontmatter(text);
+            if (safeConscienceText(text, request.disclosed) !== text)
+                return { ok: false, reason: "metadata_unsafe" };
+            check();
+            return { ok: true, body, bytes: count, digest: digest(text), notice: policy.notice };
+        }
+        finally {
+            await handle.close();
+        }
+    }
+    catch {
+        return { ok: false, reason: signal.aborted ? "timeout" : "load_failed" };
+    }
+}

package/dist/conscience-policy.d.ts

@@ -0,0 +1,24 @@
+export declare const SCORE_LEVELS: string[];
+export declare const SCORE_INSTRUCTIONS = "Assess next-step usefulness of the named candidate against task, recent context, observations, supplied capabilities and constraints. A supplied workflow must not be replaced; another skill must support a new unmet need. Conversation methods may be useful before asking the user a question. An appropriate ordinary tool does not exclude a complementary skill.";
+export declare const DISPOSITION: {
+    type: "choice";
+    instructions: string;
+    criteria: {
+        advance: string;
+        awaiting_user: string;
+        no_gap: string;
+        unclear: string;
+    };
+};
+export declare const CONSCIENCE_MODEL = "jev-1.13";
+export declare const digest: (value: unknown) => string;
+export declare const QUESTION_POLICY_HASH: string;
+export interface MeasuredPolicy {
+    questionHash: string;
+    model: string;
+    recommendation: number;
+    loading: number;
+    evidence: string;
+}
+export declare const measuredPolicy: MeasuredPolicy | undefined;
+export declare function validPolicy(policy: MeasuredPolicy | undefined, model: string): policy is MeasuredPolicy;

package/dist/conscience-policy.js

@@ -0,0 +1,28 @@
+import { createHash } from "node:crypto";
+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.",
+];
+export const SCORE_INSTRUCTIONS = "Assess next-step usefulness of the named candidate against task, recent context, observations, supplied capabilities and constraints. A supplied workflow must not be replaced; another skill must support a new unmet need. Conversation methods may be useful before asking the user a question. An appropriate ordinary tool does not exclude a complementary skill.";
+export const DISPOSITION = {
+    type: "choice",
+    instructions: "What is the current task disposition? An initial thinking request is not awaiting_user merely because clarification will be needed: its conversation method is an available next step. Awaiting_user requires an actual unanswered question from the assistant.",
+    criteria: {
+        advance: "A useful next step can be taken now.",
+        awaiting_user: "The assistant has already asked for information and must wait for the user.",
+        no_gap: "The request is satisfied with no useful missing step.",
+        unclear: "There is insufficient evidence to identify a useful next step.",
+    },
+};
+export const CONSCIENCE_MODEL = "jev-1.13";
+export const digest = (value) => createHash("sha256").update(JSON.stringify(value)).digest("hex");
+export const QUESTION_POLICY_HASH = digest({ levels: SCORE_LEVELS, instructions: SCORE_INSTRUCTIONS, disposition: DISPOSITION, stateVersion: 1 });
+// No shipping threshold exists until the frozen holdout and follow-through gates pass.
+export const measuredPolicy = undefined;
+export function validPolicy(policy, model) {
+    return !!policy && policy.questionHash === QUESTION_POLICY_HASH && policy.model === model && !!policy.evidence
+        && Number.isFinite(policy.recommendation) && policy.recommendation >= 0.5 && policy.recommendation <= 0.95
+        && Number.isFinite(policy.loading) && policy.loading >= policy.recommendation && policy.loading <= 0.95;
+}

package/dist/conscience-privacy.d.ts

@@ -0,0 +1,4 @@
+/** URLs are not local paths; protect them before scanning free text for filesystem spans. */
+export declare function safeConscienceText(text: string, disclosed?: string): string;
+export declare const safeCapabilityName: (name: string) => boolean;
+export declare const excludedCapability: (name: string, patterns: readonly string[]) => boolean;

package/dist/conscience-privacy.js

@@ -0,0 +1,11 @@
+import { redact } from "./redact.js";
+/** URLs are not local paths; protect them before scanning free text for filesystem spans. */
+export function safeConscienceText(text, disclosed = "") {
+    const urls = [];
+    const redacted = redact(text);
+    const masked = redacted.replace(/https?:\/\/[^\s<>"'`]+/gi, value => `\u0001${urls.push(value) - 1}\u0002`);
+    const clean = masked.replace(/(?:file:\/\/[^\s<>"'`]+|[A-Za-z]:[\\/][^\s<>"'`]+|\\\\[^\s<>"'`]+|~\/[^\s<>"'`]+|(?<![\w/:])\/(?:[^\s<>"'`]+))/g, path => disclosed.includes(path) ? path : "[local path]");
+    return clean.replace(/\u0001(\d+)\u0002/g, (_, index) => urls[Number(index)] ?? "[URL]");
+}
+export const safeCapabilityName = (name) => /^[A-Za-z0-9_.:\-]{1,128}$/.test(name) && redact(name) === name;
+export const excludedCapability = (name, patterns) => patterns.some(pattern => new RegExp(`^${pattern.split("*").map(part => part.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join(".*")}$`).test(name));

package/dist/discover.d.ts

@@ -0,0 +1,14 @@
+/** Directories to skip during source-file discovery. */
+export declare const SKIP_DIRS: Set<string>;
+export declare const SOURCE_RE: RegExp;
+/**
+ * Recursively walk `dir` and collect source-file paths (relative to `dir`).
+ * Skips directories in SKIP_DIRS and stops after `max` files.
+ */
+export declare function discoverSourceFiles(dir: string, max?: number): string[];
+/**
+ * Find project directories inside a workspace. A project is any directory
+ * containing a known manifest file. The workspace root itself counts if it
+ * has one.
+ */
+export declare function findProjects(cwd: string): string[];