nexus-agents 8.82.2 → 8.84.0

package/dist/{chunk-OHBE6HR2.js → chunk-JM7Z4XKP.js}

@@ -1,12 +1,13 @@
 import {
   isGatewayModelAdapter
-} from "./chunk-U3INGOUL.js";
+} from "./chunk-NO55AP2L.js";
 import {
   allOf
 } from "./chunk-OQB3XC5O.js";
 import {
   DEFAULT_CONSENSUS_CONFIG,
   DEFAULT_INCREMENTAL_QUORUM_CONFIG,
+  ERROR_ENVELOPE_META_KEY,
   ERROR_FLOOR_FRACTION,
   NOOP_NOTIFIER,
   ProposalSchema,
@@ -24,20 +25,20 @@ import {
   toolSuccessStructured,
   withProgressHeartbeat,
   wrapToolWithTimeout
-} from "./chunk-RRTISAC5.js";
+} from "./chunk-OY27GVJ4.js";
 import {
   VERSION
-} from "./chunk-2TR3B7MN.js";
+} from "./chunk-7WJIC7H6.js";
 import {
   UNRESOLVED_MODEL_ID,
   assessPanelIndependence,
   countDistinctModels,
   createEvent,
   getGlobalRegistry
-} from "./chunk-AVF7O3PL.js";
+} from "./chunk-YWEZ7W4K.js";
 import {
   getToolMemory
-} from "./chunk-F2A24T2G.js";
+} from "./chunk-AQVSAPQD.js";
 import {
   authRemediation,
   classifyExtractedError,
@@ -47,10 +48,11 @@ import {
   isTimeoutText,
   sleep,
   withTimeout
-} from "./chunk-QZDAUREE.js";
+} from "./chunk-UMFQ52XI.js";
 import {
+  sanitizeErrorDetails,
   sanitizeOutput
-} from "./chunk-KF45ROST.js";
+} from "./chunk-2NDA4DHW.js";
 import {
   AgentError,
   CLI_NAMES,
@@ -86,7 +88,7 @@ import {
   resolveClassGuardMs,
   resolveVoteTimeout,
   stepBus
-} from "./chunk-SV2TOCSR.js";
+} from "./chunk-IPZC5BXM.js";
 import {
   ensureLearningDir,
   getOutcomesFile
@@ -100,7 +102,7 @@ import {
 } from "./chunk-RNDHNRSX.js";
 
 // src/mcp/tools/consensus-vote.ts
-import { z as z15 } from "zod";
+import { z as z16 } from "zod";
 
 // src/mcp/tools/async-dispatch-input.ts
 import { z } from "zod";
@@ -6433,7 +6435,7 @@ function logPartialProposal(bounded, log) {
 }
 async function runContrarianCheck(proposal, log, opts) {
   try {
-    const { executeExpert } = await import("./expert-bridge-MTEI4DDI.js");
+    const { executeExpert } = await import("./expert-bridge-7WAFFJWN.js");
     const bounded = boundArtifactForReview(proposal, CONTRARIAN_PROPOSAL_BUDGET, "proposal");
     logPartialProposal(bounded, log);
     const result = await executeExpert("architecture", buildContrarianPrompt(bounded, opts), {
@@ -7216,7 +7218,7 @@ function warnOnce(toolName, logger11) {
 // src/mcp/jobs/job-result-store.ts
 import { existsSync as existsSync6, readdirSync, unlinkSync, writeFileSync as writeFileSync3, chmodSync, mkdirSync as mkdirSync3 } from "node:fs";
 import { dirname as dirname3 } from "node:path";
-import { z as z13 } from "zod";
+import { z as z14 } from "zod";
 
 // src/mcp/jobs/job-idempotency.ts
 import { createHash as createHash3, randomUUID } from "node:crypto";
@@ -7459,30 +7461,114 @@ function syncAlternateCandidates(jobId, primaryPath, record, logger11, persistFn
   }
 }
 
+// src/mcp/jobs/job-failure-detail.ts
+import { z as z13 } from "zod";
+var JobFailureDetailSchema = z13.object({
+  /** Identifier of the failing adapter (e.g. 'claude', 'codex', 'api:anthropic'). */
+  adapter: z13.string().min(1),
+  /** Transport mechanism where the failure occurred (e.g. 'subprocess', 'mcp', 'stdio'). */
+  transport: z13.string().min(1),
+  /** Normalized failure category (e.g. 'rate_limited', 'timeout', 'capacity_exhausted'). */
+  category: z13.string().min(1)
+});
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function getNonEmptyString(value) {
+  return typeof value === "string" && value.trim() !== "" ? value.trim() : void 0;
+}
+function normalizeFailureCategory(raw) {
+  return raw.trim().toLowerCase();
+}
+function extractCategory(candidate) {
+  const direct = getNonEmptyString(candidate.category) ?? getNonEmptyString(candidate.code);
+  if (direct !== void 0) {
+    return normalizeFailureCategory(direct);
+  }
+  const msg = getNonEmptyString(candidate.message);
+  if (msg?.toLowerCase().includes("capacity_exhausted") === true) {
+    return "capacity_exhausted";
+  }
+  return void 0;
+}
+function inspectExplicitFailureDetail(candidate) {
+  if (!isRecord(candidate.failureDetail)) return void 0;
+  const fd = candidate.failureDetail;
+  const adapter = getNonEmptyString(fd.adapter);
+  const transport = getNonEmptyString(fd.transport);
+  const category = getNonEmptyString(fd.category);
+  if (adapter !== void 0 && transport !== void 0 && category !== void 0) {
+    return {
+      adapter,
+      transport,
+      category: normalizeFailureCategory(category)
+    };
+  }
+  return void 0;
+}
+function inspectCandidateForDetail(candidate) {
+  const explicit = inspectExplicitFailureDetail(candidate);
+  if (explicit !== void 0) return explicit;
+  const adapter = getNonEmptyString(candidate.adapter) ?? getNonEmptyString(candidate.cli);
+  if (adapter === void 0) return void 0;
+  const transport = getNonEmptyString(candidate.transport) ?? "subprocess";
+  const category = extractCategory(candidate);
+  if (category === void 0) return void 0;
+  return { adapter, transport, category };
+}
+function inspectMetaForDetail(meta) {
+  if (!isRecord(meta)) return void 0;
+  const direct = inspectCandidateForDetail(meta);
+  if (direct !== void 0) return direct;
+  const env = meta[ERROR_ENVELOPE_META_KEY];
+  if (isRecord(env) && isRecord(env.detail)) {
+    return inspectCandidateForDetail(env.detail);
+  }
+  return void 0;
+}
+function extractFailureDetail(source) {
+  if (!isRecord(source)) return void 0;
+  return inspectCandidateForDetail(source) ?? inspectMetaForDetail(source._meta) ?? (isRecord(source.error) ? inspectCandidateForDetail(source.error) : void 0) ?? (isRecord(source.cause) ? inspectCandidateForDetail(source.cause) : void 0);
+}
+function validateAndSanitizeFailureDetail(detail) {
+  if (detail === void 0) return void 0;
+  return JobFailureDetailSchema.parse({
+    adapter: sanitizeErrorDetails(detail.adapter),
+    transport: sanitizeErrorDetails(detail.transport),
+    category: sanitizeErrorDetails(detail.category)
+  });
+}
+
 // src/mcp/jobs/job-result-store.ts
 var logger8 = createLogger({ component: "job-result-store" });
-var JobStatusSchema = z13.enum(["pending", "complete", "failed", "cancelled"]);
-var JobResultSchema = z13.object({
+var JobStatusSchema = z14.enum(["pending", "complete", "failed", "cancelled"]);
+var JobResultSchema = z14.object({
   /** Format version. Currently `1` — bump if the shape changes. */
-  v: z13.literal(1),
-  jobId: z13.string().min(1),
+  v: z14.literal(1),
+  jobId: z14.string().min(1),
   /** Tool that was invoked (e.g. `orchestrate`). */
-  toolName: z13.string().min(1),
+  toolName: z14.string().min(1),
   status: JobStatusSchema,
-  createdAt: z13.iso.datetime(),
+  createdAt: z14.iso.datetime(),
   /** Set when the job leaves `pending` — either via `complete` or `failed` or `cancelled`. */
-  completedAt: z13.iso.datetime().optional(),
+  completedAt: z14.iso.datetime().optional(),
   /**
    * Structured payload the synchronous mode would have returned. Present
    * only when `status === 'complete'`. Shape is tool-specific — readers
    * cast to the tool's known output type after status check.
    */
-  result: z13.unknown().optional(),
+  result: z14.unknown().optional(),
   /**
    * Failure message when `status === 'failed'`. Cannot be paired with
    * `result` — the discriminator is `status`.
    */
-  error: z13.string().optional(),
+  error: z14.string().optional(),
+  /**
+   * Structured failure detail when `status === 'failed'` (#4375).
+   * Holds normalized adapter, transport, and category information without
+   * raw response bodies or prompt strings.
+   */
+  failureDetail: JobFailureDetailSchema.optional(),
   /**
    * Machine-readable reason for a `failed` record that was NOT settled by the
    * process that ran the job (#6224). `abandoned` is written only by
@@ -7491,7 +7577,7 @@ var JobResultSchema = z13.object({
    * the sweep rewrote it rather than deleting it. Absent on every record the
    * job's own process wrote — `error` alone carries those failures.
    */
-  errorKind: z13.literal("abandoned").optional(),
+  errorKind: z14.literal("abandoned").optional(),
   /**
    * Whether the tool's `run` callback accepts `runAsJob`'s `AbortSignal`
    * (#4972).
@@ -7507,7 +7593,7 @@ var JobResultSchema = z13.object({
    * "cancellation can reach this tool", not "the work stopped". Absent means
    * the writer did not report it, which is not the same as `false`.
    */
-  signalAccepted: z13.boolean().optional(),
+  signalAccepted: z14.boolean().optional(),
   /**
    * `VERSION` of the nexus-agents process that WROTE this record (#5008) —
    * i.e. the build that ran the job, not the build that reads it back.
@@ -7528,7 +7614,7 @@ var JobResultSchema = z13.object({
    * `'dev'` — readers MUST run it through {@link isMeasuredBuildVersion}
    * before treating two stamps as comparable.
    */
-  producerVersion: z13.string().optional(),
+  producerVersion: z14.string().optional(),
   /**
    * When the job body last heartbeat — `runAsJob`'s `progress()` callback,
    * `heartbeatJob`, or a pipeline-bus event the body emitted (#6162). Present
@@ -7540,7 +7626,7 @@ var JobResultSchema = z13.object({
    * `run-as-job.ts` fails a body that stops heartbeating as wedged, measuring
    * silence from this stamp (or from job start when there is none).
    */
-  lastProgressAt: z13.iso.datetime().optional()
+  lastProgressAt: z14.iso.datetime().optional()
 });
 var UNMEASURED_BUILD_VERSION = "dev";
 function isMeasuredBuildVersion(version) {
@@ -7614,7 +7700,7 @@ function writeJobComplete(jobId, toolName, result, producerVersion = VERSION) {
   syncAlternateCandidates(jobId, primaryPath, record, logger8, persistJobRecord);
   logger8.debug("Wrote complete job record", { jobId, toolName });
 }
-function writeJobFailed(jobId, toolName, error, producerVersion = VERSION) {
+function writeJobFailed(jobId, toolName, error, producerVersion = VERSION, failureDetail) {
   const existing = readJobResult(jobId);
   if (existing?.status === "cancelled") {
     logger8.debug("Skipping failed write \u2014 job already cancelled (preserving cancellation)", {
@@ -7623,6 +7709,8 @@ function writeJobFailed(jobId, toolName, error, producerVersion = VERSION) {
     });
     return;
   }
+  const sanitizedError = sanitizeErrorDetails(error);
+  const validatedDetail = validateAndSanitizeFailureDetail(failureDetail);
   const record = {
     v: 1,
     jobId,
@@ -7630,14 +7718,15 @@ function writeJobFailed(jobId, toolName, error, producerVersion = VERSION) {
     status: "failed",
     createdAt: existing?.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
     completedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    error,
+    error: sanitizedError,
+    ...validatedDetail !== void 0 ? { failureDetail: validatedDetail } : {},
     producerVersion,
     ...carriedProgress(existing)
   };
   const primaryPath = jobResultPath(jobId);
   persistJobRecord(primaryPath, record);
   syncAlternateCandidates(jobId, primaryPath, record, logger8, persistJobRecord);
-  logger8.debug("Wrote failed job record", { jobId, toolName, error });
+  logger8.debug("Wrote failed job record", { jobId, toolName, error: sanitizedError });
 }
 function heartbeatJob(jobId, at = new Date(getTimeProvider().now()).toISOString()) {
   persistProgressStamp(jobId, at);
@@ -7664,6 +7753,7 @@ function persistProgressStamp(jobId, at) {
 }
 function writeJobCancelled(jobId, toolName, reason, producerVersion = VERSION) {
   const existing = readJobResult(jobId);
+  const sanitizedReason = reason !== void 0 ? sanitizeErrorDetails(reason) : void 0;
   const record = {
     v: 1,
     jobId,
@@ -7671,14 +7761,14 @@ function writeJobCancelled(jobId, toolName, reason, producerVersion = VERSION) {
     status: "cancelled",
     createdAt: existing?.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
     completedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    ...reason !== void 0 ? { error: reason } : {},
+    ...sanitizedReason !== void 0 ? { error: sanitizedReason } : {},
     producerVersion,
     ...carriedProgress(existing)
   };
   const primaryPath = jobResultPath(jobId);
   persistJobRecord(primaryPath, record);
   syncAlternateCandidates(jobId, primaryPath, record, logger8, persistJobRecord);
-  logger8.debug("Wrote cancelled job record", { jobId, toolName, reason });
+  logger8.debug("Wrote cancelled job record", { jobId, toolName, reason: sanitizedReason });
 }
 function readJobResult(jobId) {
   return readJobResultAcrossCandidates(jobId, logger8);
@@ -7842,8 +7932,8 @@ import * as path from "node:path";
 import { AsyncLocalStorage } from "node:async_hooks";
 
 // src/context/structured-task-state-types.ts
-import { z as z14 } from "zod";
-var TaskStageSchema = z14.enum([
+import { z as z15 } from "zod";
+var TaskStageSchema = z15.enum([
   "planning",
   "executing",
   "verifying",
@@ -7855,59 +7945,59 @@ var TaskStageSchema = z14.enum([
   // failed run in StructuredTaskState instead of the Stage-1 sidecar.
   "failed"
 ]);
-var TaskDecisionSchema = z14.object({
-  ts: z14.iso.datetime(),
-  decision: z14.string().min(1),
-  rationale: z14.string().min(1)
+var TaskDecisionSchema = z15.object({
+  ts: z15.iso.datetime(),
+  decision: z15.string().min(1),
+  rationale: z15.string().min(1)
 });
-var TaskBlockerSchema = z14.object({
-  ts: z14.iso.datetime(),
-  blocker: z14.string().min(1),
-  resolved: z14.iso.datetime().optional()
+var TaskBlockerSchema = z15.object({
+  ts: z15.iso.datetime(),
+  blocker: z15.string().min(1),
+  resolved: z15.iso.datetime().optional()
 });
-var TaskPositionSchema = z14.object({
-  currentStep: z14.string().min(1),
-  nextStep: z14.string().optional()
+var TaskPositionSchema = z15.object({
+  currentStep: z15.string().min(1),
+  nextStep: z15.string().optional()
 });
-var TaskLedgerSchema = z14.object({
+var TaskLedgerSchema = z15.object({
   /** Verifiable observations: what we have observed/measured/confirmed. */
-  facts: z14.array(z14.string()),
+  facts: z15.array(z15.string()),
   /** Working assumptions: useful guesses we proceed under, marked separately. */
-  guesses: z14.array(z14.string()),
+  guesses: z15.array(z15.string()),
   /** Things we still need to figure out before the plan is sound. */
-  openQuestions: z14.array(z14.string()),
-  updatedAt: z14.iso.datetime()
+  openQuestions: z15.array(z15.string()),
+  updatedAt: z15.iso.datetime()
 });
-var ReflectActionSchema = z14.enum(["continue", "revise_plan", "escalate_to_human", "abort"]);
-var ProgressLedgerEntrySchema = z14.object({
-  ts: z14.iso.datetime(),
+var ReflectActionSchema = z15.enum(["continue", "revise_plan", "escalate_to_human", "abort"]);
+var ProgressLedgerEntrySchema = z15.object({
+  ts: z15.iso.datetime(),
   /** What just happened (the step we are reflecting on). */
-  step: z14.string().min(1),
+  step: z15.string().min(1),
   /** Is the outer Task Ledger plan still right after this step? */
-  planStillValid: z14.boolean(),
+  planStillValid: z15.boolean(),
   /** Are we making progress, or have we stalled? */
-  stuck: z14.boolean(),
+  stuck: z15.boolean(),
   /** What the orchestrator should do next based on this reflection. */
   suggestedAction: ReflectActionSchema,
   /** Why this action was chosen — required so future readers can audit the call. */
-  rationale: z14.string().min(1)
+  rationale: z15.string().min(1)
 });
-var TaskCancellationSchema = z14.object({
-  requestedAt: z14.iso.datetime(),
+var TaskCancellationSchema = z15.object({
+  requestedAt: z15.iso.datetime(),
   /** Optional human-readable note carried back to the caller. */
-  reason: z14.string().max(1e3).optional()
+  reason: z15.string().max(1e3).optional()
 });
 var TASK_RESULT_MAX_BYTES = 1048576;
-var StructuredTaskStateSchema = z14.object({
-  taskId: z14.string().min(1),
+var StructuredTaskStateSchema = z15.object({
+  taskId: z15.string().min(1),
   /**
    * Marks state created by the shared async-job dispatcher (#5622).
    * Optional for backward compatibility; absence does not prove async dispatch.
    */
-  dispatch: z14.literal("async").optional(),
+  dispatch: z15.literal("async").optional(),
   stage: TaskStageSchema,
-  decisions: z14.array(TaskDecisionSchema),
-  blockers: z14.array(TaskBlockerSchema),
+  decisions: z15.array(TaskDecisionSchema),
+  blockers: z15.array(TaskBlockerSchema),
   position: TaskPositionSchema,
   /**
    * Magentic-One Task Ledger (#2278). Mutable single-object outer-loop state:
@@ -7920,7 +8010,7 @@ var StructuredTaskStateSchema = z14.object({
    * Most recent entry's `suggestedAction` is what `reflect()` returns. Optional
    * for the same backward-compat reason as `taskLedger`.
    */
-  progressLedger: z14.array(ProgressLedgerEntrySchema).optional(),
+  progressLedger: z15.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
@@ -7930,7 +8020,7 @@ var StructuredTaskStateSchema = z14.object({
    * state logs (pre-Stage-2) don't carry it; the reducer treats their
    * baseline as v0 and starts counting from there.
    */
-  version: z14.number().int().nonnegative().optional(),
+  version: z15.number().int().nonnegative().optional(),
   /**
    * Tool result payload (#3043 / epic #2631 Stage 2). Set atomically
    * via the `result` log event when `stage === 'complete'`. Carries the
@@ -7946,7 +8036,7 @@ var StructuredTaskStateSchema = z14.object({
    * field, then the sidecar files become legacy that the next cleanup
    * sweep can remove.
    */
-  result: z14.unknown().optional(),
+  result: z15.unknown().optional(),
   /**
    * Cancellation marker (#3043 / epic #2631 Stage 2). Set by `cancel_job`
    * — the running tool checks for this at safe-point boundaries (between
@@ -7963,70 +8053,70 @@ var StructuredTaskStateSchema = z14.object({
    * transition has been recorded. Optional for backward-compat with
    * pre-#3090 logs (the reducer backfills it from the init entry).
    */
-  createdAt: z14.iso.datetime().optional(),
-  updatedAt: z14.iso.datetime()
+  createdAt: z15.iso.datetime().optional(),
+  updatedAt: z15.iso.datetime()
 });
-var StructuredTaskLogEntrySchema = z14.discriminatedUnion("event", [
-  z14.object({
-    event: z14.literal("init"),
-    ts: z14.iso.datetime(),
+var StructuredTaskLogEntrySchema = z15.discriminatedUnion("event", [
+  z15.object({
+    event: z15.literal("init"),
+    ts: z15.iso.datetime(),
     state: StructuredTaskStateSchema
   }),
-  z14.object({
-    event: z14.literal("decision"),
-    ts: z14.iso.datetime(),
+  z15.object({
+    event: z15.literal("decision"),
+    ts: z15.iso.datetime(),
     decision: TaskDecisionSchema
   }),
-  z14.object({
-    event: z14.literal("blocker"),
-    ts: z14.iso.datetime(),
+  z15.object({
+    event: z15.literal("blocker"),
+    ts: z15.iso.datetime(),
     blocker: TaskBlockerSchema
   }),
-  z14.object({
-    event: z14.literal("blocker_resolved"),
-    ts: z14.iso.datetime(),
+  z15.object({
+    event: z15.literal("blocker_resolved"),
+    ts: z15.iso.datetime(),
     /** Index of the blocker in the state's blockers[] array. */
-    blockerIndex: z14.number().int().nonnegative(),
-    resolvedAt: z14.iso.datetime()
+    blockerIndex: z15.number().int().nonnegative(),
+    resolvedAt: z15.iso.datetime()
   }),
-  z14.object({
-    event: z14.literal("stage"),
-    ts: z14.iso.datetime(),
+  z15.object({
+    event: z15.literal("stage"),
+    ts: z15.iso.datetime(),
     stage: TaskStageSchema
   }),
-  z14.object({
-    event: z14.literal("position"),
-    ts: z14.iso.datetime(),
+  z15.object({
+    event: z15.literal("position"),
+    ts: z15.iso.datetime(),
     position: TaskPositionSchema
   }),
   // Magentic-One Task Ledger replacement event — the outer loop revises the
   // entire ledger atomically when replanning. Always replaces, never partial.
-  z14.object({
-    event: z14.literal("task_ledger"),
-    ts: z14.iso.datetime(),
+  z15.object({
+    event: z15.literal("task_ledger"),
+    ts: z15.iso.datetime(),
     ledger: TaskLedgerSchema
   }),
   // Magentic-One Progress Ledger append event — one self-reflection per step.
-  z14.object({
-    event: z14.literal("progress_ledger"),
-    ts: z14.iso.datetime(),
+  z15.object({
+    event: z15.literal("progress_ledger"),
+    ts: z15.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.
-  z14.object({
-    event: z14.literal("result"),
-    ts: z14.iso.datetime(),
-    result: z14.unknown()
+  z15.object({
+    event: z15.literal("result"),
+    ts: z15.iso.datetime(),
+    result: z15.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.
-  z14.object({
-    event: z14.literal("cancellation"),
-    ts: z14.iso.datetime(),
+  z15.object({
+    event: z15.literal("cancellation"),
+    ts: z15.iso.datetime(),
     cancellation: TaskCancellationSchema
   })
 ]);
@@ -8573,6 +8663,26 @@ function runAsJob(params) {
   void runJobInBackground(jobId, params);
   return env.pending(jobId);
 }
+function settleJobResult(jobId, params, result) {
+  const failure = detectFailureShapedResult(result);
+  if (failure !== null && params.allowFailureShapedResult === void 0) {
+    writeJobFailed(
+      jobId,
+      params.toolName,
+      describeFailureShape(failure),
+      params.producerVersion,
+      extractFailureDetail(result)
+    );
+    return;
+  }
+  if (failure !== null) {
+    params.logger?.warn(
+      `Recorded a failure-shaped ${params.toolName} result as complete (opted out)`,
+      { jobId, key: failure.key, reason: params.allowFailureShapedResult }
+    );
+  }
+  writeJobComplete(jobId, params.toolName, result, params.producerVersion);
+}
 async function runJobInBackground(jobId, params) {
   const guardMs = resolveClassGuardMs(ASYNC_JOB_BODY_GUARD_CLASS);
   params.logger?.info(`Async ${params.toolName} job started under runaway guard`, {
@@ -8589,22 +8699,17 @@ async function runJobInBackground(jobId, params) {
       () => params.run(jobId, params.input, controller.signal, guard.progress)
     );
     const result = await Promise.race([body, guard.expired]);
-    const failure = detectFailureShapedResult(result);
-    if (failure !== null && params.allowFailureShapedResult === void 0) {
-      writeJobFailed(jobId, params.toolName, describeFailureShape(failure), params.producerVersion);
-    } else {
-      if (failure !== null) {
-        params.logger?.warn(
-          `Recorded a failure-shaped ${params.toolName} result as complete (opted out)`,
-          { jobId, key: failure.key, reason: params.allowFailureShapedResult }
-        );
-      }
-      writeJobComplete(jobId, params.toolName, result, params.producerVersion);
-    }
+    settleJobResult(jobId, params, result);
   } catch (err2) {
     const errObj = err2 instanceof Error ? err2 : new Error(String(err2));
     params.logger?.error(`Async ${params.toolName} dispatch failed`, errObj, { jobId });
-    writeJobFailed(jobId, params.toolName, errObj.message, params.producerVersion);
+    writeJobFailed(
+      jobId,
+      params.toolName,
+      errObj.message,
+      params.producerVersion,
+      extractFailureDetail(err2)
+    );
   } finally {
     unbridge();
     guard.clear();
@@ -9177,49 +9282,49 @@ var ASYNC_ENVELOPES = {
 };
 var CONSENSUS_VOTE_OUTPUT_SCHEMA = {
   /** Async-dispatch envelope discriminator — absent on a completed vote. */
-  status: z15.enum(["pending", "busy", "replay"]).optional(),
-  jobId: z15.string().max(200).optional(),
-  pollTool: z15.literal("get_job_result").optional(),
-  note: z15.string().max(500).optional(),
-  retryAfterMs: z15.number().optional(),
-  proposal: z15.string().optional(),
+  status: z16.enum(["pending", "busy", "replay"]).optional(),
+  jobId: z16.string().max(200).optional(),
+  pollTool: z16.literal("get_job_result").optional(),
+  note: z16.string().max(500).optional(),
+  retryAfterMs: z16.number().optional(),
+  proposal: z16.string().optional(),
   strategy: VotingStrategySchema.optional(),
   // Reuses the canonical VoteDecisionStatusSchema (single source) — a hand-listed
   // subset here (was ['approved','rejected','no_quorum']) omitted the reachable
   // 'timeout'/'pending' outcomes and made strict clients reject those votes (#4032).
   decision: VoteDecisionStatusSchema.optional(),
-  approvalPercentage: z15.number().optional(),
-  voteCounts: z15.object({
-    approve: z15.number(),
-    reject: z15.number(),
-    abstain: z15.number(),
-    error: z15.number(),
+  approvalPercentage: z16.number().optional(),
+  voteCounts: z16.object({
+    approve: z16.number(),
+    reject: z16.number(),
+    abstain: z16.number(),
+    error: z16.number(),
     /** #6094: seats that could not read the artifact; always present. */
-    unverifiable: z15.number()
+    unverifiable: z16.number()
   }).optional(),
   // #6111: the quick-mode contrarian check is not a seat, so `voteCounts.error`
   // cannot count it. Present on every completed vote (`skipped` when it did not
   // run); optional here only because the async envelope shares this schema.
   contrarianCheck: ContrarianCheckStatusSchema.optional(),
-  votes: z15.array(
-    z15.object({
-      role: z15.string().max(100),
-      decision: z15.enum(["approve", "reject", "abstain"]),
-      confidence: z15.number(),
-      reasoning: z15.string().max(4e3),
-      simulated: z15.boolean(),
-      error: z15.boolean(),
+  votes: z16.array(
+    z16.object({
+      role: z16.string().max(100),
+      decision: z16.enum(["approve", "reject", "abstain"]),
+      confidence: z16.number(),
+      reasoning: z16.string().max(4e3),
+      simulated: z16.boolean(),
+      error: z16.boolean(),
       /** #6094: present only when the seat could not read the artifact. */
-      unverifiable: z15.literal(true).optional(),
+      unverifiable: z16.literal(true).optional(),
       /** #6115: present only when the seat answered elsewhere than assigned. */
-      fallback: z15.object({
-        fromCli: z15.string().max(100),
-        fromModel: z15.string().max(100).optional(),
-        reason: z15.enum(["rate-limit", "capacity", "auth", "timeout", "sandbox", "unknown"])
+      fallback: z16.object({
+        fromCli: z16.string().max(100),
+        fromModel: z16.string().max(100).optional(),
+        reason: z16.enum(["rate-limit", "capacity", "auth", "timeout", "sandbox", "unknown"])
       }).optional(),
-      modelUsed: z15.string().max(100).optional(),
-      rejectionCategories: z15.array(
-        z15.enum([
+      modelUsed: z16.string().max(100).optional(),
+      rejectionCategories: z16.array(
+        z16.enum([
           "YAGNI",
           "DRY_VIOLATION",
           "OVER_ENGINEERING",
@@ -9232,48 +9337,48 @@ var CONSENSUS_VOTE_OUTPUT_SCHEMA = {
     })
   ).optional(),
   threshold: VoteThresholdSchema.optional(),
-  durationMs: z15.number().optional(),
-  simulateVotes: z15.boolean().optional(),
+  durationMs: z16.number().optional(),
+  simulateVotes: z16.boolean().optional(),
   // #6110: the project the panel judged and how the name was decided. Always
   // on the response; optional here like every field, because the async
   // `pending` envelope shares this schema.
-  project: z15.object({
-    name: z15.string().max(200),
-    source: z15.enum(["input", "derived", "default"])
+  project: z16.object({
+    name: z16.string().max(200),
+    source: z16.enum(["input", "derived", "default"])
   }).optional(),
-  higherOrderMetadata: z15.object({
-    posteriorApproval: z15.number(),
-    posteriorRejection: z15.number(),
-    effectiveVoteCount: z15.number(),
-    method: z15.enum(["ow", "isp", "simple"]),
-    usedCorrelationData: z15.boolean(),
-    improvementOverBaseline: z15.number(),
-    downweightedAgents: z15.array(z15.string().max(100)).max(10),
-    reasoning: z15.string().max(2e3)
+  higherOrderMetadata: z16.object({
+    posteriorApproval: z16.number(),
+    posteriorRejection: z16.number(),
+    effectiveVoteCount: z16.number(),
+    method: z16.enum(["ow", "isp", "simple"]),
+    usedCorrelationData: z16.boolean(),
+    improvementOverBaseline: z16.number(),
+    downweightedAgents: z16.array(z16.string().max(100)).max(10),
+    reasoning: z16.string().max(2e3)
   }).optional(),
   // #3124: explains a `rejected` decision that coexists with a high
   // approvalPercentage (an error-policy short-circuit, e.g. fail_closed).
-  policyReason: z15.string().max(200).optional(),
+  policyReason: z16.string().max(200).optional(),
   // #3991: whether the authentic vote record was persisted at vote time. Post-
   // #3991 it routes through nexusDataPath under governance/, so true is the
   // normal case; false means all-simulated (skipped by design) or write-failed
   // (data dir unwritable) — voteRecordNote carries the actionable reason. Makes
   // a previously WARN-only skip visible to MCP callers.
-  voteRecordPersisted: z15.boolean().optional(),
-  voteRecordNote: z15.string().max(500).optional(),
+  voteRecordPersisted: z16.boolean().optional(),
+  voteRecordNote: z16.string().max(500).optional(),
   // #5130: the persisted record's id, so the caller-commits script can name it.
-  voteRecordId: z15.string().max(200).optional(),
+  voteRecordId: z16.string().max(200).optional(),
   // #3587: set when the panel DEGRADED (some voters errored), so the decision
   // rests on fewer voters than requested. Part of the response since #3587 but
   // omitted from this schema until #4032 — its absence made a strict MCP client
   // reject any degraded-panel vote (`-32602 additional properties`).
-  panelWarning: z15.string().optional(),
+  panelWarning: z16.string().optional(),
   // #6115: distinct answering models and seats that answered elsewhere than
   // assigned. Always on the response (explicit zeros); optional here only
   // because the async `pending` envelope shares this schema.
-  panelDiversity: z15.object({
-    distinctModels: z15.number().int().nonnegative(),
-    fallbacks: z15.number().int().nonnegative()
+  panelDiversity: z16.object({
+    distinctModels: z16.number().int().nonnegative(),
+    fallbacks: z16.number().int().nonnegative()
   }).optional(),
   // #3855: per-decision cost rollup. Same omission as panelWarning (#4032) — it
   // is present on the response whenever cost recording succeeds (common in `api`
@@ -9282,18 +9387,18 @@ var CONSENSUS_VOTE_OUTPUT_SCHEMA = {
   // #4472: declared-option outcome. Present whenever the proposal declared
   // `options`. `unattributedApprovals` is part of the contract, not telemetry:
   // without it a caller cannot tell a real split from unreadable responses.
-  optionOutcome: z15.object({
-    tally: z15.array(z15.object({ option: z15.string(), count: z15.number().int().nonnegative() })),
-    leadingOption: z15.string().optional(),
-    leadingShare: z15.number().min(0).max(1),
-    approverCount: z15.number().int().nonnegative(),
-    selectedCount: z15.number().int().nonnegative(),
-    unattributedApprovals: z15.number().int().nonnegative(),
-    thresholdMet: z15.boolean(),
+  optionOutcome: z16.object({
+    tally: z16.array(z16.object({ option: z16.string(), count: z16.number().int().nonnegative() })),
+    leadingOption: z16.string().optional(),
+    leadingShare: z16.number().min(0).max(1),
+    approverCount: z16.number().int().nonnegative(),
+    selectedCount: z16.number().int().nonnegative(),
+    unattributedApprovals: z16.number().int().nonnegative(),
+    thresholdMet: z16.boolean(),
     // #4529: present only on a veto. Declared here because a strict MCP
     // client rejects any property the advertised schema omits — the same
     // drift that made degraded-panel votes unusable before #4032.
-    vetoReason: z15.string().max(400).optional()
+    vetoReason: z16.string().max(400).optional()
   }).optional()
 };
 var CONSENSUS_VOTE_TOOL_SCHEMA = ConsensusVoteInputSchema.shape;
@@ -9438,4 +9543,4 @@ export {
   CONSENSUS_VOTE_TOOL_SCHEMA,
   registerConsensusVoteTool
 };
-//# sourceMappingURL=chunk-OHBE6HR2.js.map
+//# sourceMappingURL=chunk-JM7Z4XKP.js.map