agentic-qe 3.13.12 → 3.14.0

package/dist/mcp/handlers/memory-handlers.js

@@ -75,12 +75,16 @@ export async function handleMemoryStore(params) {
         }
         catch {
             // Non-critical — KV store succeeded, vector indexing is best-effort
-            console.warn('[MemoryHandler] VECTOR_INDEX_UNAVAILABLE: Semantic vector indexing is unavailable for this entry.');
+            const vectorUnavailableMessage = 'Semantic vector indexing is unavailable for this entry. Configure AQE_EMBEDDER_ENDPOINT ' +
+                'for the recommended remote backend. The compatible local @huggingface/transformers@4.2.0 ' +
+                'dependency chain currently has unresolved HIGH advisories ' +
+                'GHSA-xcpc-8h2w-3j85 and GHSA-f88m-g3jw-g9cj.';
+            console.warn(`[MemoryHandler] VECTOR_INDEX_UNAVAILABLE: ${vectorUnavailableMessage}`);
             vectorIndex = {
                 status: 'failed',
                 error: {
                     code: 'VECTOR_INDEX_UNAVAILABLE',
-                    message: 'Semantic vector indexing is unavailable for this entry.',
+                    message: vectorUnavailableMessage,
                 },
             };
         }

package/dist/migrations/20260830_add_learning_evidence_tables.d.ts

