@revealui/ai 0.1.0

package/dist/audit/observer.js

@@ -0,0 +1,271 @@
+/**
+ * Audit Observer
+ *
+ * The central human-facing audit system. This is the ONLY component
+ * that has full read/write access to the audit trail. Agents never
+ * receive a reference to this object.
+ *
+ * Responsibilities:
+ * - Receives events from agent emitters
+ * - Stores entries in the append-only store
+ * - Evaluates policies and generates alerts
+ * - Tracks agent halt status
+ * - Provides query interface for human review
+ */
+import { randomUUID } from 'node:crypto';
+import { createAuditEmitter } from './emitter.js';
+import { AuditPolicyEngine } from './policy.js';
+// ─── Audit Observer ─────────────────────────────────────────────────────────
+export class AuditObserver {
+    store;
+    policyEngine;
+    recentHistory = [];
+    recentHistorySize;
+    agentStatus = new Map();
+    fleetHalted = false;
+    onAlert;
+    onAgentHalted;
+    onFleetHalted;
+    constructor(config) {
+        this.store = config.store;
+        this.policyEngine = new AuditPolicyEngine();
+        this.recentHistorySize = config.recentHistorySize ?? 1000;
+        this.onAlert = config.onAlert;
+        this.onAgentHalted = config.onAgentHalted;
+        this.onFleetHalted = config.onFleetHalted;
+    }
+    // ── Emitter Factory (for agents) ────────────────────────────────────────
+    /**
+     * Create a write-only AuditEmitter for an agent.
+     * This is the only audit API agents should ever receive.
+     */
+    createEmitterForAgent(agentId) {
+        // Initialize agent status tracking
+        if (!this.agentStatus.has(agentId)) {
+            this.agentStatus.set(agentId, {
+                agentId,
+                halted: false,
+                totalEvents: 0,
+                totalViolations: 0,
+            });
+        }
+        const handler = (emitterAgentId, eventType, payload, severity) => {
+            // Drop events from halted agents (they shouldn't be running)
+            const status = this.agentStatus.get(emitterAgentId);
+            if (status?.halted || this.fleetHalted)
+                return;
+            void this.handleEvent(emitterAgentId, eventType, payload, severity);
+        };
+        return createAuditEmitter(agentId, handler);
+    }
+    // ── Internal Event Handling ─────────────────────────────────────────────
+    async handleEvent(agentId, eventType, payload, severity) {
+        const entry = {
+            id: randomUUID(),
+            timestamp: new Date(),
+            eventType,
+            severity,
+            agentId,
+            taskId: typeof payload.taskId === 'string' ? payload.taskId : undefined,
+            sessionId: typeof payload.sessionId === 'string' ? payload.sessionId : undefined,
+            payload,
+            policyViolations: [],
+        };
+        // Evaluate policies
+        const { violations, alerts, shouldHaltAgent, shouldHaltAll } = this.policyEngine.evaluate(entry, this.recentHistory);
+        entry.policyViolations = violations;
+        // Update severity if policy violations are more severe
+        if (violations.length > 0) {
+            const maxSeverity = alerts.reduce((max, a) => {
+                const rank = { info: 0, warn: 1, critical: 2 };
+                return rank[a.severity] > rank[max] ? a.severity : max;
+            }, entry.severity);
+            entry.severity = maxSeverity;
+        }
+        // Persist entry
+        await this.store.append(entry);
+        // Update recent history
+        this.recentHistory.push(entry);
+        if (this.recentHistory.length > this.recentHistorySize) {
+            this.recentHistory = this.recentHistory.slice(-this.recentHistorySize);
+        }
+        // Update agent status
+        const status = this.agentStatus.get(agentId);
+        if (status) {
+            status.totalEvents++;
+            status.lastEventAt = entry.timestamp;
+            if (violations.length > 0) {
+                status.totalViolations += violations.length;
+            }
+        }
+        // Fire alert callbacks
+        for (const alert of alerts) {
+            this.onAlert?.(alert);
+        }
+        // Execute halt actions
+        if (shouldHaltAll) {
+            this.haltFleet('system', `Policy violation by agent ${agentId}`);
+        }
+        else if (shouldHaltAgent) {
+            this.haltAgent(agentId, 'system', `Policy violation: ${violations.join(', ')}`);
+        }
+    }
+    // ── Human Control Interface ─────────────────────────────────────────────
+    /**
+     * Halt a specific agent. Only humans should call this.
+     */
+    haltAgent(agentId, haltedBy, reason) {
+        const status = this.agentStatus.get(agentId) ?? {
+            agentId,
+            halted: false,
+            totalEvents: 0,
+            totalViolations: 0,
+        };
+        status.halted = true;
+        status.haltedBy = haltedBy;
+        status.haltedAt = new Date();
+        status.haltReason = reason;
+        this.agentStatus.set(agentId, status);
+        // Log the human action
+        void this.handleEvent('system', 'human:agent:halted', {
+            targetAgentId: agentId,
+            haltedBy,
+            reason,
+        }, 'critical');
+        this.onAgentHalted?.(agentId, reason);
+    }
+    /**
+     * Resume a halted agent. Only humans should call this.
+     */
+    resumeAgent(agentId, resumedBy) {
+        const status = this.agentStatus.get(agentId);
+        if (!status)
+            return;
+        status.halted = false;
+        status.haltedBy = undefined;
+        status.haltedAt = undefined;
+        status.haltReason = undefined;
+        void this.handleEvent('system', 'human:agent:resumed', {
+            targetAgentId: agentId,
+            resumedBy,
+        }, 'info');
+    }
+    /**
+     * Halt the entire agent fleet. Emergency stop.
+     */
+    haltFleet(haltedBy, reason) {
+        this.fleetHalted = true;
+        for (const status of this.agentStatus.values()) {
+            status.halted = true;
+            status.haltedBy = haltedBy;
+            status.haltedAt = new Date();
+            status.haltReason = reason;
+        }
+        void this.handleEvent('system', 'human:fleet:halted', {
+            haltedBy,
+            reason,
+        }, 'critical');
+        this.onFleetHalted?.(reason);
+    }
+    /**
+     * Resume the entire fleet. Only humans should call this.
+     */
+    resumeFleet(resumedBy) {
+        this.fleetHalted = false;
+        for (const status of this.agentStatus.values()) {
+            status.halted = false;
+            status.haltedBy = undefined;
+            status.haltedAt = undefined;
+            status.haltReason = undefined;
+        }
+        void this.handleEvent('system', 'human:fleet:resumed', {
+            resumedBy,
+        }, 'info');
+    }
+    /**
+     * Check if an agent is halted
+     */
+    isAgentHalted(agentId) {
+        if (this.fleetHalted)
+            return true;
+        return this.agentStatus.get(agentId)?.halted ?? false;
+    }
+    /**
+     * Check if the entire fleet is halted
+     */
+    isFleetHalted() {
+        return this.fleetHalted;
+    }
+    // ── Policy Management ───────────────────────────────────────────────────
+    /**
+     * Add a human-defined policy
+     */
+    addPolicy(policy) {
+        this.policyEngine.addPolicy(policy);
+        void this.handleEvent('system', 'human:policy:added', {
+            policyId: policy.id,
+            policyName: policy.name,
+            createdBy: policy.createdBy,
+        }, 'info');
+    }
+    /**
+     * Remove a policy
+     */
+    removePolicy(policyId, removedBy) {
+        this.policyEngine.removePolicy(policyId);
+        void this.handleEvent('system', 'human:policy:removed', {
+            policyId,
+            removedBy,
+        }, 'info');
+    }
+    /**
+     * Get all active policies
+     */
+    getPolicies() {
+        return this.policyEngine.getPolicies();
+    }
+    // ── Query Interface ─────────────────────────────────────────────────────
+    /**
+     * Query audit entries
+     */
+    async query(filter) {
+        return this.store.query(filter);
+    }
+    /**
+     * Get all alerts
+     */
+    getAlerts(unacknowledgedOnly = false) {
+        return this.policyEngine.getAlerts(unacknowledgedOnly);
+    }
+    /**
+     * Acknowledge an alert
+     */
+    acknowledgeAlert(alertId, acknowledgedBy) {
+        const result = this.policyEngine.acknowledgeAlert(alertId, acknowledgedBy);
+        if (result) {
+            void this.handleEvent('system', 'human:alert:acknowledged', {
+                alertId,
+                acknowledgedBy,
+            }, 'info');
+        }
+        return result;
+    }
+    /**
+     * Get status of all tracked agents
+     */
+    getAgentStatuses() {
+        return Array.from(this.agentStatus.values());
+    }
+    /**
+     * Get status of a specific agent
+     */
+    getAgentStatus(agentId) {
+        return this.agentStatus.get(agentId);
+    }
+    /**
+     * Get total entry count
+     */
+    async getTotalEntries() {
+        return this.store.count();
+    }
+}

