fidelis 0.1.2 → 0.1.3

package/dist/auditor.js

@@ -158,68 +158,75 @@ export class Auditor {
             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;
+        // Past this point the session is AUDITING, so any failure must still end in a recorded outcome.
+        const bounded = { ...config, deadlineAt: started + config.auditDeadlineMs, onFailedCost: (costUSD) => { metrics.costUSD += costUSD; charge(costUSD); } };
         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);
-                },
+            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: bounded,
+                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: bounded,
+                    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);
         }
         catch (error) {
-            return incomplete(`Judge failed: ${error.message}`);
+            return incomplete(`Audit 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) {

package/dist/compiler.js

@@ -55,7 +55,8 @@ export function validateRules(raw, sources) {
             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);
+        // The compiler reads redacted text, so a rule that mentions a credential comes back with [REDACTED] in its quote.
+        const holds = (candidate) => normalize(candidate.text).includes(key) || normalize(redact(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`);

package/dist/config.js

@@ -18,7 +18,8 @@ const BASE = {
     allowFreeModelDataUse: false,
     trustSdkPrompts: false,
     timeoutMs: 240_000,
-    retries: 2,
+    retries: 1,
+    auditDeadlineMs: 600_000,
     retentionDays: 30,
 };
 const UI = { enabled: true, footer: true, notifications: "important", auditPanel: true, plainTextIcons: false };

package/dist/providers.d.ts

@@ -38,6 +38,10 @@ export interface RetryOptions {
     retries: number;
     timeoutMs: number;
     baseDelayMs?: number;
+    /** Whole-audit deadline, so retries cannot outlast the host's hook timeout. */
+    deadlineAt?: number;
+    /** A failed attempt can still have been billed. */
+    onFailedCost?: (costUSD: number) => void;
 }
 /** Bounded retries with backoff and a timeout. Auth, availability and quota errors fail at once. */
 export declare function withRetry<T>(run: () => Promise<T>, options: RetryOptions): Promise<T>;

package/dist/providers.js

@@ -6,15 +6,22 @@ export async function withRetry(run, options) {
     for (let attempt = 0; attempt <= options.retries; attempt++) {
         if (attempt > 0)
             await new Promise((done) => setTimeout(done, (options.baseDelayMs ?? 1000) * 2 ** (attempt - 1)));
+        const left = (options.deadlineAt ?? Infinity) - Date.now();
+        if (left <= 0)
+            throw lastError ?? new Error("the audit time limit was reached");
+        const limit = Math.min(options.timeoutMs, left);
         let timer;
         try {
             const timeout = new Promise((_, reject) => {
-                timer = setTimeout(() => reject(new Error(`timed out after ${options.timeoutMs} ms`)), options.timeoutMs);
+                timer = setTimeout(() => reject(new Error(`timed out after ${limit} ms`)), limit);
             });
             return await Promise.race([run(), timeout]);
         }
         catch (error) {
             lastError = error;
+            const cost = error?.costUSD;
+            if (typeof cost === "number" && cost > 0)
+                options.onFailedCost?.(cost);
             if (HARD_FAILURE.test(String(error?.message ?? error)))
                 break;
         }
@@ -118,9 +125,15 @@ export function textDecisions(generate, id) {
                     : `- ${question.name} (choice): ${question.instructions} Values: ${question.choices.map((choice) => `${choice.value} = ${choice.description}`).join("; ")}`),
             ].join("\n");
             const output = generated(await generate(prompt, DECISIONS_SCHEMA));
-            const parsed = parseJson(output.text);
-            if (!parsed || typeof parsed.answers !== "object")
-                throw new Error("decision output lacks answers");
+            let parsed;
+            try {
+                parsed = parseJson(output.text);
+                if (!parsed || typeof parsed.answers !== "object")
+                    throw new Error("decision output lacks answers");
+            }
+            catch (error) {
+                throw Object.assign(error, { costUSD: output.costUSD });
+            }
             const answers = {};
             for (const question of questions) {
                 const answer = parsed.answers[question.name];

package/dist/types.d.ts

@@ -164,6 +164,8 @@ export interface Config {
     trustSdkPrompts: boolean;
     timeoutMs: number;
     retries: number;
+    /** Whole-audit limit. Must stay below the host's hook timeout. */
+    auditDeadlineMs: number;
     retentionDays: number;
     ui: {
         enabled: boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fidelis",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "Harness-agnostic AI agent auditor core: checklist compiler, judge pipeline and session state machine.",
   "type": "module",
   "license": "MIT",