nexus-agents 2.83.1 → 2.85.0

package/dist/{doctor-deep-T3UUJX2E.js → doctor-deep-OUAKPLJX.js}

@@ -1,12 +1,12 @@
 import {
   formatDeepDiagnostics,
   runDeepDiagnostics
-} from "./chunk-O3XJLOEX.js";
-import "./chunk-6UI4NKT4.js";
-import "./chunk-I2HMWH4R.js";
+} from "./chunk-SOKQOPTM.js";
+import "./chunk-YLMB5MFQ.js";
+import "./chunk-2WCYG75B.js";
 import "./chunk-PR4QN5HX.js";
 export {
   formatDeepDiagnostics,
   runDeepDiagnostics
 };
-//# sourceMappingURL=doctor-deep-T3UUJX2E.js.map
+//# sourceMappingURL=doctor-deep-OUAKPLJX.js.map

package/dist/expert-bridge-22UVN5TB.js

@@ -0,0 +1,13 @@
+import {
+  executeExpert,
+  shutdownExpertBridge
+} from "./chunk-ZF3MSYLG.js";
+import "./chunk-4S5GY2MF.js";
+import "./chunk-YLMB5MFQ.js";
+import "./chunk-2WCYG75B.js";
+import "./chunk-PR4QN5HX.js";
+export {
+  executeExpert,
+  shutdownExpertBridge
+};
+//# sourceMappingURL=expert-bridge-22UVN5TB.js.map

package/dist/{factory-OKNCTJO6.js → factory-IGHUOUBS.js}

