agentic-qe 3.14.2 → 3.14.4

package/dist/mcp/protocol-server.js

@@ -29,7 +29,7 @@ handleTeamList, handleTeamHealth, handleTeamMessage, handleTeamBroadcast, handle
 // BMAD-003: Validation pipeline handler
 handleValidationPipeline, 
 // Imp-9: YAML pipeline handlers
-handlePipelineLoad, handlePipelineRun, handlePipelineList, handlePipelineValidate, 
+handlePipelineLoad, handlePipelineRun, handlePipelineStatus, handlePipelineApprove, handlePipelineReject, handlePipelineList, handlePipelineValidate, 
 // Cross-phase handlers
 handleCrossPhaseStore, handleCrossPhaseQuery, handleAgentComplete, handlePhaseStart, handlePhaseEnd, handleCrossPhaseStats, handleFormatSignals, handleCrossPhaseCleanup, 
 // ADR-072: RVF Migration handlers
@@ -44,6 +44,19 @@ import { ToolCallSignatureTracker } from '../kernel/anti-drift-middleware.js';
 import { createRequire } from 'module';
 const _require = createRequire(import.meta.url);
 const _pkg = _require('../../package.json');
+function toolExecutionError() {
+    return {
+        content: [{
+                type: 'text',
+                text: JSON.stringify({
+                    success: false,
+                    code: 'tool_execution_error',
+                    error: 'Tool execution failed',
+                }),
+            }],
+        isError: true,
+    };
+}
 // ============================================================================
 // MCP Protocol Server
 // ============================================================================
@@ -81,6 +94,15 @@ export class MCPProtocolServer {
             return false;
         return true;
     }
+    /** A completed tool can legitimately report a negative domain verdict. */
+    isFailedToolResult(result) {
+        if (!result || typeof result !== 'object')
+            return false;
+        const value = result;
+        if (value.isError === true || value.success === false)
+            return true;
+        return value.success !== true && typeof value.error === 'string' && value.error.length > 0;
+    }
     config;
     transport;
     registry;
@@ -167,14 +189,10 @@ export class MCPProtocolServer {
                 }
                 // Last-resort safety net: catch anything else that escapes handleToolsCall
                 // to prevent MCP connection from being killed (-32000)
-                const message = err instanceof Error ? err.message : String(err);
-                console.error(`[MCP] Unhandled error in request handler: ${message}`);
-                return {
-                    content: [{
-                            type: 'text',
-                            text: JSON.stringify({ success: false, error: `Internal error: ${message}` }),
-                        }],
-                };
+                console.error('[MCP] Unhandled error in request handler:', err);
+                if (request.method === 'tools/call')
+                    return toolExecutionError();
+                throw new McpError(JSON_RPC_ERRORS.INTERNAL_ERROR, 'Internal server error');
             }
         });
         // Set up notification handler
@@ -220,7 +238,7 @@ export class MCPProtocolServer {
                     const result = await this.handleRequest(request);
                     resolve(result);
                 }
-                catch (err) {
+                catch {
                     console.error(`[MCP] Failed to replay buffered request: ${request.method}`);
                 }
             }