package/dist/audit/policy.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Audit Policy Engine
+ *
+ * Human-defined rules that evaluate audit entries and trigger alerts.
+ * Policies are configured by humans, not agents. They define what
+ * constitutes suspicious or dangerous behavior and what action to take.
+ */
+import type { AuditAlert, AuditEntry, AuditPolicy } from './types.js';
+export declare class AuditPolicyEngine {
+    private policies;
+    private alerts;
+    private alertCounter;
+    /**
+     * Add a human-defined policy
+     */
+    addPolicy(policy: AuditPolicy): void;
+    /**
+     * Remove a policy by ID
+     */
+    removePolicy(policyId: string): void;
+    /**
+     * Get all active policies
+     */
+    getPolicies(): AuditPolicy[];
+    /**
+     * Evaluate an entry against all active policies.
+     * Returns the IDs of violated policies and any alerts generated.
+     */
+    evaluate(entry: AuditEntry, recentHistory: AuditEntry[]): {
+        violations: string[];
+        alerts: AuditAlert[];
+        shouldHaltAgent: boolean;
+        shouldHaltAll: boolean;
+    };
+    /**
+     * Get all alerts (newest first)
+     */
+    getAlerts(unacknowledgedOnly?: boolean): AuditAlert[];
+    /**
+     * Acknowledge an alert (human action)
+     */
+    acknowledgeAlert(alertId: string, acknowledgedBy: string): boolean;
+}
+/**
+ * Pre-built policies for common safety patterns.
+ * Humans can use these as-is or as templates for custom policies.
+ */
+export declare const builtinPolicies: {
+    /**
+     * Alert when an agent exceeds a tool call rate limit
+     */
+    readonly toolCallRateLimit: (maxCallsPerMinute: number, createdBy: string) => AuditPolicy;
+    /**
+     * Halt agent that attempts to modify its own instructions
+     */
+    readonly selfModificationBlock: (createdBy: string) => AuditPolicy;
+    /**
+     * Alert on consecutive task failures
+     */
+    readonly consecutiveFailures: (maxConsecutive: number, createdBy: string) => AuditPolicy;
+    /**
+     * Emergency halt if any agent accesses denied tools
+     */
+    readonly deniedToolAccess: (createdBy: string) => AuditPolicy;
+    /**
+     * Fleet-wide emergency stop on excessive memory writes
+     */
+    readonly fleetMemoryFlood: (maxWritesPerMinute: number, createdBy: string) => AuditPolicy;
+};
+//# sourceMappingURL=policy.d.ts.map

