agentic-qe 3.14.3 → 3.14.4

package/dist/mcp/handlers/index.d.ts

@@ -9,7 +9,7 @@ export { handleTestGenerate, handleTestExecute, handleCoverageAnalyze, handleQua
 export { handleInfraHealingStatus, handleInfraHealingFeedOutput, handleInfraHealingRecover, setInfraHealingOrchestrator, } from './domain-handlers';
 export { handleTeamList, handleTeamHealth, handleTeamMessage, handleTeamBroadcast, handleTeamScale, handleTeamRebalance, } from './team-handlers';
 export { handleMemoryStore, handleMemoryRetrieve, handleMemoryQuery, handleMemoryDelete, handleMemoryUsage, handleMemoryShare, } from './memory-handlers';
-export { handlePipelineLoad, handlePipelineRun, handlePipelineList, handlePipelineValidate, getPipelineRegistry, getPipelineLoader, type PipelineLoadParams, type PipelineLoadResult, type PipelineRunParams, type PipelineRunResult, type PipelineListParams, type PipelineListResult, type PipelineValidateParams, type PipelineValidateResult, } from './pipeline-handlers.js';
+export { handlePipelineLoad, handlePipelineRun, handlePipelineStatus, handlePipelineApprove, handlePipelineReject, type PipelineApprovalParams, type PipelineApprovalResult, handlePipelineList, handlePipelineValidate, getPipelineRegistry, getPipelineLoader, type PipelineLoadParams, type PipelineLoadResult, type PipelineRunParams, type PipelineRunResult, type PipelineStatusParams, type PipelineStatusResult, type PipelineListParams, type PipelineListResult, type PipelineValidateParams, type PipelineValidateResult, } from './pipeline-handlers.js';
 export { handleValidationPipeline, type ValidationPipelineParams, type ValidationPipelineResult, } from './validation-pipeline-handler.js';
 export { handleHypergraphQuery, type HypergraphQueryParams, type HypergraphQueryResult, } from './hypergraph-handler.js';
 export { handleHeartbeatStatus, handleHeartbeatTrigger, handleHeartbeatLog, type HeartbeatStatusParams, type HeartbeatStatusResult, type HeartbeatTriggerParams, type HeartbeatTriggerResult, type HeartbeatLogParams, type HeartbeatLogResult, } from './heartbeat-handlers.js';

package/dist/mcp/handlers/index.js

@@ -21,7 +21,7 @@ export { handleTeamList, handleTeamHealth, handleTeamMessage, handleTeamBroadcas
 // Memory handlers
 export { handleMemoryStore, handleMemoryRetrieve, handleMemoryQuery, handleMemoryDelete, handleMemoryUsage, handleMemoryShare, } from './memory-handlers.js';
 // Pipeline handlers (Imp-9: YAML Deterministic Pipelines)
-export { handlePipelineLoad, handlePipelineRun, handlePipelineList, handlePipelineValidate, getPipelineRegistry, getPipelineLoader, } from './pipeline-handlers.js';
+export { handlePipelineLoad, handlePipelineRun, handlePipelineStatus, handlePipelineApprove, handlePipelineReject, handlePipelineList, handlePipelineValidate, getPipelineRegistry, getPipelineLoader, } from './pipeline-handlers.js';
 // Validation pipeline handler (BMAD-003)
 export { handleValidationPipeline, } from './validation-pipeline-handler.js';
 // Hypergraph query handler

package/dist/mcp/handlers/pipeline-handlers.d.ts

@@ -4,13 +4,14 @@
  * Exposes YAML deterministic pipelines through MCP tools:
  * - pipeline_load: Load a pipeline from a YAML string
  * - pipeline_run: Execute a loaded pipeline
+ * - pipeline_status: Read execution and composition evidence
  * - pipeline_list: List all registered pipelines (built-in + YAML)
  * - pipeline_validate: Validate YAML without registering
  */
 import type { ToolResult } from '../types.js';
 import { YamlPipelineLoader } from '../../coordination/yaml-pipeline-loader.js';
 import { YamlPipelineRegistry } from '../../coordination/yaml-pipeline-registry.js';
-import type { WorkflowListItem } from '../../coordination/workflow-types.js';
+import type { ParallelCompositionReceipt, WorkflowListItem, WorkflowStatus } from '../../coordination/workflow-types.js';
 export interface PipelineLoadParams {
     yaml: string;
     variables?: Record<string, unknown>;
@@ -32,6 +33,20 @@ export interface PipelineRunResult {
     pipelineId: string;
     status: string;
 }
+export interface PipelineStatusParams {
+    executionId: string;
+}
+export interface PipelineStatusResult {
+    executionId: string;
+    pipelineId: string;
+    status: WorkflowStatus;
+    progress: number;
+    error?: string;
+    completedSteps: string[];
+    failedSteps: string[];
+    skippedSteps: string[];
+    parallelCompositionReceipts: ParallelCompositionReceipt[];
+}
 export type PipelineListParams = Record<string, never>;
 export interface PipelineListResult {
     pipelines: WorkflowListItem[];
@@ -64,6 +79,8 @@ export declare function handlePipelineLoad(params: PipelineLoadParams): Promise<
  * Execute a previously loaded/registered pipeline.
  */
 export declare function handlePipelineRun(params: PipelineRunParams): Promise<ToolResult<PipelineRunResult>>;
+/** Return composition evidence without exposing raw step outputs. */
+export declare function handlePipelineStatus(params: PipelineStatusParams): Promise<ToolResult<PipelineStatusResult>>;
 /**
  * List all registered pipelines (built-in + YAML).
  */
@@ -72,4 +89,17 @@ export declare function handlePipelineList(_params: PipelineListParams): Promise
  * Validate a YAML pipeline without registering it.
  */
 export declare function handlePipelineValidate(params: PipelineValidateParams): Promise<ToolResult<PipelineValidateResult>>;
+/** Resolve a pending gate on the same orchestrator used by pipeline_run. */
+export interface PipelineApprovalParams {
+    executionId: string;
+    stepId: string;
+    reason?: string;
+}
+export interface PipelineApprovalResult {
+    executionId: string;
+    stepId: string;
+    decision: 'approve' | 'reject';
+}
+export declare function handlePipelineApprove(params: PipelineApprovalParams): Promise<ToolResult<PipelineApprovalResult>>;
+export declare function handlePipelineReject(params: PipelineApprovalParams): Promise<ToolResult<PipelineApprovalResult>>;
 //# sourceMappingURL=pipeline-handlers.d.ts.map

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

@@ -4,6 +4,7 @@
  * Exposes YAML deterministic pipelines through MCP tools:
  * - pipeline_load: Load a pipeline from a YAML string
  * - pipeline_run: Execute a loaded pipeline
+ * - pipeline_status: Read execution and composition evidence
  * - pipeline_list: List all registered pipelines (built-in + YAML)
  * - pipeline_validate: Validate YAML without registering
  */
@@ -129,6 +130,34 @@ export async function handlePipelineRun(params) {
         };
     }
 }
+/** Return composition evidence without exposing raw step outputs. */
+export async function handlePipelineStatus(params) {
+    if (!isFleetInitialized())
+        return { success: false, error: 'Fleet not initialized. Call fleet_init first.' };
+    const { workflowOrchestrator } = getFleetState();
+    if (!workflowOrchestrator)
+        return { success: false, error: 'Workflow orchestrator not available.' };
+    if (!params.executionId || typeof params.executionId !== 'string') {
+        return { success: false, error: "Parameter 'executionId' is required and must be a string." };
+    }
+    const status = workflowOrchestrator.getWorkflowStatus(params.executionId);
+    if (!status)
+        return { success: false, error: `Pipeline execution not found: ${params.executionId}` };
+    return {
+        success: true,
+        data: {
+            executionId: status.executionId,
+            pipelineId: status.workflowId,
+            status: status.status,
+            progress: status.progress,
+            error: status.error,
+            completedSteps: status.completedSteps,
+            failedSteps: status.failedSteps,
+            skippedSteps: status.skippedSteps,
+            parallelCompositionReceipts: status.parallelCompositionReceipts ?? [],
+        },
+    };
+}
 /**
  * List all registered pipelines (built-in + YAML).
  */
@@ -205,4 +234,38 @@ export async function handlePipelineValidate(params) {
         };
     }
 }
