nexus-agents 2.83.0 → 2.83.1

package/dist/{chunk-PMLVZXAE.js → chunk-J4ZBKE4B.js}

@@ -1,10 +1,10 @@
 import {
   getTokenEnvVars,
   resolveToken
-} from "./chunk-Z64MSLEK.js";
+} from "./chunk-XODXYOFN.js";
 import {
   executeExpert
-} from "./chunk-NLPMYBIV.js";
+} from "./chunk-SZZS57X7.js";
 import {
   EventTopics,
   NOOP_NOTIFIER,
@@ -30,7 +30,7 @@ import {
   withAccessPolicy,
   withProgressHeartbeat,
   wrapToolWithTimeout
-} from "./chunk-4BXQ2OZY.js";
+} from "./chunk-ODKIRXN7.js";
 import {
   REGISTRY_PATH,
   getProjectRoot,
@@ -39,14 +39,14 @@ import {
   normalizeTopicToCanonical,
   savePapersRegistry,
   synthesizeResearch
-} from "./chunk-AFPHR72D.js";
+} from "./chunk-FHY7I736.js";
 import {
   IssueTriage,
   sanitizeInput
-} from "./chunk-BZUEUD4G.js";
+} from "./chunk-5QJPM5CB.js";
 import {
   generateSecurityPlan
-} from "./chunk-RVRXKNND.js";
+} from "./chunk-TKGVRHEI.js";
 import {
   analyzeGitHubRepo
 } from "./chunk-HFOQKCD2.js";
@@ -59,7 +59,7 @@ import {
   getContextForTask,
   inferTaskCategory,
   summarizeContextForPrompt
-} from "./chunk-3GJAAENS.js";
+} from "./chunk-HGPIHDC4.js";
 import {
   DEFAULT_RELEVANCE_CONFIG,
   MemoryImportance,
@@ -67,19 +67,19 @@ import {
   generateHyphenId,
   generateUUID,
   getToolMemory
-} from "./chunk-YO27YAEX.js";
+} from "./chunk-7V367KT4.js";
 import {
   DEFAULT_TASK_TTL_MS,
   DEFAULT_TOOL_RATE_LIMITS,
   clampTaskTtl
-} from "./chunk-AINOJRZX.js";
+} from "./chunk-4XSCU4B3.js";
 import {
   getAvailabilityCache,
   resolveFallback
-} from "./chunk-3WUVWZUC.js";
+} from "./chunk-W6MLS2UL.js";
 import {
   DEFAULTS
-} from "./chunk-ZM5JKJHI.js";
+} from "./chunk-DWOSFYI2.js";
 import {
   resolveInsideRoot
 } from "./chunk-NUBSJGQZ.js";
@@ -87,7 +87,7 @@ import {
   STOPWORDS,
   capitalizeWords,
   truncateWithInfo
-} from "./chunk-633WH2ML.js";
+} from "./chunk-6T3EPABN.js";
 import {
   CliDetectionCache,
   asRecord,
@@ -95,7 +95,7 @@ import {
   getAvailableClis,
   sleep,
   withTimeout
-} from "./chunk-FHGDJKCZ.js";
+} from "./chunk-ELRNVADA.js";
 import {
   BUILT_IN_EXPERTS,
   BuiltInExpertTypeSchema,
@@ -107,7 +107,7 @@ import {
 } from "./chunk-PQHVC4BD.js";
 import {
   createSessionMemory
-} from "./chunk-U6LDVJS7.js";
+} from "./chunk-UFUR6RBP.js";
 import {
   AGENT_ROUTER_TIMEOUTS,
   API_TIMEOUTS,
@@ -178,7 +178,7 @@ import {
   resolveModelIdentitySync,
   toExpertTaskAnalysisResult,
   withStep
-} from "./chunk-RXVH52UI.js";
+} from "./chunk-6UI4NKT4.js";
 import {
   getNexusDataDir,
   nexusDataPath
@@ -21086,7 +21086,12 @@ var WorkflowEngine = class {
         state: "failed",
         error: stepResults.error.message
       });