@@ -0,0 +1,7 @@
+import type { Database as DatabaseType } from 'better-sqlite3';
+export declare const MIGRATION_VERSION = "20260830_add_learning_evidence_tables";
+export declare const LEARNING_EVIDENCE_SCHEMA = "\n  CREATE TABLE IF NOT EXISTS learning_evidence_manifests (\n    id TEXT PRIMARY KEY,\n    trajectory_id TEXT,\n    trajectory_hash TEXT,\n    manifest_hash TEXT NOT NULL UNIQUE,\n    task_family TEXT NOT NULL,\n    task_identity TEXT,\n    run_identity TEXT,\n    correlation_group TEXT,\n    dedupe_fingerprint TEXT,\n    revision TEXT,\n    environment TEXT,\n    outcome TEXT NOT NULL CHECK (outcome IN ('verified-success','verified-failure','unknown')),\n    oracle_refs_json TEXT NOT NULL DEFAULT '[]',\n    source_kind TEXT NOT NULL CHECK (source_kind IN ('executed','static','human-reviewed','inferred')),\n    process_signals_json TEXT NOT NULL DEFAULT '{}',\n    manifest_version INTEGER NOT NULL DEFAULT 1,\n    created_at TEXT NOT NULL DEFAULT (datetime('now'))\n  );\n\n  CREATE TABLE IF NOT EXISTS learning_evidence_segments (\n    id TEXT NOT NULL,\n    manifest_id TEXT NOT NULL REFERENCES learning_evidence_manifests(id) ON DELETE RESTRICT,\n    segment_order INTEGER NOT NULL,\n    kind TEXT NOT NULL CHECK (kind IN ('observe','decide','act','verify','recover','other')),\n    contribution TEXT NOT NULL CHECK (contribution IN ('causal','supporting','irrelevant','harmful','unknown')),\n    evidence_refs_json TEXT NOT NULL DEFAULT '[]',\n    admit_for_learning INTEGER NOT NULL CHECK (admit_for_learning IN (0,1)),\n    reasons_json TEXT NOT NULL DEFAULT '[]',\n    content_hash TEXT,\n    PRIMARY KEY (manifest_id, id),\n    UNIQUE (manifest_id, segment_order)\n  );\n\n  CREATE TABLE IF NOT EXISTS learning_segment_edges (\n    manifest_id TEXT NOT NULL,\n    parent_segment_id TEXT NOT NULL,\n    child_segment_id TEXT NOT NULL,\n    edge_kind TEXT NOT NULL DEFAULT 'depends-on',\n    PRIMARY KEY (manifest_id, parent_segment_id, child_segment_id, edge_kind),\n    FOREIGN KEY (manifest_id, parent_segment_id)\n      REFERENCES learning_evidence_segments(manifest_id, id) ON DELETE RESTRICT,\n    FOREIGN KEY (manifest_id, child_segment_id)\n      REFERENCES learning_evidence_segments(manifest_id, id) ON DELETE RESTRICT,\n    CHECK (parent_segment_id <> child_segment_id)\n  );\n\n  CREATE TABLE IF NOT EXISTS learning_evidence_admissions (\n    id TEXT PRIMARY KEY,\n    manifest_id TEXT NOT NULL REFERENCES learning_evidence_manifests(id) ON DELETE RESTRICT,\n    decision_seq INTEGER NOT NULL CHECK (decision_seq > 0),\n    disposition TEXT NOT NULL CHECK (disposition IN ('admitted','rejected','review-required','legacy-unknown')),\n    reason_codes_json TEXT NOT NULL DEFAULT '[]',\n    assessor_kind TEXT NOT NULL CHECK (assessor_kind IN ('executed','static','human-reviewed','inferred')),\n    evidence_class TEXT NOT NULL CHECK (evidence_class IN ('EXECUTED','STATIC','INFERRED','CONJECTURE')),\n    policy_version TEXT,\n    policy_hash TEXT,\n    created_at TEXT NOT NULL DEFAULT (datetime('now')),\n    UNIQUE (manifest_id, decision_seq)\n  );\n\n  CREATE TABLE IF NOT EXISTS pattern_manifest_lineage (\n    pattern_id TEXT NOT NULL REFERENCES qe_patterns(id) ON DELETE RESTRICT,\n    manifest_id TEXT NOT NULL REFERENCES learning_evidence_manifests(id) ON DELETE RESTRICT,\n    pattern_version_id TEXT,\n    use_kind TEXT NOT NULL CHECK (use_kind IN ('candidate-source','promotion-support','rejection','rollback','legacy-context')),\n    created_at TEXT NOT NULL DEFAULT (datetime('now')),\n    PRIMARY KEY (pattern_id, manifest_id, use_kind)\n  );\n\n  CREATE TABLE IF NOT EXISTS pattern_segment_lineage (\n    pattern_id TEXT NOT NULL REFERENCES qe_patterns(id) ON DELETE RESTRICT,\n    manifest_id TEXT NOT NULL,\n    segment_id TEXT NOT NULL,\n    pattern_version_id TEXT,\n    use_kind TEXT NOT NULL CHECK (use_kind IN ('candidate-source','promotion-support','rejection','rollback')),\n    created_at TEXT NOT NULL DEFAULT (datetime('now')),\n    PRIMARY KEY (pattern_id, manifest_id, segment_id, use_kind),\n    FOREIGN KEY (manifest_id, segment_id)\n      REFERENCES learning_evidence_segments(manifest_id, id) ON DELETE RESTRICT\n  );\n\n  CREATE INDEX IF NOT EXISTS idx_learning_manifest_trajectory ON learning_evidence_manifests(trajectory_id);\n  CREATE INDEX IF NOT EXISTS idx_learning_manifest_task ON learning_evidence_manifests(task_family);\n  CREATE INDEX IF NOT EXISTS idx_learning_manifest_dedupe ON learning_evidence_manifests(dedupe_fingerprint);\n  CREATE INDEX IF NOT EXISTS idx_learning_manifest_correlation ON learning_evidence_manifests(correlation_group);\n  CREATE INDEX IF NOT EXISTS idx_learning_manifest_outcome ON learning_evidence_manifests(outcome, source_kind);\n  CREATE INDEX IF NOT EXISTS idx_learning_admission_manifest ON learning_evidence_admissions(manifest_id, decision_seq DESC);\n  CREATE INDEX IF NOT EXISTS idx_pattern_manifest_lineage_manifest ON pattern_manifest_lineage(manifest_id);\n  CREATE INDEX IF NOT EXISTS idx_pattern_segment_lineage_manifest ON pattern_segment_lineage(manifest_id, segment_id);\n\n  CREATE TRIGGER IF NOT EXISTS learning_manifests_no_update BEFORE UPDATE ON learning_evidence_manifests\n  BEGIN SELECT RAISE(ABORT, 'learning evidence manifests are append-only'); END;\n  CREATE TRIGGER IF NOT EXISTS learning_manifests_no_delete BEFORE DELETE ON learning_evidence_manifests\n  BEGIN SELECT RAISE(ABORT, 'learning evidence manifests are append-only'); END;\n  CREATE TRIGGER IF NOT EXISTS learning_segments_no_update BEFORE UPDATE ON learning_evidence_segments\n  BEGIN SELECT RAISE(ABORT, 'learning evidence segments are append-only'); END;\n  CREATE TRIGGER IF NOT EXISTS learning_segments_no_delete BEFORE DELETE ON learning_evidence_segments\n  BEGIN SELECT RAISE(ABORT, 'learning evidence segments are append-only'); END;\n  CREATE TRIGGER IF NOT EXISTS learning_edges_no_update BEFORE UPDATE ON learning_segment_edges\n  BEGIN SELECT RAISE(ABORT, 'learning evidence edges are append-only'); END;\n  CREATE TRIGGER IF NOT EXISTS learning_edges_no_delete BEFORE DELETE ON learning_segment_edges\n  BEGIN SELECT RAISE(ABORT, 'learning evidence edges are append-only'); END;\n  CREATE TRIGGER IF NOT EXISTS learning_admissions_no_update BEFORE UPDATE ON learning_evidence_admissions\n  BEGIN SELECT RAISE(ABORT, 'learning evidence admissions are append-only'); END;\n  CREATE TRIGGER IF NOT EXISTS learning_admissions_no_delete BEFORE DELETE ON learning_evidence_admissions\n  BEGIN SELECT RAISE(ABORT, 'learning evidence admissions are append-only'); END;\n";
+export declare function applyMigration(db: DatabaseType): void;
+export declare function isMigrationApplied(db: DatabaseType): boolean;
+export declare function rollbackMigration(db: DatabaseType): void;
+//# sourceMappingURL=20260830_add_learning_evidence_tables.d.ts.map