package/dist/audit/policy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"policy.d.ts","sourceRoot":"","sources":["../../src/audit/policy.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,YAAY,CAAA;AAIrE,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,QAAQ,CAAsC;IACtD,OAAO,CAAC,MAAM,CAAmB;IACjC,OAAO,CAAC,YAAY,CAAI;IAExB;;OAEG;IACH,SAAS,CAAC,MAAM,EAAE,WAAW,GAAG,IAAI;IAIpC;;OAEG;IACH,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;IAIpC;;OAEG;IACH,WAAW,IAAI,WAAW,EAAE;IAI5B;;;OAGG;IACH,QAAQ,CACN,KAAK,EAAE,UAAU,EACjB,aAAa,EAAE,UAAU,EAAE,GAC1B;QACD,UAAU,EAAE,MAAM,EAAE,CAAA;QACpB,MAAM,EAAE,UAAU,EAAE,CAAA;QACpB,eAAe,EAAE,OAAO,CAAA;QACxB,aAAa,EAAE,OAAO,CAAA;KACvB;IAuCD;;OAEG;IACH,SAAS,CAAC,kBAAkB,UAAQ,GAAG,UAAU,EAAE;IAMnD;;OAEG;IACH,gBAAgB,CAAC,OAAO,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,GAAG,OAAO;CASnE;AAID;;;GAGG;AACH,eAAO,MAAM,eAAe;IAC1B;;OAEG;oDACkC,MAAM,aAAa,MAAM,KAAG,WAAW;IAwB5E;;OAEG;gDAC8B,MAAM,KAAG,WAAW;IAwBrD;;OAEG;mDACiC,MAAM,aAAa,MAAM,KAAG,WAAW;IA2B3E;;OAEG;2CACyB,MAAM,KAAG,WAAW;IAgBhD;;OAEG;oDACkC,MAAM,aAAa,MAAM,KAAG,WAAW;CAmBpE,CAAA"}