@@ -389,6 +407,7 @@ export class MCPProtocolServer {
         // ADR-039: Track tool invocation with performance monitoring
         const startTime = performance.now();
         let success = false;
+        let cacheable;
         // Emit AG-UI progress event for tool start
         const stepId = `${name}-${Date.now()}`;
         this.eventAdapter.adapt({
@@ -408,7 +427,10 @@ export class MCPProtocolServer {
         };
         // ADR-062: Loop detection — check for repeated identical tool calls
         let loopSteeringPrefix = '';
-        if (process.env.AQE_LOOP_DETECTION_ENABLED !== 'false') {
+        // Polling a known execution is a normal status protocol, not a repeated
+        // action loop. The default three-strike detector would block the third
+        // pipeline_status call within 30 seconds while a workflow is running.
+        if (process.env.AQE_LOOP_DETECTION_ENABLED !== 'false' && name !== 'pipeline_status') {
             try {
                 const loopResult = this.loopTracker.trackCall('mcp-client', name, args);
                 if (loopResult.action === 'steer') {
@@ -434,20 +456,28 @@ export class MCPProtocolServer {
             // the same output, so we can short-circuit repeated calls with an O(1)
             // fingerprint lookup. Tools without isConcurrencySafe (writes, scans,
             // executions) always re-run.
-            const cacheable = tool.definition.isConcurrencySafe === true;
+            // Explicit quality gates depend on current measured evidence and its age,
+            // not just arguments. A cached approval can outlive or contradict evidence.
+            const measuredQualityGate = name === 'quality_assess' && processedCtx.params?.runGate === true;
+            cacheable = tool.definition.isConcurrencySafe === true && !measuredQualityGate;
             let cacheFingerprint = null;
+            let cacheGeneration = null;
             if (cacheable && process.env.AQE_SESSION_CACHE !== 'off') {
                 try {
                     const { getSessionCache } = await import('../optimization/session-cache.js');
                     const cache = getSessionCache();
                     const { domain, action } = parseToolDomainAction(name);
+                    cacheGeneration = cache.getGeneration();
                     cacheFingerprint = cache.computeFingerprint(domain, action, processedCtx.params || {});
                     const hit = cache.get(cacheFingerprint);
                     if (hit) {
                         // Cache hit — return the stored result without running the handler.
                         const cachedText = JSON.stringify(hit.result, null, 2);
+                        if (typeof cachedText !== 'string')
+                            throw new Error('Missing cached tool result');
+                        const cachedSuccess = !this.isFailedToolResult(hit.result);
                         this.eventAdapter.adapt({
-                            success: true,
+                            success: cachedSuccess,
                             data: hit.result,
                             metadata: {
                                 executionTime: performance.now() - startTime,
@@ -456,12 +486,13 @@ export class MCPProtocolServer {
                                 toolName: name,
                             },
                         });
-                        success = true;
+                        success = cachedSuccess;
                         return {
                             content: [{
                                     type: 'text',
                                     text: loopSteeringPrefix ? loopSteeringPrefix + cachedText : cachedText,
                                 }],
+                            ...(cachedSuccess ? {} : { isError: true }),
                         };
                     }
                 }
@@ -471,36 +502,26 @@ export class MCPProtocolServer {
                 }
             }
             const result = await tool.handler(processedCtx.params);
-            success = true;
             // IMP-00: Execute post-tool-result middleware
             const processedResult = await this.middlewareChain.executePostHooks(processedCtx, result);
-            // Issue #535: a mutating tool must evict its domain's cached reads, or a
-            // follow-up read (e.g. memory_retrieve after memory_delete) serves a
-            // stale "found" result and the write looks like a no-op. Writes aren't
-            // cacheable themselves; gate on a mutation-verb suffix and invalidate the
-            // same domain the sibling reads were cached under. Best-effort.
-            if (!cacheable && process.env.AQE_SESSION_CACHE !== 'off' &&
-                /_(store|delete|set|share|update|remove|clear|promote|cleanup)$/.test(name) &&
-                this.isSuccessfulResult(processedResult)) {
-                try {
-                    const { getSessionCache } = await import('../optimization/session-cache.js');
-                    const { domain } = parseToolDomainAction(name);
-                    getSessionCache().invalidateDomain(domain);
-                }
-                catch {
-                    // never block tool execution on cache invalidation
-                }
-            }
+            if (processedResult === null)
+                throw new Error('Missing tool result');
+            const resultText = JSON.stringify(processedResult, null, 2);
+            if (typeof resultText !== 'string')
+                throw new Error('Missing tool result');
+            const resultSucceeded = !this.isFailedToolResult(processedResult);
             // Issue #473: Store successful results for future cache hits.
             // Only cache successful results — error objects shouldn't be served back.
             if (cacheable && cacheFingerprint && this.isSuccessfulResult(processedResult)) {
                 try {
                     const { getSessionCache } = await import('../optimization/session-cache.js');
                     const cache = getSessionCache();
-                    const { domain, action } = parseToolDomainAction(name);
-                    // Estimate tokens conservatively by length-of-JSON / 4 chars-per-token.
-                    const tokenEstimate = Math.max(50, Math.floor(JSON.stringify(processedResult).length / 4));
-                    cache.set(cacheFingerprint, domain, action, processedResult, tokenEstimate);
+                    if (cache.getGeneration() === cacheGeneration) {
+                        const { domain, action } = parseToolDomainAction(name);
+                        // Estimate tokens conservatively by length-of-JSON / 4 chars-per-token.
+                        const tokenEstimate = Math.max(50, Math.floor(JSON.stringify(processedResult).length / 4));
+                        cache.set(cacheFingerprint, domain, action, processedResult, tokenEstimate);
+                    }
                 }
                 catch {
                     // never block on cache write
@@ -508,14 +529,14 @@ export class MCPProtocolServer {
             }
             // Emit AG-UI result event for tool completion
             this.eventAdapter.adapt({
-                success: true,
+                success: resultSucceeded,
                 data: processedResult,
                 metadata: {
                     executionTime: performance.now() - startTime,
                     requestId: stepId,
                 },
             });
-            const resultText = JSON.stringify(processedResult, null, 2);
+            success = resultSucceeded;
             return {
                 content: [
                     {
@@ -523,10 +544,14 @@ export class MCPProtocolServer {
                         text: loopSteeringPrefix ? loopSteeringPrefix + resultText : resultText,
                     },
                 ],
+                ...(resultSucceeded ? {} : { isError: true }),
             };
         }
         catch (err) {
-            const error = err;
+            // Preserve the diagnostic for operators without exposing it in the MCP
+            // response or AG-UI event. Stderr keeps stdio protocol output valid.
+            console.error(`[MCP] Tool ${name} failed:`, err);
+            const error = err instanceof Error ? err : new Error('Tool execution failed');
             // IMP-08: Detect context overflow (413) and trigger reactive compaction
             const errorMsg = error.message || '';
             const is413 = errorMsg.includes('413')
@@ -546,22 +571,27 @@ export class MCPProtocolServer {
             // Emit AG-UI result event for tool failure
             this.eventAdapter.adapt({
                 success: false,
-                error: error.message,
+                error: 'Tool execution failed',
                 metadata: {
                     executionTime: performance.now() - startTime,
                     requestId: stepId,
                 },
             });
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({ error: error.message || 'Tool execution failed' }),
-                    },
-                ],
-            };
+            return toolExecutionError();
         }
         finally {
+            // Tool names and success flags do not prove whether state changed.
+            // Unknown cross-domain effects require a global flush, including after
+            // a handler throws or reports failure following a partial effect.
+            if (cacheable === false && process.env.AQE_SESSION_CACHE !== 'off') {
+                try {
+                    const { getSessionCache } = await import('../optimization/session-cache.js');
+                    getSessionCache().invalidateAll();
+                }
+                catch {
+                    // Cache failure must not hide the tool response.
+                }
+            }
             // Record actual MCP tool execution latency
             const latency = performance.now() - startTime;
             this.monitor.recordLatency(name, latency, success);
@@ -652,7 +682,7 @@ export class MCPProtocolServer {
         this.registerTool({
             definition: {
                 name: 'task_cancel',
-                description: 'Cancel a running or pending task by ID. Example: task_cancel({ taskId: "abc-123" })',
+                description: 'Request task cancellation by ID. A running handler may continue; check cancellationResultPending in task_status.',
                 category: 'task',
                 parameters: [
                     { name: 'taskId', type: 'string', description: 'Task ID to cancel', required: true },
@@ -821,7 +851,7 @@ export class MCPProtocolServer {
                 description: 'Execute test files in parallel with automatic retry on flaky failures. Example: test_execute_parallel({ testFiles: ["tests/auth.test.ts"], parallel: true })',
                 category: 'domain',
                 parameters: [
-                    { name: 'testFiles', type: 'array', description: 'Test files to execute' },
+                    { name: 'testFiles', type: 'array', description: 'Nonempty list of concrete test file paths (relative to the project working directory or absolute). Expand glob patterns before calling; glob patterns are rejected.' },
                     { name: 'parallel', type: 'boolean', description: 'Enable parallel execution', default: true },
                 ],
             },
@@ -849,7 +879,7 @@ export class MCPProtocolServer {
                 category: 'domain',
                 isConcurrencySafe: true,
                 parameters: [
-                    { name: 'runGate', type: 'boolean', description: 'Run quality gate evaluation', default: false },
+                    { name: 'runGate', type: 'boolean', description: 'Evaluate all seven canonical measured quality checks; requires complete, valid evidence from the last 24 hours. Returns individual checks, not a static aggregate score.', default: false },
                 ],
             },
             handler: (params) => handleQualityAssess(params),
@@ -858,12 +888,13 @@ export class MCPProtocolServer {
         this.registerTool({
             definition: {
                 name: 'security_scan_comprehensive',
-                description: 'Run SAST and/or DAST security scans with vulnerability classification. Example: security_scan_comprehensive({ target: "src/", sast: true })',
+                description: 'Run security scans with execution evidence and explicit coverage limitations. Complete means the declared required scope ran, not that all vulnerabilities are absent. Example: security_scan_comprehensive({ target: "src/", sast: true })',
                 category: 'domain',
                 parameters: [
                     { name: 'sast', type: 'boolean', description: 'Run SAST scan', default: true },
                     { name: 'dast', type: 'boolean', description: 'Run DAST scan', default: false },
-                    { name: 'target', type: 'string', description: 'Target to scan' },
+                    { name: 'target', type: 'string', description: 'Source file or directory for SAST' },
+                    { name: 'targetUrl', type: 'string', description: 'URL for a requested DAST scan' },
                 ],
             },
             handler: (params) => handleSecurityScan(params),
@@ -1244,6 +1275,21 @@ export class MCPProtocolServer {
             },
             handler: (params) => handlePipelineRun(params),
         });
+        for (const decision of ['approve', 'reject']) {
+            this.registerTool({
+                definition: {
+                    name: `pipeline_${decision}`,
+                    description: `${decision === 'approve' ? 'Approve' : 'Reject'} a pending step in a pipeline started by this MCP server. Use the executionId from pipeline_run and stepId from the pipeline definition.`,
+                    category: 'coordination',
+                    parameters: [
+                        { name: 'executionId', type: 'string', description: 'Running pipeline execution ID', required: true },
+                        { name: 'stepId', type: 'string', description: 'Step awaiting approval', required: true },
+                        ...(decision === 'reject' ? [{ name: 'reason', type: 'string', description: 'Reason for rejecting the step' }] : []),
+                    ],
+                },
+                handler: (params) => (decision === 'approve' ? handlePipelineApprove : handlePipelineReject)(params),
+            });
+        }
         this.registerTool({
             definition: {
                 name: 'pipeline_list',
@@ -1254,6 +1300,19 @@ export class MCPProtocolServer {
             },
             handler: (params) => handlePipelineList(params),
         });
+        this.registerTool({
+            definition: {
+                name: 'pipeline_status',
+                description: 'Read pipeline execution status and parallel composition receipts without raw step outputs.',
+                category: 'coordination',
+                // Status changes while a run is active; the session cache must not
+                // replay an earlier "running" result for the same execution ID.
+                parameters: [
+                    { name: 'executionId', type: 'string', description: 'Execution ID returned by pipeline_run', required: true },
+                ],
+            },
+            handler: (params) => handlePipelineStatus(params),
+        });
         this.registerTool({
             definition: {
                 name: 'pipeline_validate',

package/dist/mcp/security/sampling-server.js

@@ -10,6 +10,7 @@
  * - Caching for repeated sampling requests
  */
 import { createHash, randomUUID } from 'crypto';
+import { DEFAULT_SONNET_MODEL } from '../../shared/llm/model-registry.js';
 // ============================================================================
 // Pre-built QE Decision Prompts
 // ============================================================================
@@ -129,7 +130,7 @@ export class SamplingServer {
     cleanupTimer = null;
     constructor(config = {}) {
         this.config = {
-            defaultModel: config.defaultModel || 'claude-sonnet-4-6',
+            defaultModel: config.defaultModel || DEFAULT_SONNET_MODEL,
             defaultMaxTokens: config.defaultMaxTokens || 4096,
             defaultTemperature: config.defaultTemperature || 0.7,
             enableCaching: config.enableCaching ?? true,

package/dist/mcp/tool-annotations.js

@@ -25,7 +25,7 @@ const HARD_CODED_TOOL_NAMES = [
     'memory_query', 'memory_retrieve', 'memory_share', 'memory_store',
     'memory_usage', 'migration_check', 'migration_promote', 'migration_status',
     'model_route', 'phase_end', 'phase_start', 'pipeline_list', 'pipeline_load',
-    'pipeline_run', 'pipeline_validate', 'quality_assess',
+    'pipeline_approve', 'pipeline_reject', 'pipeline_run', 'pipeline_status', 'pipeline_validate', 'quality_assess',
     'requirements_validate', 'routing_economics', 'routing_metrics',
     'security_scan_comprehensive', 'session_cache_stats', 'task_cancel',
     'task_list', 'task_orchestrate', 'task_status', 'task_submit',

package/dist/mcp/tools/test-execution/schedule.js

@@ -6,6 +6,7 @@
  */
 import { MCPToolBase, getMemoryBackend, } from '../base.js';
 import { toErrorMessage } from '../../../shared/error-utils.js';
+import { getGitRefError } from '../../../shared/git/ref-validation.js';
 // ============================================================================
 // Tool Implementation
 // ============================================================================
@@ -43,6 +44,12 @@ export class TestScheduleTool extends MCPToolBase {
         };
     }
     async execute(params, context) {
+        if (params.gitRef !== undefined) {
+            const refError = getGitRefError(params.gitRef, 'gitRef');
+            if (refError) {
+                return { success: false, error: refError };
+            }
+        }
         try {
             const { runTestPipeline } = await import('../../../test-scheduling/index.js');
             const memory = await getMemoryBackend(context);

package/dist/mcp/types.d.ts

@@ -176,6 +176,9 @@ export interface TestGenerateParams {
  * Test execution parameters
  */
 export interface TestExecuteParams {
+    /** Concrete test file paths for test_execute_parallel; provide a nonempty list.
+     * Expand glob patterns before calling. The task handler does not expand them.
+     */
     testFiles?: string[];
     testSuites?: string[];
     parallel?: boolean;
@@ -211,6 +214,8 @@ export interface SecurityScanParams {
     dast?: boolean;
     compliance?: string[];
     target?: string;
+    /** URL for explicitly requested dynamic scanning. */
+    targetUrl?: string;
 }
 /**
  * Contract validation parameters
@@ -428,7 +433,9 @@ export interface TaskSubmitResult {
     taskId: string;
     type: TaskType;
     priority: Priority;
-    status: 'pending' | 'queued';
+    status: TaskStatusResult['status'];
+    /** Execution failure, if the task already reached a failed state. */
+    error?: string;
     assignedDomain?: DomainName;
 }
 /**
@@ -438,6 +445,8 @@ export interface TaskStatusResult {
     taskId: string;
     type: TaskType;
     status: 'queued' | 'assigned' | 'running' | 'completed' | 'failed' | 'cancelled';
+    /** Reports an outstanding task result; false does not prove external effects stopped. */
+    cancellationResultPending?: boolean;
     priority: Priority;
     assignedDomain?: DomainName;
     assignedAgents: string[];

package/dist/optimization/session-cache.d.ts

@@ -45,6 +45,7 @@ export declare class SessionOperationCache {
     private config;
     private hits;
     private misses;
+    private generation;
     constructor(config?: Partial<SessionCacheConfig>);
     /**
      * Compute a deterministic fingerprint from build + domain + action + input.
@@ -81,6 +82,10 @@ export declare class SessionOperationCache {
     getStats(): SessionCacheStats;
     /** Clear all cache entries and reset counters */
     clear(): void;
+    /** Revision used to keep in-flight reads from repopulating a stale cache. */
+    getGeneration(): number;
+    /** Evict all cached reads, including persisted rows, after a stateful call. */
+    invalidateAll(): number;
     /**
      * Invalidate every cached entry for a domain. Issue #535: a mutating tool
      * (e.g. memory_delete / memory_store) must evict the sibling read entries in

package/dist/optimization/session-cache.js

@@ -60,6 +60,7 @@ export class SessionOperationCache {
     config;
     hits = 0;
     misses = 0;
+    generation = 0;
     constructor(config) {
         this.config = { ...DEFAULT_SESSION_CACHE_CONFIG, ...config };
     }
@@ -182,6 +183,27 @@ export class SessionOperationCache {
         this.cache.clear();
         this.hits = 0;
         this.misses = 0;
+        this.generation++;
+    }
+    /** Revision used to keep in-flight reads from repopulating a stale cache. */
+    getGeneration() {
+        return this.generation;
+    }
+    /** Evict all cached reads, including persisted rows, after a stateful call. */
+    invalidateAll() {
+        const removed = this.cache.size;
+        this.cache.clear();
+        this.generation++;
+        if (this.config.persistToDb) {
+            try {
+                const db = tryGetDb();
+                db?.prepare("DELETE FROM kv_store WHERE namespace = 'session_cache'").run();
+            }
+            catch {
+                // Cache invalidation must not prevent the tool response.
+            }
+        }
+        return removed;
     }
     /**
      * Invalidate every cached entry for a domain. Issue #535: a mutating tool
@@ -192,6 +214,7 @@ export class SessionOperationCache {
      * number of entries removed.
      */
     invalidateDomain(domain) {
+        this.generation++;
         let removed = 0;
         for (const [key, entry] of this.cache) {
             if (entry.domain === domain) {

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