@algosuite/vo-mcp 0.2.0-beta.35 → 0.2.0-beta.37

package/dist/runner-cli.js

@@ -2922,7 +2922,7 @@ function createControlPlaneClient({
     },
     /**
      * Read the operator's dispatch-mode config (Fast→Ultracode effort setting).
-     * Returns the mode string ('fast'|'standard'|'deep'|'ultra'|'ultracode'),
+     * Returns the mode string ('fast'|'standard'|'deep'|'ultra'|'marathon'; 'ultracode' legacy),
      * defaulting to 'standard' on any error. Never throws — best-effort.
      */
     async getDispatchMode() {
@@ -3284,6 +3284,22 @@ function flushAgentStreamBuffer({
   if (trailing) deliverAgentEvent(parseEvent(trailing), { onProgress, onResult });
   return "";
 }
+function nextDeadlineDecision({
+  nowMs,
+  startMs,
+  lastActivityMs,
+  maxWallClockMs = 0,
+  stallWindowMs = 6e5,
+  legacy = false
+} = {}) {
+  if (!(maxWallClockMs > 0)) return { action: "wait", delayMs: null };
+  const elapsed = nowMs - startMs;
+  if (elapsed < maxWallClockMs) return { action: "wait", delayMs: maxWallClockMs - elapsed };
+  if (legacy) return { action: "kill", stalledForMs: null };
+  const idle = nowMs - lastActivityMs;
+  if (idle >= stallWindowMs) return { action: "kill", stalledForMs: idle };
+  return { action: "wait", delayMs: stallWindowMs - idle };
+}
 function finalizeAgentTaskResult({
   result,
   bin,
@@ -3292,6 +3308,7 @@ function finalizeAgentTaskResult({
   killed,
   cancelReason,
   maxWallClockMs,
+  stalledForMs = null,
   forcedAfterResult,
   code,
   signal,
@@ -3302,7 +3319,8 @@ function finalizeAgentTaskResult({
       ...result,
       ok: false,
       timedOut: true,
-      summary: `wall-clock timeout (${maxWallClockMs}ms)`
+      stalledForMs,
+      summary: stalledForMs != null ? `stalled: no stream activity for ${stalledForMs}ms after the wall-clock deadline (${maxWallClockMs}ms)` : `wall-clock timeout (${maxWallClockMs}ms)`
     };
   }
   if (killed) {
@@ -4123,6 +4141,8 @@ function runAgentTask({
   shouldCancel = async () => false,
   cancelPollMs = 5e3,
   maxWallClockMs = 0,
+  stallWindowMs = Number(env2?.VO_CODE_RUNNER_STALL_WINDOW_MS) > 0 ? Number(env2.VO_CODE_RUNNER_STALL_WINDOW_MS) : 6e5,
+  legacyWallClock = env2?.VO_CODE_RUNNER_LEGACY_WALLCLOCK === "1",
   postResultExitGraceMs = 1e4,
   exitDrainGraceMs = 300,
   armTerminalCleanup = armTerminalProcessCleanup,
@@ -4250,6 +4270,7 @@ function runAgentTask({
         killed,
         cancelReason,
         maxWallClockMs,
+        stalledForMs,
         forcedAfterResult,
         code,
         signal,
@@ -4268,12 +4289,31 @@ function runAgentTask({
         }
       }, 5e3);
     };
-    const wallTimer = maxWallClockMs > 0 ? setTimeout(() => {
-      timedOut = true;
-      clearInterval(poll);
-      hardKill();
-    }, maxWallClockMs) : null;
+    const deadlineStartMs = Date.now();
+    let lastActivityMs = deadlineStartMs;
+    let stalledForMs = null;
+    let wallTimer = null;
+    const armDeadline = () => {
+      const decision = nextDeadlineDecision({
+        nowMs: Date.now(),
+        startMs: deadlineStartMs,
+        lastActivityMs,
+        maxWallClockMs,
+        stallWindowMs,
+        legacy: legacyWallClock
+      });
+      if (decision.action === "kill") {
+        timedOut = true;
+        stalledForMs = decision.stalledForMs;
+        clearInterval(poll);
+        hardKill();
+        return;
+      }
+      if (decision.delayMs != null) wallTimer = setTimeout(armDeadline, decision.delayMs);
+    };
+    armDeadline();
     child.stdout.on("data", (chunk) => {
+      lastActivityMs = Date.now();
       buffer = consumeAgentStreamChunk({
         chunk,
         buffer,
@@ -4283,6 +4323,7 @@ function runAgentTask({
       });
     });
     child.stderr.on("data", (c) => {
+      lastActivityMs = Date.now();
       stderrTail = (stderrTail + c.toString()).slice(-4e3);
     });
     child.on("error", (err) => {
@@ -6007,6 +6048,7 @@ function isMaxTurnsResult(summary) {
 }
 function partialPrTitlePrefix(run = {}) {
   if (isMaxTurnsResult(run.summary)) return "\u26A0 PARTIAL (max turns reached)";
+  if (run.timedOut && run.stalledForMs != null) return "\u26A0 PARTIAL (stalled \u2014 no progress after wall clock)";
   if (run.timedOut) return "\u26A0 PARTIAL (wall-clock timeout)";
   return "\u26A0 PARTIAL (needs continuation)";
 }
@@ -7119,6 +7161,98 @@ var init_dispatch_onboarding = __esm({
   }
 });
 
+// ../../scripts/virtual-office/code-runner/methodology-composer.mjs
+function classifyTaskShape(task) {
+  const prompt = String(task?.prompt || "");
+  for (const rule of SHAPE_RULES) {
+    if (rule.matches(task, prompt)) return rule.shape;
+  }
+  return "feature";
+}
+function composeMethodologyBlock(task) {
+  const shape = classifyTaskShape(task);
+  const lines = [
+    `## Methodology (auto-composed: ${shape})`,
+    ...UNIVERSAL_DIRECTIVES.map((d) => `- ${d}`),
+    ...(SHAPE_DIRECTIVES[shape] || []).map((d) => `- ${d}`)
+  ];
+  return { shape, block: lines.join("\n") };
+}
+function withMethodology(prompt, task) {
+  const { shape, block } = composeMethodologyBlock(task);
+  return { shape, prompt: `${prompt ?? ""}
+
+${block}` };
+}
+var SHAPE_RULES, UNIVERSAL_DIRECTIVES, SHAPE_DIRECTIVES;
+var init_methodology_composer = __esm({
+  "../../scripts/virtual-office/code-runner/methodology-composer.mjs"() {
+    "use strict";
+    SHAPE_RULES = [
+      {
+        shape: "recovery",
+        matches: (task, prompt) => Boolean(task?.resumed_from) || /VO_RECOVERY_FROM_CODE_TASK/u.test(prompt) || /previous run stopped before completion/iu.test(prompt)
+      },
+      {
+        shape: "pr-repair",
+        matches: (task) => typeof task?.repair_pr_number === "number"
+      },
+      {
+        shape: "bug-fix",
+        matches: (task, prompt) => Boolean(task?.bug_id) || /^reproduce and fix\b/iu.test(prompt) || /captured by: qa sweep/iu.test(prompt)
+      },
+      {
+        shape: "roadmap-advance",
+        matches: (task, prompt) => Boolean(task?.roadmap_app || task?.roadmap_item_id || typeof task?.roadmap_phase_index === "number") || /^roadmap:/iu.test(prompt)
+      },
+      {
+        shape: "research",
+        matches: (_task, prompt) => /\b(investigate|research|root[- ]cause|audit|diagnose|find out why|explain why)\b/iu.test(prompt)
+      },
+      {
+        shape: "design",
+        matches: (_task, prompt) => /\b(design doc|architecture|architect|adr\b|lane brief|write a plan|propose (a|the) (design|plan|approach))\b/iu.test(prompt)
+      },
+      {
+        shape: "chore",
+        matches: (_task, prompt) => prompt.length < 400 && /\b(typo|rename|bump|readme|changelog|comment|reword|lint fix|formatting)\b/iu.test(prompt)
+      }
+    ];
+    UNIVERSAL_DIRECTIVES = [
+      "Verification is a stage, not a vibe: before publishing, run the tests/build your change touches and cite their actual output. A claim without execution evidence is not done.",
+      "Work to completion or end with an explicit failure reason. Do not stop because time has passed; stop when the evidence says the work is done \u2014 or state exactly what is blocking.",
+      "Default to doing the work yourself in this session. Spawn parallel subagents ONLY for pieces that are genuinely independent and independently verifiable \u2014 and verify their results yourself before integrating; never let unreviewed parallel output merge into shared files."
+    ];
+    SHAPE_DIRECTIVES = {
+      "bug-fix": [
+        "Reproduce first: write the check that fails because of this bug, prove it fails, then fix, then prove the same check passes. A fix without a failing-then-passing check is not a fix."
+      ],
+      research: [
+        "Every claim needs its source AND exact attribution \u2014 which file:line, which benchmark, which baseline, which version. Verify attribution, not just that a source exists; misattributed real facts are the dominant research failure mode.",
+        "Deliver findings as a repo artifact (docs/) with the evidence inline, not only as chat output."
+      ],
+      "roadmap-advance": [
+        "Update the roadmap doc status, regenerate the roadmap board if the doc changed, and add the roadmap-log fragment IN THIS SAME PR \u2014 a roadmap task that does not move the roadmap did not happen."
+      ],
+      design: [
+        "Produce the plan artifact (docs/lanes/ or docs/adr/ with a Related section) BEFORE writing code. State the requirements you are designing to at the top; ambiguity resolved now is rework avoided later."
+      ],
+      recovery: [
+        "Restore the preserved context first (draft PR, branch, checkpoint notes) and finish the ORIGINAL spec. Do not redo work that is already committed; verify what exists, then close the gap."
+      ],
+      "pr-repair": [
+        "Work from the exact materialized PR source. Never force-push or rebase the existing branch; publish the replacement and let the host close the original."
+      ],
+      chore: [
+        "Keep the diff minimal and mechanical. No fan-out, no speculative refactors; the verification stage is still required."
+      ],
+      feature: [
+        "Ship the tests that prove the feature works in the same change, to the output-verified standard (assert the correct answer, not that something rendered)."
+      ]
+    };
+  }
+});
+
 // ../../scripts/virtual-office/code-runner/task-prompt.mjs
 function buildMissingKnowledgeMessage(taskId, reason) {
   const id = taskId || "unknown-task";
@@ -7162,11 +7296,16 @@ function withAttachmentManifest(prompt, markdown) {
 
 ${manifest}` : prompt;
 }
+function withComposedMethodology(prompt, task, log2, taskId) {
+  const { shape, prompt: composed } = withMethodology(prompt, task);
+  log2(`task ${taskId || "unknown-task"}: methodology shape=${shape}`);
+  return composed;
+}
 async function composeCodeTaskPrompt(client, task, { log: log2 = () => {
 }, allowMissingKnowledgeContext = false, attachmentManifestMarkdown = "" } = {}) {
   const taskId = task?.code_task_id;
   if (!taskId) {
-    return composeDispatchPrompt(withAttachmentManifest(task?.prompt, attachmentManifestMarkdown), {
+    return composeDispatchPrompt(withComposedMethodology(withAttachmentManifest(task?.prompt, attachmentManifestMarkdown), task, log2, taskId), {
       repo: task?.repo,
       knowledgeContextMarkdown: handleMissingKnowledgeContext(taskId, "missing code_task_id on the claimed task", {
         allowMissingKnowledgeContext,
@@ -7175,7 +7314,7 @@ async function composeCodeTaskPrompt(client, task, { log: log2 = () => {
     });
   }
   if (typeof client?.getTaskKnowledgeContext !== "function") {
-    return composeDispatchPrompt(withAttachmentManifest(task?.prompt, attachmentManifestMarkdown), {
+    return composeDispatchPrompt(withComposedMethodology(withAttachmentManifest(task?.prompt, attachmentManifestMarkdown), task, log2, taskId), {
       repo: task?.repo,
       knowledgeContextMarkdown: handleMissingKnowledgeContext(taskId, "control-plane client cannot fetch knowledge context", {
         allowMissingKnowledgeContext,
@@ -7204,7 +7343,7 @@ async function composeCodeTaskPrompt(client, task, { log: log2 = () => {
   const prompt = operatorInstructions ? `${task?.prompt ?? ""}
 
 ${operatorInstructions}` : task?.prompt;
-  return composeDispatchPrompt(withAttachmentManifest(prompt, attachmentManifestMarkdown), {
+  return composeDispatchPrompt(withComposedMethodology(withAttachmentManifest(prompt, attachmentManifestMarkdown), task, log2, taskId), {
     repo: task?.repo,
     knowledgeContextMarkdown
   });
@@ -7214,6 +7353,7 @@ var init_task_prompt = __esm({
   "../../scripts/virtual-office/code-runner/task-prompt.mjs"() {
     "use strict";
     init_dispatch_onboarding();
+    init_methodology_composer();
     ALLOW_MISSING_KNOWLEDGE_CONTEXT_ENV = "VO_CODE_RUNNER_ALLOW_MISSING_KNOWLEDGE_CONTEXT";
   }
 });
@@ -9763,7 +9903,21 @@ var init_control_server = __esm({
 // ../../scripts/virtual-office/code-runner/effort-mode-config.mjs
 function resolveEffortMode(mode) {
   const normalized = String(mode || "").trim().toLowerCase();
-  return EFFORT_MODE_CONFIG[normalized] || EFFORT_MODE_CONFIG[DEFAULT_MODE];
+  const canonical = LEGACY_MODE_ALIASES[normalized] || normalized;
+  return EFFORT_MODE_CONFIG[canonical] || EFFORT_MODE_CONFIG[DEFAULT_MODE];
+}
+function resolveDefaultBudgetUsd(env2 = {}) {
+  const raw = env2?.[DEFAULT_BUDGET_USD_ENV];
+  if (raw === void 0 || raw === null) return null;
+  const parsed = Number(String(raw).trim());
+  if (!Number.isFinite(parsed) || parsed <= 0) return null;
+  return parsed;
+}
+function resolveDispatchBudgetUsd({ taskBudgetUsd, env: env2 = {} } = {}) {
+  if (typeof taskBudgetUsd === "number" && Number.isFinite(taskBudgetUsd)) {
+    return taskBudgetUsd;
+  }
+  return resolveDefaultBudgetUsd(env2);
 }
 function composeEffortPrompt(basePrompt, effortConfig) {
   const parts = [];
@@ -9780,15 +9934,16 @@ ${effortConfig.multiAgentInstruction}
   parts.push(String(basePrompt || "").trim());
   return parts.join("\n");
 }
-var RED_TEAM_DIRECTIVE, EFFORT_MODE_CONFIG, DEFAULT_MODE;
+var RED_TEAM_DIRECTIVE, DEFAULT_BUDGET_USD_ENV, EFFORT_MODE_CONFIG, DEFAULT_MODE, LEGACY_MODE_ALIASES;
 var init_effort_mode_config = __esm({
   "../../scripts/virtual-office/code-runner/effort-mode-config.mjs"() {
     "use strict";
     RED_TEAM_DIRECTIVE = "Before declaring done, red-team your own work: name the top ways it could be wrong \u2014 especially code that is correct but silently not wired into production callers \u2014 give the failure scenario for each, and state the evidence that rules it out.";
+    DEFAULT_BUDGET_USD_ENV = "VO_CODE_RUNNER_DEFAULT_BUDGET_USD";
     EFFORT_MODE_CONFIG = {
       fast: {
         tier: "cheap",
-        maxBudgetUsd: 1,
+        maxBudgetUsd: null,
         permissionMode: "acceptEdits",
         maxTurns: 80,
         thinkingDirective: RED_TEAM_DIRECTIVE,
@@ -9796,7 +9951,7 @@ var init_effort_mode_config = __esm({
       },
       standard: {
         tier: "mid",
-        maxBudgetUsd: 3,
+        maxBudgetUsd: null,
         permissionMode: "acceptEdits",
         maxTurns: 200,
         thinkingDirective: RED_TEAM_DIRECTIVE,
@@ -9804,7 +9959,7 @@ var init_effort_mode_config = __esm({
       },
       deep: {
         tier: "best",
-        maxBudgetUsd: 10,
+        maxBudgetUsd: null,
         permissionMode: "acceptEdits",
         maxTurns: 300,
         thinkingDirective: `Think step-by-step. Verify assumptions against source code. Check edge cases. ${RED_TEAM_DIRECTIVE}`,
@@ -9812,15 +9967,15 @@ var init_effort_mode_config = __esm({
       },
       ultra: {
         tier: "best",
-        maxBudgetUsd: 25,
+        maxBudgetUsd: null,
         permissionMode: "acceptEdits",
         maxTurns: 500,
         thinkingDirective: `Think step-by-step. Exhaustively verify every assumption against source code and documentation. ${RED_TEAM_DIRECTIVE}`,
         multiAgentInstruction: "If this task needs multiple phases (research, build, verify), propose a plan first."
       },
-      ultracode: {
+      marathon: {
         tier: "best",
-        maxBudgetUsd: 50,
+        maxBudgetUsd: null,
         permissionMode: "acceptEdits",
         maxTurns: 800,
         thinkingDirective: `Think step-by-step. Exhaustively verify every assumption against source code and documentation. Build worked examples to validate correctness. ${RED_TEAM_DIRECTIVE}`,
@@ -9828,6 +9983,7 @@ var init_effort_mode_config = __esm({
       }
     };
     DEFAULT_MODE = "standard";
+    LEGACY_MODE_ALIASES = { ultracode: "marathon" };
   }
 });
 
@@ -11024,7 +11180,12 @@ async function resolveEffortDispatch({ client, task, agent = "claude", env: env2
     permissionMode: env2.VO_CODE_RUNNER_PERMISSION_MODE || effortConfig.permissionMode,
     maxTurns: typeof task.max_turns === "number" ? task.max_turns : applying ? decision.maxTurns : effortConfig.maxTurns,
     effort,
-    maxBudgetUsd: typeof task.max_budget_usd === "number" ? task.max_budget_usd : applying ? decision.maxBudgetUsd : effortConfig.maxBudgetUsd,
+    // Default dollar ceilings are OFF (2026-08-13). Only an EXPLICIT per-task
+    // budget — or the VO_CODE_RUNNER_DEFAULT_BUDGET_USD override a BYO-API-key
+    // operator sets — produces a `--max-budget-usd` flag. The router's dollar
+    // rung is a default too, so it is suppressed with the rest; the router
+    // still governs tier, effort, and maxTurns (the real runaway bound).
+    maxBudgetUsd: resolveDispatchBudgetUsd({ taskBudgetUsd: task.max_budget_usd, env: env2 }),
     prompt: composeEffortPrompt(basePrompt, effortConfig),
     routerDecision: decision ? toPersistedRouterDecision(decision, model) : null
   };
@@ -13352,7 +13513,7 @@ async function processOneTask(client, task, cfg, runnerInstanceId, swarmAdmissio
     const sandbox = resolveRunnerSandbox(process.env, sel.agent);
     await safeProgress(client, id, runnerStagePatch(
       "starting_agent",
-      `${cfg.runnerId} spawning ${sel.agent}:${model || "default"} (${tier}, effort ${dispatchMode}; ${sel.agent === "claude" ? `$${effectiveMaxBudgetUsd} hard API-equivalent cap` : "20m wall-clock cap"}${routerMode !== "off" && routerDecision ? `; auto-router ${routerMode}: ${routerDecision.rung}${routerDecision.effort ? ` effort=${routerDecision.effort}` : ""}` : ""})`,
+      `${cfg.runnerId} spawning ${sel.agent}:${model || "default"} (${tier}, effort ${dispatchMode}; ${sel.agent === "claude" ? typeof effectiveMaxBudgetUsd === "number" && effectiveMaxBudgetUsd > 0 ? `$${effectiveMaxBudgetUsd} hard API-equivalent cap` : `no dollar cap, ${effectiveMaxTurns}-turn ceiling` : "20m wall-clock cap"}${routerMode !== "off" && routerDecision ? `; auto-router ${routerMode}: ${routerDecision.rung}${routerDecision.effort ? ` effort=${routerDecision.effort}` : ""}` : ""})`,
       routerDecision ? { router_decision: routerDecision } : {}
     ));
     const cap = typeof attemptBudgetUsd === "number" ? attemptBudgetUsd : resolveCodeDispatchCapUsd();