@chllming/wave-orchestration 0.8.8 → 0.9.0

package/scripts/wave-orchestrator/adhoc.mjs

@@ -25,6 +25,7 @@ import {
   buildLanePaths,
   compactSingleLine,
   ensureDirectory,
+  findAdhocRunRecord,
   parseNonNegativeInt,
   readJsonOrNull,
   REPO_ROOT,
@@ -205,8 +206,8 @@ async function withSuppressedNestedUpdateNotice(fn) {
   }
 }
 
-function readEffectiveProjectProfile(config) {
-  return readProjectProfile({ config }) || buildDefaultProjectProfile(config);
+function readEffectiveProjectProfile(config, project) {
+  return readProjectProfile({ config, project }) || buildDefaultProjectProfile(config);
 }
 
 function detectKeyword(text, keywords) {
@@ -451,6 +452,10 @@ function buildCommonRequiredContext() {
   );
 }
 
+function adhocReportPath(lanePaths, filename) {
+  return repoRelativePath(path.join(lanePaths.adhocRunDir, "reports", filename));
+}
+
 function buildDocumentationOwnedPaths({ lanePaths, waveNumber, mode }) {
   const canonicalPaths = requiredDocumentationStewardPathsForWave(waveNumber, {
     laneProfile: lanePaths.laneProfile,
@@ -459,7 +464,7 @@ function buildDocumentationOwnedPaths({ lanePaths, waveNumber, mode }) {
     return canonicalPaths;
   }
   return uniqueStrings([
-    `.wave/adhoc/runs/${lanePaths.runId}/reports/wave-${waveNumber}-doc-closure.md`,
+    adhocReportPath(lanePaths, `wave-${waveNumber}-doc-closure.md`),
     ...canonicalPaths,
   ]);
 }
@@ -476,11 +481,11 @@ function buildSpecialAgents({
   const contQaReportPath =
     mode === "roadmap"
       ? `docs/plans/waves/reviews/wave-${waveNumber}-cont-qa.md`
-      : `.wave/adhoc/runs/${lanePaths.runId}/reports/wave-${waveNumber}-cont-qa.md`;
+      : adhocReportPath(lanePaths, `wave-${waveNumber}-cont-qa.md`);
   const contEvalReportPath =
     mode === "roadmap"
       ? `docs/plans/waves/reviews/wave-${waveNumber}-cont-eval.md`
-      : `.wave/adhoc/runs/${lanePaths.runId}/reports/wave-${waveNumber}-cont-eval.md`;
+      : adhocReportPath(lanePaths, `wave-${waveNumber}-cont-eval.md`);
   const documentationOwnedPaths = buildDocumentationOwnedPaths({
     lanePaths,
     waveNumber,
@@ -489,7 +494,7 @@ function buildSpecialAgents({
   const securityReportPath =
     mode === "roadmap"
       ? relativeStatePath(path.join(lanePaths.securityDir, `wave-${waveNumber}-review.md`))
-      : `.wave/adhoc/runs/${lanePaths.runId}/reports/wave-${waveNumber}-security-review.md`;
+      : adhocReportPath(lanePaths, `wave-${waveNumber}-security-review.md`);
   const integrationOwnedPaths = [
     relativeStatePath(path.join(lanePaths.integrationDir, `wave-${waveNumber}.md`)),
     relativeStatePath(path.join(lanePaths.integrationDir, `wave-${waveNumber}.json`)),
@@ -727,6 +732,7 @@ function buildAdhocRequest({ runId, lanePaths, profile, tasks, launcherArgs = []
     schemaVersion: ADHOC_SCHEMA_VERSION,
     runKind: "adhoc",
     runId,
+    project: lanePaths.project,
     lane: lanePaths.lane,
     createdAt: toIsoTimestamp(),
     oversightMode: profile.defaultOversightMode,
@@ -846,6 +852,7 @@ function buildResultRecord(lanePaths, request, spec, status, extra = {}) {
     schemaVersion: ADHOC_SCHEMA_VERSION,
     runKind: "adhoc",
     runId: request.runId,
+    project: request.project || lanePaths.project,
     lane: request.lane,
     title: spec.title,
     status,
@@ -1009,6 +1016,7 @@ function parseArgs(argv) {
   const args = Array.isArray(argv) ? argv.slice() : [];
   const subcommand = cleanText(args.shift()).toLowerCase();
   const options = {
+    project: "",
     lane: "",
     runId: "",
     wave: null,
@@ -1022,6 +1030,8 @@ function parseArgs(argv) {
     const arg = args.shift();
     if (arg === "--task") {
       options.tasks.push(cleanText(args.shift()));
+    } else if (arg === "--project") {
+      options.project = cleanText(args.shift());
     } else if (arg === "--lane") {
       options.lane = cleanText(args.shift());
     } else if (arg === "--run") {
@@ -1074,24 +1084,25 @@ function parseArgs(argv) {
 
 function printUsage() {
   console.log(`Usage:
-  wave adhoc plan --task <text> [--task <text>] [--lane <lane>] [--json]
-  wave adhoc run --task <text> [--task <text>] [--lane <lane>] [--yes] [--json] [launcher options]
-  wave adhoc list [--lane <lane>] [--json]
+  wave adhoc plan --task <text> [--task <text>] [--project <id>] [--lane <lane>] [--json]
+  wave adhoc run --task <text> [--task <text>] [--project <id>] [--lane <lane>] [--yes] [--json] [launcher options]
+  wave adhoc list [--project <id>] [--lane <lane>] [--json]
   wave adhoc show --run <id> [--json]
-  wave adhoc promote --run <id> --wave <n> [--force] [--json]
+  wave adhoc promote --run <id> [--project <id>] --wave <n> [--force] [--json]
 `);
 }
 
 function resolveLaneForOptions(config, options) {
-  const profile = readEffectiveProjectProfile(config);
+  const profile = readEffectiveProjectProfile(config, options.project || config.defaultProject);
   return cleanText(options.lane) || profile.plannerDefaults?.lane || config.defaultLane;
 }
 
 function createStoredRun({ config, options }) {
-  const profile = readEffectiveProjectProfile(config);
+  const projectId = options.project || config.defaultProject;
+  const profile = readEffectiveProjectProfile(config, projectId);
   const lane = resolveLaneForOptions(config, options);
   const runId = buildAdhocRunId();
-  const lanePaths = buildLanePaths(lane, { config, adhocRunId: runId });
+  const lanePaths = buildLanePaths(lane, { config, project: projectId, adhocRunId: runId });
   const request = buildAdhocRequest({
     runId,
     lanePaths,
@@ -1114,7 +1125,17 @@ function createStoredRun({ config, options }) {
 }
 
 function readStoredRun(runId) {
-  const lanePaths = buildLanePaths(DEFAULT_LANE_PLACEHOLDER, { adhocRunId: runId });
+  const record = findAdhocRunRecord(runId);
+  if (!record) {
+    throw new Error(`Ad-hoc run not found: ${runId}`);
+  }
+  const lanePaths = buildLanePaths(
+    record.result?.lane || DEFAULT_LANE_PLACEHOLDER,
+    {
+      project: record.project,
+      adhocRunId: runId,
+    },
+  );
   const request = readJsonOrNull(lanePaths.adhocRequestPath);
   const spec = readJsonOrNull(lanePaths.adhocSpecPath);
   const result = readJsonOrNull(lanePaths.adhocResultPath);
@@ -1166,6 +1187,7 @@ export async function runAdhocCli(argv) {
     }
     const launchLanePaths = buildLanePaths(stored.lanePaths.lane, {
       config,
+      project: stored.request.project || stored.lanePaths.project,
       adhocRunId: stored.lanePaths.runId,
       runVariant: options.launcherArgs.includes("--dry-run") ? "dry-run" : undefined,
     });
@@ -1178,6 +1200,8 @@ export async function runAdhocCli(argv) {
     try {
       await withSuppressedNestedUpdateNotice(() =>
         runLauncherCli([
+          "--project",
+          stored.request.project || stored.lanePaths.project,
           "--lane",
           stored.lanePaths.lane,
           "--adhoc-run",
@@ -1219,9 +1243,10 @@ export async function runAdhocCli(argv) {
 
   if (subcommand === "list") {
     const lane = cleanText(options.lane);
-    const lanePaths = buildLanePaths(lane || config.defaultLane, { config });
+    const projectId = options.project || config.defaultProject;
+    const lanePaths = buildLanePaths(lane || config.defaultLane, { config, project: projectId });
     const runs = collectStoredRuns(lanePaths.adhocIndexPath).filter((run) =>
-      lane ? run.lane === lane : true,
+      (lane ? run.lane === lane : true) && (options.project ? run.project === projectId : true),
     );
     if (options.json) {
       console.log(JSON.stringify(runs, null, 2));
@@ -1242,6 +1267,7 @@ export async function runAdhocCli(argv) {
     const { lanePaths, request, spec, result } = readStoredRun(options.runId);
     const payload = {
       runId: options.runId,
+      project: result.project || request.project || lanePaths.project,
       lane: result.lane,
       status: result.status,
       title: result.title,
@@ -1263,6 +1289,7 @@ export async function runAdhocCli(argv) {
       return;
     }
     console.log(`[wave:adhoc] run=${payload.runId}`);
+    console.log(`[wave:adhoc] project=${payload.project}`);
     console.log(`[wave:adhoc] lane=${payload.lane}`);
     console.log(`[wave:adhoc] status=${payload.status}`);
     console.log(`[wave:adhoc] title=${payload.title}`);
@@ -1290,8 +1317,13 @@ export async function runAdhocCli(argv) {
       throw new Error("--wave <n> is required for `wave adhoc promote`.");
     }
     const stored = readStoredRun(options.runId);
+    const projectId =
+      cleanText(options.project) ||
+      cleanText(stored.result.project) ||
+      cleanText(stored.request.project) ||
+      config.defaultProject;
     const lane = cleanText(options.lane) || stored.result.lane || config.defaultLane;
-    const lanePaths = buildLanePaths(lane, { config });
+    const lanePaths = buildLanePaths(lane, { config, project: projectId });
     const wavePath = path.join(lanePaths.wavesDir, `wave-${options.wave}.md`);
     const specPath = path.join(lanePaths.wavesDir, "specs", `wave-${options.wave}.json`);
     if (!options.force && (fs.existsSync(wavePath) || fs.existsSync(specPath))) {

package/scripts/wave-orchestrator/autonomous.mjs

@@ -4,6 +4,7 @@ import path from "node:path";
 import {
   DEFAULT_CODEX_SANDBOX_MODE,
   DEFAULT_EXECUTOR_MODE,
+  loadWaveConfig,
   normalizeCodexSandboxMode,
   normalizeExecutorMode,
   SUPPORTED_EXECUTOR_MODES,
@@ -42,6 +43,7 @@ function printUsage() {
   console.log(`Usage: pnpm exec wave autonomous [options]
 
 Options:
+  --project <id>                 Project id
   --lane <name>                 Lane name (default: ${DEFAULT_WAVE_LANE})
   --timeout-minutes <n>         Per-wave timeout passed to launcher (default: ${DEFAULT_TIMEOUT_MINUTES})
   --max-retries-per-wave <n>    Per-wave relaunches inside launcher (default: ${DEFAULT_MAX_RETRIES_PER_WAVE})
@@ -64,7 +66,9 @@ Options:
 }
 
 export function parseArgs(argv) {
+  const config = loadWaveConfig();
   const options = {
+    project: config.defaultProject,
     lane: DEFAULT_WAVE_LANE,
     timeoutMinutes: DEFAULT_TIMEOUT_MINUTES,
     maxRetriesPerWave: DEFAULT_MAX_RETRIES_PER_WAVE,
@@ -92,6 +96,8 @@ export function parseArgs(argv) {
     }
     if (arg === "--lane") {
       options.lane = sanitizeLaneName(argv[++i]);
+    } else if (arg === "--project") {
+      options.project = String(argv[++i] || "").trim();
     } else if (arg === "--timeout-minutes") {
       options.timeoutMinutes = parsePositiveInt(argv[++i], "--timeout-minutes");
     } else if (arg === "--max-retries-per-wave") {
@@ -132,7 +138,10 @@ export function parseArgs(argv) {
     }
   }
   if (!executorProvided) {
-    options.executorMode = buildLanePaths(options.lane).executors.default;
+    options.executorMode = buildLanePaths(options.lane, {
+      config,
+      project: options.project,
+    }).executors.default;
   }
   options.orchestratorId ||= `${options.lane}-autonomous`;
   if (options.executorMode === "local") {
@@ -146,8 +155,8 @@ export function parseArgs(argv) {
   return { help: false, options };
 }
 
-function getWaveNumbers(lane) {
-  const lanePaths = buildLanePaths(lane);
+function getWaveNumbers(lane, project) {
+  const lanePaths = buildLanePaths(lane, { project });
   if (!fs.existsSync(lanePaths.wavesDir)) {
     throw new Error(`Waves directory not found: ${path.relative(REPO_ROOT, lanePaths.wavesDir)}`);
   }
@@ -184,27 +193,52 @@ function runCommand(args, envOverrides = {}) {
   return Number.isInteger(result.status) ? result.status : 1;
 }
 
-function reconcile(lane) {
+function reconcile(lane, project) {
   return runCommand(
-    [path.join(PACKAGE_ROOT, "scripts", "wave-launcher.mjs"), "--lane", lane, "--reconcile-status"],
+    [
+      path.join(PACKAGE_ROOT, "scripts", "wave-launcher.mjs"),
+      "--project",
+      project,
+      "--lane",
+      lane,
+      "--reconcile-status",
+    ],
     { [WAVE_SUPPRESS_UPDATE_NOTICE_ENV]: "1" },
   );
 }
 
-function dryRun(lane) {
+function dryRun(lane, project) {
   return runCommand(
-    [path.join(PACKAGE_ROOT, "scripts", "wave-launcher.mjs"), "--lane", lane, "--dry-run", "--no-dashboard"],
+    [
+      path.join(PACKAGE_ROOT, "scripts", "wave-launcher.mjs"),
+      "--project",
+      project,
+      "--lane",
+      lane,
+      "--dry-run",
+      "--no-dashboard",
+    ],
     { [WAVE_SUPPRESS_UPDATE_NOTICE_ENV]: "1" },
   );
 }
 
-function listPendingFeedback(lane) {
-  return runCommand([path.join(PACKAGE_ROOT, "scripts", "wave-human-feedback.mjs"), "list", "--lane", lane, "--pending"]);
+function listPendingFeedback(lane, project) {
+  return runCommand([
+    path.join(PACKAGE_ROOT, "scripts", "wave-human-feedback.mjs"),
+    "list",
+    "--project",
+    project,
+    "--lane",
+    lane,
+    "--pending",
+  ]);
 }
 
 function launchSingleWave(params) {
   const args = [
     path.join(PACKAGE_ROOT, "scripts", "wave-launcher.mjs"),
+    "--project",
+    params.project,
     "--lane",
     params.lane,
     "--start-wave",
@@ -359,27 +393,27 @@ export async function runAutonomousCli(argv) {
   }
   await maybeAnnouncePackageUpdate();
   const options = parsed.options;
-  const allWaves = getWaveNumbers(options.lane);
+  const allWaves = getWaveNumbers(options.lane, options.project);
   console.log(`[autonomous] lane=${options.lane} orchestrator=${options.orchestratorId}`);
   console.log(`[autonomous] executor=${options.executorMode}`);
   console.log(`[autonomous] codex_sandbox=${options.codexSandboxMode}`);
   console.log(`[autonomous] waves=${allWaves.join(", ")}`);
 
-  const dryRunStatus = dryRun(options.lane);
+  const dryRunStatus = dryRun(options.lane, options.project);
   if (dryRunStatus !== 0) {
     throw new Error(`[autonomous] dry-run preflight failed with status=${dryRunStatus}`);
   }
-  const feedbackListStatus = listPendingFeedback(options.lane);
+  const feedbackListStatus = listPendingFeedback(options.lane, options.project);
   if (feedbackListStatus !== 0) {
     throw new Error(`[autonomous] feedback preflight failed with status=${feedbackListStatus}`);
   }
-  const reconcileStatus = reconcile(options.lane);
+  const reconcileStatus = reconcile(options.lane, options.project);
   if (reconcileStatus !== 0) {
     throw new Error(`[autonomous] initial reconcile failed with status=${reconcileStatus}`);
   }
 
   let launchedCount = 0;
-  const lanePaths = buildLanePaths(options.lane);
+  const lanePaths = buildLanePaths(options.lane, { project: options.project });
   while (true) {
     const completed = readRunState(lanePaths.defaultRunStatePath).completedWaves;
     const wave = nextIncompleteWave(allWaves, completed);
@@ -405,7 +439,7 @@ export async function runAutonomousCli(argv) {
         wave,
         attempt,
       });
-      reconcile(options.lane);
+      reconcile(options.lane, options.project);
       if (status === 0) {
         launchedCount += 1;
         success = true;

package/scripts/wave-orchestrator/benchmark-external.mjs

@@ -2,7 +2,6 @@ import fs from "node:fs";
 import path from "node:path";
 import { spawnSync } from "node:child_process";
 import {
-  DEFAULT_WAVE_LANE,
   REPO_ROOT,
   buildLanePaths,
   ensureDirectory,
@@ -107,9 +106,11 @@ function escapeMarkdownCell(value) {
     .replace(/\|/g, "\\|");
 }
 
-function benchmarkTelemetryLanePaths() {
+function benchmarkTelemetryLanePaths(options = {}) {
   try {
-    return buildLanePaths(DEFAULT_WAVE_LANE);
+    return buildLanePaths(options.lane || undefined, {
+      project: options.project || undefined,
+    });
   } catch {
     return null;
   }
@@ -119,6 +120,15 @@ function benchmarkRunId(output) {
   return `bench-${output.adapter.id}-${output.manifest.id}-${String(output.generatedAt || toIsoTimestamp()).replace(/[-:.TZ]/g, "").slice(0, 14)}`;
 }
 
+function flushBenchmarkTelemetryBestEffort(lanePaths) {
+  return flushWaveControlQueue(lanePaths).catch((error) => {
+    console.warn(
+      `[wave:benchmark] telemetry flush skipped: ${error instanceof Error ? error.message : String(error)}`,
+    );
+    return null;
+  });
+}
+
 function reviewValidityForResult(result, output) {
   if (result.success && output.comparisonReady) {
     return "comparison-valid";
@@ -179,8 +189,8 @@ function externalTaskArtifacts(result) {
   return artifacts;
 }
 
-function publishExternalBenchmarkTelemetry({ output, outputDir, failureReview }) {
-  const lanePaths = benchmarkTelemetryLanePaths();
+function publishExternalBenchmarkTelemetry({ output, outputDir, failureReview, project, lane }) {
+  const lanePaths = benchmarkTelemetryLanePaths({ project, lane });
   if (!lanePaths || lanePaths.waveControl?.captureBenchmarkRuns === false) {
     return null;
   }
@@ -338,7 +348,7 @@ function publishExternalBenchmarkTelemetry({ output, outputDir, failureReview })
       },
     });
   }
-  void flushWaveControlQueue(lanePaths);
+  void flushBenchmarkTelemetryBestEffort(lanePaths);
   return benchmarkRunIdValue;
 }
 
@@ -1376,7 +1386,13 @@ export function runExternalBenchmarkPilot(options = {}) {
   writeTextAtomic(path.join(outputDir, "results.md"), `${renderExternalResultsMarkdown(output)}\n`);
   writeJsonAtomic(path.join(outputDir, "failure-review.json"), failureReview);
   writeTextAtomic(path.join(outputDir, "failure-review.md"), `${renderExternalFailureReviewMarkdown(failureReview)}\n`);
-  publishExternalBenchmarkTelemetry({ output, outputDir, failureReview });
+  publishExternalBenchmarkTelemetry({
+    output,
+    outputDir,
+    failureReview,
+    project: options.project,
+    lane: options.lane,
+  });
   return {
     ...output,
     outputDir: path.relative(REPO_ROOT, outputDir).replaceAll(path.sep, "/"),

package/scripts/wave-orchestrator/benchmark.mjs

@@ -7,7 +7,6 @@ import {
 import { buildRequestAssignments } from "./routing-state.mjs";
 import { loadBenchmarkCases, loadExternalBenchmarkAdapters } from "./benchmark-cases.mjs";
 import {
-  DEFAULT_WAVE_LANE,
   REPO_ROOT,
   buildLanePaths,
   ensureDirectory,
@@ -44,9 +43,11 @@ function normalizeId(value, label) {
   return normalized;
 }
 
-function benchmarkTelemetryLanePaths() {
+function benchmarkTelemetryLanePaths(options = {}) {
   try {
-    return buildLanePaths(DEFAULT_WAVE_LANE);
+    return buildLanePaths(options.lane || undefined, {
+      project: options.project || undefined,
+    });
   } catch {
     return null;
   }
@@ -56,8 +57,17 @@ function localBenchmarkRunId(output) {
   return `bench-local-${String(output.generatedAt || toIsoTimestamp()).replace(/[-:.TZ]/g, "").slice(0, 14)}`;
 }
 
-function publishLocalBenchmarkTelemetry({ output, outputDir }) {
-  const lanePaths = benchmarkTelemetryLanePaths();
+function flushBenchmarkTelemetryBestEffort(lanePaths) {
+  return flushWaveControlQueue(lanePaths).catch((error) => {
+    console.warn(
+      `[wave:benchmark] telemetry flush skipped: ${error instanceof Error ? error.message : String(error)}`,
+    );
+    return null;
+  });
+}
+
+function publishLocalBenchmarkTelemetry({ output, outputDir, project, lane }) {
+  const lanePaths = benchmarkTelemetryLanePaths({ project, lane });
   if (!lanePaths || lanePaths.waveControl?.captureBenchmarkRuns === false) {
     return null;
   }
@@ -140,7 +150,7 @@ function publishLocalBenchmarkTelemetry({ output, outputDir }) {
       });
     }
   }
-  void flushWaveControlQueue(lanePaths);
+  void flushBenchmarkTelemetryBestEffort(lanePaths);
   return benchmarkRunIdValue;
 }
 
@@ -718,7 +728,12 @@ export function runBenchmarkSuite(options = {}) {
     ensureDirectory(outputDir);
     writeJsonAtomic(path.join(outputDir, "results.json"), output);
     writeTextAtomic(path.join(outputDir, "results.md"), `${renderMarkdownReport(output)}\n`);
-    publishLocalBenchmarkTelemetry({ output, outputDir });
+    publishLocalBenchmarkTelemetry({
+      output,
+      outputDir,
+      project: options.project,
+      lane: options.lane,
+    });
     output.outputDir = path.relative(REPO_ROOT, outputDir).replaceAll(path.sep, "/");
   }
   return output;
@@ -728,12 +743,12 @@ function printUsage() {
   console.log(`Usage:
   wave benchmark list [--json]
   wave benchmark show --case <id> [--json]
-  wave benchmark run [--case <id>] [--family <id>] [--benchmark <id>] [--arm <id>] [--output-dir <path>] [--json]
+  wave benchmark run [--project <id>] [--lane <lane>] [--case <id>] [--family <id>] [--benchmark <id>] [--arm <id>] [--output-dir <path>] [--json]
   wave benchmark adapters [--json]
   wave benchmark external-list [--json]
   wave benchmark external-show --adapter <id> [--json]
-  wave benchmark external-pilots [--json]
-  wave benchmark external-run --adapter <id> [--manifest <path>] [--task <id>] [--arm <id>] [--dry-run] [--command-config <path>] [run options] [--json]
+  wave benchmark external-pilots [--project <id>] [--lane <lane>] [--json]
+  wave benchmark external-run --adapter <id> [--project <id>] [--lane <lane>] [--manifest <path>] [--task <id>] [--arm <id>] [--dry-run] [--command-config <path>] [run options] [--json]
 `);
 }
 
@@ -741,6 +756,8 @@ function parseArgs(argv) {
   const args = Array.isArray(argv) ? argv.slice() : [];
   const subcommand = cleanText(args.shift()).toLowerCase();
   const options = {
+    project: "",
+    lane: "",
     json: false,
     caseIds: [],
     familyIds: [],
@@ -768,6 +785,10 @@ function parseArgs(argv) {
     const arg = args[index];
     if (arg === "--json") {
       options.json = true;
+    } else if (arg === "--project") {
+      options.project = cleanText(args[++index]);
+    } else if (arg === "--lane") {
+      options.lane = cleanText(args[++index]);
     } else if (arg === "--case") {
       options.caseIds.push(args[++index]);
     } else if (arg === "--family") {
@@ -929,6 +950,8 @@ export async function runBenchmarkCli(argv) {
       throw new Error("wave benchmark external-run requires --adapter <id>");
     }
     const output = runExternalBenchmarkPilot({
+      project: options.project || undefined,
+      lane: options.lane || undefined,
       adapterId: options.adapterId,
       manifestPath: options.manifestPath || undefined,
       taskIds: options.taskIds,