nexus-agents 2.83.1 → 2.85.0

package/dist/{chunk-J4ZBKE4B.js → chunk-6KZL5DMU.js}

@@ -1,12 +1,13 @@
 import {
   getTokenEnvVars,
   resolveToken
-} from "./chunk-XODXYOFN.js";
+} from "./chunk-ZMERLMEP.js";
 import {
   executeExpert
-} from "./chunk-SZZS57X7.js";
+} from "./chunk-ZF3MSYLG.js";
 import {
   EventTopics,
+  JobStatusSchema,
   NOOP_NOTIFIER,
   RateLimiter,
   abortSignalStorage,
@@ -20,17 +21,27 @@ import {
   getToolAnnotations,
   getToolTimeout,
   isRateLimitError,
+  listJobs,
+  readJobResult,
+  registerIdempotentJob,
+  release,
+  shortCircuitOrFreshJobId,
+  suggestRetryAfterMs,
   toSdkCallback,
   toSdkCallbackWithBudgetCheck,
   toolError,
   toolStructuredError,
   toolSuccess,
   toolSuccessStructured,
+  tryAcquire,
   warnIfSimulatedOutsideTests,
   withAccessPolicy,
   withProgressHeartbeat,
-  wrapToolWithTimeout
-} from "./chunk-ODKIRXN7.js";
+  wrapToolWithTimeout,
+  writeJobComplete,
+  writeJobFailed,
+  writeJobPending
+} from "./chunk-IF6TXCSE.js";
 import {
   REGISTRY_PATH,
   getProjectRoot,
@@ -39,14 +50,14 @@ import {
   normalizeTopicToCanonical,
   savePapersRegistry,
   synthesizeResearch
-} from "./chunk-FHY7I736.js";
+} from "./chunk-QR5KHIZG.js";
 import {
   IssueTriage,
   sanitizeInput
-} from "./chunk-5QJPM5CB.js";
+} from "./chunk-NSOB2WRI.js";
 import {
   generateSecurityPlan
-} from "./chunk-TKGVRHEI.js";
+} from "./chunk-J5S27RQ4.js";
 import {
   analyzeGitHubRepo
 } from "./chunk-HFOQKCD2.js";
@@ -59,27 +70,25 @@ import {
   getContextForTask,
   inferTaskCategory,
   summarizeContextForPrompt
-} from "./chunk-HGPIHDC4.js";
+} from "./chunk-FR3P47J2.js";
 import {
   DEFAULT_RELEVANCE_CONFIG,
   MemoryImportance,
   calculateTextJaccardSimilarity,
-  generateHyphenId,
-  generateUUID,
   getToolMemory
-} from "./chunk-7V367KT4.js";
+} from "./chunk-4SU4Q37U.js";
 import {
   DEFAULT_TASK_TTL_MS,
   DEFAULT_TOOL_RATE_LIMITS,
   clampTaskTtl
-} from "./chunk-4XSCU4B3.js";
+} from "./chunk-OXVOUVKH.js";
 import {
   getAvailabilityCache,
   resolveFallback
-} from "./chunk-W6MLS2UL.js";
+} from "./chunk-4S5GY2MF.js";
 import {
   DEFAULTS
-} from "./chunk-DWOSFYI2.js";
+} from "./chunk-25AQZKMN.js";
 import {
   resolveInsideRoot
 } from "./chunk-NUBSJGQZ.js";