@@ -3,10 +3,11 @@ import {
   createCliAdapter,
   getAvailableClis,
   isCliAvailable
-} from "./chunk-ELRNVADA.js";
-import "./chunk-LM2S2QWO.js";
-import "./chunk-6UI4NKT4.js";
-import "./chunk-I2HMWH4R.js";
+} from "./chunk-RTAIMK6P.js";
+import "./chunk-CIW2BVSN.js";
+import "./chunk-TRX7CAD5.js";
+import "./chunk-YLMB5MFQ.js";
+import "./chunk-2WCYG75B.js";
 import "./chunk-PR4QN5HX.js";
 export {
   createAllAdapters,
@@ -14,4 +15,4 @@ export {
   getAvailableClis,
   isCliAvailable
 };
-//# sourceMappingURL=factory-OKNCTJO6.js.map
+//# sourceMappingURL=factory-IGHUOUBS.js.map

package/dist/factory-JNXETBS4.js

@@ -0,0 +1,14 @@
+import {
+  createGitHubProvider,
+  createScmProvider
+} from "./chunk-7J7D3LAL.js";
+import "./chunk-ZMERLMEP.js";
+import "./chunk-EL2KV773.js";
+import "./chunk-YLMB5MFQ.js";
+import "./chunk-2WCYG75B.js";
+import "./chunk-PR4QN5HX.js";
+export {
+  createGitHubProvider,
+  createScmProvider
+};
+//# sourceMappingURL=factory-JNXETBS4.js.map

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import { ZodError, z, ZodType, ZodSafeParseResult } from 'zod';
-import { C as CliNameLiteral, I as InputModality, O as OutputModality, T as ToolCapability, S as SpecialFeature, P as Pricing, Q as QualityScores, M as ModelId, V as VotingStrategy } from './consensus-vote-types-CoGbAEjf.js';
-export { A as AgentVoteSummary, a as ConsensusVoteInput, b as ConsensusVoteInputSchema, c as ConsensusVoteResponse, d as VoteDecisionStatus } from './consensus-vote-types-CoGbAEjf.js';
+import { C as CliNameLiteral, I as InputModality, O as OutputModality, T as ToolCapability, S as SpecialFeature, P as Pricing, Q as QualityScores, M as ModelId, V as VotingStrategy } from './consensus-vote-types-COAhHVIp.js';
+export { A as AgentVoteSummary, a as ConsensusVoteInput, b as ConsensusVoteInputSchema, c as ConsensusVoteResponse, d as VoteDecisionStatus } from './consensus-vote-types-COAhHVIp.js';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { Transport } from '@modelcontextprotocol/sdk/shared/transport.js';
 
@@ -532,9 +532,15 @@ interface IAgent {
     /**
      * Execute a task.
      * @param task - Task to execute
+     * @param options - Optional execution options (#3016/#3040).
+     *   `signal` cancels the in-flight model call when the caller's deadline
+     *   wins a race; without it, the SDK keeps running to its own 10-minute
+     *   timeout after the caller has already discarded the result.
      * @returns Result with TaskResult or AgentError
      */
-    execute(task: Task$1): Promise<Result<TaskResult, AgentError$1>>;
+    execute(task: Task$1, options?: {
+        signal?: AbortSignal;
+    }): Promise<Result<TaskResult, AgentError$1>>;
     /**
      * Handle an inter-agent message.
      * @param msg - Message to handle
@@ -1061,6 +1067,14 @@ interface CliTask {
     /** Additional CLI-specific options */
     readonly options?: Record<string, unknown>;
 }
+/**
+ * Internal resolved-options shape — every "default-able" field is
+ * required, but `signal` stays optional because it's a per-call hook,
+ * not a value with a default. Used by adapter internals (subprocess,
+ * codex-mcp) and tests as the "resolved" execution options. Public
+ * callers should keep using `ExecutionOptions` (everything optional).
+ */
+type ResolvedExecutionOptions = Required<Omit<ExecutionOptions$1, 'signal'>> & Pick<ExecutionOptions$1, 'signal'>;
 /**
  * Execution options for CLI adapters.
  */
@@ -1075,6 +1089,23 @@ interface ExecutionOptions$1 {
     readonly trackUsage?: boolean;
     /** Progress callback invoked on subprocess stdout activity (Issue #1087). */
     readonly onProgress?: (() => void) | undefined;
+    /**
+     * Cancellation signal (#3026 finding 2). When the signal aborts, the
+     * adapter must cancel the in-flight execution promptly — for
+     * subprocess adapters that means SIGTERM (with SIGKILL escalation
+     * per #3026 finding 1). Without this, callers that use
+     * `Promise.race([adapter.execute(task), timeout])` for cancellation
+     * leak orphan subprocesses on race-loser: the timeout promise wins
+     * the race but the adapter call keeps running, posting late results
+     * into OutcomeStore + LinUCB state for a task whose decision has
+     * already been recorded.
+     *
+     * Typed as `AbortSignal | undefined` (not `AbortSignal?`) so
+     * `Required<ExecutionOptions>` — used pervasively by adapter
+     * internals + tests as a resolved-options shape — keeps accepting
+     * `signal: undefined` under `exactOptionalPropertyTypes`.
+     */
+    readonly signal?: AbortSignal | undefined;
 }
 /**
  * CLI adapter interface.
@@ -2724,6 +2755,22 @@ interface CompletionRequest {
     responseFormat?: ResponseFormat;
     /** Stop sequences */
     stop?: string[];
+    /**
+     * Cancellation signal (#3036). When the signal aborts, the adapter
+     * cancels the in-flight model call. All five concrete adapters
+     * (claude, openai, ollama, gemini, openai-compat) honor this by
+     * passing the signal to their respective vendor SDK.
+     *
+     * Used by `withWatchdog` to cancel race-loser model calls when the
+     * worker-dispatch timeout wins. Without this, the SDK keeps running
+     * after `Promise.race` resolves with the timeout — late results land
+     * in OutcomeStore for a decision already discarded.
+     *
+     * Typed as `AbortSignal | undefined` (not `AbortSignal?`) so adapter
+     * internals that destructure `request` keep working under
+     * `exactOptionalPropertyTypes`.
+     */
+    signal?: AbortSignal | undefined;
 }
 /**
  * Token usage statistics.
@@ -3882,9 +3929,15 @@ interface IWorkflowEngine {
      * Execute a workflow with inputs.
      * @param workflow - Workflow definition
      * @param inputs - Input values
+     * @param options - Optional execution overrides. `phaseTimeoutMs` (#3017)
+     *   overrides the per-phase execution timeout for this run only — wins
+     *   over both `workflow.timeout` (set in the template YAML) and the
+     *   engine's `defaultTimeoutMs`.
      * @returns Result with WorkflowResult or WorkflowError
      */