package/dist/migrations/20260830_add_learning_evidence_tables.js

@@ -0,0 +1,173 @@
+export const MIGRATION_VERSION = '20260830_add_learning_evidence_tables';
+export const LEARNING_EVIDENCE_SCHEMA = `
+  CREATE TABLE IF NOT EXISTS learning_evidence_manifests (
+    id TEXT PRIMARY KEY,
+    trajectory_id TEXT,
+    trajectory_hash TEXT,
+    manifest_hash TEXT NOT NULL UNIQUE,
+    task_family TEXT NOT NULL,
+    task_identity TEXT,
+    run_identity TEXT,
+    correlation_group TEXT,
+    dedupe_fingerprint TEXT,
+    revision TEXT,
+    environment TEXT,
+    outcome TEXT NOT NULL CHECK (outcome IN ('verified-success','verified-failure','unknown')),
+    oracle_refs_json TEXT NOT NULL DEFAULT '[]',
+    source_kind TEXT NOT NULL CHECK (source_kind IN ('executed','static','human-reviewed','inferred')),
+    process_signals_json TEXT NOT NULL DEFAULT '{}',
+    manifest_version INTEGER NOT NULL DEFAULT 1,
+    created_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+
+  CREATE TABLE IF NOT EXISTS learning_evidence_segments (
+    id TEXT NOT NULL,
+    manifest_id TEXT NOT NULL REFERENCES learning_evidence_manifests(id) ON DELETE RESTRICT,
+    segment_order INTEGER NOT NULL,
+    kind TEXT NOT NULL CHECK (kind IN ('observe','decide','act','verify','recover','other')),
+    contribution TEXT NOT NULL CHECK (contribution IN ('causal','supporting','irrelevant','harmful','unknown')),
+    evidence_refs_json TEXT NOT NULL DEFAULT '[]',
+    admit_for_learning INTEGER NOT NULL CHECK (admit_for_learning IN (0,1)),
+    reasons_json TEXT NOT NULL DEFAULT '[]',
+    content_hash TEXT,
+    PRIMARY KEY (manifest_id, id),
+    UNIQUE (manifest_id, segment_order)
+  );
+
+  CREATE TABLE IF NOT EXISTS learning_segment_edges (
+    manifest_id TEXT NOT NULL,
+    parent_segment_id TEXT NOT NULL,
+    child_segment_id TEXT NOT NULL,
+    edge_kind TEXT NOT NULL DEFAULT 'depends-on',
+    PRIMARY KEY (manifest_id, parent_segment_id, child_segment_id, edge_kind),
+    FOREIGN KEY (manifest_id, parent_segment_id)
+      REFERENCES learning_evidence_segments(manifest_id, id) ON DELETE RESTRICT,
+    FOREIGN KEY (manifest_id, child_segment_id)
+      REFERENCES learning_evidence_segments(manifest_id, id) ON DELETE RESTRICT,
+    CHECK (parent_segment_id <> child_segment_id)
+  );
+
+  CREATE TABLE IF NOT EXISTS learning_evidence_admissions (
+    id TEXT PRIMARY KEY,
+    manifest_id TEXT NOT NULL REFERENCES learning_evidence_manifests(id) ON DELETE RESTRICT,
+    decision_seq INTEGER NOT NULL CHECK (decision_seq > 0),
+    disposition TEXT NOT NULL CHECK (disposition IN ('admitted','rejected','review-required','legacy-unknown')),
+    reason_codes_json TEXT NOT NULL DEFAULT '[]',
+    assessor_kind TEXT NOT NULL CHECK (assessor_kind IN ('executed','static','human-reviewed','inferred')),
+    evidence_class TEXT NOT NULL CHECK (evidence_class IN ('EXECUTED','STATIC','INFERRED','CONJECTURE')),
+    policy_version TEXT,
+    policy_hash TEXT,
+    created_at TEXT NOT NULL DEFAULT (datetime('now')),
+    UNIQUE (manifest_id, decision_seq)
+  );
+
+  CREATE TABLE IF NOT EXISTS pattern_manifest_lineage (
+    pattern_id TEXT NOT NULL REFERENCES qe_patterns(id) ON DELETE RESTRICT,
+    manifest_id TEXT NOT NULL REFERENCES learning_evidence_manifests(id) ON DELETE RESTRICT,
+    pattern_version_id TEXT,
+    use_kind TEXT NOT NULL CHECK (use_kind IN ('candidate-source','promotion-support','rejection','rollback','legacy-context')),
+    created_at TEXT NOT NULL DEFAULT (datetime('now')),
+    PRIMARY KEY (pattern_id, manifest_id, use_kind)
+  );
+
+  CREATE TABLE IF NOT EXISTS pattern_segment_lineage (
+    pattern_id TEXT NOT NULL REFERENCES qe_patterns(id) ON DELETE RESTRICT,
+    manifest_id TEXT NOT NULL,
+    segment_id TEXT NOT NULL,
+    pattern_version_id TEXT,
+    use_kind TEXT NOT NULL CHECK (use_kind IN ('candidate-source','promotion-support','rejection','rollback')),
+    created_at TEXT NOT NULL DEFAULT (datetime('now')),
+    PRIMARY KEY (pattern_id, manifest_id, segment_id, use_kind),
+    FOREIGN KEY (manifest_id, segment_id)
+      REFERENCES learning_evidence_segments(manifest_id, id) ON DELETE RESTRICT
+  );
+
+  CREATE INDEX IF NOT EXISTS idx_learning_manifest_trajectory ON learning_evidence_manifests(trajectory_id);
+  CREATE INDEX IF NOT EXISTS idx_learning_manifest_task ON learning_evidence_manifests(task_family);
+  CREATE INDEX IF NOT EXISTS idx_learning_manifest_dedupe ON learning_evidence_manifests(dedupe_fingerprint);
+  CREATE INDEX IF NOT EXISTS idx_learning_manifest_correlation ON learning_evidence_manifests(correlation_group);
+  CREATE INDEX IF NOT EXISTS idx_learning_manifest_outcome ON learning_evidence_manifests(outcome, source_kind);
+  CREATE INDEX IF NOT EXISTS idx_learning_admission_manifest ON learning_evidence_admissions(manifest_id, decision_seq DESC);
+  CREATE INDEX IF NOT EXISTS idx_pattern_manifest_lineage_manifest ON pattern_manifest_lineage(manifest_id);
+  CREATE INDEX IF NOT EXISTS idx_pattern_segment_lineage_manifest ON pattern_segment_lineage(manifest_id, segment_id);
+
+  CREATE TRIGGER IF NOT EXISTS learning_manifests_no_update BEFORE UPDATE ON learning_evidence_manifests
+  BEGIN SELECT RAISE(ABORT, 'learning evidence manifests are append-only'); END;
+  CREATE TRIGGER IF NOT EXISTS learning_manifests_no_delete BEFORE DELETE ON learning_evidence_manifests
+  BEGIN SELECT RAISE(ABORT, 'learning evidence manifests are append-only'); END;
+  CREATE TRIGGER IF NOT EXISTS learning_segments_no_update BEFORE UPDATE ON learning_evidence_segments
+  BEGIN SELECT RAISE(ABORT, 'learning evidence segments are append-only'); END;
+  CREATE TRIGGER IF NOT EXISTS learning_segments_no_delete BEFORE DELETE ON learning_evidence_segments
+  BEGIN SELECT RAISE(ABORT, 'learning evidence segments are append-only'); END;
+  CREATE TRIGGER IF NOT EXISTS learning_edges_no_update BEFORE UPDATE ON learning_segment_edges
+  BEGIN SELECT RAISE(ABORT, 'learning evidence edges are append-only'); END;
+  CREATE TRIGGER IF NOT EXISTS learning_edges_no_delete BEFORE DELETE ON learning_segment_edges
+  BEGIN SELECT RAISE(ABORT, 'learning evidence edges are append-only'); END;
+  CREATE TRIGGER IF NOT EXISTS learning_admissions_no_update BEFORE UPDATE ON learning_evidence_admissions
+  BEGIN SELECT RAISE(ABORT, 'learning evidence admissions are append-only'); END;
+  CREATE TRIGGER IF NOT EXISTS learning_admissions_no_delete BEFORE DELETE ON learning_evidence_admissions
+  BEGIN SELECT RAISE(ABORT, 'learning evidence admissions are append-only'); END;
+`;
+export function applyMigration(db) {
+    db.exec(LEARNING_EVIDENCE_SCHEMA);
+    db.exec(`
+    INSERT OR IGNORE INTO learning_evidence_manifests (
+      id, trajectory_id, trajectory_hash, manifest_hash, task_family,
+      outcome, oracle_refs_json, source_kind, process_signals_json
+    )
+    SELECT
+      'legacy-pattern:' || id, NULL, NULL, 'legacy-pattern:' || id,
+      COALESCE(NULLIF(qe_domain, ''), NULLIF(domain, ''), 'unknown'),
+      'unknown', '[]', 'inferred', '{"legacy":true,"unassessed":true}'
+    FROM qe_patterns;
+
+    INSERT OR IGNORE INTO learning_evidence_admissions (
+      id, manifest_id, decision_seq, disposition, reason_codes_json,
+      assessor_kind, evidence_class
+    )
+    SELECT
+      'legacy-admission:' || id, 'legacy-pattern:' || id, 1, 'legacy-unknown',
+      '["legacy-pattern-without-qualified-trajectory"]', 'inferred', 'INFERRED'
+    FROM qe_patterns;
+
+    INSERT OR IGNORE INTO pattern_manifest_lineage (
+      pattern_id, manifest_id, use_kind
+    )
+    SELECT id, 'legacy-pattern:' || id, 'legacy-context' FROM qe_patterns;
+  `);
+}
+export function isMigrationApplied(db) {
+    const required = [
+        'learning_evidence_manifests', 'learning_evidence_segments',
+        'learning_segment_edges', 'learning_evidence_admissions',
+        'pattern_manifest_lineage', 'pattern_segment_lineage',
+    ];
+    const rows = db.prepare(`
+    SELECT name FROM sqlite_master WHERE type = 'table' AND name IN (${required.map(() => '?').join(',')})
+  `).all(...required);
+    return rows.length === required.length;
+}
+export function rollbackMigration(db) {
+    const tables = [
+        'learning_evidence_manifests', 'learning_evidence_segments',
+        'learning_segment_edges', 'learning_evidence_admissions',
+        'pattern_manifest_lineage', 'pattern_segment_lineage',
+    ];
+    for (const table of tables) {
+        const exists = db.prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name=?").get(table);
+        if (!exists)
+            continue;
+        const count = db.prepare(`SELECT COUNT(*) AS count FROM ${table}`).get().count;
+        if (count > 0)
+            throw new Error(`REFUSING rollback: ${table} contains ${count} learning evidence row(s)`);
+    }
+    db.exec(`
+    DROP TABLE IF EXISTS pattern_segment_lineage;
+    DROP TABLE IF EXISTS pattern_manifest_lineage;
+    DROP TABLE IF EXISTS learning_evidence_admissions;
+    DROP TABLE IF EXISTS learning_segment_edges;
+    DROP TABLE IF EXISTS learning_evidence_segments;
+    DROP TABLE IF EXISTS learning_evidence_manifests;
+  `);
+}
+//# sourceMappingURL=20260830_add_learning_evidence_tables.js.map

