fidelis 0.0.0-stage → 0.1.0

package/dist/store.js

@@ -0,0 +1,164 @@
+import { createHash, randomUUID } from "node:crypto";
+import { appendFileSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { homedir, platform } from "node:os";
+import { join } from "node:path";
+export function sha256(text) {
+    return createHash("sha256").update(text).digest("hex");
+}
+/** Unambiguous encoding: every value carries its type and byte length. */
+export function canonical(value) {
+    if (typeof value === "string")
+        return `s${Buffer.byteLength(value)}:${value}`;
+    if (Array.isArray(value))
+        return `a${value.length}:${value.map(canonical).join("")}`;
+    if (value && typeof value === "object") {
+        const keys = Object.keys(value).filter((key) => value[key] !== undefined).sort();
+        return `o${keys.length}:${keys.map((key) => canonical(key) + canonical(value[key])).join("")}`;
+    }
+    return `v${String(value)};`;
+}
+export function baseDir(env = process.env) {
+    if (env.FIDELIS_HOME)
+        return env.FIDELIS_HOME;
+    if (platform() === "win32")
+        return join(env.LOCALAPPDATA ?? join(homedir(), "AppData", "Local"), "fidelis");
+    if (platform() === "darwin")
+        return join(homedir(), "Library", "Caches", "fidelis");
+    return join(env.XDG_CACHE_HOME ?? join(homedir(), ".cache"), "fidelis");
+}
+/** Reversible and path-safe, including `.`, `..` and separators. */
+export function safeID(id) {
+    return encodeURIComponent(id).replace(/[.*!'()~]/g, (ch) => `%${ch.charCodeAt(0).toString(16)}`) || "%empty";
+}
+function writeAtomic(path, data) {
+    const tmp = `${path}.${randomUUID()}.tmp`;
+    writeFileSync(tmp, data, { mode: 0o600 });
+    renameSync(tmp, path);
+}
+function readJson(path) {
+    try {
+        return JSON.parse(readFileSync(path, "utf8"));
+    }
+    catch (error) {
+        if (error.code === "ENOENT" || error instanceof SyntaxError)
+            return undefined;
+        throw error;
+    }
+}
+const LOCK_STALE_MS = 30_000;
+const LOCK_WAIT_MS = 5_000;
+function lock(path) {
+    const deadline = Date.now() + LOCK_WAIT_MS;
+    for (;;) {
+        try {
+            mkdirSync(path, { mode: 0o700 });
+            return;
+        }
+        catch (error) {
+            if (error.code !== "EEXIST")
+                throw error;
+            const age = (() => {
+                try {
+                    return Date.now() - statSync(path).mtimeMs;
+                }
+                catch {
+                    return 0;
+                }
+            })();
+            if (age > LOCK_STALE_MS)
+                rmSync(path, { recursive: true, force: true });
+            else if (Date.now() > deadline)
+                throw new Error(`fidelis: session lock busy: ${path}`);
+            else
+                Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 25);
+        }
+    }
+}
+function newState(host, sessionID) {
+    return { host, sessionID, state: "READY", phase: null, revision: 0, updatedAt: 0, turn: 0, corrections: 0, humanIDs: [], boundaries: [], disclosed: [], findings: [], spentUSD: 0 };
+}
+export class Store {
+    dir;
+    host;
+    constructor(host, dir = baseDir()) {
+        this.host = host;
+        this.dir = dir;
+        mkdirSync(join(dir, "checklists"), { recursive: true, mode: 0o700 });
+    }
+    sessionDir(sessionID) {
+        const dir = join(this.dir, "sessions", safeID(this.host), safeID(sessionID));
+        mkdirSync(dir, { recursive: true, mode: 0o700 });
+        return dir;
+    }
+    getChecklist(fingerprint) {
+        return readJson(join(this.dir, "checklists", `${safeID(fingerprint)}.json`));
+    }
+    putChecklist(checklist) {
+        writeAtomic(join(this.dir, "checklists", `${safeID(checklist.fingerprint)}.json`), JSON.stringify(checklist));
+    }
+    read(sessionID) {
+        return readJson(join(this.sessionDir(sessionID), "state.json")) ?? newState(this.host, sessionID);
+    }
+    /** Read-modify-write under a short per-session lock. Never held across a model call. */
+    update(sessionID, change) {
+        const dir = this.sessionDir(sessionID);
+        const lockPath = join(dir, "lock");
+        lock(lockPath);
+        try {
+            const state = this.read(sessionID);
+            change(state);
+            state.revision += 1;
+            state.updatedAt = Date.now();
+            writeAtomic(join(dir, "state.json"), JSON.stringify(state));
+            return state;
+        }
+        finally {
+            rmSync(lockPath, { recursive: true, force: true });
+        }
+    }
+    appendAudit(sessionID, record) {
+        appendFileSync(join(this.sessionDir(sessionID), "audits.jsonl"), JSON.stringify(record) + "\n", { mode: 0o600 });
+    }
+    audits(sessionID, limit = 50) {
+        try {
+            const lines = readFileSync(join(this.sessionDir(sessionID), "audits.jsonl"), "utf8").trim().split("\n");
+            return lines.slice(-limit).flatMap((line) => {
+                try {
+                    return [JSON.parse(line)];
+                }
+                catch {
+                    return [];
+                }
+            });
+        }
+        catch {
+            return [];
+        }
+    }
+    /** Evidence that must survive host compaction. Holds redacted, clipped events by default. */
+    readLedger(sessionID) {
+        return readJson(join(this.sessionDir(sessionID), "ledger.json")) ?? [];
+    }
+    writeLedger(sessionID, events) {
+        writeAtomic(join(this.sessionDir(sessionID), "ledger.json"), JSON.stringify(events));
+    }
+    cleanup(retentionDays, now = Date.now()) {
+        const cutoff = now - retentionDays * 86_400_000;
+        const prune = (dir) => {
+            let names = [];
+            try {
+                names = readdirSync(dir);
+            }
+            catch {
+                return;
+            }
+            for (const name of names) {
+                const path = join(dir, name);
+                if (statSync(path).mtimeMs < cutoff)
+                    rmSync(path, { recursive: true, force: true });
+            }
+        };
+        prune(join(this.dir, "checklists"));
+        prune(join(this.dir, "sessions", safeID(this.host)));
+    }
+}

package/dist/types.d.ts

@@ -0,0 +1,175 @@
+export type Host = "opencode" | "claude-code";
+export interface InstructionSource {
+    path: string;
+    scope: string;
+    /** Host load order. Later wins when the host defines precedence. */
+    priority: number;
+    text: string;
+}
+export declare const OBLIGATIONS: readonly ["MUST", "MUST_NOT", "CONDITIONAL", "TEMPORAL", "STOP_CONDITION", "OTHER"];
+export type Obligation = (typeof OBLIGATIONS)[number];
+export interface Rule {
+    id: string;
+    quote: string;
+    source: string;
+    obligation: Obligation;
+    applicability: string;
+    trigger: string;
+    deadline: string;
+    exceptions: string[];
+    expectedEvidence: string;
+    counterEvidence: string;
+    repairHint: string;
+    priority: number;
+    supersedable: boolean;
+    supersededBy: string | null;
+    conflictsWith: string[];
+}
+export interface Checklist {
+    schema: number;
+    fingerprint: string;
+    model: string;
+    compiledAt: number;
+    rules: Rule[];
+    /** Model output rejected by validation, kept for traceability. */
+    dropped: string[];
+}
+export type EventKind = "user" | "assistant" | "tool" | "fidelis" | "system";
+export type EventStatus = "completed" | "failed" | "running" | "cancelled" | "unknown";
+export interface ExecEvent {
+    id: string;
+    seq: number;
+    at?: number;
+    kind: EventKind;
+    actor?: "agent" | "subagent";
+    name?: string;
+    input?: unknown;
+    output?: string;
+    text?: string;
+    status?: EventStatus;
+}
+export interface Evidence {
+    userRequest: string;
+    /** The turn under audit: from the opening prompt through every corrective turn. */
+    events: ExecEvent[];
+    /** Earlier turns. Context for temporal rules, never a source of new accusations. */
+    history?: ExecEvent[];
+    finalReply: string;
+    /** True only when the source is known to hold every event of the window. */
+    complete: boolean;
+    gaps: string[];
+}
+export type RuleStatus = "NOT_APPLICABLE" | "PENDING" | "SATISFIED" | "VIOLATED" | "UNKNOWN";
+export type Repair = "safe" | "user" | "unrepairable";
+export interface Finding {
+    ruleID: string;
+    status: RuleStatus;
+    quote: string;
+    source: string;
+    obligation: Obligation;
+    explanation: string;
+    evidence: string[];
+    severity: "high" | "low";
+    probability?: number;
+    confidenceKind?: "decision" | "self-reported";
+    uncertainty?: string;
+    repair?: Repair;
+    repairHint?: string;
+    /** The breach stays on record; later events show it was repaired or honestly acknowledged. */
+    resolved?: boolean;
+}
+export type StateName = "READY" | "RUNNING" | "AUDITING" | "CORRECTING" | "WAITING_USER" | "APPROVED" | "AUDIT_INCOMPLETE" | "STOPPED";
+export type Phase = "compiling" | "judging" | null;
+export interface SessionState {
+    host: Host;
+    sessionID: string;
+    state: StateName;
+    phase: Phase;
+    reason?: string;
+    revision: number;
+    updatedAt: number;
+    turn: number;
+    corrections: number;
+    humanIDs: string[];
+    boundaries: string[];
+    audit?: {
+        id: string;
+        boundaryID: string;
+        turn: number;
+        startedAt: number;
+    };
+    lastAuditID?: string;
+    /** Rule IDs already reported as unrepairable: disclose once, never retry. */
+    disclosed: string[];
+    violationKey?: string;
+    findings: Finding[];
+    spentUSD: number;
+}
+export interface AuditMetrics {
+    cacheHit: boolean;
+    compilerCalls: number;
+    judgeCalls: number;
+    tokens: number;
+    costUSD: number;
+    latencyMs: number;
+    uncertain: number;
+}
+export interface AuditRecord {
+    auditID: string;
+    boundaryID: string;
+    turn: number;
+    at: number;
+    state: StateName;
+    reason?: string;
+    findings: Finding[];
+    metrics: AuditMetrics;
+    corrections: number;
+}
+export type Outcome = {
+    action: "none";
+    state: StateName;
+    duplicate?: boolean;
+    reason?: string;
+    notice?: string;
+} | {
+    action: "correct";
+    state: StateName;
+    auditID: string;
+    text: string;
+} | {
+    action: "wait";
+    state: StateName;
+    auditID: string;
+    reason: string;
+    notice?: string;
+};
+export interface Config {
+    enabled: boolean;
+    compilerModel: string;
+    compilerEffort: string;
+    judgeModel: string;
+    judgeEffort: string;
+    compilerPromptPath: string | null;
+    judgePromptPath: string | null;
+    auditOnCompletion: boolean;
+    maxCorrections: number;
+    minViolationConfidence: number;
+    maxAuditTokens: number;
+    maxAuditCostUSD: number | null;
+    cacheChecklist: boolean;
+    storeRawTranscript: boolean;
+    /** Explicit consent to send rules and evidence to a free model whose data may train it. */
+    allowFreeModelDataUse: boolean;
+    /** Accept SDK-origin prompts as human replies. Off: only verified human records release a wait. */
+    trustSdkPrompts: boolean;
+    timeoutMs: number;
+    retries: number;
+    retentionDays: number;
+    ui: {
+        enabled: boolean;
+        footer: boolean;
+        notifications: "important" | "all" | "off";
+        auditPanel: boolean;
+        plainTextIcons: boolean;
+    };
+}

package/dist/types.js

@@ -0,0 +1 @@
+export const OBLIGATIONS = ["MUST", "MUST_NOT", "CONDITIONAL", "TEMPORAL", "STOP_CONDITION", "OTHER"];

package/package.json

@@ -1,6 +1,12 @@
 {
   "name": "fidelis",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "Harness-agnostic AI agent auditor core: checklist compiler, judge pipeline and session state machine.",
+  "type": "module",
+  "license": "MIT",
+  "repository": { "type": "git", "url": "git+https://github.com/insign/fidelis.git", "directory": "packages/core" },
+  "exports": { ".": { "types": "./dist/index.d.ts", "import": "./dist/index.js" } },
+  "files": ["dist", "README.md"],
+  "publishConfig": { "access": "public" },
+  "engines": { "node": ">=22.18" }
+}