-    execute(workflow: WorkflowDefinition, inputs: Record<string, unknown>): Promise<Result<WorkflowResult, WorkflowError>>;
+    execute(workflow: WorkflowDefinition, inputs: Record<string, unknown>, options?: {
+        phaseTimeoutMs?: number;
+    }): Promise<Result<WorkflowResult, WorkflowError>>;
     /**
      * Get execution status.
      * @param executionId - Execution ID to check
@@ -9210,12 +9263,22 @@ declare abstract class BaseAgent implements IAgent {
     private readonly memoryConfig;
     private memoryState;
     private relevantMemories;
+    /**
+     * AbortSignal set by `execute()` when the caller passes one. `complete()`
+     * forwards it onto `CompletionRequest.signal` so the in-flight model call
+     * cancels when the caller's deadline wins a race (#3016/#3040). Set only
+     * for the duration of one execute() and cleared in finally — the field is
+     * single-task scoped and never crosses tasks.
+     */
+    private currentExecutionSignal;
     constructor(options: BaseAgentOptions);
     get state(): AgentState$2;
     /** Builds the context state object for helper functions. */
     private get contextState();
     initialize(ctx: AgentContext): Promise<Result<void, AgentError$1>>;
-    execute(task: Task$1): Promise<Result<TaskResult, AgentError$1>>;
+    execute(task: Task$1, options?: {
+        signal?: AbortSignal;
+    }): Promise<Result<TaskResult, AgentError$1>>;
     handleMessage(msg: AgentMessage): Promise<Result<AgentResponse, AgentError$1>>;
     cleanup(): Promise<void>;
     hasCapability(capability: AgentCapability): boolean;
