agentic-qe 3.14.3 → 3.14.5

package/dist/plugins/resolver.js

@@ -1,80 +1,188 @@
-/**
- * Agentic QE v3 - Plugin Dependency Resolver (IMP-09)
- *
- * DFS dependency resolution with cycle detection.
- * Given a set of plugin manifests, produces a topologically-sorted
- * load order where dependencies are loaded before dependents.
- */
-// ============================================================================
-// PluginResolver
-// ============================================================================
+import { AQE_VERSION, validVersion, validRange, compareVersions, newestVersionFirst, satisfiesVersion, } from './version-policy.js';
 export class PluginResolver {
-    /**
-     * Resolve plugin load order via DFS topological sort.
-     *
-     * @param manifests - All available plugin manifests
-     * @returns Ordered list of plugins safe to load sequentially
-     * @throws Error if a dependency cycle is detected
-     */
-    resolve(manifests) {
-        const byName = new Map();
-        for (const m of manifests) {
-            byName.set(m.name, m);
+    aqeVersion;
+    constructor(aqeVersion = AQE_VERSION) {
+        this.aqeVersion = aqeVersion;
+    }
+    resolve(manifests, roots) {
+        const groups = new Map();
+        const rejected = new Map();
+        for (const manifest of manifests) {
+            const candidates = groups.get(manifest.name) ?? [];
+            groups.set(manifest.name, candidates);
+            const error = this.validateVersions(manifest);
+            if (error)
+                rejected.set(manifest.name, [...(rejected.get(manifest.name) ?? []), error]);
+            else
+                candidates.push(manifest);
+        }
+        for (const candidates of groups.values()) {
+            candidates.sort((a, b) => newestVersionFirst(a.version, b.version));
         }
-        const ordered = [];
-        const visited = new Set();
-        const visiting = new Set(); // cycle detection (gray nodes)
         const missing = new Map();
-        const visit = (name, path) => {
-            if (visited.has(name))
-                return;
-            if (visiting.has(name)) {
-                const cycle = [...path.slice(path.indexOf(name)), name];
-                throw new Error(`Dependency cycle detected: ${cycle.join(' -> ')}`);
+        const errors = [];
+        const result = (ordered) => ({
+            ordered: ordered.map((manifest, order) => ({ manifest, order })), missing, errors,
+            selectedVersions: Object.fromEntries(ordered.map(m => [m.name, m.version])),
+            aqeVersion: this.aqeVersion,
+        });
+        const names = [...(roots ?? groups.keys())].sort();
+        const required = new Set(names);
+        const selected = new Map();
+        let attempts = 0;
+        let limited = false;
+        const compatible = () => {
+            for (const manifest of selected.values()) {
+                for (const [dep, range] of Object.entries(manifest.dependencies ?? {})) {
+                    const chosen = selected.get(dep);
+                    const candidates = chosen ? [chosen] : groups.get(dep) ?? [];
+                    if (!candidates.some(candidate => satisfiesVersion(candidate.version, range)))
+                        return false;
+                }
             }
-            const manifest = byName.get(name);
-            if (!manifest) {
-                // Missing dependency — record it but don't fail the entire resolution
-                return;
+            return true;
+        };
+        let cycle;
+        const findCycle = () => {
+            const visited = new Set();
+            const visiting = new Set();
+            const visit = (name, path) => {
+                if (visiting.has(name))
+                    return [...path.slice(path.indexOf(name)), name];
+                if (visited.has(name))
+                    return;
+                visiting.add(name);
+                for (const dependency of Object.keys(selected.get(name)?.dependencies ?? {})) {
+                    const found = visit(dependency, [...path, name]);
+                    if (found)
+                        return found;
+                }
+                visiting.delete(name);
+                visited.add(name);
+                return undefined;
+            };
+            for (const name of selected.keys()) {
+                const found = visit(name, []);
+                if (found)
+                    return found;
             }
-            visiting.add(name);
-            // Visit dependencies first
-            const deps = Object.keys(manifest.dependencies ?? {});
-            const missingDeps = [];
-            for (const dep of deps) {
-                if (!byName.has(dep)) {
-                    missingDeps.push(dep);
+            return undefined;
+        };
+        const choose = () => {
+            const pending = new Set(names);
+            for (const manifest of selected.values()) {
+                for (const name of Object.keys(manifest.dependencies ?? {}))
+                    pending.add(name);
+            }
+            const name = [...pending].sort().find(name => !selected.has(name));
+            if (!name) {
+                const found = findCycle();
+                if (found) {
+                    cycle = found;
+                    return false;
                 }
-                else {
-                    visit(dep, [...path, name]);
+                return true;
+            }
+            required.add(name);
+            for (const candidate of groups.get(name) ?? []) {
+                if (++attempts > 10_000) {
+                    limited = true;
+                    return false;
                 }
+                selected.set(name, candidate);
+                if (compatible() && choose())
+                    return true;
+                selected.delete(name);
+                if (limited)
+                    return false;
+            }
+            return false;
+        };
+        if (!choose()) {
+            if (cycle && !limited)
+                throw new Error(`Dependency cycle detected: ${cycle.join(' -> ')}`);
+            for (const name of required) {
+                if (!groups.get(name)?.length)
+                    errors.push(...(rejected.get(name) ?? []));
             }
-            if (missingDeps.length > 0) {
-                missing.set(name, missingDeps);
+            for (const [name, candidates] of groups) {
+                const absent = [...new Set(candidates.flatMap(m => Object.keys(m.dependencies ?? {})))].filter(dep => !groups.has(dep));
+                if (absent.length)
+                    missing.set(name, absent);
             }
+            errors.push({
+                code: limited ? 'RESOLUTION_LIMIT' : missing.size ? 'MISSING_DEPENDENCY' : 'UNSATISFIED_DEPENDENCY_RANGE',
+                plugin: names.join(', '),
+                message: limited ? 'Plugin dependency search exceeded 10000 candidates' : 'No cached plugin selection satisfies all dependency ranges',
+            });
+            return result([]);
+        }
+        const ordered = [];
+        const visited = new Set();
+        const visiting = new Set();
+        const visit = (name, path) => {
+            if (visited.has(name))
+                return;
+            if (visiting.has(name))
+                throw new Error(`Dependency cycle detected: ${[...path.slice(path.indexOf(name)), name].join(' -> ')}`);
+            visiting.add(name);
+            const manifest = selected.get(name);
+            for (const dep of Object.keys(manifest.dependencies ?? {}))
+                visit(dep, [...path, name]);
             visiting.delete(name);
             visited.add(name);
             ordered.push(manifest);
         };
-        // Visit all plugins
-        for (const m of manifests) {
-            visit(m.name, []);
+        for (const name of [...selected.keys()].sort())
+            visit(name, []);
+        return result(ordered);
+    }
+    /** Startup is best-effort: retain admitted roots when another root fails. */
+    resolveAvailable(manifests) {
+        const accepted = [];
+        let result = this.resolve(manifests, []);
+        const errors = [];
+        const missing = new Map();
+        for (const name of [...new Set(manifests.map(m => m.name))].sort()) {
+            try {
+                // Re-solve together so shared dependency versions remain compatible.
+                // A failed candidate cannot invalidate the last successful selection.
+                const candidate = this.resolve(manifests, [...accepted, name]);
+                if (candidate.errors.length) {
+                    errors.push(...candidate.errors.map(error => ({ ...error, plugin: name })));
+                    for (const [plugin, dependencies] of candidate.missing)
+                        missing.set(plugin, dependencies);
+                    continue;
+                }
+                accepted.push(name);
+                result = candidate;
+            }
+            catch (error) {
+                errors.push({ code: 'DEPENDENCY_CYCLE', plugin: name,
+                    message: error instanceof Error ? error.message : String(error) });
+            }
         }
-        return {
-            ordered: ordered.map((manifest, index) => ({ manifest, order: index })),
-            missing,
-        };
+        return { ...result, errors, missing };
     }
-    /**
-     * Check if a specific plugin can be loaded given the currently loaded set.
-     */
+    /** Version-constrained dependencies require versions, not a legacy name-only Set. */
     canLoad(manifest, loaded) {
-        const deps = Object.keys(manifest.dependencies ?? {});
-        const missingDeps = deps.filter(d => !loaded.has(d));
-        return {
-            canLoad: missingDeps.length === 0,
-            missingDeps,
-        };
+        const missingDeps = Object.entries(manifest.dependencies ?? {}).filter(([name, range]) => {
+            const version = loaded instanceof Set ? undefined : loaded.get(name);
+            return !version || !validRange(range) || !satisfiesVersion(version, range);
+        }).map(([name]) => name);
+        return { canLoad: !this.validateVersions(manifest) && missingDeps.length === 0, missingDeps };
+    }
+    validateVersions(manifest) {
+        if (!validVersion(manifest.version))
+            return { code: 'INVALID_PLUGIN_VERSION', plugin: manifest.name, message: 'Invalid plugin version' };
+        for (const range of Object.values(manifest.dependencies ?? {})) {
+            if (!validRange(range))
+                return { code: 'INVALID_DEPENDENCY_RANGE', plugin: manifest.name, message: 'Invalid dependency range' };
+        }
+        if (manifest.minAqeVersion && (!validVersion(manifest.minAqeVersion) || !validVersion(this.aqeVersion) || compareVersions(this.aqeVersion, manifest.minAqeVersion) < 0)) {
+            return { code: 'AQE_VERSION_INCOMPATIBLE', plugin: manifest.name, message: `Requires AQE ${manifest.minAqeVersion}; running ${this.aqeVersion}` };
+        }
+        return undefined;
     }
 }
 //# sourceMappingURL=resolver.js.map

package/dist/plugins/version-policy.d.ts

@@ -0,0 +1,13 @@
+export declare const AQE_VERSION: string;
+export declare const validVersion: (value: unknown) => boolean;
+export declare const validRange: (value: string) => boolean;
+export declare const satisfiesVersion: (version: string, range: string) => boolean;
+export declare const compareVersions: (a: string, b: string) => number;
+/** Equal-precedence build metadata has a stable lexical tie-break, not higher precedence. */
+export declare const newestVersionFirst: (a: string, b: string) => number;
+export interface PluginVersionFailure {
+    code: 'INVALID_PLUGIN_VERSION' | 'INVALID_DEPENDENCY_RANGE' | 'MISSING_DEPENDENCY' | 'DEPENDENCY_CYCLE' | 'UNSATISFIED_DEPENDENCY_RANGE' | 'AQE_VERSION_INCOMPATIBLE' | 'RESOLUTION_LIMIT';
+    plugin: string;
+    message: string;
+}
+//# sourceMappingURL=version-policy.d.ts.map

package/dist/plugins/version-policy.js

@@ -0,0 +1,18 @@
+/** npm SemVer is the single oracle for plugin versions and ranges. */
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);
+const semver = require('semver');
+export const AQE_VERSION = typeof __CLI_VERSION__ !== 'undefined' ? __CLI_VERSION__
+    : typeof __MCP_VERSION__ !== 'undefined' ? __MCP_VERSION__
+        : require('../../package.json').version;
+// semver.valid drops build metadata; retain valid metadata but reject normalized
+// prefixes/whitespace so cache directory names remain canonical.
+// Cached manifests are untrusted JSON (older releases admitted a non-string
+// minAqeVersion), so a non-string must be rejected here rather than throw.
+export const validVersion = (value) => typeof value === 'string' && semver.valid(value) === value.split('+')[0];
+export const validRange = (value) => semver.validRange(value) !== null;
+export const satisfiesVersion = (version, range) => semver.satisfies(version, range);
+export const compareVersions = (a, b) => semver.compare(a, b);
+/** Equal-precedence build metadata has a stable lexical tie-break, not higher precedence. */
+export const newestVersionFirst = (a, b) => compareVersions(b, a) || a.localeCompare(b);
+//# sourceMappingURL=version-policy.js.map

package/dist/routing/advisor/multi-model-executor.d.ts

@@ -26,9 +26,12 @@ import { type CircuitBreakerState } from './circuit-breaker.js';
  * ADR-093 (2026-04-17): default advisor model upgraded from Opus 4 to Opus 4.7.
  * SWE-bench Verified 87.6% (vs 80.8% on 4.6), new `xhigh` effort level,
  * 1M context at standard pricing, adaptive thinking.
+ *
+ * 2026-09 model refresh: follows DEFAULT_OPUS_MODEL (Claude Opus 5.5), in its
+ * OpenRouter form.
  */
 export declare const DEFAULT_ADVISOR_PROVIDER: ExtendedProviderType;
-export declare const DEFAULT_ADVISOR_MODEL = "anthropic/claude-opus-4.7";
+export declare const DEFAULT_ADVISOR_MODEL: string;
 export declare const DEFAULT_MAX_WORDS = 100;
 /**
  * Phase 0 MultiModelExecutor implementation.

package/dist/routing/advisor/multi-model-executor.js

@@ -18,6 +18,8 @@ import { createHash } from 'crypto';
 import { redact, validateProviderForAgent, isSelfHosted, } from './redaction.js';
 import { AdvisorCircuitBreaker } from './circuit-breaker.js';
 import { applyCyberPin, CYBER_PIN_ADVISOR_FALLBACK } from '../security/cyber-pin.js';
+import { DEFAULT_OPUS_MODEL } from '../../shared/llm/model-registry.js';
+import { mapModelId } from '../../shared/llm/model-mapping.js';
 /**
  * Default advisor model per ADR-092 Phase 0 and ADR-093.
  * OpenRouter exposes Anthropic Opus — chosen for vendor-independence as the
@@ -26,9 +28,14 @@ import { applyCyberPin, CYBER_PIN_ADVISOR_FALLBACK } from '../security/cyber-pin
  * ADR-093 (2026-04-17): default advisor model upgraded from Opus 4 to Opus 4.7.
  * SWE-bench Verified 87.6% (vs 80.8% on 4.6), new `xhigh` effort level,
  * 1M context at standard pricing, adaptive thinking.
+ *
+ * 2026-09 model refresh: follows DEFAULT_OPUS_MODEL (Claude Opus 5.5), in its
+ * OpenRouter form.
  */
 export const DEFAULT_ADVISOR_PROVIDER = 'openrouter';
-export const DEFAULT_ADVISOR_MODEL = 'anthropic/claude-opus-4.7';
+// OpenRouter IDs use dotted versions (anthropic/claude-opus-5.5), so map
+// rather than prefix the canonical ID.
+export const DEFAULT_ADVISOR_MODEL = mapModelId(DEFAULT_OPUS_MODEL, 'openrouter');
 export const DEFAULT_MAX_WORDS = 100;
 // ADR-093: cyber-pin helpers moved to src/routing/security/cyber-pin.ts
 // so HybridRouter.chat() can also apply the pin — direct chat calls must

package/dist/routing/free-tier/ladder.d.ts

@@ -12,7 +12,8 @@ import type { AgentTier } from '../routing-config.js';
 /**
  * A ready-to-use, opinionated default: a free local Ollama tier under the three
  * Claude tiers. Override `bindings.local.config.model` / `.kind` to point at
- * cloud Ollama, OpenRouter, or any compatible endpoint.
+ * cloud Ollama, OpenRouter, or any compatible endpoint. The default local model
+ * is qwen3-coder:30b (ADR-111); qwen3:8b is below the QE test-gen quality floor.
  */
 export declare function defaultFreeTierLadder(model?: string): QeRoutingLadder;
 /** Validate a ladder: every tier in `tierOrder` must have a binding, bounds must exist. */

package/dist/routing/free-tier/ladder.js

@@ -11,9 +11,10 @@ import { resolveFreeTierProvider } from './provider.js';
 /**
  * A ready-to-use, opinionated default: a free local Ollama tier under the three
  * Claude tiers. Override `bindings.local.config.model` / `.kind` to point at
- * cloud Ollama, OpenRouter, or any compatible endpoint.
+ * cloud Ollama, OpenRouter, or any compatible endpoint. The default local model
+ * is qwen3-coder:30b (ADR-111); qwen3:8b is below the QE test-gen quality floor.
  */
-export function defaultFreeTierLadder(model = 'qwen3:8b') {
+export function defaultFreeTierLadder(model = 'qwen3-coder:30b') {
     return {
         tierOrder: ['local', 'haiku', 'sonnet', 'opus'],
         minTier: 'local',

package/dist/routing/security/cyber-pin.d.ts

@@ -2,16 +2,28 @@
  * Agentic QE v3 - Cyber Verification Pin
  * ADR-093: Opus 4.7 Migration
  *
- * Security and pentest agents may trip Opus 4.7's real-time cybersecurity
- * safeguards until the organization is enrolled in Anthropic's Cyber
- * Verification Program. This module pins those agents to a fallback model
- * until `AQE_CYBER_VERIFIED=true`.
+ * Security and pentest agents may trip the real-time cybersecurity
+ * safeguards that ship with Opus 4.7 and later Opus/Fable-class models until
+ * the organization is enrolled in Anthropic's Cyber Verification Program.
+ * This module pins those agents to a fallback model until
+ * `AQE_CYBER_VERIFIED=true`.
  *
  * Applied in BOTH:
  *   - HybridRouter.chat() — catches direct routing calls
  *   - MultiModelExecutor.consult() — catches advisor escalations
  *
- * so security agents cannot reach 4.7 by any code path until verified.
+ * HybridRouter also re-pins its fallback candidates (default model and
+ * fallback chain), so a failed primary cannot escalate a pinned agent. Scope:
+ * the pin covers the Opus/Fable-class models that ship these safeguards; it
+ * does NOT restrict ordinary Sonnet routing (security tasks may route to the
+ * default Sonnet).
+
+ *
+ * 2026-09 model refresh: the gate was generalized from Opus 4.7 only to every
+ * Opus/Fable model at or above 4.7, including the Claude Code aliases
+ * `opus` / `fable` (see {@link isCyberGatedModel}). Routing tier 4 and the
+ * default advisor now target Opus 5.5; matching 4.7 alone would have left the
+ * pin unreachable.
  */
 /**
  * Agent names subject to the cyber pin. These are the agents covered by
@@ -23,21 +35,27 @@
  */
 export declare const CYBER_PINNED_AGENTS: readonly string[];
 /**
- * Fallback advisor model for cyber-pinned agents. Sonnet 4.6 on OpenRouter.
+ * Fallback advisor model for cyber-pinned agents, in OpenRouter form.
  * Used by MultiModelExecutor.consult.
  */
-export declare const CYBER_PIN_ADVISOR_FALLBACK = "anthropic/claude-sonnet-4.6";
+export declare const CYBER_PIN_ADVISOR_FALLBACK: string;
 /**
  * Fallback chat model for cyber-pinned agents when targeting the Anthropic
  * provider directly. Used by HybridRouter.chat.
  */
 export declare const CYBER_PIN_CHAT_FALLBACK = "claude-sonnet-4-6";
 /**
- * Returns true if the model ID targets Opus 4.7 in any known form:
- * canonical (claude-opus-4-7), OpenRouter (anthropic/claude-opus-4.7),
- * or Bedrock (anthropic.claude-opus-4-7-v1:0).
+ * Returns true if the model ID is an Opus- or Fable-class model at or above
+ * 4.7 (claude-opus-4-7, claude-opus-4-8, claude-opus-5, claude-opus-5-5,
+ * claude-fable-5, claude-fable-5-1, …) in canonical, OpenRouter or Bedrock
+ * form. Sonnet, Haiku and Opus below 4.7 are not gated.
+ */
+export declare function isCyberGatedModel(modelId: string): boolean;
+/**
+ * @deprecated Use {@link isCyberGatedModel}. Kept as an alias for existing
+ * callers; it matches every cyber-gated model, not only Opus 4.7.
  */
-export declare function isOpus47(modelId: string): boolean;
+export declare const isOpus47: typeof isCyberGatedModel;
 /**
  * Returns true if the agent is cyber-pinned and env does not grant
  * Cyber Verification bypass. Case-sensitive "true" only — '1', 'yes',
@@ -55,4 +73,10 @@ export declare function shouldCyberPin(agentName: string, env?: NodeJS.ProcessEn
  *          or `fallback` if pin fires.
  */
 export declare function applyCyberPin(agentName: string, requestedModel: string, fallback: string, env?: NodeJS.ProcessEnv): string;
+/**
+ * The pinned Sonnet 4.6 fallback in the model-ID form a given provider
+ * expects, so a pinned request stays routable (OpenRouter needs the dotted
+ * `anthropic/…` slug, Bedrock the `anthropic.…-v1:0` form).
+ */
+export declare function cyberPinFallbackFor(provider: string): string;
 //# sourceMappingURL=cyber-pin.d.ts.map

package/dist/routing/security/cyber-pin.js

@@ -2,16 +2,28 @@
  * Agentic QE v3 - Cyber Verification Pin
  * ADR-093: Opus 4.7 Migration
  *
- * Security and pentest agents may trip Opus 4.7's real-time cybersecurity
- * safeguards until the organization is enrolled in Anthropic's Cyber
- * Verification Program. This module pins those agents to a fallback model
- * until `AQE_CYBER_VERIFIED=true`.
+ * Security and pentest agents may trip the real-time cybersecurity
+ * safeguards that ship with Opus 4.7 and later Opus/Fable-class models until
+ * the organization is enrolled in Anthropic's Cyber Verification Program.
+ * This module pins those agents to a fallback model until
+ * `AQE_CYBER_VERIFIED=true`.
  *
  * Applied in BOTH:
  *   - HybridRouter.chat() — catches direct routing calls
  *   - MultiModelExecutor.consult() — catches advisor escalations
  *
- * so security agents cannot reach 4.7 by any code path until verified.
+ * HybridRouter also re-pins its fallback candidates (default model and
+ * fallback chain), so a failed primary cannot escalate a pinned agent. Scope:
+ * the pin covers the Opus/Fable-class models that ship these safeguards; it
+ * does NOT restrict ordinary Sonnet routing (security tasks may route to the
+ * default Sonnet).
+
+ *
+ * 2026-09 model refresh: the gate was generalized from Opus 4.7 only to every
+ * Opus/Fable model at or above 4.7, including the Claude Code aliases
+ * `opus` / `fable` (see {@link isCyberGatedModel}). Routing tier 4 and the
+ * default advisor now target Opus 5.5; matching 4.7 alone would have left the
+ * pin unreachable.
  */
 /**
  * Agent names subject to the cyber pin. These are the agents covered by
@@ -28,23 +40,58 @@ export const CYBER_PINNED_AGENTS = [
     'qe-security-reviewer',
 ];
 /**
- * Fallback advisor model for cyber-pinned agents. Sonnet 4.6 on OpenRouter.
+ * Fallback model for pinned requests. Deliberately Sonnet 4.6 — the model
+ * docs/security/cyber-verification-application.md names for security agents —
+ * rather than DEFAULT_SONNET_MODEL, so the pin's target stays the documented,
+ * reviewed model across default bumps. (Claude Code maps model IDs to its
+ * `sonnet` alias, so on that provider the fallback runs on the CLI's Sonnet.)
+ * Sonnet 4.6 is served until at least 2027-02-17.
+ */
+const CYBER_PIN_SONNET = 'claude-sonnet-4-6';
+/**
+ * Fallback advisor model for cyber-pinned agents, in OpenRouter form.
  * Used by MultiModelExecutor.consult.
  */
-export const CYBER_PIN_ADVISOR_FALLBACK = 'anthropic/claude-sonnet-4.6';
+export const CYBER_PIN_ADVISOR_FALLBACK = `anthropic/${CYBER_PIN_SONNET.replace('4-6', '4.6')}`;
 /**
  * Fallback chat model for cyber-pinned agents when targeting the Anthropic
  * provider directly. Used by HybridRouter.chat.
  */
-export const CYBER_PIN_CHAT_FALLBACK = 'claude-sonnet-4-6';
+export const CYBER_PIN_CHAT_FALLBACK = CYBER_PIN_SONNET;
 /**
- * Returns true if the model ID targets Opus 4.7 in any known form:
- * canonical (claude-opus-4-7), OpenRouter (anthropic/claude-opus-4.7),
- * or Bedrock (anthropic.claude-opus-4-7-v1:0).
+ * Family + version in any known ID form: canonical (claude-opus-5-5),
+ * OpenRouter (anthropic/claude-opus-5.5), Bedrock (anthropic.claude-opus-4-7-v1:0)
+ * and dated snapshots (claude-opus-4-5-20251101). The minor version is at most
+ * two digits so a date suffix (claude-opus-4-20250514) is not read as one.
  */
-export function isOpus47(modelId) {
-    return (modelId.includes('claude-opus-4-7') || modelId.includes('claude-opus-4.7'));
+const CLI_GATED_ALIASES = new Set(['opus', 'fable']);
+const OPUS_FABLE_ID = /claude-(opus|fable)-(\d+)(?:[-.](\d{1,2})(?!\d))?/;
+/** First Opus/Fable version that ships the cyber safeguards. */
+const CYBER_GATE_MIN = { major: 4, minor: 7 };
+/**
+ * Returns true if the model ID is an Opus- or Fable-class model at or above
+ * 4.7 (claude-opus-4-7, claude-opus-4-8, claude-opus-5, claude-opus-5-5,
+ * claude-fable-5, claude-fable-5-1, …) in canonical, OpenRouter or Bedrock
+ * form. Sonnet, Haiku and Opus below 4.7 are not gated.
+ */
+export function isCyberGatedModel(modelId) {
+    const id = modelId.trim().toLowerCase();
+    // Claude Code CLI aliases resolve to the latest Opus/Fable (>= 4.7).
+    if (CLI_GATED_ALIASES.has(id))
+        return true;
+    const match = OPUS_FABLE_ID.exec(id);
+    if (!match)
+        return false;
+    const major = Number(match[2]);
+    const minor = match[3] === undefined ? 0 : Number(match[3]);
+    return (major > CYBER_GATE_MIN.major ||
+        (major === CYBER_GATE_MIN.major && minor >= CYBER_GATE_MIN.minor));
 }
+/**
+ * @deprecated Use {@link isCyberGatedModel}. Kept as an alias for existing
+ * callers; it matches every cyber-gated model, not only Opus 4.7.
+ */
+export const isOpus47 = isCyberGatedModel;
 /**
  * Returns true if the agent is cyber-pinned and env does not grant
  * Cyber Verification bypass. Case-sensitive "true" only — '1', 'yes',
@@ -68,8 +115,23 @@ export function shouldCyberPin(agentName, env = process.env) {
 export function applyCyberPin(agentName, requestedModel, fallback, env = process.env) {
     if (!shouldCyberPin(agentName, env))
         return requestedModel;
-    if (!isOpus47(requestedModel))
+    if (!isCyberGatedModel(requestedModel))
         return requestedModel;
     return fallback;
 }
+/**
+ * The pinned Sonnet 4.6 fallback in the model-ID form a given provider
+ * expects, so a pinned request stays routable (OpenRouter needs the dotted
+ * `anthropic/…` slug, Bedrock the `anthropic.…-v1:0` form).
+ */
+export function cyberPinFallbackFor(provider) {
+    switch (provider) {
+        case 'openrouter':
+            return CYBER_PIN_ADVISOR_FALLBACK;
+        case 'bedrock':
+            return 'anthropic.claude-sonnet-4-6-v1:0';
+        default:
+            return CYBER_PIN_CHAT_FALLBACK;
+    }
+}
 //# sourceMappingURL=cyber-pin.js.map

package/dist/routing/value-score.js

@@ -52,6 +52,6 @@ export const MEASURED_QE_TEST_GEN = [
     { model: 'qwen2.5-coder:7b', quality: 0.50, costPerInstance: 0 }, // 2026-06-29: stock 7B coder = 4/8 (50%) — beats general qwen3:8b (38%), 16× faster; ~25pp below 30B (PEFT-tune target)
     { model: 'qwen2.5-coder:1.5b', quality: 0.08, costPerInstance: 0 }, // 2026-06-29: stock 1.5B coder = 1/8 (8%); below floor, size dominates coder-tuning at tiny scale
     { model: 'z-ai/glm-5.2', quality: 0.71, costPerInstance: 0.0065 }, // A12: diverse, higher per-model best
-    { model: 'claude-sonnet-4-6', quality: 0.83, costPerInstance: 0.045 }, // D3: frontier ceiling
+    { model: 'claude-sonnet-4-6', quality: 0.83, costPerInstance: 0.045 }, // D3: measured frontier reference as of 2026-06-24 (not re-run on newer models)
 ];
 //# sourceMappingURL=value-score.js.map

package/dist/shared/git/index.d.ts

@@ -3,4 +3,5 @@
  */
 export { GitAnalyzer } from './git-analyzer';
 export type { GitAnalyzerConfig, GitCommit, GitBlameInfo, FileHistory, } from './git-analyzer';
+export { assertSafeGitRef, getGitRefError } from './ref-validation';
 //# sourceMappingURL=index.d.ts.map

package/dist/shared/git/index.js

@@ -2,4 +2,5 @@
  * Agentic QE v3 - Git Analysis Utilities
  */
 export { GitAnalyzer } from './git-analyzer.js';
+export { assertSafeGitRef, getGitRefError } from './ref-validation.js';
 //# sourceMappingURL=index.js.map

package/dist/shared/git/ref-validation.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Agentic QE v3 - Git ref validation
+ *
+ * Caller-supplied refs (MCP tool arguments, CLI flags) are passed to git as
+ * positional argv entries. Even without a shell, a value beginning with "-"
+ * is parsed by git as an option (e.g. `--output=<path>` makes `git diff`
+ * create or truncate an arbitrary file), so refs must be validated at the
+ * boundary before reaching git.
+ */
+/**
+ * Returns an error message when `ref` is not a safe git revision argument,
+ * or undefined when it is safe. Accepts ordinary revisions such as `main`,
+ * `origin/main`, `HEAD~3`, `v1.2.0^{commit}` and commit SHAs.
+ */
+export declare function getGitRefError(ref: unknown, label?: string): string | undefined;
+/**
+ * Throws when `ref` is not a safe git revision argument.
+ */
+export declare function assertSafeGitRef(ref: unknown, label?: string): asserts ref is string;
+//# sourceMappingURL=ref-validation.d.ts.map

package/dist/shared/git/ref-validation.js

@@ -0,0 +1,43 @@
+/**
+ * Agentic QE v3 - Git ref validation
+ *
+ * Caller-supplied refs (MCP tool arguments, CLI flags) are passed to git as
+ * positional argv entries. Even without a shell, a value beginning with "-"
+ * is parsed by git as an option (e.g. `--output=<path>` makes `git diff`
+ * create or truncate an arbitrary file), so refs must be validated at the
+ * boundary before reaching git.
+ */
+const MAX_GIT_REF_LENGTH = 256;
+// Whitespace and ASCII control characters are never valid in a revision.
+// eslint-disable-next-line no-control-regex
+const UNSAFE_REF_CHARS = /[\s\x00-\x1f\x7f]/;
+/**
+ * Returns an error message when `ref` is not a safe git revision argument,
+ * or undefined when it is safe. Accepts ordinary revisions such as `main`,
+ * `origin/main`, `HEAD~3`, `v1.2.0^{commit}` and commit SHAs.
+ */
+export function getGitRefError(ref, label = 'git ref') {
+    if (typeof ref !== 'string' || ref.length === 0) {
+        return `Invalid ${label}: must be a non-empty string`;
+    }
+    if (ref.length > MAX_GIT_REF_LENGTH) {
+        return `Invalid ${label}: longer than ${MAX_GIT_REF_LENGTH} characters`;
+    }
+    if (ref.startsWith('-')) {
+        return `Invalid ${label} "${ref}": must not start with "-"`;
+    }
+    if (UNSAFE_REF_CHARS.test(ref)) {
+        return `Invalid ${label}: must not contain whitespace or control characters`;
+    }
+    return undefined;
+}
+/**
+ * Throws when `ref` is not a safe git revision argument.
+ */
+export function assertSafeGitRef(ref, label = 'git ref') {
+    const error = getGitRefError(ref, label);
+    if (error) {
+        throw new Error(error);
+    }
+}
+//# sourceMappingURL=ref-validation.js.map