package/dist/persistence/rvf-migration-adapter.d.ts

@@ -26,6 +26,8 @@ export interface MigrationAdapterConfig {
     dimensions: number;
     /** Enable fallback on RVF read failure in stage 3+ */
     enableFallback: boolean;
+    /** Runtime provenance for injected embedding pipelines. */
+    embeddingSpaceId?: string;
 }
 export interface WriteResult {
     sqliteSuccess: boolean;

package/dist/persistence/rvf-migration-adapter.js

@@ -14,6 +14,7 @@
  *
  * @module persistence/rvf-migration-adapter
  */
+import { getActiveEmbeddingSpaceIdentity } from '../learning/real-embeddings.js';
 export const STAGE_NAMES = {
     0: 'sqlite-only',
     1: 'hybrid',
@@ -80,6 +81,12 @@ export class RvfMigrationAdapter {
             stage: this.config.stage,
             fallbackUsed: false,
         };
+        const hasSpaceContract = this.db
+            ? this.db.prepare("PRAGMA table_info('qe_pattern_embeddings')").all().some((row) => row.name === 'space_id')
+            : false;
+        const spaceId = getActiveEmbeddingSpaceIdentity()?.spaceId ?? this.config.embeddingSpaceId;
+        if (!hasSpaceContract || !spaceId)
+            return result;
         const shouldWriteSqlite = this.config.stage < 4;
         const shouldWriteRvf = this.config.stage >= 2;
         // Write to SQLite
@@ -87,12 +94,23 @@ export class RvfMigrationAdapter {
             const start = performance.now();
             try {
                 const blob = Buffer.from(vector instanceof Float32Array ? vector.buffer : new Float32Array(vector).buffer);
-                this.db.prepare(`
-          INSERT INTO qe_pattern_embeddings (pattern_id, embedding, dimension, model, created_at)
-          VALUES (?, ?, ?, 'all-MiniLM-L6-v2', datetime('now'))
-          ON CONFLICT(pattern_id) DO UPDATE SET
-            embedding = excluded.embedding, dimension = excluded.dimension, created_at = datetime('now')
-        `).run(id, blob, vector.length);
+                if (hasSpaceContract) {
+                    this.db.prepare(`
+            INSERT INTO qe_pattern_embeddings (pattern_id, embedding, dimension, model, space_id, created_at)
+            VALUES (?, ?, ?, 'all-MiniLM-L6-v2', ?, datetime('now'))
+            ON CONFLICT(pattern_id) DO UPDATE SET
+              embedding = excluded.embedding, dimension = excluded.dimension,
+              space_id = excluded.space_id, created_at = datetime('now')
+          `).run(id, blob, vector.length, spaceId);
+                }
+                else {
+                    this.db.prepare(`
+            INSERT INTO qe_pattern_embeddings (pattern_id, embedding, dimension, model, created_at)
+            VALUES (?, ?, ?, 'all-MiniLM-L6-v2', datetime('now'))
+            ON CONFLICT(pattern_id) DO UPDATE SET
+              embedding = excluded.embedding, dimension = excluded.dimension, created_at = datetime('now')
+          `).run(id, blob, vector.length);
+                }
                 result.sqliteSuccess = true;
                 this.sqliteWriteLatencies.push(performance.now() - start);
             }
@@ -120,12 +138,23 @@ export class RvfMigrationAdapter {
         if (this.config.stage === 4 && !result.rvfSuccess && this.config.enableFallback && this.db) {
             try {
                 const blob = Buffer.from(vector instanceof Float32Array ? vector.buffer : new Float32Array(vector).buffer);
-                this.db.prepare(`
-          INSERT INTO qe_pattern_embeddings (pattern_id, embedding, dimension, model, created_at)
-          VALUES (?, ?, ?, 'all-MiniLM-L6-v2', datetime('now'))
-          ON CONFLICT(pattern_id) DO UPDATE SET
-            embedding = excluded.embedding, dimension = excluded.dimension, created_at = datetime('now')
-        `).run(id, blob, vector.length);
+                if (hasSpaceContract) {
+                    this.db.prepare(`
+            INSERT INTO qe_pattern_embeddings (pattern_id, embedding, dimension, model, space_id, created_at)
+            VALUES (?, ?, ?, 'all-MiniLM-L6-v2', ?, datetime('now'))
+            ON CONFLICT(pattern_id) DO UPDATE SET
+              embedding = excluded.embedding, dimension = excluded.dimension,
+              space_id = excluded.space_id, created_at = datetime('now')
+          `).run(id, blob, vector.length, spaceId);
+                }
+                else {
+                    this.db.prepare(`
+            INSERT INTO qe_pattern_embeddings (pattern_id, embedding, dimension, model, created_at)
+            VALUES (?, ?, ?, 'all-MiniLM-L6-v2', datetime('now'))
+            ON CONFLICT(pattern_id) DO UPDATE SET
+              embedding = excluded.embedding, dimension = excluded.dimension, created_at = datetime('now')
+          `).run(id, blob, vector.length);
+                }
                 result.sqliteSuccess = true;
                 result.fallbackUsed = true;
                 this.fallbacksUsed++;
@@ -177,6 +206,21 @@ export class RvfMigrationAdapter {
     search(query, k) {
         this.totalReads++;
         const useRvf = this.config.stage >= 3;
+        if (this.db) {
+            const hasSpaceContract = this.db.prepare("PRAGMA table_info('qe_pattern_embeddings')").all().some((row) => row.name === 'space_id');
+            if (!hasSpaceContract) {
+                return { data: null, source: useRvf ? 'rvf' : 'sqlite', latencyMs: 0, stage: this.config.stage };
+            }
+            {
+                const spaceId = getActiveEmbeddingSpaceIdentity()?.spaceId ?? this.config.embeddingSpaceId;
+                const incompatible = spaceId
+                    ? this.db.prepare('SELECT COUNT(*) AS count FROM qe_pattern_embeddings WHERE space_id IS NULL OR space_id <> ?').get(spaceId).count
+                    : 1;
+                if (incompatible > 0) {
+                    return { data: null, source: useRvf ? 'rvf' : 'sqlite', latencyMs: 0, stage: this.config.stage };
+                }
+            }
+        }
         if (useRvf && this.rvfStore) {
             const start = performance.now();
             try {

package/dist/shared/llm/llm-router-service.d.ts

@@ -22,6 +22,7 @@
 import { ProviderManager } from './provider-manager.js';
 import { HybridRouter } from './router/hybrid-router.js';
 import type { RouterConfig, ExtendedProviderType } from './router/types.js';
+import type { ProviderManagerConfig } from './interfaces.js';
 /**
  * Options accepted by createLLMRouterService(). All optional — defaults
  * produce a router suitable for kernel boot when at least one provider
@@ -39,6 +40,8 @@ export interface LLMRouterServiceOptions {
      * When supplied, config loading and provider construction is skipped.
      */
     providerManager?: ProviderManager;
+    /** Ignore project-controlled network endpoints before attaching ambient credentials. */
+    allowProjectProviderEndpoints?: boolean;
 }
 /**
  * Result of building a router. Carries the router plus the resolved
@@ -74,4 +77,9 @@ export declare function pickPrimaryAndFallbacks(config: RouterConfig, enabled: E
     primary: ExtendedProviderType;
     fallbacks: ExtendedProviderType[];
 };
+/**
+ * Extract only the provider configs for the enabled set, so
+ * ProviderManager doesn't try to construct providers we don't need.
+ */
+export declare function extractProviderConfigs(config: RouterConfig, enabled: ExtendedProviderType[], allowProjectProviderEndpoints?: boolean): ProviderManagerConfig['providers'];
 //# sourceMappingURL=llm-router-service.d.ts.map

package/dist/shared/llm/llm-router-service.js

@@ -21,6 +21,7 @@
  */
 import { ProviderManager } from './provider-manager.js';
 import { HybridRouter } from './router/hybrid-router.js';
+import { ALL_PROVIDER_TYPES } from './router/types.js';
 import { loadRouterConfig, shouldEnableRouter, detectAvailableProvidersFromEnv, } from './router/config-store.js';
 import { setAgentProviderOverrides, createOverrideRoutingRules, } from './router/agent-router-config.js';
 import { DEFAULT_QE_ROUTING_RULES } from './router/routing-rules.js';
@@ -131,7 +132,7 @@ export async function createLLMRouterService(options = {}) {
     const providerManagerConfig = {
         primary: primary,
         fallbacks: fallbacks,
-        providers: extractProviderConfigs(config, enabled),
+        providers: extractProviderConfigs(config, enabled, options.allowProjectProviderEndpoints ?? true),
         loadBalancing: 'round-robin',
         global: { enableCostTracking: true, enableMetrics: true },
     };
@@ -175,6 +176,14 @@ export function pickEnabledProviders(config, env = process.env) {
     for (const p of FALLBACK_PRIORITY) {
         consider(p);
     }
+    // Finally, every AQE-shipped provider. The fixed priority list is an ordering
+    // policy, not an allowlist: treating it as one made enabled subscription
+    // hosts (`codex`, `claude-code`) unreachable unless repeated in fallbackChain.
+    // Do not implicitly activate project-declared external commands here: a
+    // checkout must not gain code execution merely through `enabled: true`.
+    for (const p of ALL_PROVIDER_TYPES) {
+        consider(p);
+    }
     return result;
 }
 /**
@@ -208,12 +217,21 @@ export function pickPrimaryAndFallbacks(config, enabled) {
  * Extract only the provider configs for the enabled set, so
  * ProviderManager doesn't try to construct providers we don't need.
  */
-function extractProviderConfigs(config, enabled) {
+export function extractProviderConfigs(config, enabled, allowProjectProviderEndpoints = true) {
     const out = {};
     for (const p of enabled) {
         const cfg = config.providers?.[p];
         if (cfg) {
-            out[p] = cfg;
+            // The kernel reads project-local config. Never let a checkout replace a
+            // trusted subscription CLI with an arbitrary executable. Callers that
+            // intentionally need a custom binary can still construct ProviderManager
+            // directly with an explicit config.
+            const sanitized = { ...cfg };
+            if (p === 'codex' || p === 'claude-code')
+                delete sanitized.binaryPath;
+            if (!allowProjectProviderEndpoints)
+                delete sanitized.baseUrl;
+            out[p] = sanitized;
         }
     }
     return out;

package/dist/shared/sql-safety.js

@@ -45,6 +45,10 @@ export const ALLOWED_TABLE_NAMES = new Set([
     // Learning/metrics tables
     'learning_daily_snapshots', 'metrics_outcomes',
     'experience_consolidation_log', 'qe_pattern_reuse',
+    // Qualified learning-evidence and lineage tables
+    'learning_evidence_manifests', 'learning_evidence_segments',
+    'learning_segment_edges', 'learning_evidence_admissions',
+    'pattern_manifest_lineage', 'pattern_segment_lineage',
     // Co-execution tables
     'qe_agent_co_execution',
 ]);

package/dist/skills/qe-court/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export declare function runRefereeCli(argv: string[]): number;
+//# sourceMappingURL=cli.d.ts.map

package/dist/skills/qe-court/cli.js

@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+import { readFileSync, realpathSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { resolveVerdict, shouldEmitScore, validateCourtConfig, validatePanel, } from './referee.js';
+const MUTANT = {
+    id: 'boundary-off-by-one', fatal: true, reproduced: true, depthFound: 1,
+};
+export function runRefereeCli(argv) {
+    const [command, value] = argv;
+    if (command === 'validate-config' && value) {
+        const config = JSON.parse(readFileSync(value, 'utf8'));
+        const violations = validateCourtConfig(config);
+        process.stdout.write(JSON.stringify({ valid: violations.length === 0, violations }) + '\n');
+        return violations.length === 0 ? 0 : 2;
+    }
+    if (command === 'self-test' && value) {
+        const passed = runOracle(value);
+        process.stdout.write(JSON.stringify({ oracle: value, passed }) + '\n');
+        return passed ? 0 : 3;
+    }
+    process.stderr.write('Usage: aqe-court-referee validate-config <config.json> | self-test <oracle>\n');
+    return 64;
+}
+function runOracle(name) {
+    switch (name) {
+        case 'overturn-catches-mutant':
+            return resolveVerdict([MUTANT], 2) === 'BLOCK';
+        case 'overturn-disabled':
+            return resolveVerdict([MUTANT], 0) === 'SHIP';
+        case 'writer-not-juror':
+            return validatePanel([
+                { role: 'writer', provider: 'codex' },
+                { role: 'jury', provider: 'codex' },
+                { role: 'prosecutor', provider: 'claude-code' },
+            ]).includes('writerIsNeverJuror');
+        case 'vendor-diversity':
+            return validatePanel([
+                { role: 'writer', provider: 'cognitum-low' },
+                { role: 'jury', provider: 'cognitum-high' },
+            ]).includes('vendor-diversity');
+        case 'doe-score-gate':
+            return !shouldEmitScore(false, true) && shouldEmitScore(true, true);
+        case 'verdict-classes':
+            return resolveVerdict([{ ...MUTANT, depthFound: 0 }], 2) === 'BLOCK'
+                && resolveVerdict([{ ...MUTANT, fatal: false, depthFound: 0 }], 2) === 'REMAND'
+                && resolveVerdict([], 2) === 'SHIP';
+        default:
+            return false;
+    }
+}
+if (process.argv[1] && realpathSync(process.argv[1]) === fileURLToPath(import.meta.url)) {
+    process.exitCode = runRefereeCli(process.argv.slice(2));
+}
+//# sourceMappingURL=cli.js.map

package/dist/verification/adversarial-verify/calibrate.d.ts

@@ -7,11 +7,52 @@
  * — a deterministic stub (characterize the k-of-n aggregation) or a real LLM
  * (empirical false-kill on a labeled corpus).
  */
-import type { AdversarialVerifyOptions, Finding } from './types.js';
+import type { AdversarialVerifyOptions, Finding, FindingSeverity } from './types.js';
 export interface LabeledFinding {
     finding: Finding;
     /** Ground truth: is this a genuine, actionable problem? */
     isReal: boolean;
+    failureType?: string;
+    domain?: string;
+    expectedSeverity?: FindingSeverity;
+    source?: 'human' | 'oracle' | 'controlled-intervention';
+}
+export interface ConfidenceInterval {
+    low: number;
+    high: number;
+    level: 0.95;
+}
+export type QualificationDisposition = 'automate' | 'human-review' | 'abstain';
+export interface QualificationSlice {
+    key: string;
+    support: number;
+    precision: number;
+    recall: number;
+    falseKillRate: number;
+    falseKeepRate: number;
+    uncertainRate: number;
+    intervals: {
+        precision: ConfidenceInterval;
+        recall: ConfidenceInterval;
+        falseKillRate: ConfidenceInterval;
+        falseKeepRate: ConfidenceInterval;
+    };
+    disposition: QualificationDisposition;
+}
+export interface QualificationOptions {
+    minSupport?: number;
+    minRecall?: number;
+    minPrecision?: number;
+    maxFalseKillRate?: number;
+    maxFalseKeepRate?: number;
+    criticalSeverities?: FindingSeverity[];
+}
+export interface JudgeQualification {
+    status: 'qualified' | 'restricted' | 'unqualified';
+    automatedSlices: string[];
+    humanReviewSlices: string[];
+    abstainSlices: string[];
+    reasons: string[];
 }
 export interface CalibrationReport {
     total: number;
@@ -26,7 +67,10 @@ export interface CalibrationReport {
     correctConfirm: number;
     correctKill: number;
     uncertain: number;
+    slices: QualificationSlice[];
+    qualification: JudgeQualification;
 }
+export declare function qualifyJudge(slices: QualificationSlice[], criticalSliceKeys?: string[]): JudgeQualification;
 /** Run the verifier over a labeled set and report the confusion vs ground truth. */
-export declare function calibrate(labeled: LabeledFinding[], opts: AdversarialVerifyOptions): Promise<CalibrationReport>;
+export declare function calibrate(labeled: LabeledFinding[], opts: AdversarialVerifyOptions, qualificationOptions?: QualificationOptions): Promise<CalibrationReport>;
 //# sourceMappingURL=calibrate.d.ts.map