@@ -19774,6 +19837,12 @@ declare const RunWorkflowInputSchema: z.ZodObject<{
     template: z.ZodString;
     inputs: z.ZodRecord<z.ZodString, z.ZodUnknown>;
     dryRun: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    timeoutMs: z.ZodOptional<z.ZodNumber>;
+    mode: z.ZodOptional<z.ZodEnum<{
+        async: "async";
+        sync: "sync";
+    }>>;
+    idempotencyKey: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 type RunWorkflowInput = z.infer<typeof RunWorkflowInputSchema>;
 /**
@@ -19952,6 +20021,11 @@ declare const OrchestrateInputSchema: z.ZodObject<{
     context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     maxIterations: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     timeout: z.ZodOptional<z.ZodNumber>;
+    mode: z.ZodOptional<z.ZodEnum<{
+        async: "async";
+        sync: "sync";
+    }>>;
+    idempotencyKey: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 type OrchestrateInput = z.infer<typeof OrchestrateInputSchema>;
 declare const OrchestrateOutputSchema: z.ZodObject<{
@@ -24748,6 +24822,25 @@ declare class CapacityTracker {
     private readonly usageHistory;
     private requestCount;
     private windowStart;
+    /**
+     * Timestamps of every recorded request (#3026 finding 4).
+     *
+     * Pre-fix, `requestCount` was a plain counter reset only by the
+     * tumbling-window branch of `pruneOldEntries`. Under continuous
+     * traffic across a window boundary, that branch drops requests that
+     * are still inside the *sliding* window — e.g. with windowMs=60s, a
+     * request at t=59s followed by one at t=61s would tumbling-reset
+     * the counter to 1 even though the t=59s request is still inside
+     * the [1s, 61s] window. The downstream `remainingRequests === 0`
+     * exhaustion check fired prematurely (or too late) depending on
+     * burst patterns.
+     *
+     * Counting via a per-request timestamp array that's pruned the same
+     * way as `usageHistory` keeps the two views consistent. Every
+     * `recordUsage` pushes here; `requestCount` is derived from
+     * `.length` after pruning.
+     */
+    private requestTimestamps;
     constructor(config: CapacityTrackerConfig);
     /**
      * Records token usage from a completed request.
@@ -24816,7 +24909,7 @@ declare abstract class BaseCliAdapter implements ICliAdapter {
      * Abstract method for executing a task.
      * Implemented by concrete adapters.
      */
-    abstract executeTask(task: CliTask, options: Required<ExecutionOptions$1>): Promise<Result<CliResponse, CliError>>;
+    abstract executeTask(task: CliTask, options: ResolvedExecutionOptions): Promise<Result<CliResponse, CliError>>;
     /**
      * Abstract method for getting model info.
      * Implemented by concrete adapters.
@@ -24852,7 +24945,7 @@ declare abstract class BaseCliAdapter implements ICliAdapter {
      * the outer loop when their own transient-retry layer is active, so the
      * two layers do not nest into multiplied spawns (#2824).
      */
-    protected shouldOuterRetry(opts: Required<ExecutionOptions$1>): boolean;
+    protected shouldOuterRetry(opts: ResolvedExecutionOptions): boolean;
     /**
      * Executes task with retry logic via shared retry loop.
      */
@@ -25012,31 +25105,65 @@ declare abstract class SubprocessCliAdapter extends BaseCliAdapter {
      * (#2824). The outer loop still runs once, so circuit-breaker failure
      * recording is unaffected.
      */
-    protected shouldOuterRetry(opts: Required<ExecutionOptions$1>): boolean;
+    protected shouldOuterRetry(opts: ResolvedExecutionOptions): boolean;
     /**
      * Gets CLI command and arguments for execution.
      * If stdin is provided, it will be written to the process stdin.
      */
     protected abstract getCommand(task: CliTask): CommandConfig;
+    /**
+     * Invokes the optional cleanup hook supplied by getCommand(). Sync
+     * throws are swallowed (warn-only) and async rejections are caught
+     * so cleanup failures never bubble up and mask the real subprocess
+     * result.
+     */
+    private runSubprocessCleanup;
+    /**
+     * #3026 finding 2: SIGTERM the child when the caller's AbortSignal
+     * aborts mid-execution. Listener auto-detaches on `'close'` so we
+     * don't leak across child lifetimes.
+     */
+    private attachAbortSignal;
     /**
      * Executes a task via subprocess, with optional transient-error retry.
      * When `transientRetry.enabled` is true, transient errors (timeout,
      * rate_limit, connection, parse) are retried with exponential backoff
      * (500ms, 1000ms). Parse errors get max 1 retry (#1533); others get 2.
      */
-    executeTask(task: CliTask, options: Required<ExecutionOptions$1>): Promise<Result<CliResponse, CliError>>;
+    executeTask(task: CliTask, options: ResolvedExecutionOptions): Promise<Result<CliResponse, CliError>>;
     /**
      * Retries a transient error with bounded exponential backoff.
      */
     private retryTransient;
     /**
      * Spawns a single subprocess execution (no retry).
+     *
+     * `requestId` (#2963 site 3) correlates the timing-breakdown log emitted
+     * on subprocess close back to the parent `executeTask` invocation —
+     * essential when multiple subprocesses for the same CLI run concurrently
+     * (pipelines, votes) and the JSDoc's stated goal ("group by cli + provider
+     * + model and surface tail-latency outliers") requires a way to
+     * disambiguate which timing row belongs to which call.
      */
     private spawnSubprocess;
     /**
      * Sets up child process event handlers for output collection and error handling.
      */
     private setupChildProcessHandlers;
+    /**
+     * Schedules the SIGTERM-on-timeout + SIGKILL-on-grace escalation
+     * (#3026 finding 1).
+     *
+     * The primary timer fires SIGTERM and resolves the caller's promise
+     * immediately so it doesn't wait on a hung child. The escalation
+     * timer (`SIGKILL_GRACE_MS` later) checks whether the child actually
+     * exited and force-reaps it with SIGKILL if not — preventing
+     * zombie accumulation when a child ignores SIGTERM (Node CLIs that
+     * install graceful-shutdown handlers can hang on a broken stream).
+     * Both timers are cleared from the `'close'` handler so a child
+     * that exits within the grace window doesn't see the second signal.
+     */
+    private scheduleTimeoutWithSigkillEscalation;
     /** Attach stdout/stderr data handlers + capture first-byte time (#2472). */
     private attachStdoutHandlers;
     /**
@@ -25310,7 +25437,7 @@ declare class CodexMcpAdapter extends BaseCliAdapter {
      * Executes a task via MCP client.
      * Called by BaseCliAdapter.execute() with retry handling.
      */
-    executeTask(_task: CliTask, options: Required<ExecutionOptions$1>): Promise<Result<CliResponse, CliError>>;
+    executeTask(_task: CliTask, options: ResolvedExecutionOptions): Promise<Result<CliResponse, CliError>>;
     /**
      * Calls the codex or codex-reply tool on Codex MCP server.
      * @see https://developers.openai.com/codex/mcp/

package/dist/index.js

@@ -1,7 +1,7 @@
 import {
   createGitHubProvider,
   createScmProvider
-} from "./chunk-MATFDJRW.js";
+} from "./chunk-7J7D3LAL.js";
 import {
   ALLOWED_COMMANDS,
   ARTIFACT_TYPES,
@@ -519,26 +519,26 @@ import {
   validateWorkflow,
   validateWorkflowDependencies,
   withLogging
-} from "./chunk-J4ZBKE4B.js";
+} from "./chunk-6KZL5DMU.js";
 import {
   getTokenEnvVars,
   hasToken,
   resolveToken
-} from "./chunk-XODXYOFN.js";
+} from "./chunk-ZMERLMEP.js";
 import "./chunk-X2M7OF27.js";
 import {
   OPENAI_MODELS,
   OPENAI_MODEL_ALIASES,
   OpenAIAdapter,
   createOpenAIAdapter
-} from "./chunk-IM2B3FK2.js";
+} from "./chunk-ELVQORLX.js";
 import {
   CliCircuitBreakerIntegration,
   createCliCircuitBreakerIntegration
-} from "./chunk-BICIQYET.js";
+} from "./chunk-XZAWH36N.js";
 import {
   executeExpert
-} from "./chunk-SZZS57X7.js";
+} from "./chunk-ZF3MSYLG.js";
 import {
   AgentFindingSchema,
   AgentPerformanceSchema,
@@ -632,7 +632,7 @@ import {
   validateToolInput,
   withModelNotFoundFallback,
   wrapResilientWithFallback
-} from "./chunk-ODKIRXN7.js";
+} from "./chunk-IF6TXCSE.js";
 import {
   AdapterModelError,
   BaseAdapter,
@@ -656,11 +656,11 @@ import {
   transformStream,
   validateApiKeyPresence,
   withTimeout
-} from "./chunk-JA6ON2RP.js";
+} from "./chunk-6QKMUPDP.js";
 import {
   PROVIDER_ENV_KEYS
-} from "./chunk-6XRNFLPI.js";
-import "./chunk-FHY7I736.js";
+} from "./chunk-POTGGTJD.js";
+import "./chunk-QR5KHIZG.js";
 import {
   AgentActionSchema,
   GitHubReviewer,
@@ -693,11 +693,11 @@ import {
   sanitizeInput,
   validateAgentAction,
   validateCorroboration
-} from "./chunk-5QJPM5CB.js";
+} from "./chunk-NSOB2WRI.js";
 import {
   GitHubProvider,
   ScmError
-} from "./chunk-ZLGU7T6J.js";
+} from "./chunk-EL2KV773.js";
 import {
   FALLBACK_SCANNER_DATA,
   buildPlanFromAnalysis,
@@ -705,7 +705,7 @@ import {
   generateSecurityPlan,
   getRegistryManifest,
   resolveScannerData
-} from "./chunk-TKGVRHEI.js";
+} from "./chunk-J5S27RQ4.js";
 import {
   analyzeGitHubRepo,
   analyzeRepo,
@@ -715,10 +715,10 @@ import "./chunk-3ACDP4E6.js";
 import {
   PersistentStrategyDistiller,
   RulesSnapshotSchema
-} from "./chunk-HGPIHDC4.js";
+} from "./chunk-FR3P47J2.js";
 import {
   MemoryError
-} from "./chunk-7V367KT4.js";
+} from "./chunk-4SU4Q37U.js";
 import {
   AppConfigSchema,
   ExpertConfigSchema,
@@ -737,7 +737,7 @@ import {
   getKnownNexusVarNames,
   startStdioServer,
   validateNexusEnv
-} from "./chunk-4XSCU4B3.js";
+} from "./chunk-OXVOUVKH.js";
 import {
   AvailabilityCache,
   filterAvailableModels,
@@ -746,15 +746,15 @@ import {
   getFallbackChain,
   resetAvailabilityCache,
   resolveFallback
-} from "./chunk-W6MLS2UL.js";
+} from "./chunk-4S5GY2MF.js";
 import {
   AvailableModelsCache,
   getDefaultAvailableModelsCache,
   setDefaultAvailableModelsCache
-} from "./chunk-VXIHHHLQ.js";
+} from "./chunk-FOG7PMGM.js";
 import {
   DEFAULTS
-} from "./chunk-DWOSFYI2.js";
+} from "./chunk-25AQZKMN.js";
 import "./chunk-NUBSJGQZ.js";
 import "./chunk-6T3EPABN.js";
 import {
@@ -785,8 +785,9 @@ import {
   isCliAvailable,
   isRetryableError,
   sleep
-} from "./chunk-ELRNVADA.js";
-import "./chunk-LM2S2QWO.js";
+} from "./chunk-RTAIMK6P.js";
+import "./chunk-CIW2BVSN.js";
+import "./chunk-TRX7CAD5.js";
 import {
   BUILT_IN_EXPERTS,
   BuiltInExpertTypeSchema,
@@ -797,7 +798,7 @@ import {
   validateExpertConfig
 } from "./chunk-ZM4O442V.js";
 import "./chunk-PQHVC4BD.js";
-import "./chunk-UFUR6RBP.js";
+import "./chunk-LY2KLNXM.js";
 import {
   AgentCapability,
   AgentError,
@@ -872,8 +873,8 @@ import {
   toError,
   unwrap,
   unwrapOr
-} from "./chunk-6UI4NKT4.js";
-import "./chunk-I2HMWH4R.js";
+} from "./chunk-YLMB5MFQ.js";
+import "./chunk-2WCYG75B.js";
 import "./chunk-PR4QN5HX.js";
 
 // src/adapters/factory.ts
@@ -1484,6 +1485,36 @@ function withRetryWrapper(fn, options = {}) {
 
 // src/adapters/ollama-adapter.ts
 import { Ollama } from "ollama";
+
+// src/adapters/abort-utils.ts
+var AbortError = class extends Error {
+  name = "AbortError";
+  constructor(message = "Operation aborted") {
+    super(message);
+  }
+};
+function raceAbort(promise, signal) {
+  if (signal === void 0) return promise;
+  if (signal.aborted) return Promise.reject(new AbortError());
+  return new Promise((resolve2, reject) => {
+    const onAbort = () => {
+      reject(new AbortError());
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+    promise.then(
+      (value) => {
+        signal.removeEventListener("abort", onAbort);
+        resolve2(value);
+      },
+      (error) => {
+        signal.removeEventListener("abort", onAbort);
+        reject(error instanceof Error ? error : new Error(String(error)));
+      }
+    );
+  });
+}
+
+// src/adapters/ollama-adapter.ts
 var OLLAMA_MODELS = {
   LLAMA3_8B: "llama3:8b",
   LLAMA3_70B: "llama3:70b",
@@ -1603,7 +1634,8 @@ var OllamaAdapter = class extends BaseAdapter {
     this.logRequest(request);
     try {
       const params = this.buildRequestParams(request);
-      const response = await this.client.chat({ ...params, stream: false });
+      const chatPromise = this.client.chat({ ...params, stream: false });
+      const response = await raceAbort(chatPromise, request.signal);
       const result = this.mapResponse(response);
       this.logResponse(result);
       return ok(result);
@@ -1965,6 +1997,7 @@ var GeminiAdapter = class extends BaseAdapter {
     if (request.tools !== void 0 && request.tools.length > 0) {
       config.tools = [{ functionDeclarations: request.tools.map(mapToolToFunctionDeclaration) }];
     }
+    if (request.signal !== void 0) config.abortSignal = request.signal;
     return config;
   }
   /**
@@ -5937,7 +5970,7 @@ function buildVotingInput(plan, config) {
 }
 async function executeSingleVote(plan, config, log) {
   try {
-    const { executeVoting } = await import("./consensus-vote-MTLP6E72.js");
+    const { executeVoting } = await import("./consensus-vote-LPYEXUVC.js");
     const input = buildVotingInput(plan, config);
     const result = await executeVoting(input, log);
     return parseVotingResult(result);