@opengsd/gsd-core 1.8.0 → 1.9.0

package/gsd-core/bin/lib/check-command-router.cjs

@@ -260,12 +260,22 @@ function loadDecisionExtraction(contextPath) {
 }
 function cmdDecisionCoveragePlan(projectDir, args, raw) {
     const phaseDir = args[2] ? resolvePath(args[2], projectDir) : '';
-    const contextPath = args[3] ? resolvePath(args[3], projectDir) : '';
+    const contextArg = args[3];
+    const contextPath = contextArg ? resolvePath(contextArg, projectDir) : '';
     if (!gateEnabled(projectDir)) {
         output({ passed: true, skipped: true, reason: 'workflow.context_coverage_gate is false', total: 0, covered: 0, uncovered: [], message: 'Decision coverage gate disabled by config.' }, raw, undefined);
         return;
     }
-    if (!contextPath || !node_fs_1.default.existsSync(contextPath)) {
+    // #2770: an EMPTY/MISSING contextPath argument is a CALLER ERROR (the workflow
+    // forgot to pass the path — e.g. a shell variable lost between Bash blocks), not
+    // evidence the phase has no CONTEXT.md. Fail closed (mirrors #1365 fail-loud) so a
+    // blocking gate cannot silently certify success on a caller mistake.
+    if (!contextArg || contextArg === '') {
+        output({ passed: false, skipped: false, reason: 'missing context path argument', total: 0, covered: 0, uncovered: [], message: 'Decision coverage gate called without a context path argument — the caller (e.g. the plan-phase workflow) must pass the CONTEXT.md path. An empty argument is a caller error, not evidence there is nothing to check (#2770).' }, raw, undefined);
+        return;
+    }
+    // A REAL path whose file genuinely does not exist is the LEGITIMATE green skip.
+    if (!node_fs_1.default.existsSync(contextPath)) {
         output({ passed: true, skipped: true, reason: 'CONTEXT.md missing', total: 0, covered: 0, uncovered: [], message: 'No CONTEXT.md - nothing to check.' }, raw, undefined);
         return;
     }

package/gsd-core/bin/lib/cjs-command-router-adapter.cjs

@@ -13,6 +13,17 @@
 // eslint-disable-next-line @typescript-eslint/no-require-imports
 const commandRoutingHub = require("./command-routing-hub.cjs");
 const { createHub, ERROR_KINDS } = commandRoutingHub;
+// #2620 (ADR-0174 §6): the Hub defaults to a no-op logger and the live CLI
+// dispatch path never injected the reference DispatchLogger, so GSD_AUDIT and
+// config.audit.enabled were inert. Inject the reference logger ONLY when
+// observability is opt-in enabled; when off, inject nothing so the Hub stays
+// byte-for-byte silent (preserving the default dispatch output contract, incl.
+// --json-errors). Enabling stderr-on-error unconditionally by default is a
+// separate, blast-radius-bearing change (it adds a second stderr line to the
+// --json-errors envelope) — deferred as its own follow-up.
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const observabilityLogger = require("./observability/logger.cjs");
+const { createDefaultLogger, isAuditEnabled } = observabilityLogger;
 // Phase 2 (#1646): import ERROR_REASON so the UnknownCommand translation can
 // pass `sdk_unknown_command` as the second arg to error(), preserving the
 // JSON-error envelope contract that capability routers' tests assert on.
@@ -73,6 +84,10 @@ function routeHubCommandFamily({ family, args, subcommands, handlers, defaultSub
     const hub = createHub({
         cjsRegistry: { [family]: registryHandlers },
         manifest: { [family]: available },
+        // #2620: wire the reference logger onto the live dispatch path (ADR-0174 §6),
+        // but only when observability is opt-in enabled — otherwise leave it unset
+        // so the Hub falls back to the no-op logger and stays byte-for-byte silent.
+        logger: isAuditEnabled() ? createDefaultLogger({ cwd }) : undefined,
     });
     const result = hub.dispatch({
         family,

package/gsd-core/bin/lib/claude-orchestration-command-router.cjs

@@ -14,12 +14,15 @@
  *
  * Subcommands:
  *   detect-backend [--runtime <id>] [--agent-sdk-version <ver>] [--no-nested-dispatch]
- *       Resolves whether the Workflow backend should activate. `--runtime`
- *       defaults to the GSD_RUNTIME env var (or 'unknown'). Reads the
+ *       Resolves whether the Workflow backend should activate. Both flags are
+ *       OPTIONAL (#2590): `--runtime` falls back to the canonical
+ *       `GSD_RUNTIME > config.runtime > 'claude'` chain, and
+ *       `--agent-sdk-version` to `GSD_AGENT_SDK_VERSION` then the installed
+ *       @anthropic-ai/claude-agent-sdk version. Reads the
  *       `claude_orchestration.*` keys from .planning/config.json. Emits
  *       { available, backend, reason }.
  *
- *   emit-workflow --waves <path> --run-id <id> [--phase-dir <dir>] [--budget <n>]
+ *   emit-workflow --waves <path> --run-id <id> [--phase-dir <dir>] [--budget <n>] [--executor-model <id>]
  *       Reads a wave/plan manifest JSON file and emits the generated Workflow
  *       script + summary. The manifest shape matches emitWorkflowScript's input:
  *       { waves: [{ id, plans: [{ id, brief, files_modified: string[], use_worktree?: boolean }] }] }.
@@ -29,7 +32,7 @@
  *
  *   resolve-wave-dispatch --waves <path> --run-id <id> [--runtime <id>]
  *       [--agent-sdk-version <ver>] [--no-nested-dispatch] [--phase-dir <dir>]
- *       [--budget <n>]
+ *       [--budget <n>] [--executor-model <id>]
  *       #2285 — the single composed seam a PRE-wave dispatch-backend selector
  *       (`execute:wave:pre`) uses: resolves detect-backend + emit-workflow in
  *       ONE call. Emits { backend: 'inline'|'workflow', reason, script?, summary? }.
@@ -48,14 +51,18 @@ const io = require("./io.cjs");
 const core = require("./claude-orchestration.cjs");
 // eslint-disable-next-line @typescript-eslint/no-require-imports
 const configLoader = require("./config-loader.cjs");
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const runtimeSlash = require("./runtime-slash.cjs");
+// eslint-disable-next-line @typescript-eslint/no-require-imports -- model-resolver.cjs is an export= CommonJS module
+const modelResolver = require("./model-resolver.cjs");
 const { output } = io;
 const { detectWorkflowBackend, emitWorkflowScript, resolveWaveDispatch } = core;
 const CAPABLE_HOST = { dispatch: { nested: true, background: true } };
 function usage(error) {
     error('Usage: gsd-tools claude-orchestration <detect-backend|emit-workflow|resolve-wave-dispatch> [...]\n' +
         '  detect-backend [--runtime <id>] [--agent-sdk-version <ver>] [--no-nested-dispatch]\n' +
-        '  emit-workflow --waves <path> --run-id <id> [--phase-dir <dir>] [--budget <n>]\n' +
-        '  resolve-wave-dispatch --waves <path> --run-id <id> [--runtime <id>] [--agent-sdk-version <ver>] [--no-nested-dispatch] [--phase-dir <dir>] [--budget <n>]');
+        '  emit-workflow --waves <path> --run-id <id> [--phase-dir <dir>] [--budget <n>] [--executor-model <id>]\n' +
+        '  resolve-wave-dispatch --waves <path> --run-id <id> [--runtime <id>] [--agent-sdk-version <ver>] [--no-nested-dispatch] [--phase-dir <dir>] [--budget <n>] [--executor-model <id>]');
 }
 function argValue(args, flag) {
     const i = args.indexOf(flag);
@@ -86,18 +93,99 @@ function resolveFlatClaudeOrchestrationConfig(cwd) {
     }
     return flatConfig;
 }
+/**
+ * Resolve the installed Agent SDK version (#2590).
+ *
+ * The `execute:wave:pre` fragment claimed the orchestrator "has no scriptable
+ * way to introspect the live Agent SDK version" and told callers to omit the
+ * flag — so gate 5 returned `agent_sdk_version_unknown` on every automated run
+ * and the Workflow backend never activated, while `capability state` still
+ * reported it `active: true`. That claim is true for BASH, but this router runs
+ * in Node: the installed package's own package.json is authoritative and
+ * requires no flag at all.
+ *
+ * Resolution is side-effect-free and fails closed to undefined (gate 5 then
+ * declines, exactly as before) rather than guessing a version.
+ */
+const AGENT_SDK_PKG = node_path_1.default.join('@anthropic-ai', 'claude-agent-sdk', 'package.json');
+function resolveInstalledAgentSdkVersion(cwd) {
+    // Walk node_modules up the tree by hand rather than require.resolve: the SDK's
+    // `exports` map does not expose './package.json', so require.resolve throws
+    // ERR_PACKAGE_PATH_NOT_EXPORTED. Reading the file directly is exports-map
+    // independent and cannot execute package code.
+    for (const start of [cwd, __dirname]) {
+        let dir;
+        try {
+            dir = node_path_1.default.resolve(start);
+        }
+        catch {
+            continue;
+        }
+        for (;;) {
+            try {
+                const pkgPath = node_path_1.default.join(dir, 'node_modules', AGENT_SDK_PKG);
+                if (node_fs_1.default.existsSync(pkgPath)) {
+                    const parsed = JSON.parse(node_fs_1.default.readFileSync(pkgPath, 'utf8'));
+                    if (typeof parsed.version === 'string' && parsed.version.length > 0)
+                        return parsed.version;
+                }
+            }
+            catch { /* unreadable/malformed — keep walking */ }
+            const parent = node_path_1.default.dirname(dir);
+            if (parent === dir)
+                break;
+            dir = parent;
+        }
+    }
+    return undefined;
+}
 /**
  * Resolve `--runtime`/`--agent-sdk-version`/`--no-nested-dispatch` into the
  * `{ runtimeId, hostIntegration, agentSdkVersion }` triple both `detect-backend`
  * and `resolve-wave-dispatch` pass to the pure detection seam.
  */
-function resolveDetectionArgs(args) {
-    const runtimeId = argValue(args, '--runtime') || process.env['GSD_RUNTIME'] || 'unknown';
-    const agentSdkVersion = argValue(args, '--agent-sdk-version');
+function resolveDetectionArgs(args, cwd) {
+    // #2590: the old fallback chain was `--runtime > GSD_RUNTIME > 'unknown'`,
+    // diverging from the canonical `GSD_RUNTIME > config.runtime > 'claude'` used
+    // by runtime-slash.resolveRuntime — so ANY manual invocation without
+    // --runtime reported `runtime_not_claude` on a perfectly ordinary Claude
+    // project. Delegate to the canonical resolver instead of re-deriving it.
+    const runtimeId = argValue(args, '--runtime') || runtimeSlash.resolveRuntime(cwd || null);
+    // Explicit flag wins (lets a caller pin a version); then the environment;
+    // then the actually-installed SDK.
+    const agentSdkVersion = argValue(args, '--agent-sdk-version')
+        || process.env['GSD_AGENT_SDK_VERSION']
+        || resolveInstalledAgentSdkVersion(cwd || process.cwd());
     const noNested = args.includes('--no-nested-dispatch');
     const hostIntegration = noNested ? { dispatch: { nested: false, background: true } } : CAPABLE_HOST;
     return { runtimeId, hostIntegration, agentSdkVersion };
 }
+/**
+ * #2686 — resolve the `gsd-executor` model this dispatch should carry.
+ *
+ * Defaults from the project config rather than requiring a flag. The Workflow
+ * backend previously emitted no model at all, so `model_overrides` /
+ * `model_policy` / `model_profile` were silently inert on that path while the
+ * inline path honored them. Reading the same source the inline path reads is
+ * what makes the two backends agree by construction: an orchestrator that never
+ * learns about a new flag would otherwise silently keep the old bug.
+ *
+ * `--executor-model` exists only to pin/override. Resolution is side-effect-free
+ * and fails closed to `undefined` (emission then omits the key, i.e. exactly the
+ * pre-#2686 output) rather than guessing a model.
+ */
+function resolveExecutorModel(args, cwd) {
+    const pinned = argValue(args, '--executor-model');
+    if (pinned !== undefined)
+        return pinned;
+    try {
+        const resolved = modelResolver.resolveModelInternal(cwd, 'gsd-executor');
+        return typeof resolved === 'string' ? resolved : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 /**
  * Read and parse a `--waves <path>` manifest file.
  *
@@ -128,7 +216,7 @@ function readWavesManifest(wavesPath, error) {
  * SDK version come from flags (the orchestrator already knows these) or env.
  */
 function cmdDetectBackend(args, cwd, raw) {
-    const { runtimeId, hostIntegration, agentSdkVersion } = resolveDetectionArgs(args);
+    const { runtimeId, hostIntegration, agentSdkVersion } = resolveDetectionArgs(args, cwd);
     const flatConfig = resolveFlatClaudeOrchestrationConfig(cwd);
     const result = detectWorkflowBackend({ runtimeId, hostIntegration, config: flatConfig, agentSdkVersion });
     output(result, raw);
@@ -136,7 +224,7 @@ function cmdDetectBackend(args, cwd, raw) {
 /**
  * Emit a Workflow script from a wave/plan manifest file.
  */
-function cmdEmitWorkflow(args, _cwd, raw, error) {
+function cmdEmitWorkflow(args, cwd, raw, error) {
     const wavesPath = argValue(args, '--waves');
     const runId = argValue(args, '--run-id');
     const phaseDir = argValue(args, '--phase-dir') || '.planning/phases/current';
@@ -159,6 +247,7 @@ function cmdEmitWorkflow(args, _cwd, raw, error) {
         runId,
         waves: read.waves,
         budgetTokens: budget,
+        executorModel: resolveExecutorModel(args, cwd),
     });
     if (!result.ok) {
         error('emit-workflow: ' + result.reason);
@@ -188,7 +277,7 @@ function cmdResolveWaveDispatch(args, cwd, raw, error) {
     const read = readWavesManifest(wavesPath, (msg) => error('resolve-wave-dispatch: ' + msg));
     if (!read.ok)
         return; // read/parse failure — error() already surfaced it loudly above
-    const { runtimeId, hostIntegration, agentSdkVersion } = resolveDetectionArgs(args);
+    const { runtimeId, hostIntegration, agentSdkVersion } = resolveDetectionArgs(args, cwd);
     const flatConfig = resolveFlatClaudeOrchestrationConfig(cwd);
     const budgetTokens = budgetRaw !== undefined ? parseInt(budgetRaw, 10) : undefined;
     const budget = (typeof budgetTokens === 'number' && !Number.isNaN(budgetTokens)) ? budgetTokens : undefined;
@@ -201,6 +290,7 @@ function cmdResolveWaveDispatch(args, cwd, raw, error) {
         runId,
         waves: read.waves,
         budgetTokens: budget,
+        executorModel: resolveExecutorModel(args, cwd),
     });
     output(result, raw);
 }

package/gsd-core/bin/lib/claude-orchestration.cjs

@@ -264,16 +264,52 @@ function partitionStages(plans) {
 function quoteString(s) {
     return JSON.stringify(s);
 }
+/**
+ * #2686 — the single decision of whether a resolved executor model is emittable,
+ * and what to emit. Shared by `agentOptions` (the emission) and the provenance
+ * comment (the claim about it) so the two can never disagree — a generated
+ * comment asserting something the generator does not actually do is the exact
+ * failure #2686 was filed for.
+ *
+ * Returns the model to emit, or `undefined` for "emit nothing":
+ *   - non-string        → malformed config; omit rather than throw, matching the
+ *                         defensive typeof guard `mapClaudeOverrideForRuntime`
+ *                         already carries in model-resolver for the same reason.
+ *   - empty/whitespace  → #2517: emitting `model: ""` 404s on runtimes without
+ *                         native tier aliases. Trimmed, so `" "` is also "none".
+ *   - "inherit"         → same rule; matched case-insensitively after trimming,
+ *                         since config is user-authored free text.
+ *
+ * NOTE it does NOT reject unscriptable characters — that is a hard input error,
+ * not a silent omission, and is rejected up front by `emitWorkflowScript` so the
+ * caller sees a reason instead of quietly losing their model routing.
+ */
+function emittableModel(executorModel) {
+    if (typeof executorModel !== 'string')
+        return undefined;
+    const trimmed = executorModel.trim();
+    if (trimmed.length === 0)
+        return undefined;
+    if (trimmed.toLowerCase() === 'inherit')
+        return undefined;
+    return trimmed;
+}
 /**
  * Render the `agent()` options object for a single plan — `isolation: "worktree"`
  * ONLY when the plan's `use_worktree` is not explicitly `false` (#2772 / #2285
  * finding 1). This is the single place that decides worktree isolation for the
  * Workflow backend; it must never diverge from the inline path's per-plan gate.
  */
-function agentOptions(p) {
-    return p.use_worktree === false
-        ? '{ agentType: "gsd-executor" }'
-        : '{ agentType: "gsd-executor", isolation: "worktree" }';
+function agentOptions(p, executorModel) {
+    const parts = ['agentType: "gsd-executor"'];
+    if (p.use_worktree !== false)
+        parts.push('isolation: "worktree"');
+    // #2686: carry the resolved executor model so this backend honors
+    // model_overrides / model_policy / model_profile exactly as the inline path.
+    const model = emittableModel(executorModel);
+    if (model !== undefined)
+        parts.push('model: ' + quoteString(model));
+    return '{ ' + parts.join(', ') + ' }';
 }
 /**
  * True if `s` is a safe identifier/path token to interpolate into the generated
@@ -301,7 +337,7 @@ function emitWorkflowScript(input) {
     if (input === null || input === undefined || typeof input !== 'object') {
         return { ok: false, reason: 'invalid_input' };
     }
-    const { phaseDir, waves, runId } = input;
+    const { phaseDir, waves, runId, executorModel } = input;
     // Identifiers/paths interpolated into the generated script must be free of any
     // character that could terminate a comment, break out of a string literal, or
     // smuggle control bytes — reject up front (security: #1143 review Finding 1).
@@ -311,9 +347,28 @@ function emitWorkflowScript(input) {
     if (!isScriptableIdentifier(runId)) {
         return { ok: false, reason: 'runId must be a non-empty string without newlines/quotes/backslash/control chars' };
     }
+    // #2686 security: the resolved model is interpolated into BOTH an object
+    // literal (safe under quoteString) and a `//` provenance comment (NOT safe
+    // under quoteString — U+2028/U+2029 are LineTerminators that end a single-line
+    // comment in every engine, so a hostile model id would make the rest of the
+    // line live code). Reject the whole emission rather than silently dropping the
+    // model: an unscriptable id is malformed input, and `resolveWaveDispatch` maps
+    // an emit failure to the inline backend WITH a reason, so the user sees it.
+    // Only a STRING carrying such a character is rejected. A non-string is a
+    // malformed config rather than an injection attempt, and stays on the existing
+    // defensive path: `emittableModel` omits it and emission proceeds.
+    if (typeof executorModel === 'string' && UNSCRIPTABLE_CHAR_RE.test(executorModel)) {
+        return { ok: false, reason: 'executorModel must not contain newlines/quotes/backslash/control/line-separator chars' };
+    }
     if (!Array.isArray(waves) || waves.length === 0) {
         return { ok: false, reason: 'waves must be a non-empty array' };
     }
+    // Wave ids must be unique ACROSS waves, not just plan ids within one (#2590).
+    // Each wave emits a `phase("Wave <id>")` call plus a matching meta.phases
+    // entry, and the Workflow tool matches phase titles by exact string — two
+    // waves sharing an id would collapse into one progress group and misattribute
+    // every agent in the second wave to the first.
+    const seenWaveIds = new Set();
     for (let i = 0; i < waves.length; i++) {
         const w = waves[i];
         if (w === null || typeof w !== 'object' || typeof w.id !== 'string') {
@@ -322,6 +377,10 @@ function emitWorkflowScript(input) {
         if (!isScriptableIdentifier(w.id)) {
             return { ok: false, reason: 'waves[' + i + '].id must not contain newlines/quotes/backslash/control chars' };
         }
+        if (seenWaveIds.has(w.id)) {
+            return { ok: false, reason: 'duplicate wave id "' + w.id + '" — wave ids must be unique (phase titles must map 1:1)' };
+        }
+        seenWaveIds.add(w.id);
         if (!Array.isArray(w.plans) || w.plans.length === 0) {
             return { ok: false, reason: 'waves[' + i + '] must have a non-empty plans array' };
         }
@@ -352,15 +411,63 @@ function emitWorkflowScript(input) {
         ? Math.floor(input.budgetTokens)
         : null;
     const lines = [];
+    // `export const meta = {…}` MUST be the first statement in the script — the
+    // Workflow tool rejects the whole script otherwise (#2590). Leading comments
+    // are not statements, but the meta block is emitted first regardless so the
+    // contract holds under the strictest reading of "first statement".
+    //
+    // meta.phases must be a PURE LITERAL (no variables, calls, spreads, or
+    // template interpolation), and its titles are matched EXACTLY against the
+    // phase() calls emitted below.
+    lines.push('export const meta = {');
+    lines.push('  name: ' + quoteString('gsd-execute-' + runId) + ',');
+    lines.push('  description: ' + quoteString('GSD wave dispatch for ' + phaseDir) + ',');
+    lines.push('  phases: [');
+    for (const w of waves) {
+        lines.push('    { title: ' + quoteString('Wave ' + w.id) + ', detail: '
+            + quoteString(w.plans.length + ' plan(s)') + ' },');
+    }
+    lines.push('  ],');
+    lines.push('}');
+    lines.push('');
     lines.push('// GSD Workflow script — generated by the claude-orchestration capability (#1143)');
     lines.push('// phase: ' + phaseDir);
     lines.push('// BETA: preview-grade; on any failure the orchestrator falls back to inline dispatch.');
     lines.push('// Composes the SAME gsd-executor agent as the inline path, so artifacts (SUMMARY.md)');
     lines.push('// and commits are produced identically. Worktree isolation is per-plan (use_worktree)');
     lines.push('// and mirrors execute-phase.md step 2.5\'s submodule gate exactly (#2772 / #2285).');
-    lines.push('resumeFromRunId(' + quoteString(runId) + ')');
+    // #2686 / ADR-1411: state which model was applied — or that none resolved —
+    // so an opted-in user can SEE the routing decision instead of having to read
+    // the emitted options. A fallback must be a visible value, never silent.
+    //
+    // SECURITY: this is a `//` comment, and U+2028/U+2029 are ECMAScript
+    // LineTerminators that END a single-line comment in every engine — the ES2019
+    // change legalized them inside string LITERALS only, so `quoteString` alone is
+    // NOT sufficient here even though it is sufficient in the object literal
+    // above. An unscriptable model id would otherwise close the comment and make
+    // the remainder live top-level code. `emitWorkflowScript` rejects such ids
+    // before reaching this point (see the validation above), which is what makes
+    // interpolating here safe.
+    const provenanceModel = emittableModel(executorModel);
+    if (provenanceModel !== undefined) {
+        lines.push('// model: ' + quoteString(provenanceModel) + ' (resolved for gsd-executor, same source as the inline path)');
+    }
+    else {
+        lines.push('// model: none applied — resolved to "inherit"/empty, so each agent inherits the');
+        lines.push('// orchestrator model (#2517: emitting an empty model 404s on some runtimes).');
+    }
+    lines.push('//');
+    // resumeFromRunId is a Workflow TOOL INPUT parameter, not a script function —
+    // calling it threw "resumeFromRunId is not defined" (#2590). The run id is
+    // carried in summary.resumeRunId for the caller to pass as that input.
+    lines.push('// resume: pass ' + quoteString(runId) + ' as the Workflow tool\'s resumeFromRunId input');
+    lines.push('// (it is a tool parameter, NOT a script function).');
     if (budgetTokens !== null) {
-        lines.push('budget(' + budgetTokens + ')');
+        // `budget` is a read-only object ({ total, spent(), remaining() }) supplied
+        // by the caller's token directive — a script cannot SET it, and `budget(n)`
+        // threw "budget is not a function" (#2590). Recorded as intent only.
+        lines.push('// budget: ' + budgetTokens + ' output tokens intended for this run; `budget` is');
+        lines.push('// read-only in a Workflow script — set it via the caller\'s token directive.');
     }
     lines.push('');
     const stagesByWave = [];
@@ -371,6 +478,8 @@ function emitWorkflowScript(input) {
         stagesByWave.push(stages);
         totalPlans += wave.plans.length;
         lines.push('// Wave ' + wave.id);
+        // Title must match this wave's meta.phases entry EXACTLY.
+        lines.push('phase(' + quoteString('Wave ' + wave.id) + ')');
         for (let si = 0; si < stages.length; si++) {
             const stagePlanIds = stages[si];
             // Resolve back to plan objects for briefs (ids are unique within a wave — validated above).
@@ -378,22 +487,15 @@ function emitWorkflowScript(input) {
             if (stages.length > 1) {
                 lines.push('// Stage ' + si + (si > 0 ? ' (sequential — files_modified overlap)' : ''));
             }
-            if (stagePlans.length === 1) {
-                const p = stagePlans[0];
-                lines.push('parallel(');
-                lines.push('  agent(' + quoteString(p.brief) + ', ' + agentOptions(p) + ')');
-                lines.push(')');
-            }
-            else {
-                lines.push('parallel(');
-                for (const p of stagePlans) {
-                    lines.push('  agent(' + quoteString(p.brief) + ', ' + agentOptions(p) + '),');
-                }
-                // Replace trailing comma on the last agent line with nothing.
-                const lastIdx = lines.length - 1;
-                lines[lastIdx] = lines[lastIdx].replace(/,$/, '');
-                lines.push(')');
+            // parallel() takes an ARRAY OF THUNKS — `parallel(agent(…), agent(…))`
+            // threw "parallel() expects an array of functions" (#2590). Passing
+            // agent() results directly would also start every agent eagerly, before
+            // parallel() could bound concurrency.
+            lines.push('await parallel([');
+            for (const p of stagePlans) {
+                lines.push('  () => agent(' + quoteString(p.brief) + ', ' + agentOptions(p, executorModel) + '),');
             }
+            lines.push('])');
         }
         if (wi < waves.length - 1)
             lines.push('');
@@ -456,6 +558,7 @@ function resolveWaveDispatch(input) {
         waves: input.waves,
         runId: input.runId,
         budgetTokens: input.budgetTokens,
+        executorModel: input.executorModel,
     });
     if (!emitted.ok) {
         return { backend: 'inline', reason: 'emit_failed: ' + emitted.reason };