nexus-agents 8.23.2 → 8.23.4

package/dist/{chunk-M7TUO6O7.js → chunk-DEVL62JD.js}

@@ -23,10 +23,10 @@ import {
   toolSuccessStructured,
   withProgressHeartbeat,
   wrapToolWithTimeout
-} from "./chunk-ZFZJ6LTJ.js";
+} from "./chunk-NUYJ4VW5.js";
 import {
   VERSION
-} from "./chunk-OXUJBY4W.js";
+} from "./chunk-FKCE4X4F.js";
 import {
   assessPanelIndependence,
   countDistinctModels,
@@ -81,7 +81,7 @@ import {
 } from "./chunk-J7QCZRVK.js";
 
 // src/mcp/tools/consensus-vote.ts
-import { z as z10 } from "zod";
+import { z as z11 } from "zod";
 
 // src/utils/bounded-artifact.ts
 function boundArtifactForReview(text, budget, label) {
@@ -99,7 +99,7 @@ function boundArtifactForReview(text, budget, label) {
 function voterModelOverrideEnvKey(role) {
   return `NEXUS_VOTER_MODEL_${role.toUpperCase()}`;
 }
-function resolveVoterModelOverrides(roles, gatewayAdapters, logger10) {
+function resolveVoterModelOverrides(roles, gatewayAdapters, logger11) {
   const overrides = /* @__PURE__ */ new Map();
   if (gatewayAdapters.length === 0) return overrides;
   const byId = /* @__PURE__ */ new Map();
@@ -111,7 +111,7 @@ function resolveVoterModelOverrides(roles, gatewayAdapters, logger10) {
     const requested = raw.trim();
     const adapter = byId.get(requested) ?? gatewayAdapters.find((a) => a.modelId.toLowerCase() === requested.toLowerCase());
     if (adapter === void 0) {
-      logger10.warn(
+      logger11.warn(
         `Voter model override ${envKey}="${requested}" is not a discovered gateway model \u2014 falling back to round-robin for role "${role}".`,
         { role, requested, available: [...byId.keys()] }
       );
@@ -120,7 +120,7 @@ function resolveVoterModelOverrides(roles, gatewayAdapters, logger10) {
     overrides.set(role, adapter);
   }
   if (overrides.size > 0) {
-    logger10.info("Applied per-role voter model overrides (#4055)", {
+    logger11.info("Applied per-role voter model overrides (#4055)", {
       overrides: Object.fromEntries([...overrides].map(([r, a]) => [r, a.modelId]))
     });
   }
@@ -146,28 +146,28 @@ function checkCodexConcurrency(codexBoundConcurrency) {
 }
 
 // src/cli/panel-independence.ts
-function reportPanelIndependence(adapters, roleCount, phase, logger10) {
+function reportPanelIndependence(adapters, roleCount, phase, logger11) {
   reportPanelModelIndependence(
     adapters.map((adapter) => adapter.modelId),
     roleCount,
     phase,
-    logger10
+    logger11
   );
 }
-function reportVoteIndependence(results, logger10) {
+function reportVoteIndependence(results, logger11) {
   const successful = results.filter((result) => result.source === "llm");
   reportPanelModelIndependence(
     successful.map((result) => result.model),
     successful.length,
     "post-vote",
-    logger10
+    logger11
   );
 }
-function reportPanelModelIndependence(modelIds, roleCount, phase, logger10) {
+function reportPanelModelIndependence(modelIds, roleCount, phase, logger11) {
   if (roleCount <= 1) return;
   const verdict = assessPanelIndependence(modelIds);
   if (verdict.kind === "collapsed") {
-    logger10.warn("Consensus panel ran on ONE model \u2014 votes may correlate", {
+    logger11.warn("Consensus panel ran on ONE model \u2014 votes may correlate", {
       model: verdict.model,
       roleCount,
       phase
@@ -175,7 +175,7 @@ function reportPanelModelIndependence(modelIds, roleCount, phase, logger10) {
     return;
   }
   if (verdict.kind === "diverse") {
-    logger10.debug("Consensus panel spans distinct models", {
+    logger11.debug("Consensus panel spans distinct models", {
       distinctModels: verdict.distinct,
       roleCount,
       phase
@@ -184,13 +184,13 @@ function reportPanelModelIndependence(modelIds, roleCount, phase, logger10) {
   }
   const context = { unresolved: verdict.unresolved, total: verdict.total, roleCount };
   if (phase === "post-vote") {
-    logger10.warn(
+    logger11.warn(
       "Panel independence UNMEASURED after voting \u2014 cannot say whether votes correlate",
       context
     );
     return;
   }
-  logger10.debug(
+  logger11.debug(
     "Panel independence not yet measurable (adapters have not detected their model)",
     context
   );
@@ -979,29 +979,29 @@ async function executeSingleVoteAttempt(role, proposal, adapter, timeoutMs, opti
     throw error;
   }
 }
-function logAbandonedRetries(logger10, role, attempt, maxRetries) {
-  logger10.warn("Durable capacity cap \u2014 abandoning retries for this voter", {
+function logAbandonedRetries(logger11, role, attempt, maxRetries) {
+  logger11.warn("Durable capacity cap \u2014 abandoning retries for this voter", {
     role,
     attempt: attempt + 1,
     remainingAttemptsSkipped: maxRetries - attempt
   });
 }
 async function executeWithRetries(opts) {
-  const { role, proposal, adapter, logger: logger10, timeoutMs, maxRetries, options } = opts;
+  const { role, proposal, adapter, logger: logger11, timeoutMs, maxRetries, options } = opts;
   let lastError = "";
   for (let attempt = 0; attempt <= maxRetries; attempt++) {
     if (attempt > 0) {
       const isRateLimit = isRateLimitError(lastError);
       const baseDelay = isRateLimit ? RATE_LIMIT_RETRY_DELAY_MS : INITIAL_RETRY_DELAY_MS;
       const delayMs = baseDelay * Math.pow(2, attempt - 1);
-      logger10.debug("Retrying vote execution", { role, attempt, delayMs, isRateLimit });
+      logger11.debug("Retrying vote execution", { role, attempt, delayMs, isRateLimit });
       await delay(delayMs);
     }
     const attemptStart = Date.now();
     const result = await executeSingleVoteAttempt(role, proposal, adapter, timeoutMs, options);
     const attemptMs = Date.now() - attemptStart;
     if (result.ok) {
-      logger10.info("Vote attempt timing", {
+      logger11.info("Vote attempt timing", {
         role,
         attempt: attempt + 1,
         attemptMs,
@@ -1012,14 +1012,14 @@ async function executeWithRetries(opts) {
     lastError = result.error;
     const rateLimited = isRateLimitError(lastError);
     const durableCap = isDurableCapacityText(lastError);
-    logger10.info("Vote attempt timing", {
+    logger11.info("Vote attempt timing", {
       role,
       attempt: attempt + 1,
       attemptMs,
       succeeded: false,
       rateLimited
     });
-    logger10.warn("Vote attempt failed", {
+    logger11.warn("Vote attempt failed", {
       role,
       attempt: attempt + 1,
       maxRetries: maxRetries + 1,
@@ -1028,7 +1028,7 @@ async function executeWithRetries(opts) {
       ...durableCap ? { durableCap: true } : {}
     });
     if (durableCap) {
-      logAbandonedRetries(logger10, role, attempt, maxRetries);
+      logAbandonedRetries(logger11, role, attempt, maxRetries);
       break;
     }
   }
@@ -1064,9 +1064,9 @@ function createKeyedSerializer() {
 }
 function raceWithDeadline(p, role, deadlineMs) {
   let timer;
-  const timeoutP = new Promise((resolve2) => {
+  const timeoutP = new Promise((resolve3) => {
     timer = setTimeout(() => {
-      resolve2(createErrorVoteResult(role, DEADLINE_MESSAGE, deadlineMs));
+      resolve3(createErrorVoteResult(role, DEADLINE_MESSAGE, deadlineMs));
     }, deadlineMs);
   });
   return Promise.race([p, timeoutP]).finally(() => {
@@ -1097,7 +1097,7 @@ async function launchRoleVote(role, index, input, voteOnAdapter) {
   return withPinnedModel(await voteOnAdapter(role, input.fallbackAdapter), pinnedModel);
 }
 async function launchVotesWithOverallDeadline(input) {
-  const { roles, proposal, logger: logger10, voteOptions, overallDeadlineMs, voteFn } = input;
+  const { roles, proposal, logger: logger11, voteOptions, overallDeadlineMs, voteFn } = input;
   const startedAt = Date.now();
   const serialize = createKeyedSerializer();
   const voteOnAdapter = (role, adapter) => (
@@ -1107,7 +1107,7 @@ async function launchVotesWithOverallDeadline(input) {
     serialize(adapterCliKey(adapter), () => {
       const remaining = Math.max(1, overallDeadlineMs - (Date.now() - startedAt));
       return raceWithDeadline(
-        voteFn(role, proposal, adapter, logger10, voteOptions),
+        voteFn(role, proposal, adapter, logger11, voteOptions),
         role,
         remaining
       );
@@ -1117,7 +1117,7 @@ async function launchVotesWithOverallDeadline(input) {
   const results = await Promise.all(wrapped);
   const expired = results.filter((r) => r.source === "error" && r.error === DEADLINE_MESSAGE);
   if (expired.length > 0) {
-    logger10.warn("Consensus overall deadline reached; returning partial results", {
+    logger11.warn("Consensus overall deadline reached; returning partial results", {
       totalRoles: roles.length,
       expiredRoles: expired.map((r) => r.role),
       overallDeadlineMs
@@ -1160,31 +1160,31 @@ function resolveVoteExecution(options) {
     declaredOptions: options?.declaredOptions
   };
 }
-async function executeAgentVote(role, proposal, adapter, logger10, options) {
+async function executeAgentVote(role, proposal, adapter, logger11, options) {
   const start = getTimeProvider().now();
   const { timeoutMs, maxRetries, allowSimulation, declaredOptions } = resolveVoteExecution(options);
-  logger10.info("Executing vote", { role, model: adapter.modelId, provider: adapter.providerId });
+  logger11.info("Executing vote", { role, model: adapter.modelId, provider: adapter.providerId });
   const result = await executeWithRetries({
     role,
     proposal,
     adapter,
-    logger: logger10,
+    logger: logger11,
     timeoutMs,
     maxRetries,
     options: declaredOptions
   });
   const processingTimeMs = getTimeProvider().now() - start;
   if (result.ok) {
-    logger10.info("Vote completed", { role, model: adapter.modelId, decision: result.vote.decision });
+    logger11.info("Vote completed", { role, model: adapter.modelId, decision: result.vote.decision });
     return buildLlmVoteResult(role, result.vote, result.usage, adapter, processingTimeMs);
   }
-  logger10.error("Vote execution failed after all retries", void 0, {
+  logger11.error("Vote execution failed after all retries", void 0, {
     role,
     model: adapter.modelId,
     errorMessage: result.error
   });
   if (allowSimulation) {
-    logger10.warn("Falling back to simulation (allowSimulation=true)", { role });
+    logger11.warn("Falling back to simulation (allowSimulation=true)", { role });
     return createSimulationVoteResult(role, proposal, processingTimeMs, result.error);
   }
   const remediation = authRemediation(result.error, adapter.providerId);
@@ -1199,26 +1199,26 @@ var NoAdapterError = class extends Error {
     this.name = "NoAdapterError";
   }
 };
-function resolveAdapter(options, logger10) {
+function resolveAdapter(options, logger11) {
   try {
     if (options.adapter !== void 0) return { adapter: options.adapter };
     const gateway = options.gatewayAdapters;
     if (gateway !== void 0 && gateway.length > 0 && gateway[0] !== void 0) {
       return { adapter: gateway[0] };
     }
-    const registry = getGlobalRegistry({ logger: logger10 });
+    const registry = getGlobalRegistry({ logger: logger11 });
     return { adapter: registry.getDefault() };
   } catch (error) {
     return { error: getErrorMessage(error) };
   }
 }
-function warnIfCodexConcurrencyExceeded(roleAdapters, logger10) {
+function warnIfCodexConcurrencyExceeded(roleAdapters, logger11) {
   const codexBound = [...roleAdapters.values()].filter(
     (a) => a.name === "codex"
   ).length;
   const warning = checkCodexConcurrency(codexBound);
   if (warning !== null) {
-    logger10.warn("Codex concurrency limit may be exceeded", { detail: warning });
+    logger11.warn("Codex concurrency limit may be exceeded", { detail: warning });
   }
 }
 function assignUniformAdapter(roles, adapter) {
@@ -1226,15 +1226,15 @@ function assignUniformAdapter(roles, adapter) {
   for (const role of roles) adapters.set(role, adapter);
   return adapters;
 }
-function createCliAdapterMap(clis, logger10) {
-  const registry = getGlobalRegistry({ logger: logger10 });
+function createCliAdapterMap(clis, logger11) {
+  const registry = getGlobalRegistry({ logger: logger11 });
   const result = /* @__PURE__ */ new Map();
   for (const cli of clis) {
     result.set(cli, registry.getAdapterForCli(cli));
   }
   return result;
 }
-function assignRoundRobinAdapters(roles, entries, logger10, source) {
+function assignRoundRobinAdapters(roles, entries, logger11, source) {
   const adapters = /* @__PURE__ */ new Map();
   const assignments = {};
   for (let i = 0; i < roles.length; i++) {
@@ -1244,70 +1244,70 @@ function assignRoundRobinAdapters(roles, entries, logger10, source) {
     adapters.set(role, entry.adapter);
     assignments[role] = entry.label;
   }
-  logger10.info("Diverse adapters assigned", {
+  logger11.info("Diverse adapters assigned", {
     source,
     count: entries.length,
     roleAssignments: assignments
   });
   return adapters;
 }
-function resolveGatewayRoleAdapters(roles, gatewayAdapters, fallbackAdapter, logger10) {
+function resolveGatewayRoleAdapters(roles, gatewayAdapters, fallbackAdapter, logger11) {
   if (gatewayAdapters.length === 1) {
     if (roles.length > 1) {
-      logger10.warn("Consensus panel collapsed to a single gateway model \u2014 votes may correlate", {
+      logger11.warn("Consensus panel collapsed to a single gateway model \u2014 votes may correlate", {
         model: gatewayAdapters[0]?.modelId,
         roleCount: roles.length
       });
     }
     return assignUniformAdapter(roles, gatewayAdapters[0] ?? fallbackAdapter);
   }
-  const overrides = resolveVoterModelOverrides(roles, gatewayAdapters, logger10);
+  const overrides = resolveVoterModelOverrides(roles, gatewayAdapters, logger11);
   const roundRobinRoles = roles.filter((r) => !overrides.has(r));
   const assigned = assignRoundRobinAdapters(
     roundRobinRoles,
     gatewayAdapters.map((a) => ({ label: a.modelId, adapter: a })),
-    logger10,
+    logger11,
     "gateway"
   );
   for (const [role, adapter] of overrides) assigned.set(role, adapter);
   const assignedModels = [...assigned.values()].map((a) => a.modelId);
   if (roles.length > 1 && countDistinctModels(assignedModels) === 1) {
-    logger10.warn(
+    logger11.warn(
       "Consensus panel collapsed to a single gateway model via overrides \u2014 votes may correlate",
       { model: assignedModels[0], roleCount: roles.length }
     );
   }
   return assigned;
 }
-async function resolveDiverseAdapters(roles, logger10, fallbackAdapter, gatewayAdapters) {
+async function resolveDiverseAdapters(roles, logger11, fallbackAdapter, gatewayAdapters) {
   if (gatewayAdapters !== void 0 && gatewayAdapters.length > 0) {
-    return resolveGatewayRoleAdapters(roles, gatewayAdapters, fallbackAdapter, logger10);
+    return resolveGatewayRoleAdapters(roles, gatewayAdapters, fallbackAdapter, logger11);
   }
   let availableClis;
   try {
     availableClis = await getAvailableClis();
   } catch (e) {
-    logger10.warn("Failed to resolve available CLIs; falling back to single adapter", {
+    logger11.warn("Failed to resolve available CLIs; falling back to single adapter", {
       error: String(e)
     });
     availableClis = [];
   }
   if (availableClis.length <= 1) {
-    logger10.info("Using single adapter for all roles", { cliCount: availableClis.length });
+    logger11.info("Using single adapter for all roles", { cliCount: availableClis.length });
     return assignUniformAdapter(roles, fallbackAdapter);
   }
-  const cliAdapters = createCliAdapterMap(availableClis, logger10);
+  const cliAdapters = createCliAdapterMap(availableClis, logger11);
   if (cliAdapters.size <= 1) return assignUniformAdapter(roles, fallbackAdapter);
-  reportPanelIndependence([...cliAdapters.values()], roles.length, "assignment", logger10);
+  reportPanelIndependence([...cliAdapters.values()], roles.length, "assignment", logger11);
   return assignRoundRobinAdapters(
     roles,
     [...cliAdapters.entries()].map(([cli, adapter]) => ({ label: cli, adapter })),
-    logger10,
+    logger11,
     "cli"
   );
 }
 async function launchStaggeredVotes(input) {
-  const { roles, proposal, roleAdapters, fallbackAdapter, logger: logger10, voteOptions, interDelay } = input;
+  const { roles, proposal, roleAdapters, fallbackAdapter, logger: logger11, voteOptions, interDelay } = input;
   const computedDeadlineMs = computeOverallConsensusDeadlineMs(
     voteOptions.timeoutMs,
     voteOptions.maxRetries,
@@ -1316,7 +1316,7 @@ async function launchStaggeredVotes(input) {
   );
   const overallDeadlineMs = getMcpSafeDeadlineMs(computedDeadlineMs, "consensus_vote");
   if (overallDeadlineMs < computedDeadlineMs) {
-    logger10.debug("Consensus deadline clamped to MCP wrapper timeout", {
+    logger11.debug("Consensus deadline clamped to MCP wrapper timeout", {
       computedDeadlineMs,
       overallDeadlineMs
     });
@@ -1326,7 +1326,7 @@ async function launchStaggeredVotes(input) {
     proposal,
     roleAdapters,
     fallbackAdapter,
-    logger: logger10,
+    logger: logger11,
     voteOptions,
     interDelay,
     overallDeadlineMs,
@@ -1335,27 +1335,27 @@ async function launchStaggeredVotes(input) {
   });
 }
 async function collectRealVotes(options) {
-  const logger10 = options.logger ?? defaultLogger;
+  const logger11 = options.logger ?? defaultLogger;
   const { roles, proposal, simulate, allowSimulation } = options;
   const timeoutMs = options.timeoutMs ?? resolveVoteTimeout();
   const maxRetries = options.maxRetries ?? VOTE_TIMEOUTS.maxRetries;
   if (simulate === true) {
-    logger10.info("Using simulation mode (explicitly requested)");
+    logger11.info("Using simulation mode (explicitly requested)");
     return createSimulatedVotes(roles, proposal);
   }
-  const adapterResult = resolveAdapter(options, logger10);
+  const adapterResult = resolveAdapter(options, logger11);
   if ("error" in adapterResult) {
-    logger10.error("No adapter available for voting", void 0, { error: adapterResult.error });
+    logger11.error("No adapter available for voting", void 0, { error: adapterResult.error });
     if (allowSimulation === true) {
-      logger10.warn("Falling back to simulation (allowSimulation=true)");
+      logger11.warn("Falling back to simulation (allowSimulation=true)");
       return createSimulatedVotes(roles, proposal, "No adapter available");
     }
     throw new NoAdapterError(
       `No adapter available for voting: ${adapterResult.error}. Install a CLI (claude/gemini/codex) or set ANTHROPIC_API_KEY.`
     );
   }
-  const roleAdapters = options.adapter !== void 0 ? assignUniformAdapter(roles, adapterResult.adapter) : await resolveDiverseAdapters(roles, logger10, adapterResult.adapter, options.gatewayAdapters);
-  warnIfCodexConcurrencyExceeded(roleAdapters, logger10);
+  const roleAdapters = options.adapter !== void 0 ? assignUniformAdapter(roles, adapterResult.adapter) : await resolveDiverseAdapters(roles, logger11, adapterResult.adapter, options.gatewayAdapters);
+  warnIfCodexConcurrencyExceeded(roleAdapters, logger11);
   const voteOptions = {
     timeoutMs,
     maxRetries,
@@ -1370,12 +1370,12 @@ async function collectRealVotes(options) {
     proposal,
     roleAdapters,
     fallbackAdapter: adapterResult.adapter,
-    logger: logger10,
+    logger: logger11,
     voteOptions,
     interDelay,
     signal: options.signal
   });
-  reportVoteIndependence(results, logger10);
+  reportVoteIndependence(results, logger11);
   return results;
 }
 
@@ -2312,11 +2312,11 @@ var ConsensusEngine = class {
   logger;
   metrics;
   voterExpansionCallback;
-  constructor(config, logger10) {
+  constructor(config, logger11) {
     this.config = { ...DEFAULT_CONSENSUS_CONFIG, ...config };
     this.cacheConfig = { ...DEFAULT_PROPOSAL_CACHE_CONFIG, ...config?.proposalCache };
     this.quorumConfig = { ...DEFAULT_INCREMENTAL_QUORUM_CONFIG, ...config?.incrementalQuorum };
-    this.logger = logger10 ?? createLogger({ component: "ConsensusEngine" });
+    this.logger = logger11 ?? createLogger({ component: "ConsensusEngine" });
     this.strategyFactory = new VotingStrategyFactory();
     this.metrics = this.createInitialMetrics();
   }
@@ -2760,15 +2760,15 @@ var ConsensusEngine = class {
     this.logger.debug("Proposal cache cleared");
   }
 };
-function createConsensusEngine(config, logger10) {
-  return new ConsensusEngine(config, logger10);
+function createConsensusEngine(config, logger11) {
+  return new ConsensusEngine(config, logger11);
 }
 
 // src/consensus/quorum-validator.ts
 var QuorumValidator = class {
   logger;
-  constructor(logger10) {
-    this.logger = logger10 ?? createLogger({ component: "QuorumValidator" });
+  constructor(logger11) {
+    this.logger = logger11 ?? createLogger({ component: "QuorumValidator" });
   }
   validateQuorum(input) {
     const { votes, config } = input;
@@ -2971,8 +2971,8 @@ var QuorumValidator = class {
     };
   }
 };
-function createQuorumValidator(logger10) {
-  return new QuorumValidator(logger10);
+function createQuorumValidator(logger11) {
+  return new QuorumValidator(logger11);
 }
 
 // src/consensus/voting-protocol-helpers.ts
@@ -4060,9 +4060,9 @@ function mergeHistory(target, source) {
   return target;
 }
 var CorrelationModelPartitions = class {
-  constructor(maxTrackedPairs, logger10) {
+  constructor(maxTrackedPairs, logger11) {
     this.maxTrackedPairs = maxTrackedPairs;
-    this.logger = logger10;
+    this.logger = logger11;
   }
   maxTrackedPairs;
   logger;
@@ -5238,8 +5238,8 @@ var VOTE_RECORDS_DATA_CATEGORY = "governance";
 var VOTE_RECORDS_FILENAME = "vote-records.jsonl";
 var VOTE_RECORDS_PATH_ENV = "NEXUS_VOTE_RECORDS_PATH";
 var MAX_PROPOSAL_RECORD_CHARS = 500;
-function voteRecordWriteFailedMessage(path) {
-  return `Authentic vote record NOT persisted: the resolved data directory is not writable (${path}). Check filesystem permissions on the .nexus-agents data dir, or set ${VOTE_RECORDS_PATH_ENV} to a writable absolute file path. See server logs for the underlying filesystem error.`;
+function voteRecordWriteFailedMessage(path2) {
+  return `Authentic vote record NOT persisted: the resolved data directory is not writable (${path2}). Check filesystem permissions on the .nexus-agents data dir, or set ${VOTE_RECORDS_PATH_ENV} to a writable absolute file path. See server logs for the underlying filesystem error.`;
 }
 function outcomeToDecision(result, votes, errorVoided) {
   const errorCount = votes.filter((v) => v.source === "error").length;
@@ -5319,7 +5319,7 @@ function buildVoteRecord(input) {
   };
   return { ...payload, hash: computeVoteRecordHash(payload) };
 }
-function readLedgerTip(filePath, logger10) {
+function readLedgerTip(filePath, logger11) {
   if (!existsSync2(filePath)) return { maxSequence: -1, lastHash: void 0 };
   try {
     const { records } = readVoteRecords(filePath);
@@ -5331,7 +5331,7 @@ function readLedgerTip(filePath, logger10) {
     const last = records[records.length - 1];
     return { maxSequence, lastHash: last?.hash };
   } catch (error) {
-    logger10.warn("Failed to read vote-record ledger tip", { error: getErrorMessage(error) });
+    logger11.warn("Failed to read vote-record ledger tip", { error: getErrorMessage(error) });
     return { maxSequence: -1, lastHash: void 0 };
   }
 }
@@ -5363,29 +5363,29 @@ function resolveVoteRecordsPath() {
   return resolved;
 }
 function persistVoteRecord(opts) {
-  const logger10 = opts.logger ?? createLogger({ component: "vote-record-store" });
+  const logger11 = opts.logger ?? createLogger({ component: "vote-record-store" });
   const filePath = opts.filePath ?? resolveVoteRecordsPath();
   if (filePath === void 0) {
-    logger10.warn(voteRecordWriteFailedMessage("<unresolved>"), { id: opts.id });
+    logger11.warn(voteRecordWriteFailedMessage("<unresolved>"), { id: opts.id });
     return void 0;
   }
   try {
     mkdirSync2(dirname(filePath), { recursive: true });
-    const { maxSequence, lastHash } = readLedgerTip(filePath, logger10);
+    const { maxSequence, lastHash } = readLedgerTip(filePath, logger11);
     const record = buildVoteRecord({
       ...opts,
       sequence: maxSequence + 1,
       previousHash: lastHash
     });
     appendFileSync2(filePath, JSON.stringify(record) + "\n", "utf-8");
-    logger10.info("Persisted authentic vote record", {
+    logger11.info("Persisted authentic vote record", {
       id: record.id,
       decision: record.decision,
       path: filePath
     });
     return record;
   } catch (error) {
-    logger10.warn("Failed to persist authentic vote record", {
+    logger11.warn("Failed to persist authentic vote record", {
       error: getErrorMessage(error),
       path: filePath
     });
@@ -5417,10 +5417,10 @@ import { appendFileSync as appendFileSync3, readFileSync as readFileSync3, write
 var PersistentOutcomeStore = class extends OutcomeStore {
   filePath;
   logger;
-  constructor(config, logger10) {
+  constructor(config, logger11) {
     super(config);
     this.filePath = config?.filePath ?? getOutcomesFile();
-    this.logger = logger10 ?? createLogger({ component: "PersistentOutcomeStore" });
+    this.logger = logger11 ?? createLogger({ component: "PersistentOutcomeStore" });
     const dataDir = config?.dataDir;
     ensureLearningDir(dataDir);
     this.hydrate();
@@ -5720,7 +5720,7 @@ function recordDecisionCost(options) {
   const billingMode = options.billingMode ?? resolveBillingMode();
   const voters = votesToCostInputs(options.votes);
   const store = options.store ?? new DecisionCostStore();
-  const logger10 = options.logger ?? defaultLogger2;
+  const logger11 = options.logger ?? defaultLogger2;
   const timestamp = new Date(getTimeProvider().now()).toISOString();
   const { record, persisted } = store.record({
     decisionId: options.decisionId,
@@ -5734,7 +5734,7 @@ function recordDecisionCost(options) {
     if (shouldWarnForDrop(droppedCostRecordCount)) {
       const suppressedSinceLastWarn = droppedCostRecordCount - warnCountSinceReset - 1;
       warnCountSinceReset += 1;
-      logger10.warn("Decision-cost rollup dropped (failed to persist) \u2014 billing telemetry lost", {
+      logger11.warn("Decision-cost rollup dropped (failed to persist) \u2014 billing telemetry lost", {
         decisionId: options.decisionId,
         gate: options.gate,
         totalCostUsd: record.summary.totalCostUsd,
@@ -5757,7 +5757,7 @@ function rejectionRulesFrom(result) {
   }
   return rules.size > 0 ? [...rules] : void 0;
 }
-function emitVoteRejectedSignal(result, bus, logger10) {
+function emitVoteRejectedSignal(result, bus, logger11) {
   if (result.outcome !== "rejected") return;
   try {
     const rejectionRules = rejectionRulesFrom(result);
@@ -5769,7 +5769,7 @@ function emitVoteRejectedSignal(result, bus, logger10) {
       ...rejectionRules !== void 0 ? { rejectionRules } : {}
     });
   } catch (error) {
-    logger10.warn("Failed to emit signal.vote_rejected", { error: getErrorMessage(error) });
+    logger11.warn("Failed to emit signal.vote_rejected", { error: getErrorMessage(error) });
   }
 }
 
@@ -5779,10 +5779,10 @@ var ALLOW_SIMULATE_ENV = "NEXUS_ALLOW_SIMULATE";
 function isTestRunner() {
   return process.env.VITEST === "true" || process.env.NODE_ENV === "test";
 }
-function checkSimulationAllowed(toolName, logger10) {
+function checkSimulationAllowed(toolName, logger11) {
   if (isTestRunner()) return { allowed: true, optedIn: false };
   if (process.env[ALLOW_SIMULATE_ENV] === "1") {
-    warnOnce(toolName, logger10);
+    warnOnce(toolName, logger11);
     return { allowed: true, optedIn: true };
   }
   return {
@@ -5797,10 +5797,10 @@ function simulationDeniedResult(reason) {
     detail: { optIn: `${ALLOW_SIMULATE_ENV}=1` }
   });
 }
-function warnOnce(toolName, logger10) {
+function warnOnce(toolName, logger11) {
   if (WARNED.has(toolName)) return;
   WARNED.add(toolName);
-  logger10.warn(
+  logger11.warn(
     `[${toolName}] simulateVotes=true: output is RANDOM and reserved for tests/demos. Do not treat the result as a real decision.`
   );
 }
@@ -5881,13 +5881,13 @@ function isAbandonedJob(record, nowMs) {
 function jobResultPath(jobId) {
   return nexusDataPathEnsure("jobs", `result-${jobId}.json`);
 }
-function persistJobRecord(path, record) {
-  writeFileSync3(path, JSON.stringify(record, null, 2), { mode: 384 });
-  chmodSync(path, 384);
+function persistJobRecord(path2, record) {
+  writeFileSync3(path2, JSON.stringify(record, null, 2), { mode: 384 });
+  chmodSync(path2, 384);
 }
 function writeJobPending(jobId, toolName, signalAccepted, producerVersion = VERSION) {
-  const path = jobResultPath(jobId);
-  if (existsSync4(path)) {
+  const path2 = jobResultPath(jobId);
+  if (existsSync4(path2)) {
     logger7.debug("Job result file already exists \u2014 leaving in place", { jobId });
     return;
   }
@@ -5900,7 +5900,7 @@ function writeJobPending(jobId, toolName, signalAccepted, producerVersion = VERS
     ...signalAccepted !== void 0 ? { signalAccepted } : {},
     producerVersion
   };
-  persistJobRecord(path, record);
+  persistJobRecord(path2, record);
   logger7.debug("Wrote pending job record", { jobId, toolName, signalAccepted });
 }
 function writeJobComplete(jobId, toolName, result, producerVersion = VERSION) {
@@ -5962,20 +5962,20 @@ function writeJobCancelled(jobId, toolName, reason, producerVersion = VERSION) {
   logger7.debug("Wrote cancelled job record", { jobId, toolName, reason });
 }
 function readJobResult(jobId) {
-  const path = nexusDataPath("jobs", `result-${jobId}.json`);
-  if (!existsSync4(path)) return null;
+  const path2 = nexusDataPath("jobs", `result-${jobId}.json`);
+  if (!existsSync4(path2)) return null;
   try {
-    const raw = JSON.parse(readFileSync4(path, "utf-8"));
+    const raw = JSON.parse(readFileSync4(path2, "utf-8"));
     const parsed = JobResultSchema.safeParse(raw);
     if (!parsed.success) {
-      logger7.warn("Job result file failed schema check", { jobId, path });
+      logger7.warn("Job result file failed schema check", { jobId, path: path2 });
       return null;
     }
     return parsed.data;
   } catch (err2) {
     logger7.warn("Job result file unreadable", {
       jobId,
-      path,
+      path: path2,
       error: err2 instanceof Error ? err2.message : String(err2)
     });
     return null;
@@ -6078,9 +6078,9 @@ function resolveIdempotency(tool, idempotencyKey, inputs, randomFallback = rando
     return { kind: "fresh", jobId: randomFallback() };
   }
   const incomingInputsHash = computeInputsHash(inputs);
-  const path = indexFilePathReadOnly(tool, idempotencyKey);
-  if (existsSync5(path)) {
-    const entry = readIndexEntry(path);
+  const path2 = indexFilePathReadOnly(tool, idempotencyKey);
+  if (existsSync5(path2)) {
+    const entry = readIndexEntry(path2);
     if (entry !== null) {
       if (entry.inputsHash === incomingInputsHash) {
         return { kind: "replay", jobId: entry.jobId, entry };
@@ -6092,14 +6092,14 @@ function resolveIdempotency(tool, idempotencyKey, inputs, randomFallback = rando
         existingJobId: entry.jobId
       };
     }
-    logger8.warn("Idempotency index file unreadable; treating as fresh dispatch", { tool, path });
+    logger8.warn("Idempotency index file unreadable; treating as fresh dispatch", { tool, path: path2 });
   }
   const jobId = `job-${tool}-${sha256Hex(`${tool}:${idempotencyKey}:${incomingInputsHash}`).slice(0, 16)}`;
   return { kind: "fresh", jobId };
 }
 function registerIdempotentJob(params) {
-  const path = indexFilePath(params.tool, params.idempotencyKey);
-  if (existsSync5(path)) {
+  const path2 = indexFilePath(params.tool, params.idempotencyKey);
+  if (existsSync5(path2)) {
     logger8.debug("Idempotency index entry already present; skipping write", {
       tool: params.tool,
       jobId: params.jobId
@@ -6114,7 +6114,7 @@ function registerIdempotentJob(params) {
     jobId: params.jobId,
     createdAt: (/* @__PURE__ */ new Date()).toISOString()
   };
-  writeFileSync4(path, JSON.stringify(entry, null, 2));
+  writeFileSync4(path2, JSON.stringify(entry, null, 2));
   logger8.debug("Wrote idempotency index entry", { tool: params.tool, jobId: params.jobId });
 }
 function shortCircuitOrFreshJobId(params) {
@@ -6132,18 +6132,18 @@ function shortCircuitOrFreshJobId(params) {
   }
   return { kind: "continue", jobId: r.jobId };
 }
-function readIndexEntry(path) {
+function readIndexEntry(path2) {
   try {
-    const raw = JSON.parse(readFileSync5(path, "utf-8"));
+    const raw = JSON.parse(readFileSync5(path2, "utf-8"));
     const parsed = IdempotencyIndexEntrySchema.safeParse(raw);
     if (!parsed.success) {
-      logger8.warn("Idempotency index file failed schema check", { path });
+      logger8.warn("Idempotency index file failed schema check", { path: path2 });
       return null;
     }
     return parsed.data;
   } catch (err2) {
     logger8.warn("Idempotency index file read failed", {
-      path,
+      path: path2,
       error: err2 instanceof Error ? err2.message : String(err2)
     });
     return null;
@@ -6244,17 +6244,486 @@ function suggestRetryAfterMs(toolName) {
   return Math.min(6e4, Math.max(5e3, base));
 }
 
+// src/context/structured-task-state.ts
+import * as fs2 from "node:fs";
+import * as path from "node:path";
+import { AsyncLocalStorage } from "node:async_hooks";
+
+// src/context/structured-task-state-types.ts
+import { z as z10 } from "zod";
+var TaskStageSchema = z10.enum([
+  "planning",
+  "executing",
+  "verifying",
+  "complete",
+  "blocked",
+  // #3091 / epic #2631: terminal failure stage. Distinct from `blocked`
+  // (recoverable, still in-flight) — `failed` is terminal and maps to the
+  // job-result `failed` status. Added so async-mode writers can record a
+  // failed run in StructuredTaskState instead of the Stage-1 sidecar.
+  "failed"
+]);
+var TaskDecisionSchema = z10.object({
+  ts: z10.iso.datetime(),
+  decision: z10.string().min(1),
+  rationale: z10.string().min(1)
+});
+var TaskBlockerSchema = z10.object({
+  ts: z10.iso.datetime(),
+  blocker: z10.string().min(1),
+  resolved: z10.iso.datetime().optional()
+});
+var TaskPositionSchema = z10.object({
+  currentStep: z10.string().min(1),
+  nextStep: z10.string().optional()
+});
+var TaskLedgerSchema = z10.object({
+  /** Verifiable observations: what we have observed/measured/confirmed. */
+  facts: z10.array(z10.string()),
+  /** Working assumptions: useful guesses we proceed under, marked separately. */
+  guesses: z10.array(z10.string()),
+  /** Things we still need to figure out before the plan is sound. */
+  openQuestions: z10.array(z10.string()),
+  updatedAt: z10.iso.datetime()
+});
+var ReflectActionSchema = z10.enum([
+  "continue",
+  "revise_plan",
+  "escalate_to_human",
+  "abort"
+]);
+var ProgressLedgerEntrySchema = z10.object({
+  ts: z10.iso.datetime(),
+  /** What just happened (the step we are reflecting on). */
+  step: z10.string().min(1),
+  /** Is the outer Task Ledger plan still right after this step? */
+  planStillValid: z10.boolean(),
+  /** Are we making progress, or have we stalled? */
+  stuck: z10.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: z10.string().min(1)
+});
+var TaskCancellationSchema = z10.object({
+  requestedAt: z10.iso.datetime(),
+  /** Optional human-readable note carried back to the caller. */
+  reason: z10.string().max(1e3).optional()
+});
+var TASK_RESULT_MAX_BYTES = 1048576;
+var StructuredTaskStateSchema = z10.object({
+  taskId: z10.string().min(1),
+  /**
+   * Marks state created by the shared async-job dispatcher (#5622).
+   * Optional for backward compatibility; absence does not prove async dispatch.
+   */
+  dispatch: z10.literal("async").optional(),
+  stage: TaskStageSchema,
+  decisions: z10.array(TaskDecisionSchema),
+  blockers: z10.array(TaskBlockerSchema),
+  position: TaskPositionSchema,
+  /**
+   * Magentic-One Task Ledger (#2278). Mutable single-object outer-loop state:
+   * facts/guesses/openQuestions revised together when the plan is replanned.
+   * Optional so the field can be added later without breaking existing logs.
+   */
+  taskLedger: TaskLedgerSchema.optional(),
+  /**
+   * Magentic-One Progress Ledger (#2278). Append-only inner-loop reflections.
+   * Most recent entry's `suggestedAction` is what `reflect()` returns. Optional
+   * for the same backward-compat reason as `taskLedger`.
+   */
+  progressLedger: z10.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: z10.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: z10.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(),
+  /**
+   * Creation timestamp (#3090 / epic #2631). Set by the reducer to the
+   * `init` entry's `ts` and never mutated thereafter — `updatedAt` advances
+   * with each write, but `createdAt` is fixed. Job-result readers need the
+   * original creation time; `updatedAt` alone can't supply it once any
+   * transition has been recorded. Optional for backward-compat with
+   * pre-#3090 logs (the reducer backfills it from the init entry).
+   */
+  createdAt: z10.iso.datetime().optional(),
+  updatedAt: z10.iso.datetime()
+});
+var StructuredTaskLogEntrySchema = z10.discriminatedUnion("event", [
+  z10.object({
+    event: z10.literal("init"),
+    ts: z10.iso.datetime(),
+    state: StructuredTaskStateSchema
+  }),
+  z10.object({
+    event: z10.literal("decision"),
+    ts: z10.iso.datetime(),
+    decision: TaskDecisionSchema
+  }),
+  z10.object({
+    event: z10.literal("blocker"),
+    ts: z10.iso.datetime(),
+    blocker: TaskBlockerSchema
+  }),
+  z10.object({
+    event: z10.literal("blocker_resolved"),
+    ts: z10.iso.datetime(),
+    /** Index of the blocker in the state's blockers[] array. */
+    blockerIndex: z10.number().int().nonnegative(),
+    resolvedAt: z10.iso.datetime()
+  }),
+  z10.object({
+    event: z10.literal("stage"),
+    ts: z10.iso.datetime(),
+    stage: TaskStageSchema
+  }),
+  z10.object({
+    event: z10.literal("position"),
+    ts: z10.iso.datetime(),
+    position: TaskPositionSchema
+  }),
+  // Magentic-One Task Ledger replacement event — the outer loop revises the
+  // entire ledger atomically when replanning. Always replaces, never partial.
+  z10.object({
+    event: z10.literal("task_ledger"),
+    ts: z10.iso.datetime(),
+    ledger: TaskLedgerSchema
+  }),
+  // Magentic-One Progress Ledger append event — one self-reflection per step.
+  z10.object({
+    event: z10.literal("progress_ledger"),
+    ts: z10.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.
+  z10.object({
+    event: z10.literal("result"),
+    ts: z10.iso.datetime(),
+    result: z10.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.
+  z10.object({
+    event: z10.literal("cancellation"),
+    ts: z10.iso.datetime(),
+    cancellation: TaskCancellationSchema
+  })
+]);
+
+// src/context/structured-task-state.ts
+var logger10 = createLogger({ component: "structured-task-state" });
+var TASKS_SUBDIR = "tasks";
+var FILE_MODE2 = 384;
+var DIR_MODE2 = 448;
+var asyncTaskStateJob = new AsyncLocalStorage();
+function withAsyncTaskStateDispatch(jobId, operation) {
+  return asyncTaskStateJob.run(jobId, operation);
+}
+function getTasksDir(customDir) {
+  if (customDir !== void 0) return path.resolve(customDir);
+  return nexusDataPath(TASKS_SUBDIR);
+}
+function getLogPath(taskId, customDir) {
+  return path.join(getTasksDir(customDir), `state-${taskId}.jsonl`);
+}
+function listTaskStateIds(customDir) {
+  const dir = getTasksDir(customDir);
+  if (!fs2.existsSync(dir)) return [];
+  let entries;
+  try {
+    entries = fs2.readdirSync(dir);
+  } catch (cause) {
+    logger10.warn("tasks directory unreadable", {
+      dir,
+      error: cause instanceof Error ? cause.message : String(cause)
+    });
+    return [];
+  }
+  const ids = [];
+  for (const entry of entries) {
+    const match = /^state-(.+)\.jsonl$/.exec(entry);
+    if (match?.[1] !== void 0) ids.push(match[1]);
+  }
+  return ids;
+}
+function validateTaskId(taskId) {
+  if (taskId.includes("..") || taskId.includes("/") || taskId.includes("\\")) {
+    return err(new Error("Invalid task ID: contains path traversal characters"));
+  }
+  if (taskId.length === 0 || taskId.length > 128) {
+    return err(new Error("Invalid task ID: must be 1-128 characters"));
+  }
+  return ok(taskId);
+}
+function ensureTasksDir(customDir) {
+  const dirPath = getTasksDir(customDir);
+  try {
+    fs2.mkdirSync(dirPath, { recursive: true, mode: DIR_MODE2 });
+    return ok(dirPath);
+  } catch (cause) {
+    const e = cause instanceof Error ? cause : new Error(String(cause));
+    return err(new Error(`Failed to create tasks directory at ${dirPath}: ${e.message}`));
+  }
+}
+function appendLogEntry(taskId, entry, customDir) {
+  const idCheck = validateTaskId(taskId);
+  if (!idCheck.ok) return err(idCheck.error);
+  const dirResult = ensureTasksDir(customDir);
+  if (!dirResult.ok) return err(dirResult.error);
+  const filePath = getLogPath(taskId, customDir);
+  const line = JSON.stringify(entry) + "\n";
+  try {
+    fs2.appendFileSync(filePath, line, { mode: FILE_MODE2 });
+    return ok(void 0);
+  } catch (cause) {
+    const e = cause instanceof Error ? cause : new Error(String(cause));
+    return err(new Error(`Failed to write task state entry: ${e.message}`));
+  }
+}
+function initTaskState(state, customDir) {
+  const isAsyncJob = asyncTaskStateJob.getStore() === state.taskId;
+  const persistedState = isAsyncJob ? { ...state, dispatch: "async" } : state;
+  return appendLogEntry(
+    state.taskId,
+    { event: "init", ts: state.updatedAt, state: persistedState },
+    customDir
+  );
+}
+function appendBlocker(taskId, blocker, customDir) {
+  return appendLogEntry(taskId, { event: "blocker", ts: blocker.ts, blocker }, customDir);
+}
+function updateStage(taskId, stage, ts, customDir) {
+  return appendLogEntry(taskId, { event: "stage", ts, stage }, customDir);
+}
+function appendResult(taskId, result, ts, customDir) {
+  let payload = result;
+  let serialized;
+  try {
+    serialized = JSON.stringify(result ?? null);
+  } catch (cause) {
+    const e = cause instanceof Error ? cause : new Error(String(cause));
+    return err(new Error(`Failed to serialize result for task ${taskId}: ${e.message}`));
+  }
+  const bytes = Buffer.byteLength(serialized, "utf-8");
+  if (bytes > TASK_RESULT_MAX_BYTES) {
+    payload = {
+      truncated: true,
+      originalBytes: bytes,
+      maxBytes: TASK_RESULT_MAX_BYTES,
+      note: "Result exceeded TASK_RESULT_MAX_BYTES \u2014 original dropped at write time."
+    };
+    logger10.warn("Task result truncated at write", {
+      taskId,
+      bytes,
+      max: TASK_RESULT_MAX_BYTES
+    });
+  }
+  return appendLogEntry(taskId, { event: "result", ts, result: payload }, customDir);
+}
+function appendCancellation(taskId, cancellation, customDir) {
+  return appendLogEntry(
+    taskId,
+    { event: "cancellation", ts: cancellation.requestedAt, cancellation },
+    customDir
+  );
+}
+function readTaskState(taskId, customDir) {
+  const idCheck = validateTaskId(taskId);
+  if (!idCheck.ok) return err(idCheck.error);
+  const filePath = getLogPath(taskId, customDir);
+  if (!fs2.existsSync(filePath)) {
+    return err(new Error(`No state log for task: ${taskId}`));
+  }
+  let content;
+  try {
+    content = fs2.readFileSync(filePath, "utf-8");
+  } catch (cause) {
+    const e = cause instanceof Error ? cause : new Error(String(cause));
+    return err(new Error(`Failed to read state log: ${e.message}`));
+  }
+  const lines = content.split("\n").filter((l) => l.length > 0);
+  const entries = [];
+  for (const line of lines) {
+    try {
+      const parsed = JSON.parse(line);
+      const validated = StructuredTaskLogEntrySchema.safeParse(parsed);
+      if (validated.success) {
+        entries.push(validated.data);
+      } else {
+        logger10.warn("Skipping malformed task-state log entry", {
+          taskId,
+          error: validated.error.message
+        });
+      }
+    } catch (cause) {
+      const msg = cause instanceof Error ? cause.message : String(cause);
+      logger10.warn("Skipping unparseable task-state log entry", { taskId, error: msg });
+    }
+  }
+  return reduceLogEntries(taskId, entries);
+}
+function reduceLogEntries(taskId, entries) {
+  const init = entries.find((e) => e.event === "init");
+  if (init === void 0) {
+    return err(new Error(`No init entry found for task: ${taskId}`));
+  }
+  const initState = init.state;
+  if (initState.taskId !== taskId) {
+    return err(
+      new Error(`Task ID mismatch: log contains state for ${initState.taskId}, expected ${taskId}`)
+    );
+  }
+  let state = {
+    ...initState,
+    decisions: [...initState.decisions],
+    blockers: initState.blockers.map((b) => ({ ...b })),
+    version: initState.version ?? 0,
+    // #3090: createdAt is fixed at the init entry's ts and never advances
+    // (unlike updatedAt). Prefer an explicit createdAt on the init state,
+    // else fall back to the init entry's ts.
+    createdAt: initState.createdAt ?? init.ts
+  };
+  for (const entry of entries) {
+    if (entry === init) continue;
+    state = applyLogEntry(state, entry);
+  }
+  return ok(state);
+}
+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 "decision":
+      return {
+        ...state,
+        decisions: [...state.decisions, entry.decision],
+        updatedAt: entry.ts,
+        version: nextVersion
+      };
+    case "stage":
+      return { ...state, stage: entry.stage, updatedAt: entry.ts, version: nextVersion };
+    case "position":
+      return { ...state, position: entry.position, updatedAt: entry.ts, version: nextVersion };
+    case "task_ledger":
+      return { ...state, taskLedger: entry.ledger, updatedAt: entry.ts, version: nextVersion };
+    case "progress_ledger":
+      return {
+        ...state,
+        progressLedger: [...state.progressLedger ?? [], entry.entry],
+        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/jobs/run-as-job.ts
 var ASYNC_JOB_BODY_GUARD_CLASS = "async-job-body";
 var ASYNC_JOB_BODY_NEAR_TIMEOUT_THRESHOLD = 0.5;
 var ASYNC_JOB_BODY_RUNAWAY_MESSAGE = "runaway guard exceeded";
-function makeAsyncBodyGuard(jobId, toolName, guardMs, logger10) {
+function makeAsyncBodyGuard(jobId, toolName, guardMs, logger11) {
   let guardTimer;
   let warnTimer;
   const expired = new Promise((_resolve, reject) => {
     warnTimer = setTimeout(
       () => {
-        logger10?.warn(`Async ${toolName} job approaching runaway guard`, {
+        logger11?.warn(`Async ${toolName} job approaching runaway guard`, {
           jobId,
           guardMs,
           thresholdFraction: ASYNC_JOB_BODY_NEAR_TIMEOUT_THRESHOLD
@@ -6373,10 +6842,11 @@ async function runJobInBackground(jobId, params) {
   const guard = makeAsyncBodyGuard(jobId, params.toolName, guardMs, params.logger);
   const controller = registerJobAbort(jobId);
   try {
-    const result = await Promise.race([
-      params.run(jobId, params.input, controller.signal),
-      guard.expired
-    ]);
+    const body = withAsyncTaskStateDispatch(
+      jobId,
+      () => params.run(jobId, params.input, controller.signal)
+    );
+    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);
@@ -6522,13 +6992,13 @@ async function processVotesThroughEngine(engineVotes, proposal, algorithm) {
     });
   return resultRes.value;
 }
-function runHigherOrderVoting(strategy, voteMap, logger10, context) {
+function runHigherOrderVoting(strategy, voteMap, logger11, context) {
   if (!isHigherOrderStrategy(strategy)) return void 0;
   const hovStrategy = new HigherOrderVotingStrategy();
   const tracker = getOrCreateCorrelationTracker();
   tracker.setCurrentModelPins?.(context.modelPins);
   const result = hovStrategy.aggregate(voteMap, tracker);
-  logger10.info("Higher-Order Voting complete", {
+  logger11.info("Higher-Order Voting complete", {
     method: result.method,
     decision: result.decision,
     posteriorApproval: result.posteriorApproval.toFixed(3)
@@ -6544,10 +7014,10 @@ function buildCorrelationContext(votes) {
   }
   return { modelPins, observedModels };
 }
-function recordVotesToTracker(votes, outcome, logger10) {
+function recordVotesToTracker(votes, outcome, logger11) {
   const llmVotes = votes.filter((v) => v.source === "llm");
   if (llmVotes.length < votes.length) {
-    logger10.warn("Recording only LLM votes to correlation tracker; excluding non-LLM votes", {
+    logger11.warn("Recording only LLM votes to correlation tracker; excluding non-LLM votes", {
       recorded: llmVotes.length,
       excluded: votes.length - llmVotes.length
     });
@@ -6559,16 +7029,16 @@ function recordVotesToTracker(votes, outcome, logger10) {
   const tracker = getOrCreateCorrelationTracker();
   const id = `consensus-${String(getTimeProvider().now())}-${getRandomProvider().random().toString(36).slice(2, 9)}`;
   tracker.recordProposalVotes(id, llmVoteMap, outcome, context);
-  logger10.debug("Recorded votes to tracker", { proposalId: id, outcome });
+  logger11.debug("Recorded votes to tracker", { proposalId: id, outcome });
   try {
     const persisted = createPersistedProposal(id, llmVoteMap, outcome, context);
     const saveResult = saveCorrelationData([persisted]);
     if (!saveResult.ok) {
-      logger10.warn("Failed to persist correlation data", { error: saveResult.error.message });
+      logger11.warn("Failed to persist correlation data", { error: saveResult.error.message });
     }
   } catch (error) {
     const message = getErrorMessage(error);
-    logger10.warn("Error persisting correlation data", { error: message });
+    logger11.warn("Error persisting correlation data", { error: message });
   }
 }
 async function processVotesWithCascade(engineVotes, opts) {
@@ -6664,37 +7134,37 @@ function buildPolicyShortCircuitResult(args) {
     policyReason: args.reason
   };
 }
-async function maybeEscalateContrarian(input, outcome, ctx, logger10, opts) {
+async function maybeEscalateContrarian(input, outcome, ctx, logger11, opts) {
   if (!input.quickMode || outcome !== "approved" || input.simulateVotes) return {};
   if (shouldEscalateLowPosterior(ctx.strategy, outcome, input.quickMode, ctx.posteriorApproval)) {
-    logger10.warn("Posterior-confidence escalation: re-running with full vote (#3174)", {
+    logger11.warn("Posterior-confidence escalation: re-running with full vote (#3174)", {
       strategy: ctx.strategy,
       posteriorApproval: ctx.posteriorApproval
     });
-    return { escalated: await executeVoting({ ...input, quickMode: false }, logger10, opts) };
+    return { escalated: await executeVoting({ ...input, quickMode: false }, logger11, opts) };
   }
-  const escalation = await runContrarianCheck(input.proposal, logger10);
+  const escalation = await runContrarianCheck(input.proposal, logger11);
   if (escalation.errored && input.errorPolicy === "absolute_quorum") {
-    logger10.warn("Contrarian check errored under absolute_quorum \u2014 degrading to no_quorum (#4132)");
+    logger11.warn("Contrarian check errored under absolute_quorum \u2014 degrading to no_quorum (#4132)");
     return {
       degradeReason: "no_quorum: re-run \u2014 contrarian check errored (absolute_quorum quick-mode)"
     };
   }
   if (!escalation.shouldEscalate) return {};
-  logger10.warn("Contrarian escalation: re-running with full vote", {
+  logger11.warn("Contrarian escalation: re-running with full vote", {
     reason: escalation.reason,
     confidence: escalation.confidence
   });
-  return { escalated: await executeVoting({ ...input, quickMode: false }, logger10, opts) };
+  return { escalated: await executeVoting({ ...input, quickMode: false }, logger11, opts) };
 }
-async function executeVoting(input, logger10, opts) {
-  const result = await executeVotingInner(input, logger10, opts ?? {});
+async function executeVoting(input, logger11, opts) {
+  const result = await executeVotingInner(input, logger11, opts ?? {});
   const correlationAlreadyRecorded = result.decision !== void 0;
   const errorCount = result.votes.filter((v) => v.source === "error").length;
   applyOptionGate(input, result);
   result.decision = resolveVoteDecision(input, result, errorCount).decision;
   if (!correlationAlreadyRecorded && (result.decision === "approved" || result.decision === "rejected")) {
-    recordVotesToTracker(result.votes, result.decision, logger10);
+    recordVotesToTracker(result.votes, result.decision, logger11);
   }
   return result;
 }
@@ -6714,13 +7184,13 @@ function applyOptionGate(input, result) {
   result.result.outcome = "rejected";
   result.optionGate = outcome.reason !== void 0 ? { ...outcome.verdict, reason: outcome.reason } : outcome.verdict;
 }
-async function executeVotingInner(input, logger10, opts) {
+async function executeVotingInner(input, logger11, opts) {
   const strategy = resolveStrategy(input);
   const algorithm = strategyToAlgorithm(strategy);
   const roles = getVoterRoles(input.quickMode);
   const startTime = getTimeProvider().now();
   const errorPolicy = input.errorPolicy ?? getDefaultErrorPolicy(strategy);
-  logger10.info("Starting consensus vote", {
+  logger11.info("Starting consensus vote", {
     strategy,
     algorithm,
     roleCount: roles.length,
@@ -6746,7 +7216,7 @@ async function executeVotingInner(input, logger10, opts) {
       errorPolicy,
       reason: policyDecision.reason ?? "error policy short-circuit",
       startTime,
-      logger: logger10
+      logger: logger11
     });
   }
   const { engineResult, higherOrderResult, outcome, cascaded } = await processVotesWithCascade(
@@ -6756,14 +7226,14 @@ async function executeVotingInner(input, logger10, opts) {
       proposal: input.proposal,
       algorithm,
       strategy,
-      log: logger10
+      log: logger11
     }
   );
   const escalation = await maybeEscalateContrarian(
     input,
     outcome,
     { strategy, posteriorApproval: higherOrderResult?.posteriorApproval },
-    logger10,
+    logger11,
     opts
   );
   if (escalation.escalated !== void 0) return escalation.escalated;
@@ -6778,7 +7248,7 @@ async function executeVotingInner(input, logger10, opts) {
     outcome,
     cascaded,
     startTime,
-    logger: logger10
+    logger: logger11
   });
   return applyContrarianDegrade(finalized, escalation.degradeReason);
 }
@@ -6786,8 +7256,8 @@ function applyContrarianDegrade(result, degradeReason) {
   if (degradeReason === void 0 || result.policyReason !== void 0) return result;
   return { ...result, policyReason: degradeReason };
 }
-async function runConsensusForGoal(goal, logger10 = createLogger({ tool: "consensus_vote" }), gatewayAdapters) {
-  return executeVoting(ConsensusVoteInputSchema.parse({ proposal: goal }), logger10, {
+async function runConsensusForGoal(goal, logger11 = createLogger({ tool: "consensus_vote" }), gatewayAdapters) {
+  return executeVoting(ConsensusVoteInputSchema.parse({ proposal: goal }), logger11, {
     ...gatewayAdapters !== void 0 && { gatewayAdapters }
   });
 }
@@ -6814,7 +7284,7 @@ function finalizeVotingResult(args) {
   if (args.higherOrderResult !== void 0) result.higherOrderResult = args.higherOrderResult;
   return result;
 }
-function recordVoteSideEffects(proposal, strategy, result, logger10, ratifies) {
+function recordVoteSideEffects(proposal, strategy, result, logger11, ratifies) {
   const decisionId = `consensus-${String(getTimeProvider().now())}-${randomUUID2().slice(0, 8)}`;
   const voteRecord = recordAuthenticVote({
     proposal,
@@ -6837,7 +7307,7 @@ function recordVoteSideEffects(proposal, strategy, result, logger10, ratifies) {
   try {
     costSummary = recordDecisionCost({ decisionId, gate: "consensus_vote", votes: result.votes });
   } catch (costError) {
-    logger10.warn("Per-decision cost rollup failed (non-fatal)", {
+    logger11.warn("Per-decision cost rollup failed (non-fatal)", {
       error: getErrorMessage(costError)
     });
     costSummary = void 0;
@@ -6845,16 +7315,16 @@ function recordVoteSideEffects(proposal, strategy, result, logger10, ratifies) {
   return { costSummary, voteRecord };
 }
 async function handleConsensusVote(deps, args, signal) {
-  const logger10 = deps.logger ?? createLogger({ tool: "consensus_vote" });
+  const logger11 = deps.logger ?? createLogger({ tool: "consensus_vote" });
   try {
-    const result = await executeVoting(args, logger10, {
+    const result = await executeVoting(args, logger11, {
       ...deps.gatewayAdapters !== void 0 && { gatewayAdapters: deps.gatewayAdapters },
       signal
     });
     const errorVotes = result.votes.filter((v) => v.source === "error");
     if (errorVotes.length === result.votes.length && result.votes.length > 0) {
       const failures = errorVotes.map((v) => `${v.role}: ${v.error ?? "unknown error"}`).join("; ");
-      logger10.warn("All voters failed", { failureCount: errorVotes.length, failures });
+      logger11.warn("All voters failed", { failureCount: errorVotes.length, failures });
       recordVoteError(args.proposal, `All ${String(errorVotes.length)} voters failed: ${failures}`);
       return {
         ok: false,
@@ -6876,15 +7346,15 @@ async function handleConsensusVote(deps, args, signal) {
       args.proposal,
       result.strategy,
       result,
-      logger10,
+      logger11,
       args.ratifies
     );
-    emitVoteRejectedSignal(result.result, getPipelineEventBus(), logger10);
+    emitVoteRejectedSignal(result.result, getPipelineEventBus(), logger11);
     return { ok: true, value: buildResponse(args, result, costSummary, voteRecord) };
   } catch (error) {
     const message = getErrorMessage(error);
     const cause = error instanceof Error ? error : new Error(message);
-    logger10.error("Consensus vote failed", cause);
+    logger11.error("Consensus vote failed", cause);
     recordVoteError(args.proposal, message);
     return { ok: false, error: `Voting failed: ${message}` };
   }
@@ -7002,35 +7472,35 @@ var ASYNC_ENVELOPES = {
 };
 var CONSENSUS_VOTE_OUTPUT_SCHEMA = {
   /** Async-dispatch envelope discriminator — absent on a completed vote. */
-  status: z10.enum(["pending", "busy", "replay"]).optional(),
-  jobId: z10.string().max(200).optional(),
-  pollTool: z10.literal("get_job_result").optional(),
-  note: z10.string().max(500).optional(),
-  retryAfterMs: z10.number().optional(),
-  proposal: z10.string().optional(),
+  status: z11.enum(["pending", "busy", "replay"]).optional(),
+  jobId: z11.string().max(200).optional(),
+  pollTool: z11.literal("get_job_result").optional(),
+  note: z11.string().max(500).optional(),
+  retryAfterMs: z11.number().optional(),
+  proposal: z11.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: z10.number().optional(),
-  voteCounts: z10.object({
-    approve: z10.number(),
-    reject: z10.number(),
-    abstain: z10.number(),
-    error: z10.number()
+  approvalPercentage: z11.number().optional(),
+  voteCounts: z11.object({
+    approve: z11.number(),
+    reject: z11.number(),
+    abstain: z11.number(),
+    error: z11.number()
   }).optional(),
-  votes: z10.array(
-    z10.object({
-      role: z10.string().max(100),
-      decision: z10.enum(["approve", "reject", "abstain"]),
-      confidence: z10.number(),
-      reasoning: z10.string().max(4e3),
-      simulated: z10.boolean(),
-      error: z10.boolean(),
-      modelUsed: z10.string().max(100).optional(),
-      rejectionCategories: z10.array(
-        z10.enum([
+  votes: z11.array(
+    z11.object({
+      role: z11.string().max(100),
+      decision: z11.enum(["approve", "reject", "abstain"]),
+      confidence: z11.number(),
+      reasoning: z11.string().max(4e3),
+      simulated: z11.boolean(),
+      error: z11.boolean(),
+      modelUsed: z11.string().max(100).optional(),
+      rejectionCategories: z11.array(
+        z11.enum([
           "YAGNI",
           "DRY_VIOLATION",
           "OVER_ENGINEERING",
@@ -7043,33 +7513,33 @@ var CONSENSUS_VOTE_OUTPUT_SCHEMA = {
     })
   ).optional(),
   threshold: VoteThresholdSchema.optional(),
-  durationMs: z10.number().optional(),
-  simulateVotes: z10.boolean().optional(),
-  higherOrderMetadata: z10.object({
-    posteriorApproval: z10.number(),
-    posteriorRejection: z10.number(),
-    effectiveVoteCount: z10.number(),
-    method: z10.enum(["ow", "isp", "simple"]),
-    usedCorrelationData: z10.boolean(),
-    improvementOverBaseline: z10.number(),
-    downweightedAgents: z10.array(z10.string().max(100)).max(10),
-    reasoning: z10.string().max(2e3)
+  durationMs: z11.number().optional(),
+  simulateVotes: z11.boolean().optional(),
+  higherOrderMetadata: z11.object({
+    posteriorApproval: z11.number(),
+    posteriorRejection: z11.number(),
+    effectiveVoteCount: z11.number(),
+    method: z11.enum(["ow", "isp", "simple"]),
+    usedCorrelationData: z11.boolean(),
+    improvementOverBaseline: z11.number(),
+    downweightedAgents: z11.array(z11.string().max(100)).max(10),
+    reasoning: z11.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: z10.string().max(200).optional(),
+  policyReason: z11.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: z10.boolean().optional(),
-  voteRecordNote: z10.string().max(500).optional(),
+  voteRecordPersisted: z11.boolean().optional(),
+  voteRecordNote: z11.string().max(500).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: z10.string().optional(),
+  panelWarning: z11.string().optional(),
   // #3855: per-decision cost rollup. Same omission as panelWarning (#4032) — it
   // is present on the response whenever cost recording succeeds (common in `api`
   // billing mode). Shared schema lives with the type (single source of truth).
@@ -7077,35 +7547,35 @@ 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: z10.object({
-    tally: z10.array(z10.object({ option: z10.string(), count: z10.number().int().nonnegative() })),
-    leadingOption: z10.string().optional(),
-    leadingShare: z10.number().min(0).max(1),
-    approverCount: z10.number().int().nonnegative(),
-    selectedCount: z10.number().int().nonnegative(),
-    unattributedApprovals: z10.number().int().nonnegative(),
-    thresholdMet: z10.boolean(),
+  optionOutcome: z11.object({
+    tally: z11.array(z11.object({ option: z11.string(), count: z11.number().int().nonnegative() })),
+    leadingOption: z11.string().optional(),
+    leadingShare: z11.number().min(0).max(1),
+    approverCount: z11.number().int().nonnegative(),
+    selectedCount: z11.number().int().nonnegative(),
+    unattributedApprovals: z11.number().int().nonnegative(),
+    thresholdMet: z11.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: z10.string().max(400).optional()
+    vetoReason: z11.string().max(400).optional()
   }).optional()
 };
 var CONSENSUS_VOTE_TOOL_SCHEMA = ConsensusVoteInputSchema.shape;
 var CONSENSUS_VOTE_DESCRIPTION = "Execute multi-model consensus voting on a proposal. Uses 7 roles by default (architect, security, devex, ai_ml, pm, catfish, scope_steward) or 3 with quickMode (architect, security, scope_steward), voting with configurable strategies. higher_order does NOT decide the verdict by correlation-aware aggregation (#4701): approve/reject is a simple tally of the panel, so correlated voters each carry full independent weight. The Bayesian correlation analysis is computed and feeds contrarian escalation only. Choose it for the escalation behaviour, not for a weighted verdict. Supports async mode (mode: 'async') \u2014 returns a jobId to poll via get_job_result. Pass ratifies=<subject> to bind an authority-ladder ratification vote into its authentic record. If your proposal asks voters to choose among named alternatives, you MUST pass them in `options` (#4472) \u2014 the threshold is then measured over WHICH option won, and the record carries the per-option tally plus selection coverage. WITHOUT `options` the tally is approve/reject/abstain only, so every voter who engages returns `approve` and a 6-1 split on which option persists as 7-0, 100% (#4452).";
 function registerConsensusVoteTool(server, deps) {
-  const logger10 = deps.logger ?? createLogger({ tool: "consensus_vote" });
+  const logger11 = deps.logger ?? createLogger({ tool: "consensus_vote" });
   const notifier = deps.notifier ?? createMcpNotifier(server);
   const depsWithNotifier = { ...deps, notifier };
   const secureHandler = createSecureHandler(createConsensusVoteHandler(depsWithNotifier), {
     toolName: "consensus_vote",
     rateLimiter: deps.rateLimiter,
-    logger: logger10
+    logger: logger11
   });
   const timeoutMs = getToolTimeout("consensus_vote", deps.security);
   const wrappedHandler = wrapToolWithTimeout("consensus_vote", secureHandler, {
     timeoutMs,
-    logger: logger10
+    logger: logger11
   });
   server.registerTool(
     "consensus_vote",
@@ -7115,9 +7585,9 @@ function registerConsensusVoteTool(server, deps) {
       outputSchema: CONSENSUS_VOTE_OUTPUT_SCHEMA,
       annotations: getToolAnnotations("consensus_vote")
     },
-    toSdkCallbackWithBudgetCheck(wrappedHandler, "consensus_vote", timeoutMs, logger10)
+    toSdkCallbackWithBudgetCheck(wrappedHandler, "consensus_vote", timeoutMs, logger11)
   );
-  logger10.info("Registered consensus_vote tool with secure handler and timeout protection");
+  logger11.info("Registered consensus_vote tool with secure handler and timeout protection");
 }
 
 export {
@@ -7132,6 +7602,13 @@ export {
   abortJob,
   resolveIdempotency,
   registerIdempotentJob,
+  listTaskStateIds,
+  initTaskState,
+  appendBlocker,
+  updateStage,
+  appendResult,
+  appendCancellation,
+  readTaskState,
   defaultPendingEnvelope,
   defaultBusyEnvelope,
   defaultReplayEnvelope,
@@ -7205,4 +7682,4 @@ export {
   CONSENSUS_VOTE_TOOL_SCHEMA,
   registerConsensusVoteTool
 };
-//# sourceMappingURL=chunk-M7TUO6O7.js.map
+//# sourceMappingURL=chunk-DEVL62JD.js.map