package/dist/audit/policy.js

@@ -0,0 +1,209 @@
+/**
+ * Audit Policy Engine
+ *
+ * Human-defined rules that evaluate audit entries and trigger alerts.
+ * Policies are configured by humans, not agents. They define what
+ * constitutes suspicious or dangerous behavior and what action to take.
+ */
+// ─── Policy Engine ──────────────────────────────────────────────────────────
+export class AuditPolicyEngine {
+    policies = new Map();
+    alerts = [];
+    alertCounter = 0;
+    /**
+     * Add a human-defined policy
+     */
+    addPolicy(policy) {
+        this.policies.set(policy.id, policy);
+    }
+    /**
+     * Remove a policy by ID
+     */
+    removePolicy(policyId) {
+        this.policies.delete(policyId);
+    }
+    /**
+     * Get all active policies
+     */
+    getPolicies() {
+        return Array.from(this.policies.values());
+    }
+    /**
+     * Evaluate an entry against all active policies.
+     * Returns the IDs of violated policies and any alerts generated.
+     */
+    evaluate(entry, recentHistory) {
+        const violations = [];
+        const newAlerts = [];
+        let shouldHaltAgent = false;
+        let shouldHaltAll = false;
+        for (const policy of this.policies.values()) {
+            if (!policy.enabled)
+                continue;
+            try {
+                if (policy.condition(entry, recentHistory)) {
+                    violations.push(policy.id);
+                    const alert = {
+                        id: `alert-${++this.alertCounter}`,
+                        policyId: policy.id,
+                        policyName: policy.name,
+                        triggeringEntryId: entry.id,
+                        agentId: entry.agentId,
+                        severity: policy.severity,
+                        action: policy.action,
+                        createdAt: new Date(),
+                        acknowledged: false,
+                    };
+                    newAlerts.push(alert);
+                    this.alerts.push(alert);
+                    if (policy.action === 'halt_agent')
+                        shouldHaltAgent = true;
+                    if (policy.action === 'halt_all')
+                        shouldHaltAll = true;
+                }
+            }
+            catch {
+                // Policy evaluation errors should never crash the system
+            }
+        }
+        return { violations, alerts: newAlerts, shouldHaltAgent, shouldHaltAll };
+    }
+    /**
+     * Get all alerts (newest first)
+     */
+    getAlerts(unacknowledgedOnly = false) {
+        const result = unacknowledgedOnly ? this.alerts.filter((a) => !a.acknowledged) : this.alerts;
+        return [...result].reverse();
+    }
+    /**
+     * Acknowledge an alert (human action)
+     */
+    acknowledgeAlert(alertId, acknowledgedBy) {
+        const alert = this.alerts.find((a) => a.id === alertId);
+        if (!alert)
+            return false;
+        alert.acknowledged = true;
+        alert.acknowledgedBy = acknowledgedBy;
+        alert.acknowledgedAt = new Date();
+        return true;
+    }
+}
+// ─── Built-in Policies ──────────────────────────────────────────────────────
+/**
+ * Pre-built policies for common safety patterns.
+ * Humans can use these as-is or as templates for custom policies.
+ */
+export const builtinPolicies = {
+    /**
+     * Alert when an agent exceeds a tool call rate limit
+     */
+    toolCallRateLimit(maxCallsPerMinute, createdBy) {
+        return {
+            id: 'builtin:tool-call-rate-limit',
+            name: 'Tool Call Rate Limit',
+            description: `Alert when an agent exceeds ${maxCallsPerMinute} tool calls per minute`,
+            severity: 'warn',
+            action: 'alert',
+            enabled: true,
+            createdBy,
+            createdAt: new Date(),
+            condition: (entry, history) => {
+                if (entry.eventType !== 'agent:tool:called')
+                    return false;
+                const oneMinuteAgo = new Date(Date.now() - 60_000);
+                const recentCalls = history.filter((e) => e.agentId === entry.agentId &&
+                    e.eventType === 'agent:tool:called' &&
+                    e.timestamp >= oneMinuteAgo);
+                return recentCalls.length >= maxCallsPerMinute;
+            },
+        };
+    },
+    /**
+     * Halt agent that attempts to modify its own instructions
+     */
+    selfModificationBlock(createdBy) {
+        return {
+            id: 'builtin:self-modification-block',
+            name: 'Self-Modification Block',
+            description: 'Halt any agent that attempts to modify its own instructions or specification',
+            severity: 'critical',
+            action: 'halt_agent',
+            enabled: true,
+            createdBy,
+            createdAt: new Date(),
+            condition: (entry) => {
+                if (entry.eventType !== 'agent:tool:called')
+                    return false;
+                const toolName = String(entry.payload.toolName ?? '');
+                const args = String(entry.payload.arguments ?? '');
+                return (toolName.includes('modify_spec') ||
+                    toolName.includes('update_instructions') ||
+                    args.includes('self_modify') ||
+                    args.includes('update_own_prompt'));
+            },
+        };
+    },
+    /**
+     * Alert on consecutive task failures
+     */
+    consecutiveFailures(maxConsecutive, createdBy) {
+        return {
+            id: 'builtin:consecutive-failures',
+            name: 'Consecutive Failure Limit',
+            description: `Alert when an agent fails ${maxConsecutive} consecutive tasks`,
+            severity: 'warn',
+            action: 'alert',
+            enabled: true,
+            createdBy,
+            createdAt: new Date(),
+            condition: (entry, history) => {
+                if (entry.eventType !== 'agent:task:failed')
+                    return false;
+                const agentHistory = history
+                    .filter((e) => e.agentId === entry.agentId &&
+                    (e.eventType === 'agent:task:completed' || e.eventType === 'agent:task:failed'))
+                    .slice(-maxConsecutive);
+                return (agentHistory.length >= maxConsecutive &&
+                    agentHistory.every((e) => e.eventType === 'agent:task:failed'));
+            },
+        };
+    },
+    /**
+     * Emergency halt if any agent accesses denied tools
+     */
+    deniedToolAccess(createdBy) {
+        return {
+            id: 'builtin:denied-tool-access',
+            name: 'Denied Tool Access',
+            description: 'Halt agent that attempts to use a denied tool',
+            severity: 'critical',
+            action: 'halt_agent',
+            enabled: true,
+            createdBy,
+            createdAt: new Date(),
+            condition: (entry) => {
+                return entry.eventType === 'agent:tool:denied';
+            },
+        };
+    },
+    /**
+     * Fleet-wide emergency stop on excessive memory writes
+     */
+    fleetMemoryFlood(maxWritesPerMinute, createdBy) {
+        return {
+            id: 'builtin:fleet-memory-flood',
+            name: 'Fleet Memory Flood Protection',
+            description: `Halt all agents if total memory writes exceed ${maxWritesPerMinute}/min across fleet`,
+            severity: 'critical',
+            action: 'halt_all',
+            enabled: true,
+            createdBy,
+            createdAt: new Date(),
+            condition: (_entry, history) => {
+                const oneMinuteAgo = new Date(Date.now() - 60_000);
+                const recentWrites = history.filter((e) => e.eventType === 'agent:memory:write' && e.timestamp >= oneMinuteAgo);
+                return recentWrites.length >= maxWritesPerMinute;
+            },
+        };
+    },
+};

