agentic-qe 3.7.13 → 3.7.15

package/dist/audit/witness-chain.js

@@ -2,47 +2,50 @@
  * Witness Chain - Cryptographic Audit Trail for QE Decisions
  * ADR-070: Witness Chain Audit Compliance
  *
- * Implements a SHA-256 hash-chained append-only log for audit compliance.
- * Every quality gate decision, pattern mutation, and dream cycle action
- * is recorded with cryptographic integrity guarantees.
- *
- * The chain is tamper-evident: modifying any entry breaks the hash chain,
- * detectable by verify().
+ * SHAKE-256 / SHA-256 hash-chained append-only log with optional Ed25519 signing.
+ * Tamper-evident: modifying any entry breaks the hash chain, detectable by verify().
  */
 import { createHash } from 'crypto';
 import { getUnifiedMemory } from '../kernel/unified-memory.js';
-// ============================================================================
-// Constants
-// ============================================================================
-/** Genesis previous hash: 64 zero characters */
+// --- Constants & Hash Functions ---
 const GENESIS_PREV_HASH = '0'.repeat(64);
-// ============================================================================
-// WitnessChain Implementation
-// ============================================================================
+function sha256(data) {
+    return createHash('sha256').update(data, 'utf-8').digest('hex');
+}
+/** SHAKE-256 (32-byte output) with SHA-256 fallback for older Node.js runtimes. */
+function shake256(data) {
+    try {
+        return createHash('shake256', { outputLength: 32 }).update(data, 'utf-8').digest('hex');
+    }
+    catch {
+        return sha256(data);
+    }
+}
+function hashWith(algo, data) {
+    return algo === 'shake256' ? shake256(data) : sha256(data);
+}
+/** Serialize a WitnessEntry to a deterministic string (original 7-field format). */
+function serializeEntry(entry) {
+    return JSON.stringify({
+        id: entry.id, prev_hash: entry.prev_hash, action_hash: entry.action_hash,
+        action_type: entry.action_type, action_data: entry.action_data,
+        timestamp: entry.timestamp, actor: entry.actor,
+    });
+}
+// --- WitnessChain ---
 /**
- * SHA-256 hash-chained append-only audit log.
- *
- * Each entry's prev_hash is the SHA-256 of the serialized previous entry,
- * creating an immutable chain. Any modification to a past entry will cause
- * verify() to detect the break.
+ * Hash-chained append-only audit log with optional Ed25519 signing.
+ * New entries use SHAKE-256. Existing SHA-256 entries remain valid.
  */
 export class WitnessChain {
     externalDb;
     db = null;
     initialized = false;
-    /**
-     * Create a WitnessChain instance.
-     *
-     * @param externalDb - Optional external database connection (for testing
-     *   with in-memory SQLite). When omitted, uses UnifiedMemoryManager.
-     */
-    constructor(externalDb) {
+    keyManager = null;
+    constructor(externalDb, keyManager) {
         this.externalDb = externalDb;
+        this.keyManager = keyManager ?? null;
     }
-    /**
-     * Initialize the witness chain.
-     * Creates the witness_chain table if it does not exist.
-     */
     async initialize() {
         if (this.initialized)
             return;
@@ -57,107 +60,114 @@ export class WitnessChain {
         this.ensureTable();
         this.initialized = true;
     }
-    /**
-     * Create the witness_chain table (additive, does not touch other tables).
-     */
+    getDatabase() { return this.db; }
+    getKeyManager() { return this.keyManager; }
     ensureTable() {
         if (!this.db)
             throw new Error('Database not initialized');
         this.db.exec(`
       CREATE TABLE IF NOT EXISTS witness_chain (
         id INTEGER PRIMARY KEY AUTOINCREMENT,
-        prev_hash TEXT NOT NULL,
-        action_hash TEXT NOT NULL,
-        action_type TEXT NOT NULL,
-        action_data TEXT,
-        timestamp TEXT NOT NULL,
-        actor TEXT NOT NULL
+        prev_hash TEXT NOT NULL, action_hash TEXT NOT NULL, action_type TEXT NOT NULL,
+        action_data TEXT, timestamp TEXT NOT NULL, actor TEXT NOT NULL,
+        hash_algo TEXT DEFAULT 'sha256', signature TEXT, signer_key_id TEXT
       );
       CREATE INDEX IF NOT EXISTS idx_witness_action_type ON witness_chain(action_type);
       CREATE INDEX IF NOT EXISTS idx_witness_timestamp ON witness_chain(timestamp);
+      CREATE INDEX IF NOT EXISTS idx_witness_actor ON witness_chain(actor);
+    `);
+        this.addColumnIfMissing('hash_algo', "TEXT DEFAULT 'sha256'");
+        this.addColumnIfMissing('signature', 'TEXT');
+        this.addColumnIfMissing('signer_key_id', 'TEXT');
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS witness_chain_archive (
+        id INTEGER PRIMARY KEY,
+        prev_hash TEXT NOT NULL, action_hash TEXT NOT NULL, action_type TEXT NOT NULL,
+        action_data TEXT, timestamp TEXT NOT NULL, actor TEXT NOT NULL,
+        hash_algo TEXT DEFAULT 'sha256', signature TEXT, signer_key_id TEXT,
+        archived_at TEXT NOT NULL
+      );
     `);
     }
-    /**
-     * Append a new entry to the witness chain.
-     *
-     * @param actionType - The type of action being recorded
-     * @param actionData - Arbitrary data describing the action
-     * @param actor - Who performed the action
-     * @returns The newly created WitnessEntry
-     */
+    addColumnIfMissing(column, definition) {
+        if (!this.db)
+            return;
+        const cols = this.db
+            .prepare("SELECT name FROM pragma_table_info('witness_chain')")
+            .all();
+        if (!cols.some((c) => c.name === column)) {
+            this.db.exec(`ALTER TABLE witness_chain ADD COLUMN ${column} ${definition}`);
+        }
+    }
+    /** Append a new SHAKE-256-hashed entry, optionally Ed25519-signed. */
     append(actionType, actionData, actor) {
         if (!this.db)
             throw new Error('WitnessChain not initialized');
         const timestamp = new Date().toISOString();
         const actionDataStr = JSON.stringify(actionData);
-        const actionHash = sha256(actionDataStr);
-        // Get the previous entry's hash
+        const algo = 'shake256';
+        const actionHash = shake256(actionDataStr);
         const lastEntry = this.db
             .prepare('SELECT * FROM witness_chain ORDER BY id DESC LIMIT 1')
             .get();
-        const prevHash = lastEntry ? sha256(serializeEntry(lastEntry)) : GENESIS_PREV_HASH;
-        const result = this.db
-            .prepare(`INSERT INTO witness_chain (prev_hash, action_hash, action_type, action_data, timestamp, actor)
-         VALUES (?, ?, ?, ?, ?, ?)`)
-            .run(prevHash, actionHash, actionType, actionDataStr, timestamp, actor);
-        const entry = {
-            id: result.lastInsertRowid,
-            prev_hash: prevHash,
-            action_hash: actionHash,
-            action_type: actionType,
-            action_data: actionDataStr,
-            timestamp,
-            actor,
+        const prevHash = lastEntry ? hashWith(algo, serializeEntry(lastEntry)) : GENESIS_PREV_HASH;
+        let signature = null;
+        let signerKeyId = null;
+        if (this.keyManager) {
+            const sigData = Buffer.from(prevHash + actionHash + actionType + timestamp + actor, 'utf-8');
+            const result = this.keyManager.sign(sigData);
+            signature = result.signature.toString('hex');
+            signerKeyId = result.keyId;
+        }
+        const ins = this.db.prepare(`INSERT INTO witness_chain
+       (prev_hash, action_hash, action_type, action_data, timestamp, actor, hash_algo, signature, signer_key_id)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(prevHash, actionHash, actionType, actionDataStr, timestamp, actor, algo, signature, signerKeyId);
+        return {
+            id: ins.lastInsertRowid, prev_hash: prevHash, action_hash: actionHash,
+            action_type: actionType, action_data: actionDataStr, timestamp, actor,
+            hash_algo: algo, signature, signer_key_id: signerKeyId,
         };
-        return entry;
     }
-    /**
-     * Verify the integrity of the entire witness chain.
-     *
-     * Walks through every entry in order and checks that each entry's
-     * prev_hash matches the SHA-256 of the previous entry's serialized form.
-     *
-     * @returns Verification result with validity status and break point
-     */
-    verify() {
+    /** Verify chain integrity. Supports mixed SHA-256/SHAKE-256 and optional signature checks. */
+    verify(options) {
         if (!this.db)
             throw new Error('WitnessChain not initialized');
-        const entries = this.db
-            .prepare('SELECT * FROM witness_chain ORDER BY id ASC')
-            .all();
-        if (entries.length === 0) {
+        const entries = this.db.prepare('SELECT * FROM witness_chain ORDER BY id ASC').all();
+        if (entries.length === 0)
             return { valid: true, entriesChecked: 0 };
-        }
-        // Check genesis entry
-        if (entries[0].prev_hash !== GENESIS_PREV_HASH) {
-            return { valid: false, brokenAt: entries[0].id, entriesChecked: 1 };
-        }
-        // Check action_hash for first entry
-        if (entries[0].action_hash !== sha256(entries[0].action_data)) {
-            return { valid: false, brokenAt: entries[0].id, entriesChecked: 1 };
-        }
-        // Walk the chain
-        for (let i = 1; i < entries.length; i++) {
+        let signatureFailures = 0;
+        const checkSigs = options?.checkSignatures === true && this.keyManager !== null;
+        for (let i = 0; i < entries.length; i++) {
             const current = entries[i];
-            const previous = entries[i - 1];
-            // Verify action_hash
-            if (current.action_hash !== sha256(current.action_data)) {
-                return { valid: false, brokenAt: current.id, entriesChecked: i + 1 };
+            const algo = current.hash_algo || 'sha256';
+            if (current.action_hash !== hashWith(algo, current.action_data)) {
+                return { valid: false, brokenAt: current.id, entriesChecked: i + 1, signatureFailures };
             }
-            // Verify prev_hash links to previous entry
-            const expectedPrevHash = sha256(serializeEntry(previous));
-            if (current.prev_hash !== expectedPrevHash) {
-                return { valid: false, brokenAt: current.id, entriesChecked: i + 1 };
+            if (i === 0) {
+                if (current.prev_hash !== GENESIS_PREV_HASH) {
+                    return { valid: false, brokenAt: current.id, entriesChecked: 1, signatureFailures };
+                }
+            }
+            else {
+                const expectedPrevHash = hashWith(algo, serializeEntry(entries[i - 1]));
+                if (current.prev_hash !== expectedPrevHash) {
+                    return { valid: false, brokenAt: current.id, entriesChecked: i + 1, signatureFailures };
+                }
+            }
+            if (checkSigs && current.signature && current.signer_key_id) {
+                const sigData = Buffer.from(current.prev_hash + current.action_hash + current.action_type + current.timestamp + current.actor, 'utf-8');
+                if (!this.keyManager.verify(Buffer.from(sigData), Buffer.from(current.signature, 'hex'), current.signer_key_id)) {
+                    signatureFailures++;
+                }
             }
         }
-        return { valid: true, entriesChecked: entries.length };
+        const valid = signatureFailures === 0;
+        return {
+            valid, entriesChecked: entries.length, signatureFailures,
+            ...(signatureFailures > 0 ? { brokenAt: entries[0].id } : {}),
+        };
     }
-    /**
-     * Query witness chain entries with optional filters.
-     *
-     * @param filter - Optional filter criteria
-     * @returns Array of matching WitnessEntry records
-     */
+    /** Query entries with optional filters. */
     getEntries(filter) {
         if (!this.db)
             throw new Error('WitnessChain not initialized');
@@ -182,75 +192,59 @@ export class WitnessChain {
         const where = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
         const limit = filter?.limit ? `LIMIT ${filter.limit}` : '';
         const offset = filter?.offset ? `OFFSET ${filter.offset}` : '';
-        const sql = `SELECT * FROM witness_chain ${where} ORDER BY id ASC ${limit} ${offset}`;
-        return this.db.prepare(sql).all(...params);
+        return this.db.prepare(`SELECT * FROM witness_chain ${where} ORDER BY id ASC ${limit} ${offset}`).all(...params);
+    }
+    /** Get all witness entries for a pattern by ID (checks both patternId and pattern_id keys). */
+    getPatternLineage(patternId) {
+        if (!this.db)
+            throw new Error('WitnessChain not initialized');
+        return this.db.prepare(`SELECT * FROM witness_chain
+       WHERE json_extract(action_data, '$.patternId') = ? OR json_extract(action_data, '$.pattern_id') = ?
+       ORDER BY id ASC`).all(patternId, patternId);
+    }
+    /** Get all witness entries for a specific actor, optionally filtered by time. */
+    getActorHistory(actorId, since) {
+        if (!this.db)
+            throw new Error('WitnessChain not initialized');
+        if (since) {
+            return this.db.prepare('SELECT * FROM witness_chain WHERE actor = ? AND timestamp >= ? ORDER BY id ASC')
+                .all(actorId, since);
+        }
+        return this.db.prepare('SELECT * FROM witness_chain WHERE actor = ? ORDER BY id ASC')
+            .all(actorId);
     }
-    /**
-     * Cross-verify our SQLite witness chain against an RVF native witness.
-     *
-     * Calls rvfAdapter.status() to get witnessValid and witnessEntries,
-     * then compares with our own verify() result.
-     *
-     * @param rvfAdapter - An RvfNativeAdapter instance with a status() method
-     * @returns Cross-verification result from both chains
-     */
+    /** Archive old entries to witness_chain_archive. Never archives genesis (id=1). */
+    archiveEntries(olderThan) {
+        if (!this.db)
+            throw new Error('WitnessChain not initialized');
+        const archivedAt = new Date().toISOString();
+        const ins = this.db.prepare(`INSERT INTO witness_chain_archive
+         (id, prev_hash, action_hash, action_type, action_data, timestamp, actor, hash_algo, signature, signer_key_id, archived_at)
+       SELECT id, prev_hash, action_hash, action_type, action_data, timestamp, actor, hash_algo, signature, signer_key_id, ?
+       FROM witness_chain WHERE timestamp < ? AND id > 1 AND id NOT IN (SELECT id FROM witness_chain_archive)`).run(archivedAt, olderThan);
+        const archived = ins.changes;
+        if (archived > 0) {
+            this.db.prepare('DELETE FROM witness_chain WHERE timestamp < ? AND id > 1').run(olderThan);
+        }
+        return { archived };
+    }
+    /** Cross-verify against an RVF native witness chain. */
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     crossVerifyWithRvf(rvfAdapter) {
         const sqliteResult = this.verify();
         const rvfStatus = rvfAdapter.status();
         const rvfValid = rvfStatus.witnessValid === true;
         const rvfEntries = typeof rvfStatus.witnessEntries === 'number' ? rvfStatus.witnessEntries : 0;
-        return {
-            sqliteValid: sqliteResult.valid,
-            rvfValid,
-            rvfEntries,
-            bothValid: sqliteResult.valid && rvfValid,
-        };
+        return { sqliteValid: sqliteResult.valid, rvfValid, rvfEntries, bothValid: sqliteResult.valid && rvfValid };
     }
-    /**
-     * Get the total number of entries in the chain.
-     */
     getChainLength() {
         if (!this.db)
             throw new Error('WitnessChain not initialized');
-        const row = this.db
-            .prepare('SELECT COUNT(*) as count FROM witness_chain')
-            .get();
-        return row.count;
+        return this.db.prepare('SELECT COUNT(*) as count FROM witness_chain').get().count;
     }
 }
-// ============================================================================
-// Helper Functions
-// ============================================================================
-/**
- * Compute SHA-256 hex digest of a string.
- */
-function sha256(data) {
-    return createHash('sha256').update(data, 'utf-8').digest('hex');
-}
-/**
- * Serialize a WitnessEntry to a deterministic string for hashing.
- * Uses a fixed field order to ensure consistency.
- */
-function serializeEntry(entry) {
-    return JSON.stringify({
-        id: entry.id,
-        prev_hash: entry.prev_hash,
-        action_hash: entry.action_hash,
-        action_type: entry.action_type,
-        action_data: entry.action_data,
-        timestamp: entry.timestamp,
-        actor: entry.actor,
-    });
-}
-// ============================================================================
-// Singleton / Factory
-// ============================================================================
+// --- Singleton / Factory ---
 let _instance = null;
-/**
- * Get or create the singleton WitnessChain instance.
- * Uses UnifiedMemoryManager for storage.
- */
 export async function getWitnessChain() {
     if (!_instance) {
         _instance = new WitnessChain();
@@ -258,12 +252,8 @@ export async function getWitnessChain() {
     }
     return _instance;
 }
-/**
- * Create a WitnessChain with an external database (for testing).
- */
-export function createWitnessChain(db) {
-    return new WitnessChain(db);
+export function createWitnessChain(db, keyManager) {
+    return new WitnessChain(db, keyManager);
 }
-// Re-export for convenience
-export { GENESIS_PREV_HASH };
+export { GENESIS_PREV_HASH, sha256, shake256, hashWith, serializeEntry };
 //# sourceMappingURL=witness-chain.js.map

package/dist/audit/witness-key-manager.d.ts

@@ -0,0 +1,100 @@
+/**
+ * Witness Key Manager - Ed25519 Signing for Witness Chain
+ * ADR-070: Witness Chain Audit Compliance (Phase 6.2)
+ *
+ * Manages Ed25519 key pairs for cryptographic signing of witness chain entries.
+ * Keys are stored in-memory with support for rotation.
+ * Uses Node.js built-in crypto — no native dependencies required.
+ */
+import { type KeyObject } from 'crypto';
+export interface KeyPairRecord {
+    keyId: string;
+    publicKey: KeyObject;
+    privateKey: KeyObject;
+    createdAt: string;
+    retired: boolean;
+}
+export interface SignResult {
+    signature: Buffer;
+    keyId: string;
+}
+export interface WitnessKeyManagerOptions {
+    /** Auto-generate an initial key pair on construction. Default: true */
+    autoGenerate?: boolean;
+    /** Directory path for persisting keys as PEM files. If provided, keys are saved/loaded automatically. */
+    keyDir?: string;
+}
+/**
+ * Manages Ed25519 key pairs for witness chain entry signing.
+ *
+ * Features:
+ * - Generate Ed25519 key pairs using Node.js crypto
+ * - Sign arbitrary data with the active key
+ * - Verify signatures against any known key
+ * - Rotate keys (retire old, generate new)
+ */
+export declare class WitnessKeyManager {
+    private keys;
+    private activeKeyId;
+    private readonly keyDir;
+    constructor(options?: WitnessKeyManagerOptions);
+    /**
+     * Generate a new Ed25519 key pair and set it as the active signing key.
+     *
+     * @returns The key ID (hex digest of public key) and the public key buffer
+     */
+    generateKeyPair(): {
+        keyId: string;
+        publicKey: Buffer;
+    };
+    /**
+     * Sign data using the active key (or a specific key by ID).
+     *
+     * @param data - The data to sign
+     * @param keyId - Optional specific key ID to use. Defaults to active key.
+     * @returns The signature buffer and the key ID used
+     * @throws Error if the key is not found or no active key exists
+     */
+    sign(data: Buffer, keyId?: string): SignResult;
+    /**
+     * Verify a signature against a known public key.
+     *
+     * @param data - The original data that was signed
+     * @param signature - The signature to verify
+     * @param keyId - The key ID that was used for signing
+     * @returns true if the signature is valid, false otherwise
+     */
+    verify(data: Buffer, signature: Buffer, keyId: string): boolean;
+    /**
+     * Rotate the active key: retire the current key and generate a new one.
+     *
+     * @returns The old key ID and the new key ID
+     * @throws Error if no active key exists to rotate
+     */
+    rotateKey(): {
+        oldKeyId: string;
+        newKeyId: string;
+    };
+    /**
+     * Get the ID of the currently active signing key.
+     *
+     * @returns The active key ID
+     * @throws Error if no active key exists
+     */
+    getActiveKeyId(): string;
+    /**
+     * Check if a key ID is known to this manager.
+     */
+    hasKey(keyId: string): boolean;
+    /**
+     * Get the number of keys managed (including retired).
+     */
+    getKeyCount(): number;
+    /** Save a single key pair as PEM files + metadata JSON. */
+    private saveKeyPairToDisk;
+    /** Save the active key ID pointer. */
+    private saveActiveKeyId;
+    /** Load all key pairs from PEM files in keyDir. */
+    private loadFromDisk;
+}
+//# sourceMappingURL=witness-key-manager.d.ts.map