fidelis 0.0.0-stage → 0.1.1

package/README.md

@@ -1,3 +1,3 @@
-# Temporary Holding Version
+# fidelis
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Core of [Fidelis](https://github.com/insign/fidelis): instruction resolution, checklist cache, judge pipeline and session state machine. Use a host adapter unless you are writing one.

package/dist/auditor.d.ts

@@ -0,0 +1,54 @@
+import type { AuditRecord, Config, Evidence, ExecEvent, Finding, Host, InstructionSource, Outcome, SessionState, StateName } from "./types.ts";
+import type { DecisionModel, GenerateText } from "./providers.ts";
+import { type Store } from "./store.ts";
+export declare const FIDELIS_MARKER = "[Fidelis audit: automated message, not from the user]";
+export type MessageOrigin = "human" | "sdk" | "synthetic" | "fidelis" | "agent" | "unknown";
+export declare function correctionReport(auditID: string, findings: Finding[]): string;
+export declare function userNotice(findings: Finding[]): string;
+export interface CompletionInput {
+    /** null means the host did not reveal what it loaded: never read that as "no rules". */
+    sources: InstructionSource[] | null;
+    evidence: Evidence;
+    /** Host identity of the final turn, e.g. the last assistant message ID. */
+    boundaryKey: string;
+}
+export interface AuditorOptions {
+    store: Store;
+    host: Host;
+    config: Config;
+    options?: Record<string, unknown>;
+    compiler: GenerateText | null;
+    judge: DecisionModel | null;
+    onChange?: (state: SessionState, transition: string) => void;
+}
+export declare class Auditor {
+    private readonly o;
+    constructor(options: AuditorOptions);
+    private save;
+    /** Only a verified human message opens a turn or releases a wait. A known ID never counts twice. */
+    userMessage(sessionID: string, message: {
+        id: string;
+        origin: MessageOrigin;
+    }): boolean;
+    /** A turn that failed or was interrupted has no completed boundary to audit: nothing is running any more. */
+    executionEnded(sessionID: string): void;
+    /** The agent never received the correction, so nothing is being corrected. */
+    deliveryFailed(sessionID: string, reason: string): void;
+    /** Merge host events with the ledger so compaction cannot erase evidence the audit still needs. */
+    retain(sessionID: string, events: ExecEvent[]): ExecEvent[];
+    complete(sessionID: string, input: CompletionInput): Promise<Outcome>;
+    /** Deterministic routing. Model output only suggests; these branches decide. */
+    private route;
+    status(sessionID: string): {
+        sessionID: string;
+        state: StateName;
+        phase: import("./types.ts").Phase;
+        reason: string | undefined;
+        revision: number;
+        updatedAt: number;
+        auditID: string | null;
+        corrections: number;
+        actionable: number;
+        audits: AuditRecord[];
+    };
+}

package/dist/auditor.js

@@ -0,0 +1,278 @@
+import { randomUUID } from "node:crypto";
+import { consentProblem } from "./config.js";
+import { getChecklist, resolveSources } from "./compiler.js";
+import { judge, LEDGER_MARK } from "./judge.js";
+import { transition } from "./machine.js";
+import { redact } from "./redact.js";
+import { canonical, sha256 } from "./store.js";
+export const FIDELIS_MARKER = "[Fidelis audit: automated message, not from the user]";
+const AUDIT_STALE_MS = 15 * 60_000;
+const MAX_TRACKED = 500;
+const LEDGER_CLIP = 2000;
+const LEDGER_MAX = 1000;
+export function correctionReport(auditID, findings) {
+    const lines = [FIDELIS_MARKER, `Audit ${auditID}. This is not new user authorization.`, ""];
+    findings.forEach((finding, index) => {
+        lines.push(`${index + 1}. Rule ${finding.ruleID} (${finding.obligation}) from ${finding.source}: "${finding.quote}"`);
+        lines.push(`   Observed: ${finding.explanation}`);
+        if (finding.repair === "unrepairable")
+            lines.push("   This cannot be undone. State it plainly in your reply and do any feasible compensating work; do not pretend the order of events changed.");
+        else
+            lines.push(`   Allowed repair: ${finding.repairHint || "the smallest change that satisfies the rule"}.`);
+    });
+    lines.push("", "Fix only what is listed. If a repair needs something the user has not authorized, ask the user and stop instead.");
+    return lines.join("\n");
+}
+export function userNotice(findings) {
+    return findings.map((finding) => `${finding.ruleID}: ${finding.explanation}`).join("\n");
+}
+export class Auditor {
+    o;
+    constructor(options) {
+        this.o = options;
+    }
+    save(sessionID, change, label = "update") {
+        const state = this.o.store.update(sessionID, change);
+        this.o.onChange?.(state, label);
+        return state;
+    }
+    /** Only a verified human message opens a turn or releases a wait. A known ID never counts twice. */
+    userMessage(sessionID, message) {
+        const trusted = message.origin === "human" || (message.origin === "sdk" && this.o.config.trustSdkPrompts);
+        const current = this.o.store.read(sessionID);
+        // An SDK prompt may open a turn but can never release a wait or a stop.
+        const opensTurn = message.origin === "sdk" && current.state !== "WAITING_USER" && current.state !== "STOPPED";
+        if ((!trusted && !opensTurn) || current.humanIDs.includes(message.id))
+            return false;
+        this.save(sessionID, (state) => {
+            if (state.humanIDs.includes(message.id))
+                return;
+            state.humanIDs = [...state.humanIDs, message.id].slice(-MAX_TRACKED);
+            state.state = transition(state.state, "human");
+            state.turn += 1;
+            state.corrections = 0;
+            state.disclosed = [];
+            state.findings = [];
+            state.violationKey = undefined;
+            state.audit = undefined;
+            state.reason = undefined;
+            state.phase = null;
+        }, "human");
+        return true;
+    }
+    /** A turn that failed or was interrupted has no completed boundary to audit: nothing is running any more. */
+    executionEnded(sessionID) {
+        if (this.o.store.read(sessionID).state !== "RUNNING")
+            return;
+        this.save(sessionID, (state) => {
+            if (state.state === "RUNNING")
+                state.state = "READY";
+        }, "ended");
+    }
+    /** The agent never received the correction, so nothing is being corrected. */
+    deliveryFailed(sessionID, reason) {
+        this.save(sessionID, (state) => {
+            if (state.state !== "CORRECTING")
+                return;
+            state.state = "AUDIT_INCOMPLETE";
+            state.reason = `The correction could not be delivered: ${reason}`;
+        }, "incomplete");
+    }
+    /** Merge host events with the ledger so compaction cannot erase evidence the audit still needs. */
+    retain(sessionID, events) {
+        const store = this.o.store;
+        const raw = this.o.config.storeRawTranscript;
+        const merged = new Map(store.readLedger(sessionID).map((event) => [event.id, event]));
+        for (const event of events)
+            merged.set(event.id, event);
+        const ordered = [...merged.values()].sort((a, b) => (a.at ?? 0) - (b.at ?? 0) || a.seq - b.seq).map((event, seq) => ({ ...event, seq }));
+        const clipField = (value) => {
+            if (value === undefined)
+                return undefined;
+            const clean = redact(value);
+            return raw || clean.length <= LEDGER_CLIP ? clean : clean.slice(0, LEDGER_CLIP) + LEDGER_MARK;
+        };
+        store.writeLedger(sessionID, ordered.slice(-LEDGER_MAX).map((event) => ({ ...event, text: clipField(event.text), output: clipField(event.output), input: clipField(typeof event.input === "string" || event.input === undefined ? event.input : JSON.stringify(event.input)) })));
+        return ordered;
+    }
+    async complete(sessionID, input) {
+        const { store, config } = this.o;
+        if (!config.enabled || !config.auditOnCompletion)
+            return { action: "none", state: store.read(sessionID).state, reason: "auditing disabled" };
+        const started = Date.now();
+        // Hash what identifies the turn, not timestamps or transcript flush order, so a replayed callback matches.
+        const acted = input.evidence.events.filter((event) => event.kind === "tool" || event.kind === "fidelis").map((event) => [event.id, event.status ?? ""]);
+        const boundaryID = sha256(canonical({ key: input.boundaryKey, acted, reply: input.evidence.finalReply }));
+        const auditID = randomUUID();
+        let skip;
+        const begin = this.save(sessionID, (state) => {
+            const inFlight = state.audit && state.audit.boundaryID === boundaryID && started - state.audit.startedAt < AUDIT_STALE_MS;
+            if (state.boundaries.includes(boundaryID) || inFlight) {
+                skip = { action: "none", state: state.state, duplicate: true };
+                return;
+            }
+            const next = transition(state.state, "complete");
+            if (next !== "AUDITING") {
+                // Locked: no audit and no push until a verified human turn.
+                state.boundaries = [...state.boundaries, boundaryID].slice(-MAX_TRACKED);
+                skip = { action: "none", state: next, reason: state.reason };
+                return;
+            }
+            state.state = next;
+            state.phase = "judging";
+            state.audit = { id: auditID, boundaryID, turn: state.turn, startedAt: started };
+        }, "auditing");
+        if (skip)
+            return skip;
+        // Spend is saved as it happens, so a superseded audit still counts against the session.
+        const charge = (costUSD) => {
+            if (costUSD)
+                this.save(sessionID, (state) => void (state.spentUSD += costUSD), "usage");
+        };
+        const metrics = { cacheHit: false, compilerCalls: 0, judgeCalls: 0, tokens: 0, costUSD: 0, latencyMs: 0, uncertain: 0 };
+        const finish = (event, reason, findings, extra = {}) => {
+            metrics.latencyMs = Date.now() - started;
+            metrics.uncertain = findings.filter((finding) => finding.status === "UNKNOWN").length;
+            let current = false;
+            const final = this.save(sessionID, (state) => {
+                current = state.audit?.id === auditID;
+                if (!current)
+                    return;
+                Object.assign(state, extra);
+                state.state = transition("AUDITING", event);
+                state.phase = null;
+                state.audit = undefined;
+                state.reason = reason;
+                state.findings = findings;
+                state.lastAuditID = auditID;
+                state.boundaries = [...state.boundaries, boundaryID].slice(-MAX_TRACKED);
+            }, event);
+            if (!current)
+                return null;
+            const record = { auditID, boundaryID, turn: begin.turn, at: Date.now(), state: final.state, reason, findings, metrics, corrections: final.corrections };
+            store.appendAudit(sessionID, record);
+            return final.state;
+        };
+        const stale = () => ({ action: "none", state: store.read(sessionID).state, reason: "audit superseded by a newer turn" });
+        const incomplete = (reason, findings = []) => {
+            const state = finish("incomplete", reason, findings);
+            return state ? { action: "none", state, reason, notice: `Fidelis audit incomplete: ${reason}` } : stale();
+        };
+        if (config.maxAuditCostUSD !== null && begin.spentUSD >= config.maxAuditCostUSD) {
+            const reason = `Audit budget of $${config.maxAuditCostUSD} is exhausted.`;
+            const state = finish("stop", reason, []);
+            return state ? { action: "none", state, reason, notice: `Fidelis stopped: ${reason}` } : stale();
+        }
+        if (!input.sources)
+            return incomplete("The host did not reveal which instructions it loaded.");
+        const sources = resolveSources(input.sources);
+        if (sources.length === 0) {
+            const reason = "No effective instructions to audit.";
+            const state = finish("clean", reason, []);
+            return state ? { action: "none", state, reason } : stale();
+        }
+        const options = this.o.options ?? {};
+        const compileConsent = consentProblem(config.compilerModel, options, config);
+        const compiled = await getChecklist({
+            store,
+            host: this.o.host,
+            sources,
+            config,
+            generate: compileConsent ? null : this.o.compiler,
+            onCompile: () => this.save(sessionID, (state) => void (state.phase = "compiling"), "compiling"),
+        });
+        metrics.cacheHit = compiled.cacheHit;
+        metrics.compilerCalls = compiled.calls;
+        metrics.tokens = compiled.tokens;
+        metrics.costUSD = compiled.costUSD;
+        charge(compiled.costUSD);
+        if (!compiled.checklist)
+            return incomplete(compileConsent && !compiled.cacheHit ? compileConsent : (compiled.reason ?? "Checklist unavailable."));
+        this.save(sessionID, (state) => void (state.phase = "judging"), "judging");
+        const judgeConsent = consentProblem(config.judgeModel, options, config);
+        if (judgeConsent)
+            return incomplete(judgeConsent);
+        if (!this.o.judge)
+            return incomplete("No decision model is available.");
+        let verdict;
+        try {
+            verdict = await judge({
+                checklist: compiled.checklist,
+                evidence: input.evidence,
+                prior: begin.findings.filter((finding) => finding.status === "VIOLATED"),
+                model: this.o.judge,
+                config,
+                stopReason: () => {
+                    const current = store.read(sessionID);
+                    if (current.audit?.id !== auditID)
+                        return "the audit was superseded by a newer turn";
+                    return config.maxAuditCostUSD !== null && current.spentUSD >= config.maxAuditCostUSD ? "the audit budget is exhausted" : null;
+                },
+                onUsage: (tokens, costUSD) => {
+                    metrics.tokens += tokens;
+                    metrics.costUSD += costUSD;
+                    charge(costUSD);
+                },
+            });
+        }
+        catch (error) {
+            return incomplete(`Judge failed: ${error.message}`);
+        }
+        metrics.judgeCalls = verdict.calls;
+        return this.route(verdict.findings, verdict.waiting, compiled.checklist.dropped.length, begin, auditID, finish, stale, incomplete);
+    }
+    /** Deterministic routing. Model output only suggests; these branches decide. */
+    route(findings, waiting, dropped, begin, auditID, finish, stale, incomplete) {
+        const violated = findings.filter((finding) => finding.status === "VIOLATED");
+        const open = violated.filter((finding) => !finding.resolved);
+        const forUser = open.filter((finding) => finding.repair === "user");
+        if (waiting || forUser.length) {
+            const reason = forUser.length ? `Repair needs user authorization: ${forUser.map((finding) => finding.ruleID).join(", ")}.` : "The agent is waiting for a user decision.";
+            const state = finish("wait", reason, findings);
+            return state ? { action: "wait", state, auditID, reason, notice: violated.length ? `Fidelis findings:\n${userNotice(violated)}` : undefined } : stale();
+        }
+        // A rule disclosed as unrepairable is never corrected again, even if the model later calls it repairable.
+        const undisclosed = open.filter((finding) => !begin.disclosed.includes(finding.ruleID));
+        if (undisclosed.length) {
+            if (begin.corrections >= this.o.config.maxCorrections) {
+                const reason = `Correction limit of ${this.o.config.maxCorrections} reached with unresolved violations.`;
+                const state = finish("stop", reason, findings);
+                return state ? { action: "none", state, reason, notice: `Fidelis stopped: ${reason}\n${userNotice(undisclosed)}` } : stale();
+            }
+            const state = finish("correct", undefined, findings, {
+                corrections: begin.corrections + 1,
+                disclosed: [...begin.disclosed, ...undisclosed.filter((finding) => finding.repair === "unrepairable").map((finding) => finding.ruleID)],
+            });
+            return state ? { action: "correct", state, auditID, text: correctionReport(auditID, undisclosed) } : stale();
+        }
+        if (open.length) {
+            const reason = "Only already disclosed unrepairable violations remain.";
+            const state = finish("stop", reason, findings);
+            return state ? { action: "none", state, reason, notice: `Fidelis findings:\n${userNotice(open)}` } : stale();
+        }
+        const unknown = findings.filter((finding) => finding.status === "UNKNOWN");
+        if (unknown.length)
+            return incomplete(`${unknown.length} rule(s) could not be assessed.`, findings);
+        // A rule the compiler produced but validation rejected was never judged, so this cannot be a clean pass.
+        if (dropped)
+            return incomplete(`${dropped} compiled rule(s) failed validation and were not assessed.`, findings);
+        const reason = violated.length ? `${violated.length} violation(s) on record, repaired or acknowledged after correction.` : undefined;
+        const state = finish("clean", reason, findings);
+        return state ? { action: "none", state, reason, notice: violated.length ? `Fidelis findings:\n${userNotice(violated)}` : undefined } : stale();
+    }
+    status(sessionID) {
+        const state = this.o.store.read(sessionID);
+        return {
+            sessionID,
+            state: state.state,
+            phase: state.phase,
+            reason: state.reason,
+            revision: state.revision,
+            updatedAt: state.updatedAt,
+            auditID: state.audit?.id ?? state.lastAuditID ?? null,
+            corrections: state.corrections,
+            actionable: state.findings.filter((finding) => finding.status === "VIOLATED" && !finding.resolved).length,
+            audits: this.o.store.audits(sessionID, 20),
+        };
+    }
+}

package/dist/compiler.d.ts

@@ -0,0 +1,45 @@
+import type { Checklist, Config, Host, InstructionSource, Rule } from "./types.ts";
+import { type GenerateText } from "./providers.ts";
+import { type Store } from "./store.ts";
+export declare const SCHEMA_VERSION = 1;
+export declare const COMPILER_VERSION = 1;
+/** Ordered by the host's load order, without double-counting a file reached twice. */
+export declare function resolveSources(sources: InstructionSource[]): InstructionSource[];
+export declare function compilerPrompt(config: Pick<Config, "compilerPromptPath">): string;
+export declare function checklistFingerprint(host: Host, sources: InstructionSource[], config: Pick<Config, "compilerModel" | "compilerEffort">, prompt: string): string;
+/** Schema check plus traceability: a rule whose quote is not verbatim in its source is rejected. */
+export declare function validateRules(raw: any, sources: InstructionSource[]): {
+    rules: Rule[];
+    dropped: string[];
+};
+export declare const CHECKLIST_SCHEMA: {
+    type: string;
+    properties: {
+        confidence: {
+            type: string;
+        };
+        rules: {
+            type: string;
+            items: {
+                type: string;
+            };
+        };
+    };
+    required: string[];
+};
+export interface CompileResult {
+    checklist?: Checklist;
+    cacheHit: boolean;
+    calls: number;
+    tokens: number;
+    costUSD: number;
+    reason?: string;
+}
+export declare function getChecklist(input: {
+    store: Store;
+    host: Host;
+    sources: InstructionSource[];
+    config: Config;
+    generate: GenerateText | null;
+    onCompile?: () => void;
+}): Promise<CompileResult>;

package/dist/compiler.js

@@ -0,0 +1,138 @@
+import { readFileSync } from "node:fs";
+import { OBLIGATIONS } from "./types.js";
+import { COMPILER_PROMPT } from "./prompts.js";
+import { generated, parseJson, withRetry } from "./providers.js";
+import { redact } from "./redact.js";
+import { canonical, sha256 } from "./store.js";
+export const SCHEMA_VERSION = 1;
+export const COMPILER_VERSION = 1;
+const MIN_CONFIDENCE = 0.5;
+/** Ordered by the host's load order, without double-counting a file reached twice. */
+export function resolveSources(sources) {
+    const seen = new Set();
+    return [...sources]
+        .sort((a, b) => a.priority - b.priority)
+        .filter((source) => {
+        const key = source.path || sha256(source.text);
+        if (seen.has(key) || !source.text.trim())
+            return false;
+        seen.add(key);
+        return true;
+    });
+}
+export function compilerPrompt(config) {
+    return config.compilerPromptPath ? readFileSync(config.compilerPromptPath, "utf8") : COMPILER_PROMPT;
+}
+export function checklistFingerprint(host, sources, config, prompt) {
+    return sha256(canonical({
+        schema: SCHEMA_VERSION,
+        compiler: COMPILER_VERSION,
+        host,
+        sources: sources.map((source) => ({ path: source.path, scope: source.scope, priority: source.priority, text: source.text })),
+        model: config.compilerModel,
+        effort: config.compilerEffort,
+        prompt: sha256(prompt),
+    }));
+}
+const normalize = (text) => text.replace(/\s+/g, " ").trim();
+const isString = (value) => typeof value === "string";
+/** Schema check plus traceability: a rule whose quote is not verbatim in its source is rejected. */
+export function validateRules(raw, sources) {
+    if (!raw || !Array.isArray(raw.rules))
+        throw new Error("compiler output lacks rules");
+    const dropped = [];
+    const byQuote = new Map();
+    const localToStable = new Map();
+    const pending = [];
+    raw.rules.forEach((item, index) => {
+        const label = String(item?.id ?? index);
+        const valid = item &&
+            isString(item.quote) &&
+            isString(item.source) &&
+            OBLIGATIONS.includes(item.obligation) &&
+            ["applicability", "deadline", "expectedEvidence", "counterEvidence"].every((key) => isString(item[key]));
+        if (!valid)
+            return void dropped.push(`${label}: invalid shape`);
+        // The verbatim quote is the traceability anchor. Models often shorten a path, so it may correct the source.
+        const key = normalize(item.quote);
+        const holds = (candidate) => normalize(candidate.text).includes(key);
+        const source = sources.find((candidate) => candidate.path === item.source && holds(candidate)) ?? sources.find(holds);
+        if (!source || !key)
+            return void dropped.push(`${label}: quote not verbatim`);
+        const existing = byQuote.get(key);
+        if (existing)
+            return void localToStable.set(label, existing.id);
+        const rule = {
+            id: `R-${sha256(`${source.path}\0${key}`).slice(0, 10)}`,
+            quote: item.quote,
+            source: source.path,
+            obligation: item.obligation,
+            applicability: item.applicability,
+            trigger: isString(item.trigger) ? item.trigger : "",
+            deadline: item.deadline,
+            exceptions: Array.isArray(item.exceptions) ? item.exceptions.filter(isString) : [],
+            expectedEvidence: item.expectedEvidence,
+            counterEvidence: item.counterEvidence,
+            repairHint: isString(item.repairHint) ? item.repairHint : "",
+            priority: source.priority,
+            supersedable: item.supersedable === true,
+            supersededBy: null,
+            conflictsWith: [],
+        };
+        byQuote.set(key, rule);
+        localToStable.set(label, rule.id);
+        pending.push({ rule, raw: item });
+    });
+    for (const { rule, raw: item } of pending) {
+        rule.supersededBy = localToStable.get(String(item.supersededBy)) ?? null;
+        rule.conflictsWith = (Array.isArray(item.conflictsWith) ? item.conflictsWith : []).flatMap((id) => localToStable.get(String(id)) ?? []);
+    }
+    const known = new Set(pending.map(({ rule }) => rule.id));
+    for (const { rule } of pending)
+        for (const other of rule.conflictsWith)
+            if (known.has(other))
+                byId(pending, other).conflictsWith = [...new Set([...byId(pending, other).conflictsWith, rule.id])];
+    return { rules: pending.map(({ rule }) => rule), dropped };
+}
+const byId = (pending, id) => pending.find(({ rule }) => rule.id === id).rule;
+export const CHECKLIST_SCHEMA = {
+    type: "object",
+    properties: { confidence: { type: "number" }, rules: { type: "array", items: { type: "object" } } },
+    required: ["confidence", "rules"],
+};
+export async function getChecklist(input) {
+    const { store, host, config, generate } = input;
+    const sources = resolveSources(input.sources);
+    const prompt = compilerPrompt(config);
+    const fingerprint = checklistFingerprint(host, sources, config, prompt);
+    const cached = config.cacheChecklist ? store.getChecklist(fingerprint) : undefined;
+    const miss = { cacheHit: false, calls: 1, tokens: 0, costUSD: 0 };
+    if (cached?.schema === SCHEMA_VERSION && cached.dropped.length === 0)
+        return { checklist: cached, cacheHit: true, calls: 0, tokens: 0, costUSD: 0 };
+    if (!generate)
+        return { ...miss, calls: 0, reason: "No compiler model is available." };
+    input.onCompile?.();
+    const full = prompt + sources.map((source) => `\n--- source: ${source.path} (scope ${source.scope}) ---\n${redact(source.text)}`).join("\n");
+    try {
+        const output = generated(await withRetry(() => generate(full, CHECKLIST_SCHEMA), config));
+        miss.tokens = output.tokens ?? 0;
+        miss.costUSD = output.costUSD ?? 0;
+        const raw = parseJson(output.text);
+        const confidence = raw?.confidence;
+        if (typeof confidence !== "number" || !(confidence >= 0 && confidence <= 1))
+            return { ...miss, reason: "Compiler output has no valid confidence." };
+        const { rules, dropped } = validateRules(raw, sources);
+        if (confidence < MIN_CONFIDENCE)
+            return { ...miss, reason: `Compiler confidence ${confidence} is too low.` };
+        if (rules.length === 0)
+            return { ...miss, reason: `Compiler produced no valid rules from the instructions (${dropped.length} rejected).` };
+        const checklist = { schema: SCHEMA_VERSION, fingerprint, model: config.compilerModel, compiledAt: Date.now(), rules, dropped };
+        // Only a fully validated checklist is reused; a partial one is retried on the next turn.
+        if (config.cacheChecklist && dropped.length === 0)
+            store.putChecklist(checklist);
+        return { ...miss, checklist };
+    }
+    catch (error) {
+        return { ...miss, reason: `Checklist compilation failed: ${error.message}` };
+    }
+}

package/dist/config.d.ts

@@ -0,0 +1,12 @@
+import type { Config, Host } from "./types.ts";
+export declare const HOST_DEFAULTS: Record<Host, {
+    compilerModel: string;
+    compilerEffort: string;
+    judgeModel: string;
+    judgeEffort: string;
+}>;
+/** Default models whose free tier may use submitted data for training. Needs explicit consent. */
+export declare const DATA_USE_MODELS: Set<string>;
+export declare function resolveConfig(host: Host, options?: Record<string, unknown>): Config;
+/** Consent is implied only when the user named the model; the built-in default must be opted in. */
+export declare function consentProblem(model: string, options: Record<string, unknown>, config: Config): string | null;

package/dist/config.js

@@ -0,0 +1,44 @@
+export const HOST_DEFAULTS = {
+    opencode: { compilerModel: "opencode/big-pickle", compilerEffort: "default", judgeModel: "opencode/jev-1.13-free", judgeEffort: "default" },
+    "claude-code": { compilerModel: "claude-haiku-5-5", compilerEffort: "xhigh", judgeModel: "claude-haiku-5-5", judgeEffort: "xhigh" },
+};
+/** Default models whose free tier may use submitted data for training. Needs explicit consent. */
+export const DATA_USE_MODELS = new Set(["opencode/big-pickle"]);
+const BASE = {
+    enabled: true,
+    compilerPromptPath: null,
+    judgePromptPath: null,
+    auditOnCompletion: true,
+    maxCorrections: 3,
+    minViolationConfidence: 0.9,
+    maxAuditTokens: 12000,
+    maxAuditCostUSD: null,
+    cacheChecklist: true,
+    storeRawTranscript: false,
+    allowFreeModelDataUse: false,
+    trustSdkPrompts: false,
+    timeoutMs: 240_000,
+    retries: 2,
+    retentionDays: 30,
+};
+const UI = { enabled: true, footer: true, notifications: "important", auditPanel: true, plainTextIcons: false };
+export function resolveConfig(host, options = {}) {
+    const merged = { ...BASE, ...HOST_DEFAULTS[host] };
+    for (const [key, value] of Object.entries(options)) {
+        if (value === undefined || value === "auto" || key === "ui" || !(key in merged))
+            continue;
+        const expected = BASE[key];
+        if (expected !== null && expected !== undefined && typeof value !== typeof expected)
+            throw new Error(`fidelis: option ${key} must be ${typeof expected}`);
+        merged[key] = value;
+    }
+    merged.ui = { ...UI, ...options.ui };
+    return merged;
+}
+/** Consent is implied only when the user named the model; the built-in default must be opted in. */
+export function consentProblem(model, options, config) {
+    const named = Object.values(options).includes(model);
+    if (!DATA_USE_MODELS.has(model) || named || config.allowFreeModelDataUse)
+        return null;
+    return `Default model ${model} may use submitted data for training during its free period. Set allowFreeModelDataUse: true or configure another model.`;
+}

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export * from "./types.ts";
+export * from "./config.ts";
+export * from "./store.ts";
+export * from "./redact.ts";
+export * from "./machine.ts";
+export * from "./providers.ts";
+export * from "./compiler.ts";
+export * from "./judge.ts";
+export * from "./auditor.ts";
+export * from "./prompts.ts";

package/dist/index.js

@@ -0,0 +1,10 @@
+export * from "./types.js";
+export * from "./config.js";
+export * from "./store.js";
+export * from "./redact.js";
+export * from "./machine.js";
+export * from "./providers.js";
+export * from "./compiler.js";
+export * from "./judge.js";
+export * from "./auditor.js";
+export * from "./prompts.js";

package/dist/judge.d.ts

@@ -0,0 +1,32 @@
+import type { Checklist, Config, Evidence, Finding } from "./types.ts";
+import { type DecisionModel } from "./providers.ts";
+/** Marks text the ledger cut. An event read back from it can no longer prove what it does not show. */
+export declare const LEDGER_MARK = "\u2026[clipped in ledger]";
+export declare class EvidenceTooLarge extends Error {
+}
+/**
+ * The turn is clipped loudly and never loses an event: over budget means an incomplete audit. Older context may be
+ * omitted to fit, and the digest then says so, because a missing event can no longer prove anything.
+ */
+export declare function digest(evidence: Evidence, prior: Finding[], budgetChars: number, rawIDs?: ReadonlySet<string>, preamble?: string): {
+    text: string;
+    clipped: boolean;
+    complete: boolean;
+};
+export interface JudgeResult {
+    findings: Finding[];
+    waiting: boolean;
+    calls: number;
+    tokens: number;
+    costUSD: number;
+}
+export declare function judgePreamble(config: Pick<Config, "judgePromptPath">): string;
+export declare function judge(input: {
+    checklist: Checklist;
+    evidence: Evidence;
+    prior: Finding[];
+    model: DecisionModel;
+    config: Config;
+    stopReason?: () => string | null;
+    onUsage?: (tokens: number, costUSD: number) => void;
+}): Promise<JudgeResult>;