@chllming/wave-orchestration 0.6.0 → 0.6.2

package/docs/research/agent-context-sources.md

@@ -7,6 +7,8 @@ summary: "Primary external sources used as inspiration for planning, harness des
 
 This repository does not commit converted paper/article caches. Keep any hydrated local copies under `docs/research/agent-context-cache/` or another ignored cache directory.
 
+For a narrative synthesis of the most relevant MAS failure modes and how Wave responds to them, start with [coordination-failure-review.md](./coordination-failure-review.md) and then use this page as the bibliography.
+
 ## Practice Articles
 
 - [Harness engineering: leveraging Codex in an agent-first world](https://openai.com/index/harness-engineering/)

package/docs/research/coordination-failure-review.md

@@ -17,7 +17,28 @@ The Wave orchestrator addresses several coordination failure modes constructivel
 
 That is materially stronger than the common "agents talk in a shared channel and we hope that was enough" pattern criticized by recent multi-agent papers.
 
-The main weakness is empirical, not architectural. The repo does not yet contain a benchmark family that proves the blackboard actually helps agents reconstruct distributed state under HiddenBench or Silo-Bench style pressure, or that it handles DPBench-style simultaneous coordination reliably.
+The main weakness is empirical, not architectural. The repo now carries coordination-oriented benchmark vocabulary, but it does not yet present enough hard evidence that the blackboard reconstructs distributed state under HiddenBench or Silo-Bench style pressure, or that it handles DPBench-style simultaneous coordination reliably.
+
+## Common MAS Failure Cases
+
+The research cited in this repo keeps returning to a fairly stable set of failure modes. In Wave language, the common ones are:
+
+- `Cosmetic board, no canonical state`
+  Agents appear coordinated because they share a board or chat, but there is no machine-trustable source of truth underneath. Wave responds with a canonical coordination log and treats the board as a projection.
+- `Hidden evidence never gets pooled`
+  One agent has the decision-changing fact, but it never reaches the shared state before closure. Wave responds with shared summaries, per-agent inboxes, and integration gating, but this still needs stronger empirical validation.
+- `Communication without global-state reconstruction`
+  Agents exchange information, yet nobody reconstructs the correct cross-agent picture. Wave responds with integration summaries and barrier-based closure so the final decision depends on integrated state rather than message volume.
+- `Simultaneous coordination collapse`
+  A team that looks competent in serial work falls apart when multiple owners, blockers, or resources must move together. Wave responds with helper assignments, dependency barriers, and staged closure, but still lacks a stronger contention benchmark story.
+- `Expert signal gets averaged away`
+  The strongest specialist view is diluted into a weaker compromise. Wave responds with explicit ownership, named stewards, and capability routing instead of free-form consensus, though expertise weighting is still shallow.
+- `Blackboard projection drift`
+  The raw shared state may be right, but summaries, inboxes, ledgers, or integration artifacts lose the important fact. Wave responds by compiling those surfaces from canonical state and by adding `blackboard-fidelity` to the eval vocabulary.
+- `Contradictions get smoothed over`
+  Conflicting claims look resolved in prose, but the system never turns them into bounded repair work. Wave responds with clarification flow, integration barriers, and contradiction-oriented eval vocabulary, though subtle semantic conflicts can still leak through.
+- `Premature closure`
+  Agents say they are done before proof, evals, or integrated state actually support PASS. Wave responds with structured proof markers, exit contracts, eval gates, closure stewards, and replay-visible traces.
 
 ## What The Papers Warn About
 
@@ -175,23 +196,26 @@ That alignment matters. In many MAS projects the docs promise a blackboard, but
 
 ## What Is Still Missing To Make The Claim Credible
 
-### 1. No distributed-information benchmark family yet
+### 1. The benchmark vocabulary exists, but the empirical proof is still thin
 
-The biggest gap is in [docs/evals/benchmark-catalog.json](../evals/benchmark-catalog.json). The current families are:
+[docs/evals/benchmark-catalog.json](../evals/benchmark-catalog.json) and [docs/evals/README.md](../evals/README.md) now define coordination-oriented benchmark families such as:
 
-- `service-output`
-- `latency`
-- `quality-regression`
+- `hidden-profile-pooling`
+- `silo-escape`
+- `simultaneous-coordination`
+- `expertise-leverage`
+- `blackboard-fidelity`
+- `contradiction-recovery`
 
-There is nothing yet for:
+That is a real improvement because the repo now has a vocabulary for the exact MAS failures the research highlights.
 
-- hidden-profile reconstruction
-- silo escape under partial information
-- blackboard consistency across raw log, summary, inboxes, ledger, and integration state
-- contradiction injection and recovery
-- simultaneous coordination under contention
+The remaining gap is not the absence of categories. The gap is still empirical proof:
 
-So the repo can reasonably claim "we built mechanisms intended to mitigate these failures," but it cannot yet claim "we demonstrated that these mechanisms overcome the failures highlighted by HiddenBench, Silo-Bench, or DPBench."
+- not enough published results showing those families are exercised systematically
+- not enough evidence that the blackboard actually improves hidden-state reconstruction
+- not enough stress data showing simultaneous coordination remains reliable under contention
+
+So the repo can reasonably claim "we built mechanisms and eval categories intended to mitigate these failures," but it still cannot claim "we demonstrated that those mechanisms consistently overcome the failures highlighted by HiddenBench, Silo-Bench, or DPBench."
 
 ### 2. Information integration is supported, but not measured directly
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chllming/wave-orchestration",
-  "version": "0.6.0",
+  "version": "0.6.2",
   "license": "MIT",
   "description": "Generic wave-based multi-agent orchestration for repository work.",
   "repository": {

package/releases/manifest.json

@@ -2,6 +2,39 @@
   "schemaVersion": 1,
   "packageName": "@chllming/wave-orchestration",
   "releases": [
+    {
+      "version": "0.6.2",
+      "date": "2026-03-22",
+      "summary": "Runtime preview visibility, dashboard/operator UX fixes, dry-run cleanup, and safer shared-component retries.",
+      "features": [
+        "Claude runtime config now exposes first-class `claude.effort`, and runtime previews now include structured `limits` metadata for known attempt and turn ceilings.",
+        "Codex previews and docs now make turn-limit visibility explicit: Wave records when it emitted no Codex turn-limit flag and warns that any effective ceiling may come from the selected Codex profile or upstream runtime.",
+        "The dashboard surface now distinguishes done, active, pending, and failed counts, keeps a stable `Current Wave Dashboard` terminal target, and adds simple TTY color cues for faster scanning.",
+        "Dry-run executor preview directories are pruned when wave agent sets shrink, so stale overlay folders no longer linger under `.tmp/.../dry-run/executors/`.",
+        "Shared promoted-component retries now preserve already-landed owner slices and relaunch only the sibling owners still required for closure proof."
+      ],
+      "manualSteps": [
+        "After upgrading, rerun `pnpm exec wave doctor` and `pnpm exec wave launch --lane main --dry-run --no-dashboard` to inspect the new preview `limits` metadata and confirm your repo runtime config still resolves as expected.",
+        "If you relied on a local Claude wrapper only to inject `--effort`, move that setting into `wave.config.json` or the agent `### Executor` block and retire the wrapper when convenient.",
+        "If you document Codex turn ceilings in repo-local guidance, update that guidance to reflect that Wave now reports Codex ceiling visibility as opaque unless the limit is surfaced by the selected Codex profile or runtime."
+      ],
+      "breaking": false
+    },
+    {
+      "version": "0.6.1",
+      "date": "2026-03-22",
+      "summary": "Patch release that aligns the published package with merged main and refreshed 0.6.1 release docs.",
+      "features": [
+        "The package version and release metadata now advertise `0.6.1` consistently across `package.json`, the shipped README, the changelog, and the release manifest.",
+        "Current-surface docs such as runtime configuration, sample waves, eval guidance, migration notes, and npm publishing instructions now point at the `0.6.1` release instead of the earlier `0.6.0` tag.",
+        "This patch release carries forward the `0.6.0` runtime behavior, including the workspace-scoped tmux resource isolation fix that unblocked publish-time CI."
+      ],
+      "manualSteps": [
+        "After upgrading, rerun `pnpm exec wave doctor` and `pnpm exec wave launch --lane main --dry-run --no-dashboard` if you want to verify your repo against the same `0.6.1` package surface documented in this release.",
+        "If you pinned package docs or release references to `0.6.0`, update them to `0.6.1` so your operator guidance matches the published package tag."
+      ],
+      "breaking": false
+    },
     {
       "version": "0.6.0",
       "date": "2026-03-22",

package/scripts/wave-orchestrator/agent-state.mjs

@@ -183,7 +183,7 @@ function findLatestComponentMatches(text) {
   return Array.from(byComponent.values());
 }
 
-function detectTermination(logText, statusRecord) {
+function detectTermination(agent, logText, statusRecord) {
   const patterns = [
     { reason: "max-turns", regex: /(Reached max turns \(\d+\))/i },
     { reason: "timeout", regex: /(timed out(?: after [^\n.]+)?)/i },
@@ -192,9 +192,16 @@ function detectTermination(logText, statusRecord) {
   for (const pattern of patterns) {
     const match = String(logText || "").match(pattern.regex);
     if (match) {
+      const baseHint = cleanText(match[1] || match[0]);
+      if (pattern.reason === "max-turns" && agent?.executorResolved?.id === "codex") {
+        return {
+          reason: pattern.reason,
+          hint: `${baseHint}. Wave does not set a Codex turn-limit flag; inspect launch-preview.json limits for any profile or upstream-runtime ceiling notes.`,
+        };
+      }
       return {
         reason: pattern.reason,
-        hint: cleanText(match[1] || match[0]),
+        hint: baseHint,
       };
     }
   }
@@ -341,7 +348,7 @@ export function buildAgentExecutionSummary({ agent, statusRecord, logPath, repor
   const reportVerdict = parseVerdictFromText(reportText, REPORT_VERDICT_REGEX);
   const logVerdict = parseVerdictFromText(signalText, WAVE_VERDICT_REGEX);
   const verdict = reportVerdict.verdict ? reportVerdict : logVerdict;
-  const termination = detectTermination(logText, statusRecord);
+  const termination = detectTermination(agent, logText, statusRecord);
   return {
     agentId: agent?.agentId || null,
     promptHash: statusRecord?.promptHash || null,

package/scripts/wave-orchestrator/config.mjs

@@ -445,6 +445,19 @@ function normalizeClaudeOutputFormat(value, label = "executors.claude.outputForm
   return normalized;
 }
 
+export function normalizeClaudeEffort(value, label = "executors.claude.effort", fallback = null) {
+  const normalized = String(value ?? "")
+    .trim()
+    .toLowerCase();
+  if (!normalized) {
+    return fallback;
+  }
+  if (!["low", "medium", "high", "max"].includes(normalized)) {
+    throw new Error(`${label} must be one of: low, medium, high, max`);
+  }
+  return normalized;
+}
+
 function normalizeOpenCodeFormat(value, label = "executors.opencode.format") {
   const normalized = String(value || "default")
     .trim()
@@ -519,6 +532,11 @@ function normalizeExecutorProfile(rawProfile = {}, label = "executors.profiles.<
             rawProfile.claude.permissionPromptTool,
             null,
           ),
+          effort: normalizeClaudeEffort(
+            rawProfile.claude.effort,
+            `${label}.claude.effort`,
+            null,
+          ),
           maxTurns: normalizeOptionalPositiveInt(
             rawProfile.claude.maxTurns,
             `${label}.claude.maxTurns`,
@@ -685,6 +703,7 @@ function normalizeExecutors(rawExecutors = {}) {
         executors.claude?.permissionPromptTool,
         null,
       ),
+      effort: normalizeClaudeEffort(executors.claude?.effort, "executors.claude.effort", null),
       maxTurns: normalizeOptionalPositiveInt(executors.claude?.maxTurns, "executors.claude.maxTurns"),
       mcpConfig: normalizeOptionalStringOrStringArray(
         executors.claude?.mcpConfig,

package/scripts/wave-orchestrator/dashboard-renderer.mjs

@@ -1,7 +1,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import { analyzeMessageBoardCommunication } from "./coordination.mjs";
-import { commsAgeSummary, deploymentSummary, renderCountsByState } from "./dashboard-state.mjs";
+import { commsAgeSummary, deploymentSummary } from "./dashboard-state.mjs";
 import {
   DEFAULT_REFRESH_MS,
   DEFAULT_WAVE_LANE,
@@ -81,20 +81,125 @@ function isGlobalDashboardState(state) {
   return Boolean(state && Array.isArray(state.waves) && !Array.isArray(state.agents));
 }
 
-function renderWaveDashboard({ state, dashboardPath, messageBoardPath, lane }) {
+const ANSI = {
+  reset: "\u001b[0m",
+  dim: "\u001b[2m",
+  red: "\u001b[31m",
+  green: "\u001b[32m",
+  yellow: "\u001b[33m",
+  blue: "\u001b[34m",
+  magenta: "\u001b[35m",
+  cyan: "\u001b[36m",
+};
+
+function paint(text, color, colorize = false) {
+  if (!colorize || !color) {
+    return text;
+  }
+  return `${color}${text}${ANSI.reset}`;
+}
+
+function paintState(text, state, colorize = false) {
+  const normalized = String(state || "").trim().toLowerCase();
+  const color =
+    normalized === "completed"
+      ? ANSI.green
+      : normalized === "failed" || normalized === "timed_out"
+        ? ANSI.red
+        : normalized === "deploying" || normalized === "finalizing" || normalized === "validating"
+          ? ANSI.yellow
+          : normalized === "running" || normalized === "coding" || normalized === "launching"
+            ? ANSI.cyan
+            : normalized === "pending"
+              ? ANSI.dim
+              : normalized === "dry-run"
+                ? ANSI.magenta
+                : null;
+  return paint(text, color, colorize);
+}
+
+function paintLevel(text, level, colorize = false) {
+  const normalized = String(level || "").trim().toLowerCase();
+  const color =
+    normalized === "error"
+      ? ANSI.red
+      : normalized === "warn"
+        ? ANSI.yellow
+        : normalized === "info"
+          ? ANSI.blue
+          : null;
+  return paint(text, color, colorize);
+}
+
+function paintExitCode(text, exitCode, colorize = false) {
+  if (exitCode === 0 || exitCode === "0") {
+    return paint(text, ANSI.green, colorize);
+  }
+  if (exitCode === null || exitCode === undefined || exitCode === "-") {
+    return text;
+  }
+  return paint(text, ANSI.red, colorize);
+}
+
+function paintDeploymentSummary(text, deploymentState, colorize = false) {
+  const normalized = String(deploymentState || "").trim().toLowerCase();
+  const color =
+    normalized === "healthy"
+      ? ANSI.green
+      : normalized === "failed"
+        ? ANSI.red
+        : normalized === "deploying" || normalized === "rolledover"
+          ? ANSI.yellow
+          : null;
+  return paint(text, color, colorize);
+}
+
+function renderColoredCountsByState(agents, colorize = false) {
+  const counts = new Map();
+  for (const agent of agents || []) {
+    const key = agent?.state || "unknown";
+    counts.set(key, (counts.get(key) || 0) + 1);
+  }
+  return Array.from(counts.entries())
+    .toSorted((a, b) => a[0].localeCompare(b[0]))
+    .map(([state, count]) => `${paintState(state, state, colorize)}:${count}`)
+    .join("  ");
+}
+
+function paintWaveAgentSummary(summary, wave, colorize = false) {
+  const failed = Number(wave?.agentsFailed ?? 0) || 0;
+  const active = Number(wave?.agentsActive ?? 0) || 0;
+  const total = Number(wave?.agentsTotal ?? 0) || 0;
+  const completed = Number(wave?.agentsCompleted ?? 0) || 0;
+  const color =
+    failed > 0
+      ? ANSI.red
+      : active > 0
+        ? ANSI.cyan
+        : total > 0 && completed >= total
+          ? ANSI.green
+          : ANSI.dim;
+  return paint(summary, color, colorize);
+}
+
+function renderWaveDashboard({ state, dashboardPath, messageBoardPath, lane, colorize = false }) {
   if (!state) {
     return `Dashboard file not found or invalid: ${dashboardPath}`;
   }
   const lines = [];
   const laneName = String(state?.lane || lane || "").trim() || DEFAULT_WAVE_LANE;
   lines.push(
-    `${laneName} Wave Dashboard | wave=${state.wave ?? "?"} | status=${state.status ?? "unknown"} | attempt=${state.attempt ?? "?"}/${state.maxAttempts ?? "?"}`,
+    `${laneName} Wave Dashboard | wave=${state.wave ?? "?"} | status=${paintState(
+      state.status ?? "unknown",
+      state.status,
+      colorize,
+    )} | attempt=${state.attempt ?? "?"}/${state.maxAttempts ?? "?"}`,
   );
   lines.push(
     `Updated ${formatAgeFromTimestamp(Date.parse(state.updatedAt || ""))} | Started ${state.startedAt || "n/a"} | Elapsed ${formatElapsed(state.startedAt)}`,
   );
   lines.push(`Run tag: ${state.runTag || "n/a"} | Wave file: ${state.waveFile || "n/a"}`);
-  lines.push(`Counts: ${renderCountsByState(state.agents || []) || "none"}`);
+  lines.push(`Counts: ${renderColoredCountsByState(state.agents || [], colorize) || "none"}`);
   const comms = analyzeMessageBoardCommunication(messageBoardPath);
   if (!comms.available) {
     lines.push(`Comms: unavailable ${comms.reason || ""}`.trim());
@@ -116,10 +221,19 @@ function renderWaveDashboard({ state, dashboardPath, messageBoardPath, lane }) {
   );
   for (const agent of state.agents || []) {
     lines.push(
-      `${pad(agent.agentId || "-", 8)} ${pad(agent.state || "-", 12)} ${pad(agent.attempts ?? 0, 8)} ${pad(
-        agent.exitCode ?? "-",
-        6,
-      )} ${pad(deploymentSummary({ service: agent.deploymentService, state: agent.deploymentState }), 24)} ${pad(
+      `${pad(agent.agentId || "-", 8)} ${paintState(
+        pad(agent.state || "-", 12),
+        agent.state,
+        colorize,
+      )} ${pad(agent.attempts ?? 0, 8)} ${paintExitCode(
+        pad(agent.exitCode ?? "-", 6),
+        agent.exitCode,
+        colorize,
+      )} ${paintDeploymentSummary(
+        pad(deploymentSummary({ service: agent.deploymentService, state: agent.deploymentState }), 24),
+        agent.deploymentState,
+        colorize,
+      )} ${pad(
         formatAgeFromTimestamp(Date.parse(agent.lastUpdateAt || "")),
         12,
       )} ${truncate(agent.detail || "", 72)}`,
@@ -130,7 +244,7 @@ function renderWaveDashboard({ state, dashboardPath, messageBoardPath, lane }) {
   for (const event of (state.events || []).slice(-12)) {
     const prefix = event.agentId ? `[${event.agentId}]` : "[wave]";
     lines.push(
-      `${event.at || "n/a"} ${pad(event.level || "info", 5)} ${prefix} ${event.message || ""}`,
+      `${event.at || "n/a"} ${paintLevel(pad(event.level || "info", 5), event.level, colorize)} ${prefix} ${event.message || ""}`,
     );
   }
   if ((state.events || []).length === 0) {
@@ -143,14 +257,29 @@ function renderWaveDashboard({ state, dashboardPath, messageBoardPath, lane }) {
   return lines.join("\n");
 }
 
-function renderGlobalDashboard({ state, dashboardPath, lane }) {
+function renderGlobalDashboard({ state, dashboardPath, lane, colorize = false }) {
   if (!state) {
     return `Dashboard file not found or invalid: ${dashboardPath}`;
   }
+  const formatGlobalWaveAgentSummary = (wave) => {
+    const total = Number(wave?.agentsTotal ?? 0) || 0;
+    const completed = Number(wave?.agentsCompleted ?? 0) || 0;
+    const failed = Number(wave?.agentsFailed ?? 0) || 0;
+    const active = Number(wave?.agentsActive ?? 0) || 0;
+    const pending =
+      wave?.agentsPending === undefined || wave?.agentsPending === null
+        ? Math.max(0, total - completed - failed - active)
+        : Number(wave.agentsPending ?? 0) || 0;
+    return `done ${completed}/${total} active ${active} pending ${pending} fail ${failed}`;
+  };
   const lines = [];
   const laneName = String(state?.lane || lane || "").trim() || DEFAULT_WAVE_LANE;
   lines.push(
-    `${laneName} Wave Global Dashboard | run=${state.runId || "n/a"} | status=${state.status || "unknown"}`,
+    `${laneName} Wave Global Dashboard | run=${state.runId || "n/a"} | status=${paintState(
+      state.status || "unknown",
+      state.status,
+      colorize,
+    )}`,
   );
   lines.push(
     `Updated ${formatAgeFromTimestamp(Date.parse(state.updatedAt || ""))} | Started ${state.startedAt || "n/a"} | Elapsed ${formatElapsed(state.startedAt)}`,
@@ -161,18 +290,18 @@ function renderGlobalDashboard({ state, dashboardPath, lane }) {
   lines.push("");
   lines.push("Waves:");
   lines.push(
-    `${pad("Wave", 6)} ${pad("Status", 10)} ${pad("Attempt", 9)} ${pad("Agents", 16)} ${pad("Started", 12)} ${pad("Last Message", 70)}`,
+    `${pad("Wave", 6)} ${pad("Status", 10)} ${pad("Attempt", 9)} ${pad("Agents", 36)} ${pad("Started", 12)} ${pad("Last Message", 70)}`,
   );
   lines.push(
-    `${"-".repeat(6)} ${"-".repeat(10)} ${"-".repeat(9)} ${"-".repeat(16)} ${"-".repeat(12)} ${"-".repeat(70)}`,
+    `${"-".repeat(6)} ${"-".repeat(10)} ${"-".repeat(9)} ${"-".repeat(36)} ${"-".repeat(12)} ${"-".repeat(70)}`,
   );
   for (const wave of state.waves || []) {
-    const agents = `${wave.agentsCompleted ?? 0}/${wave.agentsTotal ?? 0} ok, ${wave.agentsFailed ?? 0} fail`;
+    const agents = formatGlobalWaveAgentSummary(wave);
     lines.push(
-      `${pad(wave.wave ?? "-", 6)} ${pad(wave.status || "-", 10)} ${pad(
+      `${pad(wave.wave ?? "-", 6)} ${paintState(pad(wave.status || "-", 10), wave.status, colorize)} ${pad(
         `${wave.attempt ?? 0}/${wave.maxAttempts ?? 0}`,
         9,
-      )} ${pad(agents, 16)} ${pad(
+      )} ${paintWaveAgentSummary(pad(agents, 36), wave, colorize)} ${pad(
         formatAgeFromTimestamp(Date.parse(wave.startedAt || "")),
         12,
       )} ${truncate(wave.lastMessage || "", 70)}`,
@@ -191,7 +320,7 @@ function renderGlobalDashboard({ state, dashboardPath, lane }) {
   for (const event of (state.events || []).slice(-16)) {
     const waveTag = event.wave ? `wave:${event.wave}` : "wave:-";
     lines.push(
-      `${event.at || "n/a"} ${pad(event.level || "info", 5)} [${waveTag}] ${event.message || ""}`,
+      `${event.at || "n/a"} ${paintLevel(pad(event.level || "info", 5), event.level, colorize)} [${waveTag}] ${event.message || ""}`,
     );
   }
   if ((state.events || []).length === 0) {
@@ -200,10 +329,10 @@ function renderGlobalDashboard({ state, dashboardPath, lane }) {
   return lines.join("\n");
 }
 
-export function renderDashboard({ state, dashboardPath, messageBoardPath, lane }) {
+export function renderDashboard({ state, dashboardPath, messageBoardPath, lane, colorize = false }) {
   return isGlobalDashboardState(state)
-    ? renderGlobalDashboard({ state, dashboardPath, lane })
-    : renderWaveDashboard({ state, dashboardPath, messageBoardPath, lane });
+    ? renderGlobalDashboard({ state, dashboardPath, lane, colorize })
+    : renderWaveDashboard({ state, dashboardPath, messageBoardPath, lane, colorize });
 }
 
 export async function runDashboardCli(argv) {
@@ -232,6 +361,7 @@ Options:
       dashboardPath: options.dashboardFile,
       messageBoardPath: boardPath,
       lane: options.lane,
+      colorize: process.stdout.isTTY,
     });
     if (process.stdout.isTTY) {
       process.stdout.write("\u001bc");

package/scripts/wave-orchestrator/dashboard-state.mjs

@@ -228,8 +228,10 @@ export function buildGlobalDashboardState({
       startedAt: null,
       completedAt: null,
       agentsTotal: wave.agents.length,
+      agentsActive: 0,
       agentsCompleted: 0,
       agentsFailed: 0,
+      agentsPending: wave.agents.length,
       helperAssignmentsOpen: 0,
       inboundDependenciesOpen: 0,
       outboundDependenciesOpen: 0,
@@ -306,10 +308,16 @@ export function syncGlobalWaveFromWaveDashboard(globalState, waveDashboard) {
   }
   const agents = Array.isArray(waveDashboard.agents) ? waveDashboard.agents : [];
   entry.agentsTotal = agents.length;
+  entry.agentsActive = agents.filter((agent) =>
+    ["launching", "running", "coding", "validating", "deploying", "finalizing"].includes(
+      agent.state,
+    ),
+  ).length;
   entry.agentsCompleted = agents.filter((agent) => agent.state === "completed").length;
   entry.agentsFailed = agents.filter(
     (agent) => agent.state === "failed" || agent.state === "timed_out",
   ).length;
+  entry.agentsPending = agents.filter((agent) => agent.state === "pending").length;
   const latestEvent = waveDashboard.events.at(-1);
   entry.lastMessage = latestEvent?.message || entry.lastMessage || "";
   entry.helperAssignmentsOpen = waveDashboard.helperAssignmentsOpen || 0;

package/scripts/wave-orchestrator/executors.mjs

@@ -217,6 +217,7 @@ function buildClaudeLaunchSpec({ agent, promptPath, logPath, overlayDir }) {
   appendSingleValueFlag(tokens, "--agent", executor.claude.agent);
   appendSingleValueFlag(tokens, "--permission-mode", executor.claude.permissionMode);
   appendSingleValueFlag(tokens, "--permission-prompt-tool", executor.claude.permissionPromptTool);
+  appendSingleValueFlag(tokens, "--effort", executor.claude.effort);
   appendSingleValueFlag(tokens, "--max-turns", executor.claude.maxTurns);
   appendRepeatedFlag(tokens, "--mcp-config", executor.claude.mcpConfig);
   appendSingleValueFlag(tokens, "--settings", settingsPath);
@@ -299,6 +300,55 @@ function buildLocalLaunchSpec({ promptPath, logPath }) {
   };
 }
 
+function buildLaunchLimitsMetadata(agent) {
+  const executor = agent?.executorResolved || {};
+  const executorId = normalizeExecutorMode(executor.id || DEFAULT_EXECUTOR_MODE);
+  const attemptTimeoutMinutes = executor?.budget?.minutes ?? null;
+  if (executorId === "claude") {
+    const source = executor?.claude?.maxTurnsSource || null;
+    return {
+      attemptTimeoutMinutes,
+      knownTurnLimit: executor?.claude?.maxTurns ?? null,
+      turnLimitSource: source,
+      notes:
+        source === "budget.turns"
+          ? ["Known turn limit was derived from generic budget.turns."]
+          : [],
+    };
+  }
+  if (executorId === "opencode") {
+    const source = executor?.opencode?.stepsSource || null;
+    return {
+      attemptTimeoutMinutes,
+      knownTurnLimit: executor?.opencode?.steps ?? null,
+      turnLimitSource: source,
+      notes:
+        source === "budget.turns"
+          ? ["Known turn limit was derived from generic budget.turns."]
+          : [],
+    };
+  }
+  if (executorId === "codex") {
+    const profileNote = executor?.codex?.profileName
+      ? ` via Codex profile ${executor.codex.profileName}`
+      : "";
+    return {
+      attemptTimeoutMinutes,
+      knownTurnLimit: null,
+      turnLimitSource: "not-set-by-wave",
+      notes: [
+        `Wave emits no Codex turn-limit flag; any effective ceiling may come from the selected Codex profile${profileNote} or the upstream Codex runtime.`,
+      ],
+    };
+  }
+  return {
+    attemptTimeoutMinutes,
+    knownTurnLimit: null,
+    turnLimitSource: "not-applicable",
+    notes: ["Local executor does not use model turn limits."],
+  };
+}
+
 function buildCodexLaunchSpec({ agent, promptPath, logPath, skillProjection }) {
   const executor = agent.executorResolved;
   return {
@@ -329,16 +379,29 @@ function buildCodexLaunchSpec({ agent, promptPath, logPath, skillProjection }) {
 export function buildExecutorLaunchSpec({ agent, promptPath, logPath, overlayDir, skillProjection }) {
   const executorId = normalizeExecutorMode(agent?.executorResolved?.id || DEFAULT_EXECUTOR_MODE);
   ensureDirectory(overlayDir);
+  const limits = buildLaunchLimitsMetadata(agent);
   if (executorId === "local") {
-    return buildLocalLaunchSpec({ promptPath, logPath });
+    return {
+      ...buildLocalLaunchSpec({ promptPath, logPath }),
+      limits,
+    };
   }
   if (executorId === "claude") {
-    return buildClaudeLaunchSpec({ agent, promptPath, logPath, overlayDir, skillProjection });
+    return {
+      ...buildClaudeLaunchSpec({ agent, promptPath, logPath, overlayDir, skillProjection }),
+      limits,
+    };
   }
   if (executorId === "opencode") {
-    return buildOpenCodeLaunchSpec({ agent, promptPath, logPath, overlayDir, skillProjection });
+    return {
+      ...buildOpenCodeLaunchSpec({ agent, promptPath, logPath, overlayDir, skillProjection }),
+      limits,
+    };
   }
-  return buildCodexLaunchSpec({ agent, promptPath, logPath, skillProjection });
+  return {
+    ...buildCodexLaunchSpec({ agent, promptPath, logPath, skillProjection }),
+    limits,
+  };
 }
 
 export function commandForExecutor(executor, executorId = executor?.id) {

package/scripts/wave-orchestrator/launcher-runtime.mjs

@@ -139,6 +139,7 @@ export async function launchAgentSession(lanePaths, params, { runTmuxFn }) {
       env: launchSpec.env || {},
       useRateLimitRetries: launchSpec.useRateLimitRetries === true,
       invocationLines: launchSpec.invocationLines,
+      limits: launchSpec.limits || null,
       skills: summarizeResolvedSkills(agent.skillsResolved),
     });
     return {