agentic-qe 3.13.12 → 3.14.1

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/validation/quality-gate-runner.d.ts

@@ -8,14 +8,17 @@
  *   1. loads the pinned, hash-checked ADR-117 anchor via `loadAnchorSet` (which
  *      throws on drift — the frozen checklist can't be silently edited),
  *   2. selects the constant-denominator checklist for `checklistId`,
- *   3. runs the two-gate, three-valued `computeQualityVerdict` with the injected
- *      frontier judge.
+ *   3. evaluates the revision-bound failure-mode reach manifest before any
+ *      judge call (missing legacy manifests remain explicitly inconclusive),
+ *   4. runs the two-gate, three-valued `computeQualityVerdict` with the injected
+ *      frontier judge and combines the independent verdicts fail-closed.
  *
  * The oracle result and the judge are injected — this module owns no LLM and no
  * mutation runner, so it is deterministic and unit-testable with a fake judge.
  */
 import { type Judge, type QualityVerdictResult, type RequirementChecklist } from './quality-verdict.js';
 import type { OracleResult } from './oracle-eval.js';
+import { type VerificationCoverageVerdict, type VerificationReachManifest, type VerificationReachResult } from './verification-reach.js';
 /** Default frozen anchor location, relative to the project root (ADR-117). */
 export declare const DEFAULT_ANCHOR_RELATIVE_PATH = "verification/anchors/qe-anchor-v1.json";
 export interface QualityGateRequest {
@@ -32,13 +35,33 @@ export interface QualityGateRequest {
     judge: Judge;
     /** Override the frozen anchor path (absolute, or relative to project root). */
     anchorPath?: string;
+    /** Revision-bound failure-mode reach evidence. Omit only for legacy migration. */
+    verificationManifest?: VerificationReachManifest;
+}
+export interface LegacyUnknownVerificationCoverage {
+    kind: 'legacy-unknown';
+    coverageVerdict: 'inconclusive';
+    reason: string;
+}
+export interface VerifiedVerificationCoverage extends VerificationReachResult {
+    kind: 'verified';
+}
+export type QualityGateVerificationCoverage = LegacyUnknownVerificationCoverage | VerifiedVerificationCoverage;
+export interface ReachAwareQualityGateResult extends QualityVerdictResult {
+    /** Threshold/oracle/judge verdict before verification-reach preflight. */
+    qualityVerdict: QualityVerdictResult['verdict'];
+    /** Independent verdict for required failure-mode observation coverage. */
+    coverageVerdict: VerificationCoverageVerdict;
+    /** Overall fail-closed verdict. A pass requires both independent gates to pass. */
+    verdict: QualityVerdictResult['verdict'];
+    verification: QualityGateVerificationCoverage;
 }
 /**
  * Run the two-gate quality gate for one artifact against one pinned checklist.
  * Throws only for caller error (unknown checklist id, unloadable/drifted anchor);
- * every judgement outcome is returned as a three-valued `QualityVerdictResult`.
+ * every judgement outcome is returned as a three-valued reach-aware result.
  */
-export declare function runQualityGate(req: QualityGateRequest): Promise<QualityVerdictResult>;
+export declare function runQualityGate(req: QualityGateRequest): Promise<ReachAwareQualityGateResult>;
 /**
  * Load the pinned checklist for `checklistId` from the frozen anchor. Exposed so
  * callers (CLI/MCP) can list valid ids or pre-validate before building a judge.

package/dist/validation/quality-gate-runner.js

@@ -8,8 +8,10 @@
  *   1. loads the pinned, hash-checked ADR-117 anchor via `loadAnchorSet` (which
  *      throws on drift — the frozen checklist can't be silently edited),
  *   2. selects the constant-denominator checklist for `checklistId`,
- *   3. runs the two-gate, three-valued `computeQualityVerdict` with the injected
- *      frontier judge.
+ *   3. evaluates the revision-bound failure-mode reach manifest before any
+ *      judge call (missing legacy manifests remain explicitly inconclusive),
+ *   4. runs the two-gate, three-valued `computeQualityVerdict` with the injected
+ *      frontier judge and combines the independent verdicts fail-closed.
  *
  * The oracle result and the judge are injected — this module owns no LLM and no
  * mutation runner, so it is deterministic and unit-testable with a fake judge.
@@ -18,21 +20,48 @@ import path from 'node:path';
 import { loadAnchorSet } from './anchor-set.js';
 import { computeQualityVerdict, } from './quality-verdict.js';
 import { findProjectRoot } from '../kernel/unified-memory.js';
+import { computeVerificationArtifactDigest, evaluateVerificationReach, } from './verification-reach.js';
 /** Default frozen anchor location, relative to the project root (ADR-117). */
 export const DEFAULT_ANCHOR_RELATIVE_PATH = 'verification/anchors/qe-anchor-v1.json';
 /**
  * Run the two-gate quality gate for one artifact against one pinned checklist.
  * Throws only for caller error (unknown checklist id, unloadable/drifted anchor);
- * every judgement outcome is returned as a three-valued `QualityVerdictResult`.
+ * every judgement outcome is returned as a three-valued reach-aware result.
  */
 export async function runQualityGate(req) {
     const checklist = loadChecklist(req.checklistId, req.anchorPath);
-    return computeQualityVerdict({
+    if (req.verificationManifest
+        && req.verificationManifest.artifact.digest !== computeVerificationArtifactDigest(req.artifact)) {
+        throw new Error('Verification reach manifest artifact digest does not match the judged artifact');
+    }
+    const verification = req.verificationManifest
+        ? { kind: 'verified', ...evaluateVerificationReach(req.verificationManifest) }
+        : {
+            kind: 'legacy-unknown',
+            coverageVerdict: 'inconclusive',
+            reason: 'legacy quality-gate request has no verification reach manifest',
+        };
+    const coverageVerdict = verification.coverageVerdict;
+    const quality = await computeQualityVerdict({
         oracle: req.oracleResult,
         artifact: req.artifact,
         checklist,
         judge: req.judge,
     });
+    return {
+        ...quality,
+        qualityVerdict: quality.verdict,
+        coverageVerdict,
+        verdict: combineVerdicts(quality.verdict, coverageVerdict),
+        verification,
+    };
+}
+function combineVerdicts(quality, coverage) {
+    if (quality === 'fail' || coverage === 'fail')
+        return 'fail';
+    if (quality === 'pass' && coverage === 'pass')
+        return 'pass';
+    return 'inconclusive';
 }
 /**
  * Load the pinned checklist for `checklistId` from the frozen anchor. Exposed so

package/dist/validation/verification-reach.d.ts

@@ -0,0 +1,90 @@
+/**
+ * Failure-mode verification reach contracts (#651).
+ *
+ * Quality evidence is useful only within the boundary it actually observed.
+ * This module keeps that boundary revision-bound and fail-closed: direct,
+ * executed, fresh evidence with the required oracle can cover a risk; partial,
+ * inferred, stale, unavailable, and wrong-target evidence remains visible but
+ * cannot silently produce a passing coverage verdict.
+ */
+export type FailureModeSeverity = 'critical' | 'high' | 'medium' | 'low';
+export type VerificationChannel = 'static' | 'build' | 'runtime' | 'api' | 'browser' | 'telemetry' | 'hardware' | 'human';
+export type VerificationReachLevel = 'direct' | 'partial' | 'none';
+export type VerificationEvidenceClass = 'EXECUTED' | 'STATIC' | 'INFERRED' | 'UNKNOWN';
+export type VerificationExecutionStatus = 'passed' | 'failed' | 'not-run' | 'unavailable';
+export type UncoveredDisposition = 'fail' | 'inconclusive' | 'human-review';
+export type VerificationCoverageVerdict = 'pass' | UncoveredDisposition;
+export interface VerificationTarget {
+    revision: string;
+    digest: string;
+    environment: string;
+}
+export interface VerificationCost {
+    tokens?: number;
+    durationMs?: number;
+    monetary?: number;
+}
+export interface VerificationReach {
+    checkId: string;
+    channel: VerificationChannel;
+    reach: VerificationReachLevel;
+    evidenceClass: VerificationEvidenceClass;
+    executionStatus: VerificationExecutionStatus;
+    target: VerificationTarget;
+    oracleRef?: string;
+    observedAt?: string;
+    limitations: string[];
+    cost?: VerificationCost;
+}
+export interface FailureModeRequirement {
+    riskId: string;
+    failureMode: string;
+    severity: FailureModeSeverity;
+    requiredOracle: string;
+    requiredObservations: VerificationChannel[];
+    checks: VerificationReach[];
+    dispositionWhenUncovered: UncoveredDisposition;
+}
+export interface VerificationReachManifest {
+    id: string;
+    systemUnderTest: string;
+    artifact: VerificationTarget;
+    risks: FailureModeRequirement[];
+    generatedAt: string;
+    expiresAt?: string;
+    manifestHash: string;
+}
+export type VerificationReachManifestInput = Omit<VerificationReachManifest, 'manifestHash'>;
+export interface FailureModeReachResult {
+    riskId: string;
+    failureMode: string;
+    severity: FailureModeSeverity;
+    verdict: VerificationCoverageVerdict;
+    directCheckIds: string[];
+    partialCheckIds: string[];
+    failedCheckIds: string[];
+    uncoveredObservations: VerificationChannel[];
+    limitations: string[];
+    reason: string;
+}
+export interface VerificationReachResult {
+    manifestId: string;
+    manifestHash: string;
+    systemUnderTest: string;
+    artifact: VerificationTarget;
+    coverageVerdict: VerificationCoverageVerdict;
+    risks: FailureModeReachResult[];
+    evaluatedAt: string;
+}
+export interface VerificationReachEvaluationOptions {
+    now?: Date;
+}
+/** Create a manifest whose hash binds its target, risks, checks, and lifetime. */
+export declare function createVerificationReachManifest(input: VerificationReachManifestInput): VerificationReachManifest;
+/** Compute the canonical SHA-256 identity for all manifest content except the hash itself. */
+export declare function computeVerificationReachManifestHash(manifest: VerificationReachManifest | VerificationReachManifestInput): string;
+/** Bind a reach manifest to the exact artifact bytes submitted to the gate. */
+export declare function computeVerificationArtifactDigest(artifact: string): string;
+/** Evaluate whether the declared evidence can directly observe every required failure mode. */
+export declare function evaluateVerificationReach(manifest: VerificationReachManifest, options?: VerificationReachEvaluationOptions): VerificationReachResult;
+//# sourceMappingURL=verification-reach.d.ts.map