agentic-qe 3.11.2 → 3.11.4

package/dist/kernel/unified-memory.js

@@ -29,6 +29,7 @@ import * as os from 'os';
 import * as path from 'path';
 import { MEMORY_CONSTANTS } from './constants.js';
 import { LoggerFactory } from '../logging/index.js';
+import { HashChainGate } from '../integrations/ruvector/proof-gate.js';
 const logger = LoggerFactory.create('unified-memory');
 // Re-export from shared module for backward compatibility
 export { validateTableName, ALLOWED_TABLE_NAMES } from '../shared/sql-safety.js';
@@ -122,6 +123,12 @@ export class UnifiedMemoryManager {
     vectorIndex = new UnifiedHnswIndex('qe-memory');
     // CRDT store for distributed state synchronization
     crdtStore = null;
+    // Proof-gate (AQE ADR-116; upstream ADR-194): tamper-evident SHA-256 hash chain over kv writes.
+    // Off by default; enable per audit window via enableProofGate() / AQE_PROOF_GATE=1.
+    proofGate = null;
+    proofGateEnvChecked = false;
+    static PROOF_NS = '__proofgate__';
+    static PROOF_KEY = 'chain';
     constructor(config) {
         const resolvedDefaults = getResolvedDefaultConfig();
         this.config = { ...resolvedDefaults, ...config };
@@ -506,6 +513,8 @@ export class UnifiedMemoryManager {
       INSERT OR REPLACE INTO kv_store (key, namespace, value, expires_at)
       VALUES (?, ?, ?, ?)
     `).run(key, namespace, serialized, expiresAt);
+        // ADR-194: tamper-evident audit (no-op unless the proof-gate is enabled).
+        this.auditWrite('kvSet', namespace, key, serialized);
     }
     async kvGet(key, namespace = 'default') {
         this.ensureInitialized();
@@ -524,6 +533,9 @@ export class UnifiedMemoryManager {
     async kvDelete(key, namespace = 'default') {
         this.ensureInitialized();
         const result = this.db.prepare('DELETE FROM kv_store WHERE key = ? AND namespace = ?').run(key, namespace);
+        // ADR-194: audit deletes too (no-op unless the proof-gate is enabled).
+        if (result.changes > 0)
+            this.auditWrite('kvDelete', namespace, key, '');
         return result.changes > 0;
     }
     async kvExists(key, namespace = 'default') {
@@ -551,6 +563,99 @@ export class UnifiedMemoryManager {
         return result.changes;
     }
     // ============================================================================
+    // Proof-Gate: tamper-evident write audit (ADR-194)
+    // ============================================================================
+    /**
+     * Enable the tamper-evident proof-gate audit. OFF by default — once enabled,
+     * every kv write/delete admits a receipt to a persisted SHA-256 hash chain so
+     * {@link verifyMemoryIntegrity} can later prove no admitted write was mutated,
+     * reordered, or dropped. Restores any chain persisted from a prior process.
+     *
+     * Intended for BOUNDED audit windows (a sync / migration / publish gate), not
+     * permanent always-on use: the chain grows O(n) with audited writes and its
+     * snapshot is rewritten per write. Idempotent.
+     */
+    enableProofGate() {
+        this.ensureInitialized();
+        this.proofGateEnvChecked = true;
+        if (this.proofGate)
+            return;
+        this.proofGate = this.loadProofChain() ?? new HashChainGate();
+    }
+    isProofGateEnabled() {
+        return this.proofGate !== null;
+    }
+    /**
+     * Re-derive the proof-gate chain from genesis. Returns true iff no admitted
+     * write was mutated, reordered, or dropped. Throws if the gate is not enabled.
+     */
+    verifyMemoryIntegrity() {
+        if (!this.proofGate) {
+            throw new Error('Proof-gate not enabled — call enableProofGate() or set AQE_PROOF_GATE=1');
+        }
+        return this.proofGate.verifyIntegrity();
+    }
+    /** Current proof-gate chain head (hex), or null if the gate is not enabled. */
+    getProofChainRoot() {
+        return this.proofGate ? this.proofGate.chainRoot() : null;
+    }
+    /** Number of writes admitted to the proof-gate chain (0 if not enabled). */
+    getProofChainLength() {
+        return this.proofGate ? this.proofGate.length : 0;
+    }
+    /**
+     * Best-effort audit of a kv mutation. Admits a content-bound receipt and
+     * persists the chain. NEVER throws into the caller — the actual write has
+     * already committed; a failed audit must not break or alter it.
+     */
+    auditWrite(op, namespace, key, serializedValue) {
+        // Lazy env-enable so an operator can turn auditing on without a code change.
+        if (!this.proofGate) {
+            if (this.proofGateEnvChecked)
+                return;
+            this.proofGateEnvChecked = true;
+            if (process.env.AQE_PROOF_GATE !== '1')
+                return;
+            this.proofGate = this.loadProofChain() ?? new HashChainGate();
+        }
+        // Never audit the chain's own persistence namespace (no self-reference / recursion).
+        if (namespace === UnifiedMemoryManager.PROOF_NS)
+            return;
+        try {
+            this.proofGate.admit({ op, ns: namespace, key, value: serializedValue });
+            this.persistProofChain();
+        }
+        catch (error) {
+            logger.warn(`proof-gate audit skipped for ${namespace}/${key}: ${toErrorMessage(error)}`);
+        }
+    }
+    /** Persist the chain snapshot via a DIRECT write (bypasses kvSet → no recursion). */
+    persistProofChain() {
+        if (!this.proofGate || !this.db)
+            return;
+        this.db.prepare(`
+      INSERT OR REPLACE INTO kv_store (key, namespace, value, expires_at)
+      VALUES (?, ?, ?, NULL)
+    `).run(UnifiedMemoryManager.PROOF_KEY, UnifiedMemoryManager.PROOF_NS, JSON.stringify(this.proofGate.toJSON()));
+    }
+    /** Restore a persisted chain from the reserved namespace, or null if none/corrupt. */
+    loadProofChain() {
+        if (!this.db)
+            return null;
+        const row = this.db.prepare(`
+      SELECT value FROM kv_store WHERE key = ? AND namespace = ?
+    `).get(UnifiedMemoryManager.PROOF_KEY, UnifiedMemoryManager.PROOF_NS);
+        if (!row)
+            return null;
+        try {
+            return HashChainGate.fromJSON(JSON.parse(row.value));
+        }
+        catch (error) {
+            logger.warn(`proof-gate chain failed to load (starting fresh): ${toErrorMessage(error)}`);
+            return null;
+        }
+    }
+    // ============================================================================
     // Vector Operations
     // ============================================================================
     async vectorStore(id, embedding, namespace = 'default', metadata) {

package/dist/learning/local-judge-client.js

@@ -17,6 +17,7 @@
  *   qwen3:30b-a3b   — 18GB, highest quality, use only if RAM permits
  */
 import { LoggerFactory } from '../logging/index.js';
+import { resolveOllamaBaseUrl } from '../shared/llm/ollama-url.js';
 const logger = LoggerFactory.create('local-judge');
 const DEFAULT_URL = 'http://localhost:11434';
 const DEFAULT_MODEL = 'qwen3:8b';
@@ -46,7 +47,7 @@ export class LocalJudgeClient {
     model;
     enabled;
     constructor(opts) {
-        this.baseUrl = opts?.url ?? process.env['NAGUAL_JUDGE_URL'] ?? DEFAULT_URL;
+        this.baseUrl = opts?.url ?? process.env['NAGUAL_JUDGE_URL'] ?? resolveOllamaBaseUrl(DEFAULT_URL);
         this.model = opts?.model ?? process.env['NAGUAL_JUDGE_MODEL'] ?? DEFAULT_MODEL;
         // Only active when explicitly configured via env or constructor options
         this.enabled = Boolean(opts?.url ?? opts?.model ??