package/dist/audit/store.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Audit Store
+ *
+ * Append-only storage interface for audit entries.
+ * No update or delete operations — the log is immutable.
+ * Includes an in-memory implementation and a pluggable interface
+ * for persistent backends (PostgreSQL, etc.).
+ */
+import type { AuditEntry, AuditFilter } from './types.js';
+/**
+ * Append-only audit store.
+ * Implementations MUST NOT provide update or delete methods.
+ */
+export interface AuditStore {
+    /** Append a single entry to the log */
+    append(entry: AuditEntry): Promise<void>;
+    /** Append multiple entries atomically */
+    appendBatch(entries: AuditEntry[]): Promise<void>;
+    /** Query entries with filters (human-side only) */
+    query(filter: AuditFilter): Promise<AuditEntry[]>;
+    /** Get total entry count (optionally filtered by agent) */
+    count(agentId?: string): Promise<number>;
+    /** Get entries since a given timestamp */
+    since(timestamp: Date, limit?: number): Promise<AuditEntry[]>;
+}
+/**
+ * In-memory audit store for development and testing.
+ * Entries are stored in a simple array — not suitable for production.
+ */
+export declare class InMemoryAuditStore implements AuditStore {
+    private entries;
+    private readonly maxEntries;
+    constructor(maxEntries?: number);
+    append(entry: AuditEntry): Promise<void>;
+    appendBatch(entries: AuditEntry[]): Promise<void>;
+    query(filter: AuditFilter): Promise<AuditEntry[]>;
+    count(agentId?: string): Promise<number>;
+    since(timestamp: Date, limit?: number): Promise<AuditEntry[]>;
+    /** Evict oldest entries when over the limit */
+    private enforceLimit;
+}
+//# sourceMappingURL=store.d.ts.map