+export async function handlePipelineApprove(params) {
+    return resolvePipelineApproval(params, 'approve');
+}
+export async function handlePipelineReject(params) {
+    return resolvePipelineApproval(params, 'reject');
+}
+function resolvePipelineApproval(params, decision) {
+    if (!isFleetInitialized()) {
+        return { success: false, error: 'Fleet not initialized. Call fleet_init first.' };
+    }
+    for (const key of ['executionId', 'stepId']) {
+        if (typeof params[key] !== 'string' || !params[key].trim()) {
+            return { success: false, error: `Parameter '${key}' is required and must be a non-empty string.` };
+        }
+    }
+    if (params.reason !== undefined && typeof params.reason !== 'string') {
+        return { success: false, error: "Parameter 'reason' must be a string." };
+    }
+    const { workflowOrchestrator } = getFleetState();
+    if (!workflowOrchestrator)
+        return { success: false, error: 'Workflow orchestrator not available.' };
+    const execution = workflowOrchestrator.getWorkflowStatus(params.executionId);
+    if (!execution)
+        return { success: false, error: `Execution not found: ${params.executionId}` };
+    if (execution.status !== 'running') {
+        return { success: false, error: `Cannot ${decision} a step while the workflow is ${execution.status}.` };
+    }
+    const accepted = decision === 'approve'
+        ? workflowOrchestrator.approveStep(params.executionId, params.stepId)
+        : workflowOrchestrator.rejectStep(params.executionId, params.stepId, params.reason);
+    if (!accepted)
+        return { success: false, error: 'No pending approval found for this execution and step.' };
+    return { success: true, data: { executionId: params.executionId, stepId: params.stepId, decision } };
+}
 //# sourceMappingURL=pipeline-handlers.js.map