-      return stepResults;
+      const elapsedMs = getTimeProvider().now() - startTime;
+      const innerErr = stepResults.error;
+      const enriched = new WorkflowError(innerErr.message, {
+        context: { ...innerErr.context ?? {}, executionId, durationMs: elapsedMs }
+      });
+      return err(enriched);
     }
     const result = {
       executionId,
@@ -23484,10 +23489,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 z108 = getZScore(confidence);
+  const z107 = getZScore(confidence);
   return {
-    lower: difference - z108 * seDiff,
-    upper: difference + z108 * seDiff,
+    lower: difference - z107 * seDiff,
+    upper: difference + z107 * seDiff,
     estimate: difference,
     confidence,
     n: total1 + total2,
@@ -23510,11 +23515,11 @@ function proportionConfidenceInterval(successes, total, options = {}) {
       standardError: 0
     };
   }
-  const z108 = getZScore(opts.confidence);
-  const z210 = z108 * z108;
+  const z107 = getZScore(opts.confidence);
+  const z210 = z107 * z107;
   const denominator = 1 + z210 / n;
   const center = (p + z210 / (2 * n)) / denominator;
-  const margin = z108 / denominator * Math.sqrt(p * (1 - p) / n + z210 / (4 * n * n));
+  const margin = z107 / 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);
@@ -23544,8 +23549,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 z108 = getZScore(opts.confidence);
-  const margin = z108 * standardError;
+  const z107 = getZScore(opts.confidence);
+  const margin = z107 * standardError;
   return {
     lower: mean - margin,
     upper: mean + margin,
@@ -26129,14 +26134,14 @@ function successResponse(data) {
 function errorResponse(message) {
   return toolError(message);
 }
-function createFailedResult(workflowName, errorMessage) {
+function createFailedResult(workflowName, errorMessage, opts = {}) {
   const result = {
-    executionId: "unknown",
+    executionId: opts.executionId ?? "unknown",
     workflowName,
     status: "failed",
     stepResults: [],
     output: null,
-    durationMs: 0,
+    durationMs: opts.durationMs ?? 0,
     error: errorMessage
   };
   return toolStructuredError({
@@ -26226,6 +26231,15 @@ function recordWorkflowError(template, errorMessage) {
     });
   }
 }
+function buildFailureEnvelope(workflowName, error) {
+  const ctx = error.context;
+  const executionId = typeof ctx?.["executionId"] === "string" ? ctx["executionId"] : void 0;
+  const durationMs = typeof ctx?.["durationMs"] === "number" ? ctx["durationMs"] : void 0;
+  return createFailedResult(workflowName, error.message, {
+    ...executionId !== void 0 ? { executionId } : {},
+    ...durationMs !== void 0 ? { durationMs } : {}
+  });
+}
 async function handleRunWorkflow(deps, args) {
   const { template, inputs, dryRun } = args;
   deps.logger?.debug("run_workflow called", { template, dryRun, inputKeys: Object.keys(inputs) });
@@ -26244,7 +26258,7 @@ async function handleRunWorkflow(deps, args) {
   const executeResult = await executeWorkflow(deps, workflow, inputs);
   if (!executeResult.ok) {
     recordWorkflowError(template, executeResult.error.message);
-    return createFailedResult(workflow.name, executeResult.error.message);
+    return buildFailureEnvelope(workflow.name, executeResult.error);
   }
   recordWorkflowSuccess(
     template,
@@ -26689,7 +26703,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-QY4FNTDZ.js");
+    const { getContextForTask: getContextForTask2, inferTaskCategory: inferTaskCategory2 } = await import("./context-retriever-GQRC2MVM.js");
     const ctx = await getContextForTask2({
       task: taskCandidate,
       category: inferTaskCategory2(taskCandidate),
@@ -42000,7 +42014,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-Y77JI7WF.js");
+    const { createIssueTriage } = await import("./issue-triage-MURMDN2G.js");
     const triage = createIssueTriage();
     const owner = issueMatch[1] ?? "";
     const num = issueMatch[2] ?? "";
@@ -42028,7 +42042,7 @@ var VALID_TEMPLATES = /* @__PURE__ */ new Set([
 ]);
 async function classifyWithLLM(task) {
   try {
-    const { executeExpert: executeExpert2 } = await import("./expert-bridge-FHPWDFJX.js");
+    const { executeExpert: executeExpert2 } = await import("./expert-bridge-7LPGCPPR.js");
     const prompt = [
       "Classify this task into exactly one pipeline template.",
       "Templates: dev (implementation/bug fix/refactor), research (investigate/evaluate/compare),",
@@ -42810,7 +42824,7 @@ var memoryInitPromise = null;
 async function initPipelineMemory() {
   if (cachedMemory !== null) return cachedMemory;
   try {
-    const { createSessionMemory: createSessionMemory2 } = await import("./session-memory-WARRGYY7.js");
+    const { createSessionMemory: createSessionMemory2 } = await import("./session-memory-X6SCDFER.js");
     const { getLearningDir } = await import("./learning-persistence-NX2KHL5T.js");
     const mem = createSessionMemory2(getLearningDir());
     mem.startSession(`pipeline-${String(getTimeProvider().now())}`);
@@ -42867,7 +42881,7 @@ function recordRoutingExperience(category, success, durationMs) {
     callRecord(routingMemoryCache);
     return;
   }
-  routingMemoryInitPromise ??= import("./routing-memory-QRIJPRVD.js").then(({ createRoutingMemory }) => {
+  routingMemoryInitPromise ??= import("./routing-memory-6IEPJ3EP.js").then(({ createRoutingMemory }) => {
     routingMemoryCache ??= createRoutingMemory();
     return routingMemoryCache;
   }).catch((error) => {
@@ -42901,7 +42915,7 @@ ${text}` : "";
 }
 async function getWeatherContext() {
   try {
-    const { generateWeatherReport: generateWeatherReport2 } = await import("./weather-report-RACZWJQL.js");
+    const { generateWeatherReport: generateWeatherReport2 } = await import("./weather-report-6BC3JK5H.js");
     const report = generateWeatherReport2({ includeAdaptive: true });
     const mappings = "recommendedMappings" in report ? report.recommendedMappings : [];
     if (!Array.isArray(mappings) || mappings.length === 0) return "";
@@ -42919,7 +42933,7 @@ ${lines}
 }
 async function getMemoryContext(task) {
   try {
-    const { createSessionMemory: createSessionMemory2 } = await import("./session-memory-WARRGYY7.js");
+    const { createSessionMemory: createSessionMemory2 } = await import("./session-memory-X6SCDFER.js");
     const { getLearningDir } = await import("./learning-persistence-NX2KHL5T.js");
     const memory = createSessionMemory2(getLearningDir(), { maxLearningsInContext: 10 });
     const learnings = memory.searchLearnings(task.slice(0, 200));
@@ -43025,7 +43039,7 @@ ${contextBlock}`;
       const strategy = config.votingStrategy ?? "higher_order";
       await postProgress(config, "Vote", `Running consensus with ${strategy} strategy...`);
       try {
-        const { executeVoting } = await import("./consensus-vote-KZ6UURUI.js");
+        const { executeVoting } = await import("./consensus-vote-MTLP6E72.js");
         const votingResult = await executeVoting(
           {
             proposal: plan.slice(0, 4e3),
@@ -43952,7 +43966,7 @@ async function searchCodebaseForTask(task) {
 }
 async function queryResearchRegistry(task) {
   try {
-    const { synthesizeResearch: synthesizeResearch2 } = await import("./research-helpers-synthesize-PVP6JRZV.js");
+    const { synthesizeResearch: synthesizeResearch2 } = await import("./research-helpers-synthesize-36QBOKII.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));
@@ -44023,7 +44037,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-RHSLO7H6.js");
+          const { generateSecurityPlan: generateSecurityPlan2 } = await import("./repo-security-plan-N3CDMW6L.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);
@@ -48292,100 +48306,25 @@ var AgreementCascadeConfigSchema = z102.object({
 // src/cli-adapters/agreement-cascade-router.ts
 var logger43 = createLogger({ component: "agreement-cascade-router" });
 
-// src/cli-adapters/daao-types.ts
-import { z as z103 } from "zod";
-var EncodedFeaturesSchema = z103.object({
-  /** Lexical complexity score (vocabulary diversity, rare words) */
-  lexicalComplexity: z103.number().min(0).max(1),
-  /** Syntactic complexity score (sentence structure, nesting) */
-  syntacticComplexity: z103.number().min(0).max(1),
-  /** Semantic density score (concept density, abstraction level) */
-  semanticDensity: z103.number().min(0).max(1),
-  /** Technical specificity (domain-specific terminology) */
-  technicalSpecificity: z103.number().min(0).max(1),
-  /** Task scope (breadth of requirements) */
-  taskScope: z103.number().min(0).max(1),
-  /** Constraint complexity (constraints, edge cases, requirements) */
-  constraintComplexity: z103.number().min(0).max(1),
-  /** Ambiguity level (inverse - higher means more clear/specific) */
-  clarity: z103.number().min(0).max(1),
-  /** Output complexity expectation */
-  outputComplexity: z103.number().min(0).max(1)
-});
-var FeatureWeightsSchema = z103.object({
-  lexicalComplexity: z103.number().min(0).max(1),
-  syntacticComplexity: z103.number().min(0).max(1),
-  semanticDensity: z103.number().min(0).max(1),
-  technicalSpecificity: z103.number().min(0).max(1),
-  taskScope: z103.number().min(0).max(1),
-  constraintComplexity: z103.number().min(0).max(1),
-  clarity: z103.number().min(0).max(1),
-  outputComplexity: z103.number().min(0).max(1)
-});
-var DEFAULT_FEATURE_WEIGHTS = {
-  lexicalComplexity: 0.1,
-  syntacticComplexity: 0.1,
-  semanticDensity: 0.15,
-  technicalSpecificity: 0.15,
-  taskScope: 0.15,
-  constraintComplexity: 0.15,
-  clarity: 0.1,
-  // Inverted - high clarity reduces difficulty
-  outputComplexity: 0.1
-};
-var DEFAULT_DAAO_THRESHOLDS = {
-  easyUpperBound: 0.35,
-  hardLowerBound: 0.65
-};
-var DEFAULT_DAAO_TIER_TO_CLIS = {
-  fast: ["gemini", "codex", "opencode", "claude"],
-  balanced: ["codex", "opencode", "gemini", "claude"],
-  powerful: ["claude", "codex", "opencode", "gemini"]
-};
-var DAAOConfigSchema = z103.object({
-  /** Difficulty thresholds for level classification */
-  thresholds: z103.object({
-    easyUpperBound: z103.number().min(0).max(1),
-    hardLowerBound: z103.number().min(0).max(1)
-  }).default(DEFAULT_DAAO_THRESHOLDS),
-  /** Feature weights for difficulty aggregation */
-  weights: FeatureWeightsSchema.default(DEFAULT_FEATURE_WEIGHTS),
-  /** Mapping from model tier to CLI preference order */
-  tierToClis: z103.record(
-    z103.enum(["fast", "balanced", "powerful"]),
-    z103.array(z103.enum(["claude", "gemini", "codex", "opencode"]))
-  ).default(DEFAULT_DAAO_TIER_TO_CLIS),
-  /** Enable adaptive calibration from outcomes */
-  enableCalibration: z103.boolean().default(true),
-  /** Maximum outcomes to store for calibration */
-  maxCalibrationOutcomes: z103.number().int().positive().default(1e3),
-  /** Minimum outcomes before applying calibration adjustments */
-  minCalibrationOutcomes: z103.number().int().positive().default(50),
-  /** Reconstruction error threshold for typical patterns */
-  typicalPatternThreshold: z103.number().min(0).max(1).default(0.3),
-  /** Verbose logging */
-  verbose: z103.boolean().default(false)
-});
-
 // src/cli-adapters/task-classifier.ts
-import { z as z104 } from "zod";
-var ClassificationPatternsSchema = z104.object({
-  code: z104.array(z104.string()).readonly(),
-  research: z104.array(z104.string()).readonly(),
-  documentation: z104.array(z104.string()).readonly(),
-  analysis: z104.array(z104.string()).readonly()
+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()
 });
 
 // src/cli-adapters/response-cache-types.ts
-import { z as z105 } from "zod";
-var ResponseCacheConfigSchema = z105.object({
-  defaultTTL: z105.number().min(1e3).max(36e5).default(3e5),
+import { z as z104 } from "zod";
+var ResponseCacheConfigSchema = z104.object({
+  defaultTTL: z104.number().min(1e3).max(36e5).default(3e5),
   // 5 minutes
-  maxEntries: z105.number().min(10).max(1e5).default(1e3),
-  maxMemoryMB: z105.number().min(1).max(1e3).default(50),
-  cleanupInterval: z105.number().min(1e3).max(6e5).default(6e4),
+  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),
   // 1 minute
-  enableLogging: z105.boolean().default(false)
+  enableLogging: z104.boolean().default(false)
 });
 
 // src/cli-adapters/response-cache-utils.ts
@@ -48393,12 +48332,12 @@ import { createHash as createHash4 } from "crypto";
 var logger44 = createLogger({ component: "ResponseCacheUtils" });
 
 // src/cli-adapters/unified-routing-types.ts
-import { z as z106 } from "zod";
-var UnifiedRoutingDecisionSchema = z106.object({
-  selectedCli: z106.string(),
-  confidence: z106.number().min(0).max(1),
-  reason: z106.string(),
-  strategy: z106.enum([
+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([
     "composite",
     "quality",
     "budget",
@@ -48410,57 +48349,57 @@ var UnifiedRoutingDecisionSchema = z106.object({
     "linucb",
     "direct"
   ]),
-  decisionTimeMs: z106.number().nonnegative(),
-  alternatives: z106.array(z106.string()).readonly(),
-  stagesExecuted: z106.array(z106.string()).readonly(),
-  withinBudget: z106.boolean().optional(),
-  estimatedComplexity: z106.enum(["simple", "moderate", "complex", "expert"]).optional(),
-  estimatedTokens: z106.number().int().positive().optional(),
-  topsisScore: z106.number().optional(),
-  ucbScore: z106.number().optional(),
-  resolvedAtStage: z106.number().int().nonnegative().optional(),
-  consensusReached: z106.boolean().optional(),
-  agreementScore: z106.number().min(0).max(1).optional(),
-  metadata: z106.record(z106.string(), z106.unknown()).optional()
+  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()
 });
 
 // src/learning/outcome-feedback-types.ts
-import { z as z107 } from "zod";
-var QualitySignalsSchema = z107.object({
-  testsPass: z107.boolean().optional(),
-  lintErrors: z107.number().int().min(0).optional(),
-  userApproved: z107.boolean().optional(),
-  retryCount: z107.number().int().min(0).default(0),
-  completionRatio: z107.number().min(0).max(1).default(1),
-  validStructure: z107.boolean().optional(),
-  coherenceScore: z107.number().min(0).max(1).optional()
+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()
 });
-var RoutingDecisionSchema = z107.object({
-  id: z107.uuid(),
-  timestamp: z107.iso.datetime(),
-  query: z107.string(),
-  routerType: z107.enum(["linucb", "preference", "quality", "cascade", "topsis"]),
-  selectedModel: z107.string(),
-  selectedTier: z107.enum(["strong", "weak"]).optional(),
-  armIndex: z107.number().int().min(0).optional(),
-  banditContext: z107.record(z107.string(), z107.unknown()).optional(),
-  queryFeatures: z107.record(z107.string(), z107.unknown()).optional(),
-  ucbScore: z107.number().optional(),
-  confidence: z107.number().min(0).max(1).optional(),
-  traceId: z107.string(),
-  domain: z107.string().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 TaskOutcomeSchema = z107.object({
-  routingDecisionId: z107.uuid(),
-  timestamp: z107.iso.datetime(),
-  outcomeClass: z107.enum(["success", "partial", "failure", "timeout", "error"]),
-  success: z107.boolean(),
-  qualityScore: z107.number().min(0).max(1),
-  durationMs: z107.number().min(0),
-  tokenUsage: z107.number().int().min(0),
-  errorMessage: z107.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(),
   qualitySignals: QualitySignalsSchema,
-  traceId: z107.string()
+  traceId: z106.string()
 });
 var DEFAULT_FEEDBACK_COLLECTOR_CONFIG = {
   maxPendingDecisions: 1e3,
@@ -48475,17 +48414,17 @@ var DEFAULT_FEEDBACK_COLLECTOR_CONFIG = {
   targetTokenUsage: 2e3,
   maxHistorySize: 1e4
 };
-var FeedbackCollectorConfigSchema = z107.object({
-  maxPendingDecisions: z107.number().int().positive().default(1e3),
-  pendingTimeoutMs: z107.number().positive().default(3e5),
-  enableAutoReward: z107.boolean().default(true),
-  qualityWeight: z107.number().min(0).max(1).default(0.5),
-  speedWeight: z107.number().min(0).max(1).default(0.2),
-  efficiencyWeight: z107.number().min(0).max(1).default(0.2),
-  retryPenalty: z107.number().min(0).max(1).default(0.1),
-  targetDurationMs: z107.number().positive().default(5e3),
-  targetTokenUsage: z107.number().positive().default(2e3),
-  maxHistorySize: z107.number().int().positive().default(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)
 });
 
 // src/learning/outcome-feedback-helpers.ts
@@ -50102,7 +50041,7 @@ var GitHubTaskTracker = class {
   cachedProvider = null;
   async getProvider() {
     if (this.cachedProvider !== null) return this.cachedProvider;
-    const { createScmProvider } = await import("./factory-W6KROBFN.js");
+    const { createScmProvider } = await import("./factory-3XB5CAAA.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;
@@ -50812,4 +50751,4 @@ export {
   detectBackend,
   createTaskTracker
 };
-//# sourceMappingURL=chunk-PMLVZXAE.js.map
+//# sourceMappingURL=chunk-J4ZBKE4B.js.map