nexus-agents 2.85.0 → 2.86.0

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

@@ -38,10 +38,11 @@ import {
   withAccessPolicy,
   withProgressHeartbeat,
   wrapToolWithTimeout,
+  writeJobCancelled,
   writeJobComplete,
   writeJobFailed,
   writeJobPending
-} from "./chunk-IF6TXCSE.js";
+} from "./chunk-EHBSXLX6.js";
 import {
   REGISTRY_PATH,
   getProjectRoot,
@@ -81,7 +82,7 @@ import {
   DEFAULT_TASK_TTL_MS,
   DEFAULT_TOOL_RATE_LIMITS,
   clampTaskTtl
-} from "./chunk-OXVOUVKH.js";
+} from "./chunk-QOOYL3B3.js";
 import {
   getAvailabilityCache,
   resolveFallback
@@ -23546,10 +23547,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 z109 = getZScore(confidence);
+  const z110 = getZScore(confidence);
   return {
-    lower: difference - z109 * seDiff,
-    upper: difference + z109 * seDiff,
+    lower: difference - z110 * seDiff,
+    upper: difference + z110 * seDiff,
     estimate: difference,
     confidence,
     n: total1 + total2,
@@ -23572,11 +23573,11 @@ function proportionConfidenceInterval(successes, total, options = {}) {
       standardError: 0
     };
   }
-  const z109 = getZScore(opts.confidence);
-  const z210 = z109 * z109;
+  const z110 = getZScore(opts.confidence);
+  const z210 = z110 * z110;
   const denominator = 1 + z210 / n;
   const center = (p + z210 / (2 * n)) / denominator;
-  const margin = z109 / denominator * Math.sqrt(p * (1 - p) / n + z210 / (4 * n * n));
+  const margin = z110 / 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);
@@ -23606,8 +23607,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 z109 = getZScore(opts.confidence);
-  const margin = z109 * standardError;
+  const z110 = getZScore(opts.confidence);
+  const margin = z110 * standardError;
   return {
     lower: mean - margin,
     upper: mean + margin,
@@ -43475,7 +43476,7 @@ ${contextBlock}`;
       const strategy = config.votingStrategy ?? "higher_order";
       await postProgress(config, "Vote", `Running consensus with ${strategy} strategy...`);
       try {
-        const { executeVoting } = await import("./consensus-vote-LPYEXUVC.js");
+        const { executeVoting } = await import("./consensus-vote-K7HSOLYR.js");
         const votingResult = await executeVoting(
           {
             proposal: plan.slice(0, 4e3),
@@ -46422,12 +46423,90 @@ function registerListJobsTool(server, deps) {
   logger53.info("Registered list_jobs tool");
 }
 
+// src/mcp/tools/cancel-job-tool.ts
+import { z as z99 } from "zod";
+var CancelJobInputSchema = z99.object({
+  jobId: z99.string().min(1).max(128).describe("Job ID returned by orchestrate / run_workflow / consensus_vote in async mode"),
+  reason: z99.string().max(1e3).optional().describe('Optional human-readable note (e.g. "user clicked cancel").')
+});
+function cancelJobHandler(args) {
+  const parsed = CancelJobInputSchema.safeParse(args);
+  if (!parsed.success) {
+    return Promise.resolve(
+      toolStructuredError({
+        errorCategory: "validation",
+        message: `Validation error: ${formatZodError(parsed.error)}`
+      })
+    );
+  }
+  const { jobId, reason } = parsed.data;
+  const existing = readJobResult(jobId);
+  if (existing === null) {
+    const response2 = {
+      jobId,
+      outcome: "unknown_job",
+      message: `No job record found for jobId "${jobId}". The job may never have been dispatched, or the sidecar file is unreadable.`
+    };
+    return Promise.resolve(toolSuccess(JSON.stringify(response2, null, 2)));
+  }
+  if (existing.status === "complete" || existing.status === "failed") {
+    const response2 = {
+      jobId,
+      outcome: "already_complete",
+      status: existing.status,
+      message: `Job already terminated with status "${existing.status}" \u2014 cancel is a no-op.`
+    };
+    return Promise.resolve(toolSuccess(JSON.stringify(response2, null, 2)));
+  }
+  if (existing.status === "cancelled") {
+    const response2 = {
+      jobId,
+      outcome: "already_cancelled",
+      status: "cancelled",
+      message: "Job is already cancelled \u2014 second cancel is an idempotent no-op."
+    };
+    return Promise.resolve(toolSuccess(JSON.stringify(response2, null, 2)));
+  }
+  writeJobCancelled(jobId, existing.toolName, reason);
+  const response = {
+    jobId,
+    outcome: "cancelled",
+    status: "cancelled",
+    message: `Job ${jobId} marked cancelled. In-flight work in the dispatching process aborts via AbortSignal; cross-process workers need to poll get_job_result to observe.`
+  };
+  return Promise.resolve(toolSuccess(JSON.stringify(response, null, 2)));
+}
+function registerCancelJobTool(server, deps) {
+  const logger53 = deps.logger ?? createLogger({ tool: "cancel_job" });
+  const toolSchema = {
+    jobId: z99.string().min(1).max(128).describe("Job ID returned by orchestrate / run_workflow / consensus_vote in async mode"),
+    reason: z99.string().max(1e3).optional().describe('Optional human-readable note (e.g. "user clicked cancel").')
+  };
+  const description2 = "Mark an async-mode job as cancelled (#3042 Stage 1b / epic #2631). Same-process dispatcher unwinds via AbortSignal (#3035/#3038); cross-process workers observe via get_job_result. Idempotent \u2014 cancel-after-complete is a no-op (preserves the terminal record); second cancel returns already_cancelled.";
+  const secureHandler = createSecureHandler(cancelJobHandler, {
+    toolName: "cancel_job",
+    rateLimiter: deps.rateLimiter,
+    logger: logger53
+  });
+  const timeoutMs = getToolTimeout("cancel_job", deps.security);
+  const wrappedHandler = wrapToolWithTimeout("cancel_job", secureHandler, {
+    timeoutMs,
+    logger: logger53
+  });
+  server.registerTool(
+    "cancel_job",
+    { description: description2, inputSchema: toolSchema, annotations: getToolAnnotations("cancel_job") },
+    toSdkCallback(wrappedHandler)
+  );
+  logger53.info("Registered cancel_job tool");
+}
+
 // src/mcp/tools/verify-audit-chain-tool.ts
 import * as fs12 from "fs/promises";
 import * as path11 from "path";
-import { z as z99 } from "zod";
-var VerifyAuditChainInputSchema = z99.object({
-  logDir: z99.string().min(1).max(512).describe(
+import { z as z100 } from "zod";
+var VerifyAuditChainInputSchema = z100.object({
+  logDir: z100.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."
   )
 });
@@ -46504,7 +46583,7 @@ async function handler2(args, ctx) {
 function registerVerifyAuditChainTool(server, deps) {
   const logger53 = deps.logger ?? createLogger({ tool: "verify_audit_chain" });
   const toolSchema = {
-    logDir: z99.string().min(1).max(512).describe(
+    logDir: z100.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."
     )
   };
@@ -46528,18 +46607,18 @@ function registerVerifyAuditChainTool(server, deps) {
 }
 
 // src/mcp/tools/pipeline-tool.ts
-import { z as z100 } from "zod";
+import { z as z101 } from "zod";
 import * as fs13 from "fs";
 import * as path12 from "path";
-var PipelineInputSchema = z100.object({
+var PipelineInputSchema = z101.object({
   /** The task to execute. */
-  task: z100.string().min(5).max(1e4).describe("Task description \u2014 pipeline template auto-selected based on content"),
+  task: z101.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: z100.string().max(500).optional().describe("Path to a spec file \u2014 content prepended to task for greenfield projects"),
+  specFile: z101.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: z100.string().max(50).optional().describe(`Pipeline template override. Available: ${listTemplateIds().join(", ")}`),
+  template: z101.string().max(50).optional().describe(`Pipeline template override. Available: ${listTemplateIds().join(", ")}`),
   /** Voting strategy for consensus stages. */
-  votingStrategy: z100.enum([
+  votingStrategy: z101.enum([
     "simple_majority",
     "supermajority",
     "unanimous",
@@ -46550,13 +46629,13 @@ var PipelineInputSchema = z100.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: z100.boolean().default(false).describe("Use 3 agents instead of 6 for faster consensus voting"),
+  quickMode: z101.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: z100.number().int().min(3e4).max(6e5).optional().describe("Max time per stage in ms (30000-600000). Default: varies by stage complexity"),
+  timeoutMs: z101.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: z100.boolean().default(false).describe("Stop after vote stage (no implementation)"),
+  dryRun: z101.boolean().default(false).describe("Stop after vote stage (no implementation)"),
   /** TESTS ONLY — 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)")
+  simulateVotes: z101.boolean().default(false).describe("TESTS ONLY \u2014 random output, must not be used for real decisions (#2319)")
 });
 function buildOutput2(result) {
   return {
@@ -46658,7 +46737,7 @@ function registerPipelineTool(server, deps) {
 }
 
 // src/mcp/tools/supply-chain-tradeoff-panel.ts
-import { z as z101 } from "zod";
+import { z as z102 } from "zod";
 var DEFAULT_AXES = [
   "build_time_determinism",
   "supply_chain_risk",
@@ -46678,16 +46757,16 @@ var FULL_PANEL = [
   "scope_steward"
 ];
 var QUICK_PANEL = ["architect", "security", "scope_steward"];
-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(
+var SupplyChainTradeoffPanelInputSchema = z102.object({
+  proposal: z102.string().min(1).max(MAX_PROPOSAL_LENGTH).describe('The proposal under tradeoff review (e.g. "Should aegis-boot adopt cargo-nextest?")'),
+  axes: z102.array(z102.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: z101.string().max(MAX_CONTEXT_LENGTH).optional().describe(
+  context: z102.string().max(MAX_CONTEXT_LENGTH).optional().describe(
     "Optional context: relevant repo state, dependency tree, vendor publishing patterns, etc."
   ),
-  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)")
+  quickMode: z102.boolean().optional().default(false).describe("Use 3 voters (architect, security, scope_steward) instead of 7"),
+  simulate: z102.boolean().optional().default(false).describe("Use simulated voters (testing only)")
 });
 function buildTradeoffProposal(input) {
   const axes = input.axes ?? DEFAULT_AXES;
@@ -47353,6 +47432,25 @@ var TOOL_ANNOTATIONS = {
       }
     ]
   },
+  cancel_job: {
+    annotations: {
+      title: "Cancel Job",
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false
+    },
+    sideEffects: [
+      {
+        category: "explicit",
+        description: "Writes cancellation record to the async-mode sidecar (#3042 Stage 1b)"
+      },
+      {
+        category: "coupling",
+        description: "Triggers AbortSignal unwind in same-process dispatcher (cross-process workers must poll)"
+      }
+    ]
+  },
   verify_audit_chain: {
     annotations: {
       title: "Verify Audit Chain",
@@ -47571,6 +47669,7 @@ var REGISTERED_TOOL_NAMES = [
   "query_task_state",
   "get_job_result",
   "list_jobs",
+  "cancel_job",
   "verify_audit_chain",
   "repo_analyze",
   "repo_security_plan",
@@ -47715,40 +47814,40 @@ var RiskLevel = /* @__PURE__ */ ((RiskLevel2) => {
 })(RiskLevel || {});
 
 // src/mcp/safety/stpa-schemas.ts
-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()
+import { z as z103 } from "zod";
+var HazardCategorySchema = z103.enum(HazardCategory);
+var HazardSeveritySchema = z103.enum(HazardSeverity);
+var ConstraintPrioritySchema = z103.enum(ConstraintPriority);
+var RiskLevelSchema = z103.enum(RiskLevel);
+var TriggerPatternSchema = z103.object({
+  parameter: z103.string().min(1),
+  matchType: z103.enum(["contains", "regex", "equals", "startsWith", "endsWith"]),
+  pattern: z103.string(),
+  reason: z103.string()
 });
-var HazardSchema = z102.object({
-  id: z102.string().min(1),
-  description: z102.string(),
+var HazardSchema = z103.object({
+  id: z103.string().min(1),
+  description: z103.string(),
   category: HazardCategorySchema,
   severity: HazardSeveritySchema,
-  likelihood: z102.enum(["almost_certain", "likely", "possible", "unlikely", "rare"]),
-  triggerConditions: z102.array(z102.string()),
-  consequences: z102.array(z102.string())
+  likelihood: z103.enum(["almost_certain", "likely", "possible", "unlikely", "rare"]),
+  triggerConditions: z103.array(z103.string()),
+  consequences: z103.array(z103.string())
 });
-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 UnsafeControlActionSchema = z103.object({
+  id: z103.string().min(1),
+  toolName: z103.string().min(1),
+  type: z103.enum(["not_provided", "provided_causes_hazard", "wrong_timing", "wrong_duration"]),
+  description: z103.string(),
+  unsafeContext: z103.string(),
+  relatedHazards: z103.array(z103.string()),
+  triggerPatterns: z103.array(TriggerPatternSchema).optional()
 });
-var SafetyConstraintSchema = z102.object({
-  id: z102.string().min(1),
-  description: z102.string(),
-  mitigates: z102.array(z102.string()),
-  enforcement: z102.enum([
+var SafetyConstraintSchema = z103.object({
+  id: z103.string().min(1),
+  description: z103.string(),
+  mitigates: z103.array(z103.string()),
+  enforcement: z103.enum([
     "prevent",
     "require_confirmation",
     "alert",
@@ -47756,54 +47855,54 @@ var SafetyConstraintSchema = z102.object({
     "rate_limit",
     "require_privilege"
   ]),
-  validationFunction: z102.string().optional(),
+  validationFunction: z103.string().optional(),
   priority: ConstraintPrioritySchema
 });
-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 PropertySchemaSchema = z103.object({
+  type: z103.string(),
+  description: z103.string().optional(),
+  enum: z103.array(z103.unknown()).optional(),
+  pattern: z103.string().optional(),
+  minimum: z103.number().optional(),
+  maximum: z103.number().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 ToolInputSchemaSchema = z103.object({
+  type: z103.string(),
+  properties: z103.record(z103.string(), PropertySchemaSchema).optional(),
+  required: z103.array(z103.string()).optional(),
+  additionalProperties: z103.boolean().optional()
 });
-var ToolDefinitionSchema = z102.object({
-  name: z102.string().min(1),
-  description: z102.string(),
+var ToolDefinitionSchema = z103.object({
+  name: z103.string().min(1),
+  description: z103.string(),
   inputSchema: ToolInputSchemaSchema
 });
-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 AnalysisConfigurationSchema = z103.object({
+  includeLowSeverity: z103.boolean().default(true),
+  generateAllConstraints: z103.boolean().default(true),
+  checkInteractions: z103.boolean().default(true),
+  maxHazardsPerTool: z103.number().int().min(1).max(100).default(50),
+  categories: z103.array(HazardCategorySchema).default([])
 });
-var ConstraintViolationSchema = z102.object({
-  constraintId: z102.string().min(1),
-  constraintDescription: z102.string(),
+var ConstraintViolationSchema = z103.object({
+  constraintId: z103.string().min(1),
+  constraintDescription: z103.string(),
   severity: HazardSeveritySchema,
-  details: z102.string(),
-  remediation: z102.string()
+  details: z103.string(),
+  remediation: z103.string()
 });
-var ValidationWarningSchema = z102.object({
-  code: z102.string().min(1),
-  message: z102.string(),
-  affected: z102.string()
+var ValidationWarningSchema = z103.object({
+  code: z103.string().min(1),
+  message: z103.string(),
+  affected: z103.string()
 });
-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()
+var ValidationResultSchema = z103.object({
+  valid: z103.boolean(),
+  toolName: z103.string().min(1),
+  violations: z103.array(ConstraintViolationSchema),
+  passed: z103.array(z103.string()),
+  warnings: z103.array(ValidationWarningSchema),
+  validatedAt: z103.date()
 });
 
 // src/mcp/safety/stpa-types.ts
@@ -48888,43 +48987,43 @@ var GeminiResponseParser = class {
 };
 
 // src/cli-adapters/router-types.ts
-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)
+import { z as z104 } from "zod";
+var RouterConfigSchema = z104.object({
+  minCapacityThreshold: z104.number().min(0).max(1).default(0.1),
+  preferCostEfficient: z104.boolean().default(false),
+  maxDecisionTimeMs: z104.number().min(1).max(1e3).default(100)
 });
 
 // src/cli-adapters/agreement-cascade-types.ts
-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)
+import { z as z105 } from "zod";
+var AgreementCascadeConfigSchema = z105.object({
+  agreementThreshold: z105.number().min(0.5).max(1).default(0.7),
+  maxStages: z105.number().int().min(1).max(5).default(3),
+  modelTimeoutMs: z105.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 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()
+import { z as z106 } from "zod";
+var ClassificationPatternsSchema = z106.object({
+  code: z106.array(z106.string()).readonly(),
+  research: z106.array(z106.string()).readonly(),
+  documentation: z106.array(z106.string()).readonly(),
+  analysis: z106.array(z106.string()).readonly()
 });
 
 // src/cli-adapters/response-cache-types.ts
-import { z as z106 } from "zod";
-var ResponseCacheConfigSchema = z106.object({
-  defaultTTL: z106.number().min(1e3).max(36e5).default(3e5),
+import { z as z107 } from "zod";
+var ResponseCacheConfigSchema = z107.object({
+  defaultTTL: z107.number().min(1e3).max(36e5).default(3e5),
   // 5 minutes
-  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),
+  maxEntries: z107.number().min(10).max(1e5).default(1e3),
+  maxMemoryMB: z107.number().min(1).max(1e3).default(50),
+  cleanupInterval: z107.number().min(1e3).max(6e5).default(6e4),
   // 1 minute
-  enableLogging: z106.boolean().default(false)
+  enableLogging: z107.boolean().default(false)
 });
 
 // src/cli-adapters/response-cache-utils.ts
@@ -48932,12 +49031,12 @@ import { createHash as createHash4 } from "crypto";
 var logger44 = createLogger({ component: "ResponseCacheUtils" });
 
 // src/cli-adapters/unified-routing-types.ts
-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([
+import { z as z108 } from "zod";
+var UnifiedRoutingDecisionSchema = z108.object({
+  selectedCli: z108.string(),
+  confidence: z108.number().min(0).max(1),
+  reason: z108.string(),
+  strategy: z108.enum([
     "composite",
     "quality",
     "budget",
@@ -48949,57 +49048,57 @@ var UnifiedRoutingDecisionSchema = z107.object({
     "linucb",
     "direct"
   ]),
-  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()
+  decisionTimeMs: z108.number().nonnegative(),
+  alternatives: z108.array(z108.string()).readonly(),
+  stagesExecuted: z108.array(z108.string()).readonly(),
+  withinBudget: z108.boolean().optional(),
+  estimatedComplexity: z108.enum(["simple", "moderate", "complex", "expert"]).optional(),
+  estimatedTokens: z108.number().int().positive().optional(),
+  topsisScore: z108.number().optional(),
+  ucbScore: z108.number().optional(),
+  resolvedAtStage: z108.number().int().nonnegative().optional(),
+  consensusReached: z108.boolean().optional(),
+  agreementScore: z108.number().min(0).max(1).optional(),
+  metadata: z108.record(z108.string(), z108.unknown()).optional()
 });
 
 // src/learning/outcome-feedback-types.ts
-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()
+import { z as z109 } from "zod";
+var QualitySignalsSchema = z109.object({
+  testsPass: z109.boolean().optional(),
+  lintErrors: z109.number().int().min(0).optional(),
+  userApproved: z109.boolean().optional(),
+  retryCount: z109.number().int().min(0).default(0),
+  completionRatio: z109.number().min(0).max(1).default(1),
+  validStructure: z109.boolean().optional(),
+  coherenceScore: z109.number().min(0).max(1).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 RoutingDecisionSchema = z109.object({
+  id: z109.uuid(),
+  timestamp: z109.iso.datetime(),
+  query: z109.string(),
+  routerType: z109.enum(["linucb", "preference", "quality", "cascade", "topsis"]),
+  selectedModel: z109.string(),
+  selectedTier: z109.enum(["strong", "weak"]).optional(),
+  armIndex: z109.number().int().min(0).optional(),
+  banditContext: z109.record(z109.string(), z109.unknown()).optional(),
+  queryFeatures: z109.record(z109.string(), z109.unknown()).optional(),
+  ucbScore: z109.number().optional(),
+  confidence: z109.number().min(0).max(1).optional(),
+  traceId: z109.string(),
+  domain: z109.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(),
+var TaskOutcomeSchema = z109.object({
+  routingDecisionId: z109.uuid(),
+  timestamp: z109.iso.datetime(),
+  outcomeClass: z109.enum(["success", "partial", "failure", "timeout", "error"]),
+  success: z109.boolean(),
+  qualityScore: z109.number().min(0).max(1),
+  durationMs: z109.number().min(0),
+  tokenUsage: z109.number().int().min(0),
+  errorMessage: z109.string().optional(),
   qualitySignals: QualitySignalsSchema,
-  traceId: z108.string()
+  traceId: z109.string()
 });
 var DEFAULT_FEEDBACK_COLLECTOR_CONFIG = {
   maxPendingDecisions: 1e3,
@@ -49014,17 +49113,17 @@ var DEFAULT_FEEDBACK_COLLECTOR_CONFIG = {
   targetTokenUsage: 2e3,
   maxHistorySize: 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)
+var FeedbackCollectorConfigSchema = z109.object({
+  maxPendingDecisions: z109.number().int().positive().default(1e3),
+  pendingTimeoutMs: z109.number().positive().default(3e5),
+  enableAutoReward: z109.boolean().default(true),
+  qualityWeight: z109.number().min(0).max(1).default(0.5),
+  speedWeight: z109.number().min(0).max(1).default(0.2),
+  efficiencyWeight: z109.number().min(0).max(1).default(0.2),
+  retryPenalty: z109.number().min(0).max(1).default(0.1),
+  targetDurationMs: z109.number().positive().default(5e3),
+  targetTokenUsage: z109.number().positive().default(2e3),
+  maxHistorySize: z109.number().int().positive().default(1e4)
 });
 
 // src/learning/outcome-feedback-helpers.ts
@@ -51270,6 +51369,7 @@ export {
   registerQueryTaskStateTool,
   registerGetJobResultTool,
   registerListJobsTool,
+  registerCancelJobTool,
   AuditError,
   AuditCategorySchema,
   AuditSeveritySchema,
@@ -51353,4 +51453,4 @@ export {
   detectBackend,
   createTaskTracker
 };
-//# sourceMappingURL=chunk-6KZL5DMU.js.map
+//# sourceMappingURL=chunk-RZNED4KY.js.map