package/dist/audit/store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../src/audit/store.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,YAAY,CAAA;AAIzD;;;GAGG;AACH,MAAM,WAAW,UAAU;IACzB,uCAAuC;IACvC,MAAM,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAExC,yCAAyC;IACzC,WAAW,CAAC,OAAO,EAAE,UAAU,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAEjD,mDAAmD;IACnD,KAAK,CAAC,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC,CAAA;IAEjD,2DAA2D;IAC3D,KAAK,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAA;IAExC,0CAA0C;IAC1C,KAAK,CAAC,SAAS,EAAE,IAAI,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC,CAAA;CAC9D;AAID;;;GAGG;AACH,qBAAa,kBAAmB,YAAW,UAAU;IACnD,OAAO,CAAC,OAAO,CAAmB;IAClC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAQ;gBAEvB,UAAU,SAAU;IAI1B,MAAM,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;IAKxC,WAAW,CAAC,OAAO,EAAE,UAAU,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAKjD,KAAK,CAAC,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC;IA0CjD,KAAK,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAOxC,KAAK,CAAC,SAAS,EAAE,IAAI,EAAE,KAAK,SAAO,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC;IAIjE,+CAA+C;IAC/C,OAAO,CAAC,YAAY;CAKrB"}

package/dist/audit/store.js

@@ -0,0 +1,80 @@
+/**
+ * Audit Store
+ *
+ * Append-only storage interface for audit entries.
+ * No update or delete operations — the log is immutable.
+ * Includes an in-memory implementation and a pluggable interface
+ * for persistent backends (PostgreSQL, etc.).
+ */
+// ─── In-Memory Implementation ───────────────────────────────────────────────
+/**
+ * In-memory audit store for development and testing.
+ * Entries are stored in a simple array — not suitable for production.
+ */
+export class InMemoryAuditStore {
+    entries = [];
+    maxEntries;
+    constructor(maxEntries = 100_000) {
+        this.maxEntries = maxEntries;
+    }
+    async append(entry) {
+        this.entries.push(entry);
+        this.enforceLimit();
+    }
+    async appendBatch(entries) {
+        this.entries.push(...entries);
+        this.enforceLimit();
+    }
+    async query(filter) {
+        let results = this.entries;
+        if (filter.agentId) {
+            results = results.filter((e) => e.agentId === filter.agentId);
+        }
+        if (filter.taskId) {
+            results = results.filter((e) => e.taskId === filter.taskId);
+        }
+        if (filter.sessionId) {
+            results = results.filter((e) => e.sessionId === filter.sessionId);
+        }
+        if (filter.eventTypes && filter.eventTypes.length > 0) {
+            const types = new Set(filter.eventTypes);
+            results = results.filter((e) => types.has(e.eventType));
+        }
+        if (filter.severity && filter.severity.length > 0) {
+            const sevs = new Set(filter.severity);
+            results = results.filter((e) => sevs.has(e.severity));
+        }
+        if (filter.startTime) {
+            const startTime = filter.startTime;
+            results = results.filter((e) => e.timestamp >= startTime);
+        }
+        if (filter.endTime) {
+            const endTime = filter.endTime;
+            results = results.filter((e) => e.timestamp <= endTime);
+        }
+        // Most recent first
+        results = [...results].reverse();
+        if (filter.offset) {
+            results = results.slice(filter.offset);
+        }
+        if (filter.limit) {
+            results = results.slice(0, filter.limit);
+        }
+        return results;
+    }
+    async count(agentId) {
+        if (agentId) {
+            return this.entries.filter((e) => e.agentId === agentId).length;
+        }
+        return this.entries.length;
+    }
+    async since(timestamp, limit = 1000) {
+        return this.entries.filter((e) => e.timestamp >= timestamp).slice(-limit);
+    }
+    /** Evict oldest entries when over the limit */
+    enforceLimit() {
+        if (this.entries.length > this.maxEntries) {
+            this.entries = this.entries.slice(this.entries.length - this.maxEntries);
+        }
+    }
+}