package/dist/mcp/handlers/task-handlers.d.ts

@@ -15,6 +15,7 @@ export declare function handleTaskStatus(params: TaskStatusParams): Promise<Tool
 export declare function handleTaskCancel(params: TaskCancelParams): Promise<ToolResult<{
     taskId: string;
     cancelled: boolean;
+    cancellationResultPending: boolean;
 }>>;
 export interface TaskOrchestrateParams {
     task: string;

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

@@ -47,14 +47,18 @@ export async function handleTaskSubmit(params) {
         }
         // Get task status for response
         const taskStatus = queen.getTaskStatus(result.value);
+        if (!taskStatus) {
+            return { success: false, error: `Task ${result.value} was accepted but its execution status is unavailable.` };
+        }
         return {
             success: true,
             data: {
                 taskId: result.value,
                 type: params.type,
                 priority: params.priority || 'p1',
-                status: taskStatus?.status === 'running' ? 'pending' : 'queued',
-                assignedDomain: taskStatus?.assignedDomain,
+                status: taskStatus.status,
+                error: taskStatus.error,
+                assignedDomain: taskStatus.assignedDomain,
             },
         };
     }
@@ -88,6 +92,7 @@ export async function handleTaskList(params) {
             taskId: execution.taskId,
             type: execution.task.type,
             status: execution.status,
+            cancellationResultPending: execution.cancellationResultPending,
             priority: execution.task.priority,
             assignedDomain: execution.assignedDomain,
             assignedAgents: execution.assignedAgents,
@@ -135,6 +140,7 @@ export async function handleTaskStatus(params) {
             taskId: execution.taskId,
             type: execution.task.type,
             status: execution.status,
+            cancellationResultPending: execution.cancellationResultPending,
             priority: execution.task.priority,
             assignedDomain: execution.assignedDomain,
             assignedAgents: execution.assignedAgents,
@@ -183,6 +189,7 @@ export async function handleTaskCancel(params) {
             data: {
                 taskId: params.taskId,
                 cancelled: true,
+                cancellationResultPending: queen.getTaskStatus(params.taskId)?.cancellationResultPending ?? false,
             },
         };
     }
@@ -780,6 +787,7 @@ export async function handleTaskStatusWithLearning(params) {
             taskId: execution.taskId,
             type: execution.task.type,
             status: execution.status,
+            cancellationResultPending: execution.cancellationResultPending,
             priority: execution.task.priority,
             assignedDomain: execution.assignedDomain,
             assignedAgents: execution.assignedAgents,
@@ -870,13 +878,13 @@ export function subscribeTrajectoryEvents(router) {
     unsubscribeTrajectoryEvents(router);
     const completedId = router.subscribeToEventType('TaskCompleted', async (event) => {
         const { taskId } = event.payload;
-        if (taskId) {
+        if (taskId && getFleetState().queen?.getTaskStatus(taskId)?.status !== 'cancelled') {
             await endTaskTrajectory(taskId, true).catch(() => { });
         }
     });
     const failedId = router.subscribeToEventType('TaskFailed', async (event) => {
         const { taskId, error: errorMsg } = event.payload;
-        if (taskId) {
+        if (taskId && getFleetState().queen?.getTaskStatus(taskId)?.status !== 'cancelled') {
             await endTaskTrajectory(taskId, false, errorMsg).catch(() => { });
         }
     });

package/dist/mcp/protocol-server.d.ts

@@ -39,6 +39,8 @@ export declare class MCPProtocolServer {
      * errors back to future callers.
      */
     private isSuccessfulResult;
+    /** A completed tool can legitimately report a negative domain verdict. */
+    private isFailedToolResult;
     private readonly config;
     private readonly transport;
     private readonly registry;

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') {
@@ -437,20 +459,25 @@ export class MCPProtocolServer {
             // 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;
-            const cacheable = tool.definition.isConcurrencySafe === true && !measuredQualityGate;
+            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,
@@ -459,12 +486,13 @@ export class MCPProtocolServer {
                                 toolName: name,
                             },
                         });
-                        success = true;
+                        success = cachedSuccess;
                         return {
                             content: [{
                                     type: 'text',
                                     text: loopSteeringPrefix ? loopSteeringPrefix + cachedText : cachedText,
                                 }],
+                            ...(cachedSuccess ? {} : { isError: true }),
                         };
                     }
                 }
@@ -474,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
@@ -511,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: [
                     {
@@ -526,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')
@@ -549,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);
@@ -655,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 },
@@ -1248,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',
@@ -1258,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

@@ -433,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;
 }
 /**
@@ -443,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