@@ -95,7 +104,11 @@ import {
   getAvailableClis,
   sleep,
   withTimeout
-} from "./chunk-ELRNVADA.js";
+} from "./chunk-RTAIMK6P.js";
+import {
+  generateHyphenId,
+  generateUUID
+} from "./chunk-TRX7CAD5.js";
 import {
   BUILT_IN_EXPERTS,
   BuiltInExpertTypeSchema,
@@ -107,7 +120,7 @@ import {
 } from "./chunk-PQHVC4BD.js";
 import {
   createSessionMemory
-} from "./chunk-UFUR6RBP.js";
+} from "./chunk-LY2KLNXM.js";
 import {
   AGENT_ROUTER_TIMEOUTS,
   API_TIMEOUTS,
@@ -178,11 +191,11 @@ import {
   resolveModelIdentitySync,
   toExpertTaskAnalysisResult,
   withStep
-} from "./chunk-6UI4NKT4.js";
+} from "./chunk-YLMB5MFQ.js";
 import {
   getNexusDataDir,
   nexusDataPath
-} from "./chunk-I2HMWH4R.js";
+} from "./chunk-2WCYG75B.js";
 
 // src/agents/state-machine-types.ts
 var VALID_TRANSITIONS = /* @__PURE__ */ new Map([
@@ -2611,11 +2624,25 @@ function setupExecute(ctx, task) {
   }
   return { valid: true, startTime: getTimeProvider().now() };
 }
-async function runTaskWithTimeout(task, agentId, executeTask) {
+function wireExternalAbort(externalSignal, controller) {
+  if (externalSignal === void 0) return void 0;
+  if (externalSignal.aborted) {
+    controller.abort();
+    return void 0;
+  }
+  const listener = () => {
+    controller.abort();
+  };
+  externalSignal.addEventListener("abort", listener, { once: true });
+  return listener;
+}
+async function runTaskWithTimeout(task, agentId, executeTask, options) {
   const maxDuration = task.constraints?.maxDuration ?? HEARTBEAT_TIMEOUTS.absoluteMaxMs;
   const controller = new AbortController();
   const monitor = getHeartbeatMonitor();
   const sessionId = monitor.startSession(agentId);
+  const externalSignal = options?.externalSignal;
+  const externalAbortListener = wireExternalAbort(externalSignal, controller);
   const healthCheckTimer = setInterval(() => {
     const transition = monitor.getSessionHealth(sessionId);
     if (transition?.changed === true) {
@@ -2643,6 +2670,9 @@ async function runTaskWithTimeout(task, agentId, executeTask) {
   } finally {
     clearInterval(healthCheckTimer);
     monitor.endSession(sessionId);
+    if (externalSignal !== void 0 && externalAbortListener !== void 0) {
+      externalSignal.removeEventListener("abort", externalAbortListener);
+    }
   }
 }
 function handleExecutionFailure(task, result, ctx) {
@@ -2992,6 +3022,14 @@ var BaseAgent = class {
   memoryConfig;
   memoryState = null;
   relevantMemories = [];
+  /**
+   * AbortSignal set by `execute()` when the caller passes one. `complete()`
+   * forwards it onto `CompletionRequest.signal` so the in-flight model call
+   * cancels when the caller's deadline wins a race (#3016/#3040). Set only
+   * for the duration of one execute() and cleared in finally — the field is
+   * single-task scoped and never crosses tasks.
+   */
+  currentExecutionSignal = void 0;
   constructor(options) {
     const validation = BaseAgentOptionsSchema.safeParse(options);
     if (!validation.success) {
@@ -3075,7 +3113,7 @@ var BaseAgent = class {
     this.initialized = true;
     return ok(void 0);
   }
-  async execute(task) {
+  async execute(task, options) {
     const execCtx = buildExecuteFlowContext(this.contextState);
     const setup = setupExecute(execCtx, task);
     if (!setup.valid && setup.error !== void 0) return err(setup.error);
@@ -3084,8 +3122,11 @@ var BaseAgent = class {
     this.budgetTracker.startTask(task.id);
     this.logger.info("Executing task", { taskId: task.id, priority: task.priority });
     const taskMemCtx = buildTaskMemoryContext(this.contextState);
+    this.currentExecutionSignal = options?.signal;
     try {
-      const result = await runTaskWithTimeout(task, this.id, (t) => this.executeTask(t));
+      const result = await runTaskWithTimeout(task, this.id, (t) => this.executeTask(t), {
+        externalSignal: options?.signal
+      });
       if (!result.ok) return handleExecutionFailure(task, result, execCtx);
       this.memoryState = await finalizeSuccessfulExecution(
         task,
@@ -3104,6 +3145,8 @@ var BaseAgent = class {
       );
       this.memoryState = updatedMemoryState;
       return err(agentError);
+    } finally {
+      this.currentExecutionSignal = void 0;
     }
   }
   async handleMessage(msg) {
@@ -3152,7 +3195,8 @@ var BaseAgent = class {
       logger: this.logger,
       newState: "acting"
     });
-    const result = await runModelCompletion(ctx, adapterResult.value, request);
+    const requestWithSignal = request.signal === void 0 && this.currentExecutionSignal !== void 0 ? { ...request, signal: this.currentExecutionSignal } : request;
+    const result = await runModelCompletion(ctx, adapterResult.value, requestWithSignal);
     transitionToState({
       stateMachine: this.stateMachine,
       logger: this.logger,
@@ -20434,9 +20478,10 @@ var StepExecutor = class {
     }
   }
   async runExpertWithTimeout(expert, task, step, timeoutMs, startTime) {
+    const controller = new AbortController();
     try {
       const taskResult = await Promise.race([
-        expert.execute(task),
+        expert.execute(task, { signal: controller.signal }),
         createTimeout(timeoutMs, step.id)
       ]);
       if (!taskResult.ok) {
@@ -20455,6 +20500,8 @@ var StepExecutor = class {
       });
     } catch (error) {
       return this.handleExecutionError(error, step, timeoutMs);
+    } finally {
+      controller.abort();
     }
   }
   handleExecutionError(error, step, timeoutMs) {
@@ -21049,8 +21096,16 @@ var WorkflowEngine = class {
   async loadTemplate(path14) {
     return this.deps.loadWorkflowFile(path14);
   }
-  /** Execute a workflow with inputs. */
-  async execute(workflow, inputs) {
+  /**
+   * Execute a workflow with inputs.
+   *
+   * `options.phaseTimeoutMs` (added in #3017) overrides the per-phase
+   * execution timeout for this run only — wins over both `workflow.timeout`
+   * (set in the template YAML) and the engine's `defaultTimeoutMs`. Used
+   * by the `run_workflow` MCP tool to expose a caller-supplied `timeoutMs`
+   * for known-long templates (e.g. security-audit over a large repo).
+   */
+  async execute(workflow, inputs, options) {
     const inputValidation = this.validateInputs(workflow, inputs);
     if (!inputValidation.ok) {
       return inputValidation;
@@ -21068,19 +21123,21 @@ var WorkflowEngine = class {
     });
     this.executions.set(initResult.executionId, initResult.execution);
     try {
-      return await this.runExecution(
+      return await this.runExecution({
         workflow,
-        planResult.value,
-        initResult.context,
-        initResult.executionId,
-        initResult.startTime
-      );
+        plan: planResult.value,
+        context: initResult.context,
+        executionId: initResult.executionId,
+        startTime: initResult.startTime,
+        ...options?.phaseTimeoutMs !== void 0 ? { phaseTimeoutMs: options.phaseTimeoutMs } : {}
+      });
     } catch (error) {
       return this.handleExecutionError(error, initResult.executionId, workflow.name);
     }
   }
-  async runExecution(workflow, plan, context, executionId, startTime) {
-    const stepResults = await this.executePhases(plan, context, workflow);
+  async runExecution(args) {
+    const { workflow, plan, context, executionId, startTime, phaseTimeoutMs } = args;
+    const stepResults = await this.executePhases(plan, context, workflow, phaseTimeoutMs);
     if (!stepResults.ok) {
       this.updateExecutionStatus(executionId, {
         state: "failed",
@@ -21191,7 +21248,7 @@ var WorkflowEngine = class {
     }
     return ok(void 0);
   }
-  async executePhases(plan, context, workflow) {
+  async executePhases(plan, context, workflow, phaseTimeoutMs) {
     const allResults = [];
     const totalSteps = plan.phases.reduce((sum, p) => sum + p.steps.length, 0);
     let completedSteps = 0;
@@ -21219,7 +21276,7 @@ var WorkflowEngine = class {
       const options = {
         maxConcurrency: this.config.maxConcurrency,
         failFast: true,
-        timeoutMs: workflow.timeout ?? this.config.defaultTimeoutMs
+        timeoutMs: phaseTimeoutMs ?? workflow.timeout ?? this.config.defaultTimeoutMs
       };
       const phaseResult = await this.deps.executePhase(phase.steps, context, options);
       if (!phaseResult.ok) return phaseResult;
@@ -23489,10 +23546,10 @@ function calculateZStatistic(params) {
 function calculateDifferenceCI(p1, p2, total1, total2, confidence) {
   const difference = p1 - p2;
   const seDiff = Math.sqrt(p1 * (1 - p1) / (total1 || 1) + p2 * (1 - p2) / (total2 || 1));
-  const z107 = getZScore(confidence);
+  const z109 = getZScore(confidence);
   return {
-    lower: difference - z107 * seDiff,
-    upper: difference + z107 * seDiff,
+    lower: difference - z109 * seDiff,
+    upper: difference + z109 * seDiff,
     estimate: difference,
     confidence,
     n: total1 + total2,
@@ -23515,11 +23572,11 @@ function proportionConfidenceInterval(successes, total, options = {}) {
       standardError: 0
     };
   }
-  const z107 = getZScore(opts.confidence);
-  const z210 = z107 * z107;
+  const z109 = getZScore(opts.confidence);
+  const z210 = z109 * z109;
   const denominator = 1 + z210 / n;
   const center = (p + z210 / (2 * n)) / denominator;
-  const margin = z107 / denominator * Math.sqrt(p * (1 - p) / n + z210 / (4 * n * n));
+  const margin = z109 / denominator * Math.sqrt(p * (1 - p) / n + z210 / (4 * n * n));
   const lower = Math.max(0, center - margin);
   const upper = Math.min(1, center + margin);
   const standardError = Math.sqrt(p * (1 - p) / n);
@@ -23549,8 +23606,8 @@ function meanConfidenceInterval(values, options = {}) {
   const variance = values.reduce((sum, v) => sum + (v - mean) ** 2, 0) / (n - 1 || 1);
   const stdDev = Math.sqrt(variance);
   const standardError = stdDev / Math.sqrt(n);
-  const z107 = getZScore(opts.confidence);
-  const margin = z107 * standardError;
+  const z109 = getZScore(opts.confidence);
+  const margin = z109 * standardError;
   return {
     lower: mean - margin,
     upper: mean + margin,
@@ -25958,7 +26015,45 @@ import { z as z45 } from "zod";
 var RunWorkflowInputSchema = z45.object({
   template: z45.string().min(1).describe("Workflow template name (e.g., code-review) or file path"),
   inputs: z45.record(z45.string(), z45.unknown()).describe("Workflow inputs as key-value pairs"),
-  dryRun: z45.boolean().optional().default(false).describe("Validate workflow without executing")
+  dryRun: z45.boolean().optional().default(false).describe("Validate workflow without executing"),
+  /**
+   * Per-phase execution timeout in milliseconds (closes #3017). Wins over
+   * both `workflow.timeout` (set in the template YAML) and the engine's
+   * `defaultTimeoutMs`. Use for known-long workflow templates (e.g.,
+   * security-audit over a large repo) where the default phase budget
+   * isn't enough. Bounded to [1s, 30min] to prevent both flapping
+   * cancellations and unbounded hangs that would defeat the
+   * timeout-mismatch telemetry.
+   */
+  timeoutMs: z45.number().int().min(1e3).max(18e5).optional().describe("Per-phase execution timeout in ms (overrides workflow.timeout)"),
+  /**
+   * Async-mode dispatch (#3044, Stage 3 of epic #2631). Default `sync` —
+   * backward-compat invariant; existing callers see no behavior change.
+   * `async` returns `{ status: 'pending', jobId }` immediately; caller
+   * polls `get_job_result(jobId)` for the structured payload. Sidesteps
+   * the MCP-SDK 60s client-request timeout that's the #2631 root cause
+   * (per #2703 telemetry: run_workflow was the gate-firing tool at
+   * 28.6% timeout-shaped errors).
+   *
+   * Per the #3041 vote's binding staging order this lands AFTER
+   * Stage 1's protocol (#3048) was validated on orchestrate. Concurrency
+   * cap is enforced in-process via NEXUS_JOB_MAX_CONCURRENT_RUN_WORKFLOW;
+   * over-cap returns `{ status: 'busy', retryAfterMs }` synchronously.
+   *
+   * Kept optional (no `.default()`) so the inferred type doesn't force
+   * `mode: 'sync'` on every existing call site / test fixture. The
+   * handler treats `undefined` as `'sync'`.
+   */
+  mode: z45.enum(["sync", "async"]).optional().describe('Dispatch mode (default: sync). Use "async" for long-running workflows.'),
+  /**
+   * Idempotency key for async-mode replay-safety (#3042 Stage 1c / epic
+   * #2631). When set: identical (key, inputs) returns the existing job;
+   * same key with different inputs fails closed with
+   * `idempotency_key_collision`. Sync mode ignores this.
+   */
+  idempotencyKey: z45.string().min(1).max(256).optional().describe(
+    "Replay-safe key for async-mode dispatch (#3042 Stage 1c). Same (key, inputs) returns existing jobId."
+  )
 });
 
 // src/mcp/tools/run-workflow.ts
@@ -26158,14 +26253,16 @@ function formatValidationErrors(validation) {
 }
 
 // src/mcp/tools/run-workflow.ts
-async function executeWorkflow(deps, workflow, inputs) {
+import { randomUUID as randomUUID8 } from "crypto";
+async function executeWorkflow(deps, workflow, inputs, options) {
   const { workflowEngine, logger: logger53 } = deps;
   logger53?.info("Executing workflow", {
     workflowName: workflow.name,
-    inputCount: Object.keys(inputs).length
+    inputCount: Object.keys(inputs).length,
+    ...options?.phaseTimeoutMs !== void 0 ? { phaseTimeoutMs: options.phaseTimeoutMs } : {}
   });
   const startTime = getTimeProvider().now();
-  const result = await workflowEngine.execute(workflow, inputs);
+  const result = options?.phaseTimeoutMs !== void 0 ? await workflowEngine.execute(workflow, inputs, { phaseTimeoutMs: options.phaseTimeoutMs }) : await workflowEngine.execute(workflow, inputs);
   if (!result.ok) {
     logger53?.error("Workflow execution failed", result.error, {
       workflowName: workflow.name
@@ -26241,8 +26338,13 @@ function buildFailureEnvelope(workflowName, error) {
   });
 }
 async function handleRunWorkflow(deps, args) {
-  const { template, inputs, dryRun } = args;
-  deps.logger?.debug("run_workflow called", { template, dryRun, inputKeys: Object.keys(inputs) });
+  const { template, inputs, dryRun, timeoutMs } = args;
+  deps.logger?.debug("run_workflow called", {
+    template,
+    dryRun,
+    inputKeys: Object.keys(inputs),
+    ...timeoutMs !== void 0 ? { timeoutMs } : {}
+  });
   const loadResult = await loadWorkflow(deps, template);
   if (!loadResult.ok) {
     return errorResponse(loadResult.error.message);
@@ -26255,7 +26357,12 @@ async function handleRunWorkflow(deps, args) {
   if (!validation.valid) {
     return errorResponse(formatValidationErrors(validation));
   }
-  const executeResult = await executeWorkflow(deps, workflow, inputs);
+  const executeResult = await executeWorkflow(
+    deps,
+    workflow,
+    inputs,
+    timeoutMs !== void 0 ? { phaseTimeoutMs: timeoutMs } : void 0
+  );
   if (!executeResult.ok) {
     recordWorkflowError(template, executeResult.error.message);
     return buildFailureEnvelope(workflow.name, executeResult.error);
@@ -26270,8 +26377,73 @@ async function handleRunWorkflow(deps, args) {
 var toolInputSchema = {
   template: z46.string().min(1).describe("Workflow template name (e.g., code-review) or file path"),
   inputs: z46.record(z46.string().max(100), z46.unknown()).describe("Workflow inputs as key-value pairs"),
-  dryRun: z46.boolean().optional().default(false).describe("Validate workflow without executing")
+  dryRun: z46.boolean().optional().default(false).describe("Validate workflow without executing"),
+  // #3017
+  timeoutMs: z46.number().int().min(1e3).max(18e5).optional().describe("Per-phase execution timeout in ms (overrides workflow.timeout, bound [1s, 30min])"),
+  // #3044 / epic #2631 Stage 3
+  mode: z46.enum(["sync", "async"]).optional().describe(
+    'Dispatch mode (default: sync). "async" returns { jobId } immediately; poll via get_job_result.'
+  )
 };
+function buildRunWorkflowReplayEnvelope(jobId) {
+  return successResponse({
+    status: "replay",
+    jobId,
+    pollTool: "get_job_result",
+    note: "Idempotency key matched a prior dispatch \u2014 poll get_job_result for current status."
+  });
+}
+function buildRunWorkflowCollisionEnvelope(existingJobId) {
+  return errorResponse(
+    `Idempotency key already used with different inputs. Existing jobId: ${existingJobId}. Use a fresh key or omit it.`
+  );
+}
+function dispatchAsyncRunWorkflow(deps, args) {
+  const idempotency = shortCircuitOrFreshJobId({
+    tool: "run_workflow",
+    idempotencyKey: args.idempotencyKey,
+    inputs: args,
+    freshJobId: () => `job-rw-${randomUUID8()}`,
+    replayEnvelope: buildRunWorkflowReplayEnvelope,
+    collisionEnvelope: buildRunWorkflowCollisionEnvelope
+  });
+  if (idempotency.kind === "shortCircuit") return idempotency.value;
+  if (!tryAcquire("run_workflow")) {
+    return successResponse({
+      status: "busy",
+      retryAfterMs: suggestRetryAfterMs("run_workflow"),
+      note: 'Async-mode concurrency cap reached for run_workflow. Retry later or use mode: "sync".'
+    });
+  }
+  const jobId = idempotency.jobId;
+  writeJobPending(jobId, "run_workflow");
+  if (args.idempotencyKey !== void 0 && args.idempotencyKey !== "") {
+    registerIdempotentJob({
+      tool: "run_workflow",
+      idempotencyKey: args.idempotencyKey,
+      inputs: args,
+      jobId
+    });
+  }
+  void (async () => {
+    try {
+      const result = await handleRunWorkflow(deps, args);
+      writeJobComplete(jobId, "run_workflow", result);
+    } catch (err2) {
+      const errObj = err2 instanceof Error ? err2 : new Error(String(err2));
+      deps.logger?.error("Async run_workflow dispatch failed", errObj, { jobId });
+      writeJobFailed(jobId, "run_workflow", errObj.message);
+    } finally {
+      release("run_workflow");
+    }
+  })();
+  return successResponse({
+    status: "pending",
+    jobId,
+    pollTool: "get_job_result",
+    note: 'Poll via get_job_result({ jobId }) until status !== "pending".'
+  });
+}
 function createRunWorkflowHandler(deps) {
   const notifier = deps.notifier ?? NOOP_NOTIFIER;
   return async (args, ctx) => {
@@ -26282,10 +26454,19 @@ function createRunWorkflowHandler(deps) {
     }
     ctx.logger.debug("Running workflow", {
       template: validated.data.template,
-      dryRun: validated.data.dryRun
+      dryRun: validated.data.dryRun,
+      ...validated.data.mode !== void 0 ? { mode: validated.data.mode } : {}
     });
     notifier.info("run_workflow", { event: "workflow_start", template: validated.data.template });
     const startMs = getTimeProvider().now();
+    if (validated.data.mode === "async" && !validated.data.dryRun) {
+      const asyncResult = dispatchAsyncRunWorkflow(deps, validated.data);
+      notifier.info("run_workflow", {
+        event: "workflow_dispatched_async",
+        template: validated.data.template
+      });
+      return asyncResult;
+    }
     const result = await handleRunWorkflow(deps, validated.data);
     if (result.isError !== true) {
       notifier.info("run_workflow", {
@@ -26703,7 +26884,7 @@ async function populateUnifiedContextOnState(state) {
   try {
     const taskCandidate = state["task"];
     if (typeof taskCandidate !== "string" || taskCandidate === "") return;
-    const { getContextForTask: getContextForTask2, inferTaskCategory: inferTaskCategory2 } = await import("./context-retriever-GQRC2MVM.js");
+    const { getContextForTask: getContextForTask2, inferTaskCategory: inferTaskCategory2 } = await import("./context-retriever-3TKV4EEC.js");
     const ctx = await getContextForTask2({
       task: taskCandidate,
       category: inferTaskCategory2(taskCandidate),
@@ -28384,11 +28565,11 @@ function logViolations(context, violations, mode) {
 }
 
 // src/pipeline/task-contract-builders.ts
-import { randomUUID as randomUUID8 } from "crypto";
+import { randomUUID as randomUUID9 } from "crypto";
 function buildBaseTaskContract(input) {
   const now = Date.now();
   return {
-    id: `${input.idPrefix}-${randomUUID8().slice(0, 8)}`,
+    id: `${input.idPrefix}-${randomUUID9().slice(0, 8)}`,
     description: input.task,
     status: "approved",
     analysis: input.analysis,
@@ -28578,7 +28759,7 @@ async function executeOrchestratePipeline(task) {
 }
 
 // src/orchestration/orchestrator-factory.ts
-import { randomUUID as randomUUID9 } from "crypto";
+import { randomUUID as randomUUID10 } from "crypto";
 
 // src/orchestration/orchestrator-adapters.ts
 function generateId2(prefix) {
@@ -28777,7 +28958,7 @@ var WorkflowOrchestratorAdapter = class {
   executions = /* @__PURE__ */ new Map();
   history = [];
   constructor(engine, logger53) {
-    this.id = `workflow-${randomUUID9().slice(0, 8)}`;
+    this.id = `workflow-${randomUUID10().slice(0, 8)}`;
     this.engine = engine;
     this.logger = logger53 ?? createLogger({ component: "WorkflowOrchestratorAdapter" });
   }
@@ -28790,7 +28971,7 @@ var WorkflowOrchestratorAdapter = class {
         )
       );
     }
-    const executionId = randomUUID9();
+    const executionId = randomUUID10();
     const startTime = getTimeProvider().now();
     this.setRunning(executionId);
     try {
@@ -29258,7 +29439,32 @@ var OrchestrateInputSchema = z50.object({
   task: z50.string().min(1).max(5e4).describe("Task description to orchestrate"),
   context: z50.record(z50.string(), z50.unknown()).optional().describe("Additional context for the task"),
   maxIterations: z50.number().min(1).max(50).optional().default(10).describe("Maximum iterations for orchestration"),
-  timeout: z50.number().min(1e3).max(6e5).optional().describe("Timeout in milliseconds for orchestration (default: 300000)")
+  timeout: z50.number().min(1e3).max(6e5).optional().describe("Timeout in milliseconds for orchestration (default: 300000)"),
+  /**
+   * Async-mode dispatch (#3042, Stage 1 of epic #2631). Default `sync` —
+   * backward-compat invariant; existing callers see no behavior change.
+   * `async` returns `{ status: 'pending', jobId }` immediately; caller
+   * polls `get_job_result(jobId)` for the structured payload. Sidesteps
+   * the MCP-SDK 60s client-request timeout that was killing long
+   * orchestrations (#2631 evidence: 28.6% timeout-shaped errors on
+   * `run_workflow` at the gate-firing measurement).
+   *
+   * Kept optional (no `.default()`) so the inferred type doesn't force
+   * `mode: 'sync'` on every existing call site / test fixture. The
+   * handler treats `undefined` as `'sync'`.
+   */
+  mode: z50.enum(["sync", "async"]).optional().describe('Dispatch mode (default: sync). Use "async" for long-running orchestrations.'),
+  /**
+   * Idempotency key for async-mode replay-safety (#3042 Stage 1c / epic
+   * #2631). When set: identical (key, inputs) returns the existing job;
+   * same key with different inputs fails closed with
+   * `idempotency_key_collision`. Without a key, every call gets a fresh
+   * jobId (existing behavior). Sync mode ignores this — sync calls are
+   * synchronous by definition and the caller can dedupe themselves.
+   */
+  idempotencyKey: z50.string().min(1).max(256).optional().describe(
+    "Replay-safe key for async-mode dispatch (#3042 Stage 1c). Same (key, inputs) returns existing jobId; same key + different inputs fails closed."
+  )
 });
 var OrchestrateOutputSchema = z50.object({
   taskId: z50.string().describe("Unique execution ID"),
@@ -29306,7 +29512,13 @@ var ORCHESTRATE_TOOL_SCHEMA = {
   task: z50.string().min(1).max(5e4).describe("Task description to orchestrate"),
   context: z50.record(z50.string(), z50.unknown()).optional().describe("Additional context for the task"),
   maxIterations: z50.number().min(1).max(50).optional().describe("Maximum iterations for orchestration (default: 10)"),
-  timeout: z50.number().min(1e3).max(6e5).optional().describe("Timeout in milliseconds for orchestration (default: 300000)")
+  timeout: z50.number().min(1e3).max(6e5).optional().describe("Timeout in milliseconds for orchestration (default: 300000)"),
+  mode: z50.enum(["sync", "async"]).optional().describe(
+    'Dispatch mode (default: sync). "async" returns { jobId } immediately; poll via get_job_result.'
+  ),
+  idempotencyKey: z50.string().min(1).max(256).optional().describe(
+    "Replay-safe key for async-mode dispatch (#3042 Stage 1c). Same (key, inputs) returns existing jobId."
+  )
 };
 function mapPatternToOrchestratorType(pattern) {
   if (pattern === "puppeteer") return "puppeteer";
@@ -30132,42 +30344,58 @@ async function withWatchdog(role, timeoutMs, task) {
     timeoutMs,
     state: "healthy"
   };
-  const taskPromise = task();
-  let timeoutHandle;
-  const timeoutPromise = new Promise((_, reject) => {
-    timeoutHandle = setTimeout(() => {
+  const controller = new AbortController();
+  const taskPromise = task(controller.signal);
+  const { promise: timeoutPromise, cancel: cancelTimeout } = createTerminationTimer(
+    entry,
+    timeoutMs,
+    controller
+  );
+  const watchdogTimer = startEscalationMonitor(entry, timeoutMs);
+  try {
+    return await Promise.race([taskPromise, timeoutPromise]);
+  } finally {
+    clearInterval(watchdogTimer);
+    cancelTimeout();
+    controller.abort();
+  }
+}
+function createTerminationTimer(entry, timeoutMs, controller) {
+  let handle;
+  const promise = new Promise((_, reject) => {
+    handle = setTimeout(() => {
       entry.state = "terminated";
       logger23.warn("Worker terminated by watchdog", {
-        role,
+        role: entry.role,
         timeoutMs,
         elapsed: getTimeProvider().now() - entry.startMs,
         state: "terminated"
       });
+      controller.abort();
       reject(new Error(`Worker timeout after ${String(timeoutMs)}ms`));
     }, timeoutMs);
   });
-  const watchdogTimer = setInterval(() => {
+  const cancel = () => {
+    if (handle !== void 0) clearTimeout(handle);
+  };
+  return { promise, cancel };
+}
+function startEscalationMonitor(entry, timeoutMs) {
+  return setInterval(() => {
     const newState = evaluateState(entry, getTimeProvider().now());
-    if (newState !== entry.state) {
-      entry.state = newState;
-      if (newState === "warned") {
-        const elapsed = getTimeProvider().now() - entry.startMs;
-        logger23.warn("Worker approaching timeout", {
-          role,
-          elapsed,
-          timeoutMs,
-          percentUsed: Math.round(elapsed / timeoutMs * 100),
-          state: "warned"
-        });
-      }
+    if (newState === entry.state) return;
+    entry.state = newState;
+    if (newState === "warned") {
+      const elapsed = getTimeProvider().now() - entry.startMs;
+      logger23.warn("Worker approaching timeout", {
+        role: entry.role,
+        elapsed,
+        timeoutMs,
+        percentUsed: Math.round(elapsed / timeoutMs * 100),
+        state: "warned"
+      });
     }
   }, WATCHDOG_CHECK_INTERVAL_MS);
-  try {
-    return await Promise.race([taskPromise, timeoutPromise]);
-  } finally {
-    clearInterval(watchdogTimer);
-    if (timeoutHandle !== void 0) clearTimeout(timeoutHandle);
-  }
 }
 
 // src/orchestration/aorchestra/quality-gate.ts
@@ -30557,7 +30785,8 @@ function createWorkerTask(entry, taskIndex, waveNumber, opts) {
         error: "Role auto-disabled after consecutive failures"
       };
     }
-    const staggerMs = taskIndex * opts.staggerDelayMs;
+    const staggerSlot = taskIndex % opts.maxConcurrency;
+    const staggerMs = staggerSlot * opts.staggerDelayMs;
     if (staggerMs > 0) {
       await new Promise((resolve19) => setTimeout(resolve19, staggerMs));
     }
@@ -30676,7 +30905,11 @@ async function executeSafe(opts) {
 async function attemptExecution(entry, executeWorker, priorWaveResults, timeoutMs) {
   const startMs = Date.now();
   try {
-    return await withWatchdog(entry.role, timeoutMs, () => executeWorker(entry, priorWaveResults));
+    return await withWatchdog(
+      entry.role,
+      timeoutMs,
+      (signal) => executeWorker(entry, priorWaveResults, signal)
+    );
   } catch (error) {
     const durationMs = Date.now() - startMs;
     const message = getErrorMessage(error);
@@ -31593,7 +31826,16 @@ function resolveWorkerAdapter(entry, fallback, fallbackCli, perWorkerRouting, lo
   return { adapter: resolved, cliName };
 }
 async function executeOnAdapter(opts) {
-  const { entry, adapter, cliName, taskDescription, learnings, priorWaveResults, workerStartMs } = opts;
+  const {
+    entry,
+    adapter,
+    cliName,
+    taskDescription,
+    learnings,
+    priorWaveResults,
+    workerStartMs,
+    signal
+  } = opts;
   const prompt = composeWorkerPrompt({
     entry,
     taskDescription,
@@ -31603,7 +31845,8 @@ async function executeOnAdapter(opts) {
   try {
     const result = await adapter.complete({
       messages: [{ role: "user", content: prompt }],
-      maxTokens: WORKER_MAX_TOKENS
+      maxTokens: WORKER_MAX_TOKENS,
+      ...signal !== void 0 ? { signal } : {}
     });
     if (!result.ok) {
       return makeErrorResult(entry, workerStartMs, result.error.message, cliName);
@@ -31625,7 +31868,7 @@ async function executeOnAdapter(opts) {
 function createWorkerExecutor(config) {
   const { taskDescription, modelAdapter, logger: logger53, learnings, perWorkerRouting } = config;
   const effectiveFallbackCli = modelAdapter.providerId;
-  return async (entry, priorWaveResults) => {
+  return async (entry, priorWaveResults, signal) => {
     const workerStartMs = getTimeProvider().now();
     const { adapter, cliName } = resolveWorkerAdapter(
       entry,
@@ -31641,7 +31884,8 @@ function createWorkerExecutor(config) {
       taskDescription,
       workerStartMs,
       ...learnings !== void 0 ? { learnings } : {},
-      ...priorWaveResults !== void 0 ? { priorWaveResults } : {}
+      ...priorWaveResults !== void 0 ? { priorWaveResults } : {},
+      ...signal !== void 0 ? { signal } : {}
     });
   };
 }
@@ -31661,7 +31905,7 @@ function resolveAltAdapter(entry, primaryCli, log) {
 function createAltWorkerExecutor(config) {
   const { taskDescription, modelAdapter, logger: log, learnings } = config;
   const primaryCli = modelAdapter.providerId;
-  return async (entry, priorWaveResults) => {
+  return async (entry, priorWaveResults, signal) => {
     const workerStartMs = getTimeProvider().now();
     const alt = resolveAltAdapter(entry, primaryCli, log);
     if (alt === null) {
@@ -31675,7 +31919,8 @@ function createAltWorkerExecutor(config) {
       taskDescription,
       workerStartMs,
       ...learnings !== void 0 ? { learnings } : {},
-      ...priorWaveResults !== void 0 ? { priorWaveResults } : {}
+      ...priorWaveResults !== void 0 ? { priorWaveResults } : {},
+      ...signal !== void 0 ? { signal } : {}
     });
   };
 }
@@ -32744,6 +32989,11 @@ var ProgressLedgerEntrySchema = z55.object({
   /** Why this action was chosen — required so future readers can audit the call. */
   rationale: z55.string().min(1)
 });
+var TaskCancellationSchema = z55.object({
+  requestedAt: z55.iso.datetime(),
+  /** Optional human-readable note carried back to the caller. */
+  reason: z55.string().max(1e3).optional()
+});
 var StructuredTaskStateSchema = z55.object({
   taskId: z55.string().min(1),
   stage: TaskStageSchema,
@@ -32762,6 +33012,40 @@ var StructuredTaskStateSchema = z55.object({
    * for the same backward-compat reason as `taskLedger`.
    */
   progressLedger: z55.array(ProgressLedgerEntrySchema).optional(),
+  /**
+   * Monotonic version counter (#3043 / epic #2631 Stage 2). Increments by
+   * 1 on every write; polling clients use this to detect "I missed a
+   * transition" and resync rather than silently observe a stale snapshot.
+   *
+   * Optional + defaulting-to-0 in the reducer for backward-compat — old
+   * state logs (pre-Stage-2) don't carry it; the reducer treats their
+   * baseline as v0 and starts counting from there.
+   */
+  version: z55.number().int().nonnegative().optional(),
+  /**
+   * Tool result payload (#3043 / epic #2631 Stage 2). Set atomically
+   * via the `result` log event when `stage === 'complete'`. Carries the
+   * same shape the synchronous mode would have returned inline.
+   *
+   * Capped at `TASK_RESULT_MAX_BYTES` at write time; over-cap payloads
+   * are replaced with `{ truncated: true, originalBytes }` so the
+   * cap is observable rather than silent.
+   *
+   * Once Stage 2 (this) ships, Stage 3+ (#3044 / #3045) migrate the
+   * orchestrate / run_workflow / consensus_vote async-mode writers
+   * from the Stage-1 sidecar (`mcp/jobs/job-result-store.ts`) to this
+   * field, then the sidecar files become legacy that the next cleanup
+   * sweep can remove.
+   */
+  result: z55.unknown().optional(),
+  /**
+   * Cancellation marker (#3043 / epic #2631 Stage 2). Set by `cancel_job`
+   * — the running tool checks for this at safe-point boundaries (between
+   * steps, between waves) and aborts via the AbortSignal plumbing from
+   * #3035 / #3038. Append-only by construction (the reducer ignores a
+   * second cancellation event).
+   */
+  cancellation: TaskCancellationSchema.optional(),
   updatedAt: z55.iso.datetime()
 });
 var StructuredTaskLogEntrySchema = z55.discriminatedUnion("event", [
@@ -32809,6 +33093,23 @@ var StructuredTaskLogEntrySchema = z55.discriminatedUnion("event", [
     event: z55.literal("progress_ledger"),
     ts: z55.iso.datetime(),
     entry: ProgressLedgerEntrySchema
+  }),
+  // #3043 / epic #2631 Stage 2 — tool result payload set when stage flips
+  // to 'complete'. Written by appendResult; replayed into state.result.
+  // The payload itself is `unknown` because each tool's result shape is
+  // its own; readers cast after a status check.
+  z55.object({
+    event: z55.literal("result"),
+    ts: z55.iso.datetime(),
+    result: z55.unknown()
+  }),
+  // #3043 / epic #2631 Stage 2 — cancellation marker. Append-only: the
+  // reducer ignores a second cancellation event so a malicious or buggy
+  // double-cancel can't rewrite the requestedAt timestamp.
+  z55.object({
+    event: z55.literal("cancellation"),
+    ts: z55.iso.datetime(),
+    cancellation: TaskCancellationSchema
   })
 ]);
 
@@ -32916,7 +33217,8 @@ function reduceLogEntries(taskId, entries) {
   let state = {
     ...initState,
     decisions: [...initState.decisions],
-    blockers: initState.blockers.map((b) => ({ ...b }))
+    blockers: initState.blockers.map((b) => ({ ...b })),
+    version: initState.version ?? 0
   };
   for (const entry of entries) {
     if (entry === init) continue;
@@ -32924,47 +33226,98 @@ function reduceLogEntries(taskId, entries) {
   }
   return ok(state);
 }
-function applyLogEntry(state, entry) {
+function applyBlockerEvent(state, entry, nextVersion) {
+  if (entry.event === "blocker") {
+    return {
+      ...state,
+      blockers: [...state.blockers, entry.blocker],
+      updatedAt: entry.ts,
+      version: nextVersion
+    };
+  }
+  return {
+    ...state,
+    blockers: state.blockers.map(
+      (b, i) => i === entry.blockerIndex ? { ...b, resolved: entry.resolvedAt } : b
+    ),
+    updatedAt: entry.ts,
+    version: nextVersion
+  };
+}
+function applyReplacementEvent(state, entry, nextVersion) {
   switch (entry.event) {
-    case "init":
-      return state;
-    // init is handled by reduceLogEntries
     case "decision":
       return {
         ...state,
         decisions: [...state.decisions, entry.decision],
-        updatedAt: entry.ts
-      };
-    case "blocker":
-      return {
-        ...state,
-        blockers: [...state.blockers, entry.blocker],
-        updatedAt: entry.ts
-      };
-    case "blocker_resolved":
-      return {
-        ...state,
-        blockers: state.blockers.map(
-          (b, i) => i === entry.blockerIndex ? { ...b, resolved: entry.resolvedAt } : b
-        ),
-        updatedAt: entry.ts
+        updatedAt: entry.ts,
+        version: nextVersion
       };
     case "stage":
-      return { ...state, stage: entry.stage, updatedAt: entry.ts };
+      return { ...state, stage: entry.stage, updatedAt: entry.ts, version: nextVersion };
     case "position":
-      return { ...state, position: entry.position, updatedAt: entry.ts };
+      return { ...state, position: entry.position, updatedAt: entry.ts, version: nextVersion };
     case "task_ledger":
-      return { ...state, taskLedger: entry.ledger, updatedAt: entry.ts };
+      return { ...state, taskLedger: entry.ledger, updatedAt: entry.ts, version: nextVersion };
     case "progress_ledger":
       return {
         ...state,
         progressLedger: [...state.progressLedger ?? [], entry.entry],
-        updatedAt: entry.ts
+        updatedAt: entry.ts,
+        version: nextVersion
       };
   }
 }
+function applyTerminalEvent(state, entry, nextVersion) {
+  if (entry.event === "result") {
+    return { ...state, result: entry.result, updatedAt: entry.ts, version: nextVersion };
+  }
+  return {
+    ...state,
+    cancellation: state.cancellation ?? entry.cancellation,
+    updatedAt: entry.ts,
+    version: nextVersion
+  };
+}
+var EVENT_CATEGORY = {
+  init: "init",
+  blocker: "blocker",
+  blocker_resolved: "blocker",
+  decision: "replace",
+  stage: "replace",
+  position: "replace",
+  task_ledger: "replace",
+  progress_ledger: "replace",
+  result: "terminal",
+  cancellation: "terminal"
+};
+function applyLogEntry(state, entry) {
+  const category = EVENT_CATEGORY[entry.event];
+  if (category === "init") return state;
+  const nextVersion = (state.version ?? 0) + 1;
+  if (category === "blocker") {
+    return applyBlockerEvent(
+      state,
+      entry,
+      nextVersion
+    );
+  }
+  if (category === "terminal") {
+    return applyTerminalEvent(
+      state,
+      entry,
+      nextVersion
+    );
+  }
+  return applyReplacementEvent(
+    state,
+    entry,
+    nextVersion
+  );
+}
 
 // src/mcp/tools/orchestrate.ts
+import { randomUUID as randomUUID11 } from "crypto";
 function generateTaskId() {
   const timestamp = getTimeProvider().now().toString(36);
   const random = getRandomProvider().random().toString(36).substring(2, 8);
@@ -33651,6 +34004,15 @@ function createOrchestrateHandler(deps) {
         message: `Validation error: ${formatZodError(validated.error)}`
       });
     }
+    if (validated.data.mode === "async") {
+      return dispatchAsyncOrchestrate({
+        input: validated.data,
+        deps,
+        notifier,
+        logger: ctx.logger,
+        trustTier: ctx.requestContext.trustTier
+      });
+    }
     try {
       return await withDepthGuard(
         "orchestrate",
@@ -33670,6 +34032,80 @@ function createOrchestrateHandler(deps) {
     }
   };
 }
+function buildReplayEnvelope(jobId) {
+  return toolSuccess(
+    JSON.stringify({
+      status: "replay",
+      jobId,
+      pollTool: "get_job_result",
+      note: "Idempotency key matched a prior dispatch \u2014 poll get_job_result for current status."
+    })
+  );
+}
+function buildCollisionEnvelope(existingJobId) {
+  return toolStructuredError({
+    errorCategory: "validation",
+    message: `Idempotency key already used with different inputs. Existing jobId: ${existingJobId}. Use a fresh key or omit it.`
+  });
+}
+function dispatchAsyncOrchestrate(params) {
+  const idempotency = shortCircuitOrFreshJobId({
+    tool: "orchestrate",
+    idempotencyKey: params.input.idempotencyKey,
+    inputs: params.input,
+    freshJobId: () => `job-orch-${randomUUID11()}`,
+    replayEnvelope: buildReplayEnvelope,
+    collisionEnvelope: buildCollisionEnvelope
+  });
+  if (idempotency.kind === "shortCircuit") return idempotency.value;
+  if (!tryAcquire("orchestrate")) {
+    return toolSuccess(
+      JSON.stringify({
+        status: "busy",
+        retryAfterMs: suggestRetryAfterMs("orchestrate"),
+        note: 'Async-mode concurrency cap reached for orchestrate. Retry later or use mode: "sync".'
+      })
+    );
+  }
+  const jobId = idempotency.jobId;
+  recordPendingAndRegister(jobId, params.input.idempotencyKey, params.input);
+  void runOrchestrateInBackground(jobId, params);
+  return toolSuccess(
+    JSON.stringify({
+      status: "pending",
+      jobId,
+      pollTool: "get_job_result",
+      note: 'Poll via get_job_result({ jobId }) until status !== "pending".'
+    })
+  );
+}
+function recordPendingAndRegister(jobId, key, inputs) {
+  writeJobPending(jobId, "orchestrate");
+  if (key !== void 0 && key !== "") {
+    registerIdempotentJob({ tool: "orchestrate", idempotencyKey: key, inputs, jobId });
+  }
+}
+async function runOrchestrateInBackground(jobId, params) {
+  try {
+    const result = await withDepthGuard(
+      "orchestrate",
+      () => runOrchestratePipeline({
+        input: params.input,
+        deps: params.deps,
+        notifier: params.notifier,
+        logger: params.logger,
+        ...params.trustTier !== void 0 ? { trustTier: params.trustTier } : {}
+      })
+    );
+    writeJobComplete(jobId, "orchestrate", result);
+  } catch (err2) {
+    const errObj = err2 instanceof Error ? err2 : new Error(String(err2));
+    params.logger.error("Async orchestrate dispatch failed", errObj, { jobId });
+    writeJobFailed(jobId, "orchestrate", errObj.message);
+  } finally {
+    release("orchestrate");
+  }
+}
 function registerOrchestrateTool(server, deps) {
   const logger53 = deps.logger ?? createLogger({ tool: "orchestrate" });
   const notifier = deps.notifier ?? createMcpNotifier(server);
@@ -42014,7 +42450,7 @@ async function tryIssueTriage(task) {
   try {
     const issueMatch = task.match(/github\.com\/([^/]+\/[^/]+)\/issues\/(\d+)/);
     if (issueMatch === null) return null;
-    const { createIssueTriage } = await import("./issue-triage-MURMDN2G.js");
+    const { createIssueTriage } = await import("./issue-triage-WUK7L25X.js");
     const triage = createIssueTriage();
     const owner = issueMatch[1] ?? "";
     const num = issueMatch[2] ?? "";
@@ -42042,7 +42478,7 @@ var VALID_TEMPLATES = /* @__PURE__ */ new Set([
 ]);
 async function classifyWithLLM(task) {
   try {
-    const { executeExpert: executeExpert2 } = await import("./expert-bridge-7LPGCPPR.js");
+    const { executeExpert: executeExpert2 } = await import("./expert-bridge-22UVN5TB.js");
     const prompt = [
       "Classify this task into exactly one pipeline template.",
       "Templates: dev (implementation/bug fix/refactor), research (investigate/evaluate/compare),",
@@ -42824,8 +43260,8 @@ var memoryInitPromise = null;
 async function initPipelineMemory() {
   if (cachedMemory !== null) return cachedMemory;
   try {
-    const { createSessionMemory: createSessionMemory2 } = await import("./session-memory-X6SCDFER.js");
-    const { getLearningDir } = await import("./learning-persistence-NX2KHL5T.js");
+    const { createSessionMemory: createSessionMemory2 } = await import("./session-memory-PUJMR6FE.js");
+    const { getLearningDir } = await import("./learning-persistence-5ALG6XRC.js");
     const mem = createSessionMemory2(getLearningDir());
     mem.startSession(`pipeline-${String(getTimeProvider().now())}`);
     cachedMemory = {
@@ -42881,7 +43317,7 @@ function recordRoutingExperience(category, success, durationMs) {
     callRecord(routingMemoryCache);
     return;
   }
-  routingMemoryInitPromise ??= import("./routing-memory-6IEPJ3EP.js").then(({ createRoutingMemory }) => {
+  routingMemoryInitPromise ??= import("./routing-memory-UY6KTGT2.js").then(({ createRoutingMemory }) => {
     routingMemoryCache ??= createRoutingMemory();
     return routingMemoryCache;
   }).catch((error) => {
@@ -42915,7 +43351,7 @@ ${text}` : "";
 }
 async function getWeatherContext() {
   try {
-    const { generateWeatherReport: generateWeatherReport2 } = await import("./weather-report-6BC3JK5H.js");
+    const { generateWeatherReport: generateWeatherReport2 } = await import("./weather-report-RQMZOL7C.js");
     const report = generateWeatherReport2({ includeAdaptive: true });
     const mappings = "recommendedMappings" in report ? report.recommendedMappings : [];
     if (!Array.isArray(mappings) || mappings.length === 0) return "";
@@ -42933,8 +43369,8 @@ ${lines}
 }
 async function getMemoryContext(task) {
   try {
-    const { createSessionMemory: createSessionMemory2 } = await import("./session-memory-X6SCDFER.js");
-    const { getLearningDir } = await import("./learning-persistence-NX2KHL5T.js");
+    const { createSessionMemory: createSessionMemory2 } = await import("./session-memory-PUJMR6FE.js");
+    const { getLearningDir } = await import("./learning-persistence-5ALG6XRC.js");
     const memory = createSessionMemory2(getLearningDir(), { maxLearningsInContext: 10 });
     const learnings = memory.searchLearnings(task.slice(0, 200));
     if (learnings.length === 0) return "";
@@ -43039,7 +43475,7 @@ ${contextBlock}`;
       const strategy = config.votingStrategy ?? "higher_order";
       await postProgress(config, "Vote", `Running consensus with ${strategy} strategy...`);
       try {
-        const { executeVoting } = await import("./consensus-vote-MTLP6E72.js");
+        const { executeVoting } = await import("./consensus-vote-LPYEXUVC.js");
         const votingResult = await executeVoting(
           {
             proposal: plan.slice(0, 4e3),
@@ -43966,7 +44402,7 @@ async function searchCodebaseForTask(task) {
 }
 async function queryResearchRegistry(task) {
   try {
-    const { synthesizeResearch: synthesizeResearch2 } = await import("./research-helpers-synthesize-36QBOKII.js");
+    const { synthesizeResearch: synthesizeResearch2 } = await import("./research-helpers-synthesize-KNRCAIXK.js");
     const topic = task.split(/[.!?\n]/).filter((s) => s.trim().length > 10)[0]?.trim();
     if (topic === void 0) return null;
     const result = await synthesizeResearch2(topic.slice(0, 50));
@@ -44037,7 +44473,7 @@ function createScanStageWrapper() {
       try {
         const slug = ctx.task.match(/([a-zA-Z0-9._-]+\/[a-zA-Z0-9._-]+)/)?.[1];
         if (slug !== void 0) {
-          const { generateSecurityPlan: generateSecurityPlan2 } = await import("./repo-security-plan-N3CDMW6L.js");
+          const { generateSecurityPlan: generateSecurityPlan2 } = await import("./repo-security-plan-THHLNGEQ.js");
           const plan = await generateSecurityPlan2({ repo: slug, maxScanners: 10 });
           const recs = plan.recommendations.slice(0, 5).map((r) => `${r.priority}: ${r.displayName} (${r.category})`).join("; ");
           return output(PIPELINE_STATE_KEYS.FINDINGS, recs, getTimeProvider().now() - start, true);
@@ -45854,12 +46290,144 @@ function registerQueryTaskStateTool(server, deps) {
   logger53.info("Registered query_task_state tool");
 }
 
+// src/mcp/tools/get-job-result-tool.ts
+import { z as z97 } from "zod";
+var GetJobResultInputSchema = z97.object({
+  jobId: z97.string().min(1).max(128).describe('Job ID returned by orchestrate({ mode: "async" })')
+});
+function getJobResultHandler(args) {
+  const parsed = GetJobResultInputSchema.safeParse(args);
+  if (!parsed.success) {
+    return Promise.resolve(
+      toolStructuredError({
+        errorCategory: "validation",
+        message: `Validation error: ${formatZodError(parsed.error)}`
+      })
+    );
+  }
+  const record = readJobResult(parsed.data.jobId);
+  if (record === null) {
+    const response2 = {
+      jobId: parsed.data.jobId,
+      found: false,
+      errorMessage: "Unknown jobId, or the sidecar file is unreadable (corrupt / future schema). Re-check the jobId returned by the async-mode dispatch."
+    };
+    return Promise.resolve(toolSuccess(JSON.stringify(response2, null, 2)));
+  }
+  const response = {
+    jobId: parsed.data.jobId,
+    found: true,
+    record
+  };
+  return Promise.resolve(toolSuccess(JSON.stringify(response, null, 2)));
+}
+function registerGetJobResultTool(server, deps) {
+  const logger53 = deps.logger ?? createLogger({ tool: "get_job_result" });
+  const toolSchema = {
+    jobId: z97.string().min(1).max(128).describe('Job ID returned by orchestrate({ mode: "async" })')
+  };
+  const description2 = 'Read the result of an async-mode tool invocation by jobId. Returns the structured record (status, result | error, timestamps). Poll until status !== "pending". Stage-1 of epic #2631 \u2014 Stage 2 will fold this into query_task_state once StructuredTaskState gains the result field.';
+  const secureHandler = createSecureHandler(getJobResultHandler, {
+    toolName: "get_job_result",
+    rateLimiter: deps.rateLimiter,
+    logger: logger53
+  });
+  const timeoutMs = getToolTimeout("get_job_result", deps.security);
+  const wrappedHandler = wrapToolWithTimeout("get_job_result", secureHandler, {
+    timeoutMs,
+    logger: logger53
+  });
+  server.registerTool(
+    "get_job_result",
+    { description: description2, inputSchema: toolSchema, annotations: getToolAnnotations("get_job_result") },
+    toSdkCallback(wrappedHandler)
+  );
+  logger53.info("Registered get_job_result tool");
+}
+
+// src/mcp/tools/list-jobs-tool.ts
+import { z as z98 } from "zod";
+var MAX_LIST_JOBS_RESULTS = 200;
+var ListJobsInputSchema = z98.object({
+  /**
+   * Filter to jobs from a specific tool (exact match — e.g. `'orchestrate'`).
+   * Omit to list every tool's jobs.
+   */
+  toolName: z98.string().min(1).max(128).optional().describe("Filter to one tool (exact match)."),
+  /**
+   * Filter to jobs in a specific lifecycle state.
+   * Omit to list every state.
+   */
+  status: JobStatusSchema.optional().describe(
+    "Filter to pending | complete | failed | cancelled. Omit for all."
+  ),
+  /**
+   * Maximum summaries to return — capped at MAX_LIST_JOBS_RESULTS (200).
+   * Newest jobs are returned first, so a smaller limit shows the most
+   * recent activity.
+   */
+  limit: z98.number().int().min(1).max(MAX_LIST_JOBS_RESULTS).optional().describe(`Max summaries to return (1-${String(MAX_LIST_JOBS_RESULTS)}, newest first).`)
+});
+function listJobsHandler(args) {
+  const parsed = ListJobsInputSchema.safeParse(args);
+  if (!parsed.success) {
+    return Promise.resolve(
+      toolStructuredError({
+        errorCategory: "validation",
+        message: `Validation error: ${formatZodError(parsed.error)}`
+      })
+    );
+  }
+  const { toolName, status, limit } = parsed.data;
+  const all = listJobs();
+  const filtered = all.filter((j) => {
+    if (toolName !== void 0 && j.toolName !== toolName) return false;
+    if (status !== void 0 && j.status !== status) return false;
+    return true;
+  });
+  const cap = limit ?? MAX_LIST_JOBS_RESULTS;
+  const trimmed = filtered.slice(0, cap);
+  const response = {
+    count: trimmed.length,
+    truncated: filtered.length > trimmed.length,
+    jobs: trimmed
+  };
+  return Promise.resolve(toolSuccess(JSON.stringify(response, null, 2)));
+}
+function registerListJobsTool(server, deps) {
+  const logger53 = deps.logger ?? createLogger({ tool: "list_jobs" });
+  const toolSchema = {
+    toolName: z98.string().min(1).max(128).optional().describe("Filter to one tool (exact match)."),
+    status: JobStatusSchema.optional().describe(
+      "Filter to pending | complete | failed | cancelled. Omit for all."
+    ),
+    limit: z98.number().int().min(1).max(MAX_LIST_JOBS_RESULTS).optional().describe(`Max summaries to return (1-${String(MAX_LIST_JOBS_RESULTS)}, newest first).`)
+  };
+  const description2 = "List async-mode jobs (cross-session discovery). Returns summaries \u2014 jobId, toolName, status, timestamps \u2014 newest first. Filter by toolName / status / limit. Result payloads excluded; fetch via get_job_result(jobId). Stage 5 of epic #2631.";
+  const secureHandler = createSecureHandler(listJobsHandler, {
+    toolName: "list_jobs",
+    rateLimiter: deps.rateLimiter,
+    logger: logger53
+  });
+  const timeoutMs = getToolTimeout("list_jobs", deps.security);
+  const wrappedHandler = wrapToolWithTimeout("list_jobs", secureHandler, {
+    timeoutMs,
+    logger: logger53
+  });
+  server.registerTool(
+    "list_jobs",
+    { description: description2, inputSchema: toolSchema, annotations: getToolAnnotations("list_jobs") },
+    toSdkCallback(wrappedHandler)
+  );
+  logger53.info("Registered list_jobs tool");
+}
+
 // src/mcp/tools/verify-audit-chain-tool.ts
 import * as fs12 from "fs/promises";
 import * as path11 from "path";
-import { z as z97 } from "zod";
-var VerifyAuditChainInputSchema = z97.object({
-  logDir: z97.string().min(1).max(512).describe(
+import { z as z99 } from "zod";
+var VerifyAuditChainInputSchema = z99.object({
+  logDir: z99.string().min(1).max(512).describe(
     "Filesystem path to the FileAuditStorage log directory. Tool reads all `audit-*.jsonl` files in lexicographic order and verifies the combined chain."
   )
 });
@@ -45936,7 +46504,7 @@ async function handler2(args, ctx) {
 function registerVerifyAuditChainTool(server, deps) {
   const logger53 = deps.logger ?? createLogger({ tool: "verify_audit_chain" });
   const toolSchema = {
-    logDir: z97.string().min(1).max(512).describe(
+    logDir: z99.string().min(1).max(512).describe(
       "Filesystem path to the FileAuditStorage log directory. Tool reads all `audit-*.jsonl` files and verifies the combined hash chain."
     )
   };
@@ -45960,18 +46528,18 @@ function registerVerifyAuditChainTool(server, deps) {
 }
 
 // src/mcp/tools/pipeline-tool.ts
-import { z as z98 } from "zod";
+import { z as z100 } from "zod";
 import * as fs13 from "fs";
 import * as path12 from "path";
-var PipelineInputSchema = z98.object({
+var PipelineInputSchema = z100.object({
   /** The task to execute. */
-  task: z98.string().min(5).max(1e4).describe("Task description \u2014 pipeline template auto-selected based on content"),
+  task: z100.string().min(5).max(1e4).describe("Task description \u2014 pipeline template auto-selected based on content"),
   /** Path to a spec file (.md, .yaml) to use as task input. */
-  specFile: z98.string().max(500).optional().describe("Path to a spec file \u2014 content prepended to task for greenfield projects"),
+  specFile: z100.string().max(500).optional().describe("Path to a spec file \u2014 content prepended to task for greenfield projects"),
   /** Override template — see `listTemplateIds()` for the canonical list (#2728). Auto-detected if omitted. */
-  template: z98.string().max(50).optional().describe(`Pipeline template override. Available: ${listTemplateIds().join(", ")}`),
+  template: z100.string().max(50).optional().describe(`Pipeline template override. Available: ${listTemplateIds().join(", ")}`),
   /** Voting strategy for consensus stages. */
-  votingStrategy: z98.enum([
+  votingStrategy: z100.enum([
     "simple_majority",
     "supermajority",
     "unanimous",
@@ -45982,13 +46550,13 @@ var PipelineInputSchema = z98.object({
     "Voting strategy for plan approval. simple_majority (default), supermajority (67%), unanimous, higher_order (Bayesian), proof_of_learning, opinion_wise"
   ),
   /** Use 3 agents instead of 6 for faster voting. */
-  quickMode: z98.boolean().default(false).describe("Use 3 agents instead of 6 for faster consensus voting"),
+  quickMode: z100.boolean().default(false).describe("Use 3 agents instead of 6 for faster consensus voting"),
   /** Maximum execution time per stage in milliseconds (min 30s, max 600s). */
-  timeoutMs: z98.number().int().min(3e4).max(6e5).optional().describe("Max time per stage in ms (30000-600000). Default: varies by stage complexity"),
+  timeoutMs: z100.number().int().min(3e4).max(6e5).optional().describe("Max time per stage in ms (30000-600000). Default: varies by stage complexity"),
   /** Stop after planning/voting (no implementation). */
-  dryRun: z98.boolean().default(false).describe("Stop after vote stage (no implementation)"),
+  dryRun: z100.boolean().default(false).describe("Stop after vote stage (no implementation)"),
   /** TESTS ONLY — random output, must not be used for real decisions. (#2319) */
-  simulateVotes: z98.boolean().default(false).describe("TESTS ONLY \u2014 random output, must not be used for real decisions (#2319)")
+  simulateVotes: z100.boolean().default(false).describe("TESTS ONLY \u2014 random output, must not be used for real decisions (#2319)")
 });
 function buildOutput2(result) {
   return {
@@ -46090,7 +46658,7 @@ function registerPipelineTool(server, deps) {
 }
 
 // src/mcp/tools/supply-chain-tradeoff-panel.ts
-import { z as z99 } from "zod";
+import { z as z101 } from "zod";
 var DEFAULT_AXES = [
   "build_time_determinism",
   "supply_chain_risk",
@@ -46110,16 +46678,16 @@ var FULL_PANEL = [
   "scope_steward"
 ];
 var QUICK_PANEL = ["architect", "security", "scope_steward"];
-var SupplyChainTradeoffPanelInputSchema = z99.object({
-  proposal: z99.string().min(1).max(MAX_PROPOSAL_LENGTH).describe('The proposal under tradeoff review (e.g. "Should aegis-boot adopt cargo-nextest?")'),
-  axes: z99.array(z99.string().min(1).max(MAX_AXIS_NAME_LENGTH)).min(1).max(MAX_AXES).optional().describe(
+var SupplyChainTradeoffPanelInputSchema = z101.object({
+  proposal: z101.string().min(1).max(MAX_PROPOSAL_LENGTH).describe('The proposal under tradeoff review (e.g. "Should aegis-boot adopt cargo-nextest?")'),
+  axes: z101.array(z101.string().min(1).max(MAX_AXIS_NAME_LENGTH)).min(1).max(MAX_AXES).optional().describe(
     `Tradeoff axes to evaluate. Default: ${DEFAULT_AXES.join(", ")}. Custom axes accepted; max ${String(MAX_AXES)}.`
   ),
-  context: z99.string().max(MAX_CONTEXT_LENGTH).optional().describe(
+  context: z101.string().max(MAX_CONTEXT_LENGTH).optional().describe(
     "Optional context: relevant repo state, dependency tree, vendor publishing patterns, etc."
   ),
-  quickMode: z99.boolean().optional().default(false).describe("Use 3 voters (architect, security, scope_steward) instead of 7"),
-  simulate: z99.boolean().optional().default(false).describe("Use simulated voters (testing only)")
+  quickMode: z101.boolean().optional().default(false).describe("Use 3 voters (architect, security, scope_steward) instead of 7"),
+  simulate: z101.boolean().optional().default(false).describe("Use simulated voters (testing only)")
 });
 function buildTradeoffProposal(input) {
   const axes = input.axes ?? DEFAULT_AXES;
@@ -46755,6 +47323,36 @@ var TOOL_ANNOTATIONS = {
       { category: "implicit", description: "Reads the structured task-state log (#2278)" }
     ]
   },
+  get_job_result: {
+    annotations: {
+      title: "Get Job Result",
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false
+    },
+    sideEffects: [
+      {
+        category: "implicit",
+        description: "Reads the async-mode job-result sidecar (#3042 / epic #2631)"
+      }
+    ]
+  },
+  list_jobs: {
+    annotations: {
+      title: "List Jobs",
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false
+    },
+    sideEffects: [
+      {
+        category: "implicit",
+        description: "Lists async-mode job summaries from the sidecar dir (#3046 / epic #2631 Stage 5)"
+      }
+    ]
+  },
   verify_audit_chain: {
     annotations: {
       title: "Verify Audit Chain",
@@ -46971,6 +47569,8 @@ var REGISTERED_TOOL_NAMES = [
   "registry_import",
   "query_trace",
   "query_task_state",
+  "get_job_result",
+  "list_jobs",
   "verify_audit_chain",
   "repo_analyze",
   "repo_security_plan",
@@ -47115,40 +47715,40 @@ var RiskLevel = /* @__PURE__ */ ((RiskLevel2) => {
 })(RiskLevel || {});
 
 // src/mcp/safety/stpa-schemas.ts
-import { z as z100 } from "zod";
-var HazardCategorySchema = z100.enum(HazardCategory);
-var HazardSeveritySchema = z100.enum(HazardSeverity);
-var ConstraintPrioritySchema = z100.enum(ConstraintPriority);
-var RiskLevelSchema = z100.enum(RiskLevel);
-var TriggerPatternSchema = z100.object({
-  parameter: z100.string().min(1),
-  matchType: z100.enum(["contains", "regex", "equals", "startsWith", "endsWith"]),
-  pattern: z100.string(),
-  reason: z100.string()
+import { z as z102 } from "zod";
+var HazardCategorySchema = z102.enum(HazardCategory);
+var HazardSeveritySchema = z102.enum(HazardSeverity);
+var ConstraintPrioritySchema = z102.enum(ConstraintPriority);
+var RiskLevelSchema = z102.enum(RiskLevel);
+var TriggerPatternSchema = z102.object({
+  parameter: z102.string().min(1),
+  matchType: z102.enum(["contains", "regex", "equals", "startsWith", "endsWith"]),
+  pattern: z102.string(),
+  reason: z102.string()
 });
-var HazardSchema = z100.object({
-  id: z100.string().min(1),
-  description: z100.string(),
+var HazardSchema = z102.object({
+  id: z102.string().min(1),
+  description: z102.string(),
   category: HazardCategorySchema,
   severity: HazardSeveritySchema,
-  likelihood: z100.enum(["almost_certain", "likely", "possible", "unlikely", "rare"]),
-  triggerConditions: z100.array(z100.string()),
-  consequences: z100.array(z100.string())
+  likelihood: z102.enum(["almost_certain", "likely", "possible", "unlikely", "rare"]),
+  triggerConditions: z102.array(z102.string()),
+  consequences: z102.array(z102.string())
 });
-var UnsafeControlActionSchema = z100.object({
-  id: z100.string().min(1),
-  toolName: z100.string().min(1),
-  type: z100.enum(["not_provided", "provided_causes_hazard", "wrong_timing", "wrong_duration"]),
-  description: z100.string(),
-  unsafeContext: z100.string(),
-  relatedHazards: z100.array(z100.string()),
-  triggerPatterns: z100.array(TriggerPatternSchema).optional()
+var UnsafeControlActionSchema = z102.object({
+  id: z102.string().min(1),
+  toolName: z102.string().min(1),
+  type: z102.enum(["not_provided", "provided_causes_hazard", "wrong_timing", "wrong_duration"]),
+  description: z102.string(),
+  unsafeContext: z102.string(),
+  relatedHazards: z102.array(z102.string()),
+  triggerPatterns: z102.array(TriggerPatternSchema).optional()
 });
-var SafetyConstraintSchema = z100.object({
-  id: z100.string().min(1),
-  description: z100.string(),
-  mitigates: z100.array(z100.string()),
-  enforcement: z100.enum([
+var SafetyConstraintSchema = z102.object({
+  id: z102.string().min(1),
+  description: z102.string(),
+  mitigates: z102.array(z102.string()),
+  enforcement: z102.enum([
     "prevent",
     "require_confirmation",
     "alert",
@@ -47156,54 +47756,54 @@ var SafetyConstraintSchema = z100.object({
     "rate_limit",
     "require_privilege"
   ]),
-  validationFunction: z100.string().optional(),
+  validationFunction: z102.string().optional(),
   priority: ConstraintPrioritySchema
 });
-var PropertySchemaSchema = z100.object({
-  type: z100.string(),
-  description: z100.string().optional(),
-  enum: z100.array(z100.unknown()).optional(),
-  pattern: z100.string().optional(),
-  minimum: z100.number().optional(),
-  maximum: z100.number().optional()
+var PropertySchemaSchema = z102.object({
+  type: z102.string(),
+  description: z102.string().optional(),
+  enum: z102.array(z102.unknown()).optional(),
+  pattern: z102.string().optional(),
+  minimum: z102.number().optional(),
+  maximum: z102.number().optional()
 });
-var ToolInputSchemaSchema = z100.object({
-  type: z100.string(),
-  properties: z100.record(z100.string(), PropertySchemaSchema).optional(),
-  required: z100.array(z100.string()).optional(),
-  additionalProperties: z100.boolean().optional()
+var ToolInputSchemaSchema = z102.object({
+  type: z102.string(),
+  properties: z102.record(z102.string(), PropertySchemaSchema).optional(),
+  required: z102.array(z102.string()).optional(),
+  additionalProperties: z102.boolean().optional()
 });
-var ToolDefinitionSchema = z100.object({
-  name: z100.string().min(1),
-  description: z100.string(),
+var ToolDefinitionSchema = z102.object({
+  name: z102.string().min(1),
+  description: z102.string(),
   inputSchema: ToolInputSchemaSchema
 });
-var AnalysisConfigurationSchema = z100.object({
-  includeLowSeverity: z100.boolean().default(true),
-  generateAllConstraints: z100.boolean().default(true),
-  checkInteractions: z100.boolean().default(true),
-  maxHazardsPerTool: z100.number().int().min(1).max(100).default(50),
-  categories: z100.array(HazardCategorySchema).default([])
+var AnalysisConfigurationSchema = z102.object({
+  includeLowSeverity: z102.boolean().default(true),
+  generateAllConstraints: z102.boolean().default(true),
+  checkInteractions: z102.boolean().default(true),
+  maxHazardsPerTool: z102.number().int().min(1).max(100).default(50),
+  categories: z102.array(HazardCategorySchema).default([])
 });
-var ConstraintViolationSchema = z100.object({
-  constraintId: z100.string().min(1),
-  constraintDescription: z100.string(),
+var ConstraintViolationSchema = z102.object({
+  constraintId: z102.string().min(1),
+  constraintDescription: z102.string(),
   severity: HazardSeveritySchema,
-  details: z100.string(),
-  remediation: z100.string()
+  details: z102.string(),
+  remediation: z102.string()
 });
-var ValidationWarningSchema = z100.object({
-  code: z100.string().min(1),
-  message: z100.string(),
-  affected: z100.string()
+var ValidationWarningSchema = z102.object({
+  code: z102.string().min(1),
+  message: z102.string(),
+  affected: z102.string()
 });
-var ValidationResultSchema = z100.object({
-  valid: z100.boolean(),
-  toolName: z100.string().min(1),
-  violations: z100.array(ConstraintViolationSchema),
-  passed: z100.array(z100.string()),
-  warnings: z100.array(ValidationWarningSchema),
-  validatedAt: z100.date()
+var ValidationResultSchema = z102.object({
+  valid: z102.boolean(),
+  toolName: z102.string().min(1),
+  violations: z102.array(ConstraintViolationSchema),
+  passed: z102.array(z102.string()),
+  warnings: z102.array(ValidationWarningSchema),
+  validatedAt: z102.date()
 });
 
 // src/mcp/safety/stpa-types.ts
@@ -48288,43 +48888,43 @@ var GeminiResponseParser = class {
 };
 
 // src/cli-adapters/router-types.ts
-import { z as z101 } from "zod";
-var RouterConfigSchema = z101.object({
-  minCapacityThreshold: z101.number().min(0).max(1).default(0.1),
-  preferCostEfficient: z101.boolean().default(false),
-  maxDecisionTimeMs: z101.number().min(1).max(1e3).default(100)
+import { z as z103 } from "zod";
+var RouterConfigSchema = z103.object({
+  minCapacityThreshold: z103.number().min(0).max(1).default(0.1),
+  preferCostEfficient: z103.boolean().default(false),
+  maxDecisionTimeMs: z103.number().min(1).max(1e3).default(100)
 });
 
 // src/cli-adapters/agreement-cascade-types.ts
-import { z as z102 } from "zod";
-var AgreementCascadeConfigSchema = z102.object({
-  agreementThreshold: z102.number().min(0.5).max(1).default(0.7),
-  maxStages: z102.number().int().min(1).max(5).default(3),
-  modelTimeoutMs: z102.number().int().min(1e3).max(3e5).default(6e4)
+import { z as z104 } from "zod";
+var AgreementCascadeConfigSchema = z104.object({
+  agreementThreshold: z104.number().min(0.5).max(1).default(0.7),
+  maxStages: z104.number().int().min(1).max(5).default(3),
+  modelTimeoutMs: z104.number().int().min(1e3).max(3e5).default(6e4)
 });
 
 // src/cli-adapters/agreement-cascade-router.ts
 var logger43 = createLogger({ component: "agreement-cascade-router" });
 
 // src/cli-adapters/task-classifier.ts
-import { z as z103 } from "zod";
-var ClassificationPatternsSchema = z103.object({
-  code: z103.array(z103.string()).readonly(),
-  research: z103.array(z103.string()).readonly(),
-  documentation: z103.array(z103.string()).readonly(),
-  analysis: z103.array(z103.string()).readonly()
+import { z as z105 } from "zod";
+var ClassificationPatternsSchema = z105.object({
+  code: z105.array(z105.string()).readonly(),
+  research: z105.array(z105.string()).readonly(),
+  documentation: z105.array(z105.string()).readonly(),
+  analysis: z105.array(z105.string()).readonly()
 });
 
 // src/cli-adapters/response-cache-types.ts
-import { z as z104 } from "zod";
-var ResponseCacheConfigSchema = z104.object({
-  defaultTTL: z104.number().min(1e3).max(36e5).default(3e5),
+import { z as z106 } from "zod";
+var ResponseCacheConfigSchema = z106.object({
+  defaultTTL: z106.number().min(1e3).max(36e5).default(3e5),
   // 5 minutes
-  maxEntries: z104.number().min(10).max(1e5).default(1e3),
-  maxMemoryMB: z104.number().min(1).max(1e3).default(50),
-  cleanupInterval: z104.number().min(1e3).max(6e5).default(6e4),
+  maxEntries: z106.number().min(10).max(1e5).default(1e3),
+  maxMemoryMB: z106.number().min(1).max(1e3).default(50),
+  cleanupInterval: z106.number().min(1e3).max(6e5).default(6e4),
   // 1 minute
-  enableLogging: z104.boolean().default(false)
+  enableLogging: z106.boolean().default(false)
 });
 
 // src/cli-adapters/response-cache-utils.ts
@@ -48332,12 +48932,12 @@ import { createHash as createHash4 } from "crypto";
 var logger44 = createLogger({ component: "ResponseCacheUtils" });
 
 // src/cli-adapters/unified-routing-types.ts
-import { z as z105 } from "zod";
-var UnifiedRoutingDecisionSchema = z105.object({
-  selectedCli: z105.string(),
-  confidence: z105.number().min(0).max(1),
-  reason: z105.string(),
-  strategy: z105.enum([
+import { z as z107 } from "zod";
+var UnifiedRoutingDecisionSchema = z107.object({
+  selectedCli: z107.string(),
+  confidence: z107.number().min(0).max(1),
+  reason: z107.string(),
+  strategy: z107.enum([
     "composite",
     "quality",
     "budget",
@@ -48349,57 +48949,57 @@ var UnifiedRoutingDecisionSchema = z105.object({
     "linucb",
     "direct"
   ]),
-  decisionTimeMs: z105.number().nonnegative(),
-  alternatives: z105.array(z105.string()).readonly(),
-  stagesExecuted: z105.array(z105.string()).readonly(),
-  withinBudget: z105.boolean().optional(),
-  estimatedComplexity: z105.enum(["simple", "moderate", "complex", "expert"]).optional(),
-  estimatedTokens: z105.number().int().positive().optional(),
-  topsisScore: z105.number().optional(),
-  ucbScore: z105.number().optional(),
-  resolvedAtStage: z105.number().int().nonnegative().optional(),
-  consensusReached: z105.boolean().optional(),
-  agreementScore: z105.number().min(0).max(1).optional(),
-  metadata: z105.record(z105.string(), z105.unknown()).optional()
+  decisionTimeMs: z107.number().nonnegative(),
+  alternatives: z107.array(z107.string()).readonly(),
+  stagesExecuted: z107.array(z107.string()).readonly(),
+  withinBudget: z107.boolean().optional(),
+  estimatedComplexity: z107.enum(["simple", "moderate", "complex", "expert"]).optional(),
+  estimatedTokens: z107.number().int().positive().optional(),
+  topsisScore: z107.number().optional(),
+  ucbScore: z107.number().optional(),
+  resolvedAtStage: z107.number().int().nonnegative().optional(),
+  consensusReached: z107.boolean().optional(),
+  agreementScore: z107.number().min(0).max(1).optional(),
+  metadata: z107.record(z107.string(), z107.unknown()).optional()
 });
 
 // src/learning/outcome-feedback-types.ts
-import { z as z106 } from "zod";
-var QualitySignalsSchema = z106.object({
-  testsPass: z106.boolean().optional(),
-  lintErrors: z106.number().int().min(0).optional(),
-  userApproved: z106.boolean().optional(),
-  retryCount: z106.number().int().min(0).default(0),
-  completionRatio: z106.number().min(0).max(1).default(1),
-  validStructure: z106.boolean().optional(),
-  coherenceScore: z106.number().min(0).max(1).optional()
+import { z as z108 } from "zod";
+var QualitySignalsSchema = z108.object({
+  testsPass: z108.boolean().optional(),
+  lintErrors: z108.number().int().min(0).optional(),
+  userApproved: z108.boolean().optional(),
+  retryCount: z108.number().int().min(0).default(0),
+  completionRatio: z108.number().min(0).max(1).default(1),
+  validStructure: z108.boolean().optional(),
+  coherenceScore: z108.number().min(0).max(1).optional()
 });
-var RoutingDecisionSchema = z106.object({
-  id: z106.uuid(),
-  timestamp: z106.iso.datetime(),
-  query: z106.string(),
-  routerType: z106.enum(["linucb", "preference", "quality", "cascade", "topsis"]),
-  selectedModel: z106.string(),
-  selectedTier: z106.enum(["strong", "weak"]).optional(),
-  armIndex: z106.number().int().min(0).optional(),
-  banditContext: z106.record(z106.string(), z106.unknown()).optional(),
-  queryFeatures: z106.record(z106.string(), z106.unknown()).optional(),
-  ucbScore: z106.number().optional(),
-  confidence: z106.number().min(0).max(1).optional(),
-  traceId: z106.string(),
-  domain: z106.string().optional()
+var RoutingDecisionSchema = z108.object({
+  id: z108.uuid(),
+  timestamp: z108.iso.datetime(),
+  query: z108.string(),
+  routerType: z108.enum(["linucb", "preference", "quality", "cascade", "topsis"]),
+  selectedModel: z108.string(),
+  selectedTier: z108.enum(["strong", "weak"]).optional(),
+  armIndex: z108.number().int().min(0).optional(),
+  banditContext: z108.record(z108.string(), z108.unknown()).optional(),
+  queryFeatures: z108.record(z108.string(), z108.unknown()).optional(),
+  ucbScore: z108.number().optional(),
+  confidence: z108.number().min(0).max(1).optional(),
+  traceId: z108.string(),
+  domain: z108.string().optional()
 });
-var TaskOutcomeSchema = z106.object({
-  routingDecisionId: z106.uuid(),
-  timestamp: z106.iso.datetime(),
-  outcomeClass: z106.enum(["success", "partial", "failure", "timeout", "error"]),
-  success: z106.boolean(),
-  qualityScore: z106.number().min(0).max(1),
-  durationMs: z106.number().min(0),
-  tokenUsage: z106.number().int().min(0),
-  errorMessage: z106.string().optional(),
+var TaskOutcomeSchema = z108.object({
+  routingDecisionId: z108.uuid(),
+  timestamp: z108.iso.datetime(),
+  outcomeClass: z108.enum(["success", "partial", "failure", "timeout", "error"]),
+  success: z108.boolean(),
+  qualityScore: z108.number().min(0).max(1),
+  durationMs: z108.number().min(0),
+  tokenUsage: z108.number().int().min(0),
+  errorMessage: z108.string().optional(),
   qualitySignals: QualitySignalsSchema,
-  traceId: z106.string()
+  traceId: z108.string()
 });
 var DEFAULT_FEEDBACK_COLLECTOR_CONFIG = {
   maxPendingDecisions: 1e3,
@@ -48414,21 +49014,21 @@ var DEFAULT_FEEDBACK_COLLECTOR_CONFIG = {
   targetTokenUsage: 2e3,
   maxHistorySize: 1e4
 };
-var FeedbackCollectorConfigSchema = z106.object({
-  maxPendingDecisions: z106.number().int().positive().default(1e3),
-  pendingTimeoutMs: z106.number().positive().default(3e5),
-  enableAutoReward: z106.boolean().default(true),
-  qualityWeight: z106.number().min(0).max(1).default(0.5),
-  speedWeight: z106.number().min(0).max(1).default(0.2),
-  efficiencyWeight: z106.number().min(0).max(1).default(0.2),
-  retryPenalty: z106.number().min(0).max(1).default(0.1),
-  targetDurationMs: z106.number().positive().default(5e3),
-  targetTokenUsage: z106.number().positive().default(2e3),
-  maxHistorySize: z106.number().int().positive().default(1e4)
+var FeedbackCollectorConfigSchema = z108.object({
+  maxPendingDecisions: z108.number().int().positive().default(1e3),
+  pendingTimeoutMs: z108.number().positive().default(3e5),
+  enableAutoReward: z108.boolean().default(true),
+  qualityWeight: z108.number().min(0).max(1).default(0.5),
+  speedWeight: z108.number().min(0).max(1).default(0.2),
+  efficiencyWeight: z108.number().min(0).max(1).default(0.2),
+  retryPenalty: z108.number().min(0).max(1).default(0.1),
+  targetDurationMs: z108.number().positive().default(5e3),
+  targetTokenUsage: z108.number().positive().default(2e3),
+  maxHistorySize: z108.number().int().positive().default(1e4)
 });
 
 // src/learning/outcome-feedback-helpers.ts
-import { randomUUID as randomUUID10 } from "crypto";
+import { randomUUID as randomUUID12 } from "crypto";
 function countOutcomesByClass(outcomes) {
   const counts = {
     success: 0,
@@ -48481,7 +49081,7 @@ function generateRewardExplanation(outcome, reward) {
 }
 function createRoutingDecision(params) {
   return {
-    id: randomUUID10(),
+    id: randomUUID12(),
     timestamp: getTimeProvider().nowIso(),
     ...params
   };
@@ -48737,7 +49337,7 @@ var DEFAULT_FEEDBACK_INTEGRATION_CONFIG = {
 };
 
 // src/learning/feedback-integration.ts
-import { randomUUID as randomUUID11 } from "crypto";
+import { randomUUID as randomUUID13 } from "crypto";
 var STEP_QUALITY_SCORING = {
   /** Base score for successful steps. */
   successBase: 0.8,
@@ -48813,8 +49413,8 @@ var FeedbackIntegration = class {
     });
   }
   recordRoutingDecision(decision, traceId) {
-    const id = randomUUID11();
-    const trace = traceId ?? randomUUID11();
+    const id = randomUUID13();
+    const trace = traceId ?? randomUUID13();
     const now = getTimeProvider().now();
     this.evictStaleEntriesThrottled(now);
     if (this.decisionMap.size >= MAX_DECISION_MAP_SIZE) {
@@ -48887,7 +49487,7 @@ var FeedbackIntegration = class {
     } = params;
     const outcomeClass = this.determineOutcomeClass(success, qualityScore);
     const completionRatio = success ? 1 : qualityScore / this.config.successQualityThreshold;
-    const trace = traceId ?? randomUUID11();
+    const trace = traceId ?? randomUUID13();
     const outcome = {
       routingDecisionId,
       timestamp: getTimeProvider().nowIso(),
@@ -50041,7 +50641,7 @@ var GitHubTaskTracker = class {
   cachedProvider = null;
   async getProvider() {
     if (this.cachedProvider !== null) return this.cachedProvider;
-    const { createScmProvider } = await import("./factory-3XB5CAAA.js");
+    const { createScmProvider } = await import("./factory-JNXETBS4.js");
     const result = await createScmProvider({ repo: this.config.repo ?? "" });
     if (!result.ok) throw new Error(`SCM provider error: ${result.error.message}`);
     this.cachedProvider = result.value;
@@ -50668,6 +51268,8 @@ export {
   QueryTraceInputSchema,
   registerQueryTraceTool,
   registerQueryTaskStateTool,
+  registerGetJobResultTool,
+  registerListJobsTool,
   AuditError,
   AuditCategorySchema,
   AuditSeveritySchema,
@@ -50751,4 +51353,4 @@ export {
   detectBackend,
   createTaskTracker
 };
-//# sourceMappingURL=chunk-J4ZBKE4B.js.map
+//# sourceMappingURL=chunk-6KZL5DMU.js.map