@chllming/wave-orchestration 0.8.9 → 0.9.0

package/scripts/wave-orchestrator/dep-cli.mjs

@@ -15,10 +15,10 @@ import { parseWaveFiles } from "./wave-files.mjs";
 
 function printUsage() {
   console.log(`Usage:
-  wave dep post --owner-lane <lane> --requester-lane <lane> --owner-wave <n> --requester-wave <n> --agent <id> --summary <text> [options]
-  wave dep show --lane <lane> [--wave <n>] [--json]
-  wave dep resolve --lane <lane> --id <id> --agent <id> [--detail <text>] [--status resolved|closed]
-  wave dep render --lane <lane> [--wave <n>] [--json]
+  wave dep post --owner-project <id> --owner-lane <lane> --requester-project <id> --requester-lane <lane> --owner-wave <n> --requester-wave <n> --agent <id> --summary <text> [options]
+  wave dep show --project <id> --lane <lane> [--wave <n>] [--json]
+  wave dep resolve --project <id> --lane <lane> --id <id> --agent <id> [--detail <text>] [--status resolved|closed]
+  wave dep render --project <id> --lane <lane> [--wave <n>] [--json]
 `);
 }
 
@@ -26,6 +26,9 @@ function parseArgs(argv) {
   const args = argv[0] === "--" ? argv.slice(1) : argv;
   const subcommand = String(args[0] || "").trim().toLowerCase();
   const options = {
+    project: "",
+    ownerProject: "",
+    requesterProject: "",
     lane: "",
     ownerLane: "",
     requesterLane: "",
@@ -46,7 +49,13 @@ function parseArgs(argv) {
   };
   for (let index = 1; index < args.length; index += 1) {
     const arg = args[index];
-    if (arg === "--lane") {
+    if (arg === "--project") {
+      options.project = String(args[++index] || "").trim();
+    } else if (arg === "--owner-project") {
+      options.ownerProject = String(args[++index] || "").trim();
+    } else if (arg === "--requester-project") {
+      options.requesterProject = String(args[++index] || "").trim();
+    } else if (arg === "--lane") {
       options.lane = String(args[++index] || "").trim();
     } else if (arg === "--owner-lane") {
       options.ownerLane = String(args[++index] || "").trim();
@@ -112,11 +121,15 @@ export async function runDependencyCli(argv) {
     return;
   }
   const { subcommand, options } = parseArgs(argv);
+  const baseProject =
+    options.project || options.ownerProject || options.requesterProject || undefined;
   const baseLane = options.lane || options.ownerLane || options.requesterLane || "main";
-  const lanePaths = buildLanePaths(baseLane);
+  const lanePaths = buildLanePaths(baseLane, { project: baseProject });
   ensureDirectory(lanePaths.crossLaneDependenciesDir);
 
   if (subcommand === "post") {
+    const ownerProject = options.ownerProject || options.project || lanePaths.project;
+    const requesterProject = options.requesterProject || options.project || lanePaths.project;
     const ownerLane = options.ownerLane || options.lane;
     const requesterLane = options.requesterLane || lanePaths.lane;
     if (!ownerLane || !requesterLane || options.ownerWave === null || options.requesterWave === null) {
@@ -125,13 +138,17 @@ export async function runDependencyCli(argv) {
     if (!options.agent || !options.summary) {
       throw new Error("--agent and --summary are required");
     }
-    const record = appendDependencyTicket(lanePaths.crossLaneDependenciesDir, ownerLane, {
+    const ownerLanePaths = buildLanePaths(ownerLane, { project: ownerProject });
+    ensureDirectory(ownerLanePaths.crossLaneDependenciesDir);
+    const record = appendDependencyTicket(ownerLanePaths.crossLaneDependenciesDir, ownerLane, {
       id: options.id || `dep-${Date.now().toString(36)}`,
       kind: "request",
       lane: ownerLane,
       wave: options.ownerWave,
+      ownerProject,
       ownerLane,
       ownerWave: options.ownerWave,
+      requesterProject,
       requesterLane,
       requesterWave: options.requesterWave,
       agentId: options.agent,
@@ -155,14 +172,15 @@ export async function runDependencyCli(argv) {
     if (!lane || !options.id || !options.agent) {
       throw new Error("--lane, --id, and --agent are required for resolve");
     }
-    const filePath = dependencyFilePath(lanePaths, lane);
-    const latest = materializeCoordinationState(readDependencyTickets(lanePaths.crossLaneDependenciesDir, lane)).byId.get(
+    const targetProject = options.project || options.ownerProject || lanePaths.project;
+    const targetLanePaths = buildLanePaths(lane, { project: targetProject });
+    const latest = materializeCoordinationState(readDependencyTickets(targetLanePaths.crossLaneDependenciesDir, lane)).byId.get(
       options.id,
     );
     if (!latest) {
       throw new Error(`Dependency ${options.id} not found for lane ${lane}`);
     }
-    const record = appendDependencyTicket(lanePaths.crossLaneDependenciesDir, lane, {
+    const record = appendDependencyTicket(targetLanePaths.crossLaneDependenciesDir, lane, {
       ...latest,
       agentId: options.agent,
       status: options.status || "resolved",
@@ -175,17 +193,23 @@ export async function runDependencyCli(argv) {
 
   if (subcommand === "show") {
     const lane = options.lane || options.ownerLane || lanePaths.lane;
+    const targetProject = options.project || options.ownerProject || lanePaths.project;
+    const targetLanePaths = buildLanePaths(lane, { project: targetProject });
     const records =
       options.wave === null
-        ? readAllDependencyTickets(lanePaths.crossLaneDependenciesDir).filter(
-            (record) => record.ownerLane === lane || record.requesterLane === lane || record.lane === lane,
+        ? readAllDependencyTickets(targetLanePaths.crossLaneDependenciesDir).filter(
+            (record) =>
+              (record.ownerLane === lane || record.requesterLane === lane || record.lane === lane) &&
+              (!options.project ||
+                record.ownerProject === targetProject ||
+                record.requesterProject === targetProject),
           )
         : buildDependencySnapshot({
-            dirPath: lanePaths.crossLaneDependenciesDir,
+            dirPath: targetLanePaths.crossLaneDependenciesDir,
             lane,
             waveNumber: options.wave,
-            agents: loadWaveAgents(lanePaths, options.wave),
-            capabilityRouting: lanePaths.capabilityRouting,
+            agents: loadWaveAgents(targetLanePaths, options.wave),
+            capabilityRouting: targetLanePaths.capabilityRouting,
           });
     if (options.json || options.wave !== null) {
       console.log(JSON.stringify(records, null, 2));
@@ -201,20 +225,22 @@ export async function runDependencyCli(argv) {
 
   if (subcommand === "render") {
     const lane = options.lane || options.ownerLane || lanePaths.lane;
+    const targetProject = options.project || options.ownerProject || lanePaths.project;
+    const targetLanePaths = buildLanePaths(lane, { project: targetProject });
     const snapshot = buildDependencySnapshot({
-      dirPath: lanePaths.crossLaneDependenciesDir,
+      dirPath: targetLanePaths.crossLaneDependenciesDir,
       lane,
       waveNumber: options.wave ?? 0,
-      agents: loadWaveAgents(lanePaths, options.wave ?? 0),
-      capabilityRouting: lanePaths.capabilityRouting,
+      agents: loadWaveAgents(targetLanePaths, options.wave ?? 0),
+      capabilityRouting: targetLanePaths.capabilityRouting,
     });
-    const markdownPath = dependencyMarkdownPath(lanePaths, lane);
-    writeDependencySnapshot(path.join(lanePaths.crossLaneDependenciesDir, `${lane}.json`), snapshot, {
+    const markdownPath = dependencyMarkdownPath(targetLanePaths, lane);
+    writeDependencySnapshot(path.join(targetLanePaths.crossLaneDependenciesDir, `${lane}.json`), snapshot, {
       lane,
       wave: options.wave ?? 0,
     });
     writeTextAtomic(markdownPath, `${renderDependencySnapshotMarkdown(snapshot)}\n`);
-    console.log(JSON.stringify({ markdownPath, jsonPath: path.join(lanePaths.crossLaneDependenciesDir, `${lane}.json`) }, null, 2));
+    console.log(JSON.stringify({ markdownPath, jsonPath: path.join(targetLanePaths.crossLaneDependenciesDir, `${lane}.json`) }, null, 2));
     return;
   }
 

package/scripts/wave-orchestrator/feedback.mjs

@@ -6,10 +6,10 @@ import {
   DEFAULT_WAIT_TIMEOUT_SECONDS,
   DEFAULT_WATCH_REFRESH_MS,
   DEFAULT_WAVE_LANE,
-  REPO_ROOT,
   buildLanePaths,
   compactSingleLine,
   ensureDirectory,
+  findAdhocRunRecord,
   formatAgeFromTimestamp,
   parseNonNegativeInt,
   parsePositiveInt,
@@ -41,9 +41,12 @@ function requestFilePath(feedbackRequestsDir, requestId) {
   return path.join(feedbackRequestsDir, `${requestId}.json`);
 }
 
-function resolveLaneForRun(runId, fallbackLane) {
-  const resultPath = path.join(REPO_ROOT, ".wave", "adhoc", "runs", runId, "result.json");
-  return readJsonOrNull(resultPath)?.lane || fallbackLane;
+function resolveRunContext(runId, fallbackProject, fallbackLane) {
+  const record = findAdhocRunRecord(runId);
+  return {
+    project: record?.project || fallbackProject,
+    lane: record?.result?.lane || fallbackLane,
+  };
 }
 
 function buildRequestId({ lane, wave, agentId }) {
@@ -55,6 +58,7 @@ function buildRequestId({ lane, wave, agentId }) {
 export function createFeedbackRequest({
   feedbackStateDir,
   feedbackRequestsDir,
+  project = null,
   lane,
   wave,
   agentId,
@@ -69,6 +73,7 @@ export function createFeedbackRequest({
   const now = toIsoTimestamp();
   const payload = {
     id: requestId,
+    project: project || null,
     createdAt: now,
     updatedAt: now,
     lane,
@@ -88,7 +93,9 @@ export function createFeedbackRequest({
   });
   if (recordTelemetry) {
     try {
-      const lanePaths = buildLanePaths(lane);
+      const lanePaths = buildLanePaths(lane, {
+        project: project || undefined,
+      });
       safeQueueWaveControlEvent(lanePaths, {
         category: "feedback",
         entityType: "human_input",
@@ -148,7 +155,9 @@ export function answerFeedbackRequest({
   });
   if (recordTelemetry) {
     try {
-      const lanePaths = buildLanePaths(answeredPayload?.lane || DEFAULT_WAVE_LANE);
+      const lanePaths = buildLanePaths(answeredPayload?.lane || DEFAULT_WAVE_LANE, {
+        project: answeredPayload?.project || undefined,
+      });
       safeQueueWaveControlEvent(lanePaths, {
         category: "feedback",
         entityType: "human_input",
@@ -245,6 +254,7 @@ function parseFeedbackArgs(argv) {
     id: "",
     response: "",
     operator: "human-operator",
+    project: "",
     force: false,
     pending: false,
     json: false,
@@ -255,7 +265,9 @@ function parseFeedbackArgs(argv) {
     if (arg === "--") {
       continue;
     }
-    if (arg === "--lane") {
+    if (arg === "--project") {
+      out.project = String(args[++i] || "").trim();
+    } else if (arg === "--lane") {
       out.lane = sanitizeLaneName(args[++i]);
     } else if (arg === "--run") {
       out.runId = sanitizeAdhocRunId(args[++i]);
@@ -310,10 +322,10 @@ async function waitForAnswer(filePath, timeoutSeconds) {
 
 function printHelp() {
   console.log(`Usage:
-  pnpm exec wave-feedback ask --lane <lane> --wave <n> --agent <id> --question "<text>" [options]
+  pnpm exec wave-feedback ask --project <id> --lane <lane> --wave <n> --agent <id> --question "<text>" [options]
   pnpm exec wave-feedback respond --id <request-id> --response "<text>" [options]
-  pnpm exec wave-feedback list [--pending] [--lane <lane>] [--wave <n>] [--agent <id>] [--json]
-  pnpm exec wave-feedback watch [--pending] [--lane <lane>] [--wave <n>] [--agent <id>] [--refresh-ms <n>]
+  pnpm exec wave-feedback list [--pending] [--project <id>] [--lane <lane>] [--wave <n>] [--agent <id>] [--json]
+  pnpm exec wave-feedback watch [--pending] [--project <id>] [--lane <lane>] [--wave <n>] [--agent <id>] [--refresh-ms <n>]
   pnpm exec wave-feedback show --id <request-id>
 `);
 }
@@ -325,9 +337,12 @@ export async function runFeedbackCli(argv) {
     return;
   }
   if (options.runId) {
-    options.lane = resolveLaneForRun(options.runId, options.lane);
+    const context = resolveRunContext(options.runId, options.project, options.lane);
+    options.project = context.project;
+    options.lane = context.lane;
   }
   const lanePaths = buildLanePaths(options.lane, {
+    project: options.project || undefined,
     adhocRunId: options.runId || null,
   });
   const requestsDir = lanePaths.feedbackRequestsDir;
@@ -340,6 +355,7 @@ export async function runFeedbackCli(argv) {
     const result = createFeedbackRequest({
       feedbackStateDir: stateDir,
       feedbackRequestsDir: requestsDir,
+      project: lanePaths.project,
       lane: options.lane,
       wave: options.wave,
       agentId: options.agent,
@@ -375,6 +391,7 @@ export async function runFeedbackCli(argv) {
     });
     if (answered?.lane && Number.isFinite(Number(answered.wave))) {
       answerHumanInputByRequest({
+        project: answered.project || options.project || null,
         lane: answered.lane,
         waveNumber: Number(answered.wave),
         requestId: options.id,

package/scripts/wave-orchestrator/human-input-resolution.mjs

@@ -331,13 +331,17 @@ export function answerHumanInputAndReconcile({
 }
 
 export function answerHumanInputByRequest({
+  project = null,
   lane,
   waveNumber,
   requestId,
   operator = "human-operator",
   runId = null,
 }) {
-  const lanePaths = buildLanePaths(lane, { adhocRunId: runId || null });
+  const lanePaths = buildLanePaths(lane, {
+    project: project || undefined,
+    adhocRunId: runId || null,
+  });
   const wave = loadWave(lanePaths, waveNumber);
   return answerHumanInputAndReconcile({
     lanePaths,

package/scripts/wave-orchestrator/launcher.mjs

@@ -5,6 +5,7 @@ import path from "node:path";
 import {
   CODEX_SANDBOX_MODES,
   DEFAULT_CODEX_SANDBOX_MODE,
+  loadWaveConfig,
   normalizeCodexSandboxMode,
   normalizeExecutorMode,
   SUPPORTED_EXECUTOR_MODES,
@@ -234,6 +235,7 @@ function printUsage(lanePaths, terminalSurface) {
   console.log(`Usage: pnpm exec wave launch [options]
 
 Options:
+  --project <id>        Project id (default: ${lanePaths.project})
   --lane <name>          Wave lane name (default: ${DEFAULT_WAVE_LANE})
   --start-wave <n>       Start from wave number (default: 0)
   --end-wave <n>         End at wave number (default: last available)
@@ -278,9 +280,10 @@ Options:
 }
 
 function parseArgs(argv) {
-  let lanePaths = buildLanePaths(DEFAULT_WAVE_LANE);
-  const projectProfile = readProjectProfile();
+  const config = loadWaveConfig();
+  let lanePaths = buildLanePaths(DEFAULT_WAVE_LANE, { config, project: config.defaultProject });
   const options = {
+    project: config.defaultProject,
     lane: DEFAULT_WAVE_LANE,
     startWave: 0,
     endWave: null,
@@ -298,7 +301,9 @@ function parseArgs(argv) {
     codexSandboxMode: DEFAULT_CODEX_SANDBOX_MODE,
     manifestOut: lanePaths.defaultManifestPath,
     dryRun: false,
-    terminalSurface: resolveDefaultTerminalSurface(projectProfile),
+    terminalSurface: resolveDefaultTerminalSurface(
+      readProjectProfile({ config, project: config.defaultProject }),
+    ),
     dashboard: true,
     cleanupSessions: true,
     keepTerminals: false,
@@ -348,14 +353,28 @@ function parseArgs(argv) {
     } else if (arg === "--no-orchestrator-board") {
       options.orchestratorBoardPath = null;
       orchestratorBoardProvided = true;
+    } else if (arg === "--project") {
+      options.project = String(argv[++i] || "").trim();
+      lanePaths = buildLanePaths(options.lane, {
+        config,
+        project: options.project,
+        adhocRunId: options.adhocRunId,
+      });
+      options.terminalSurface = resolveDefaultTerminalSurface(
+        readProjectProfile({ config, project: options.project }),
+      );
     } else if (arg === "--lane") {
       options.lane = String(argv[++i] || "").trim();
       lanePaths = buildLanePaths(options.lane, {
+        config,
+        project: options.project,
         adhocRunId: options.adhocRunId,
       });
     } else if (arg === "--adhoc-run") {
       options.adhocRunId = sanitizeAdhocRunId(argv[++i]);
       lanePaths = buildLanePaths(options.lane, {
+        config,
+        project: options.project,
         adhocRunId: options.adhocRunId,
       });
     } else if (arg === "--orchestrator-id") {
@@ -406,6 +425,8 @@ function parseArgs(argv) {
   }
 
   lanePaths = buildLanePaths(options.lane, {
+    config,
+    project: options.project,
     runVariant: options.dryRun ? "dry-run" : undefined,
     adhocRunId: options.adhocRunId,
   });

package/scripts/wave-orchestrator/planner.mjs

@@ -36,8 +36,8 @@ import {
   buildDefaultProjectProfile,
   normalizeDraftTemplate,
   normalizeOversightMode,
+  projectProfilePath,
   PROJECT_OVERSIGHT_MODES,
-  PROJECT_PROFILE_PATH,
   PROJECT_PROFILE_TERMINAL_SURFACES,
   readProjectProfile,
   updateProjectProfile,
@@ -1336,8 +1336,9 @@ function collectPlannerSources({ config, lanePaths, task, fromWave }) {
   )) {
     sources.add(sourcePath, "core-context", "planner core context");
   }
-  if (fileExists(PROJECT_PROFILE_PATH)) {
-    sources.add(repoRelativePath(PROJECT_PROFILE_PATH), "project-profile", "saved project profile");
+  const plannerProfilePath = projectProfilePath(lanePaths.project || config.defaultProject);
+  if (fileExists(plannerProfilePath)) {
+    sources.add(repoRelativePath(plannerProfilePath), "project-profile", "saved project profile");
   }
   for (const sourcePath of ensureRepoRelativePathList(
     plannerConfig.lessonsPaths || DEFAULT_PLANNER_AGENTIC_LESSONS_PATHS,
@@ -2587,9 +2588,10 @@ function parsePlannerWaveSelection(rawValue, waveOrder) {
 
 async function runAgenticDraftFlow(options = {}) {
   const config = options.config || loadWaveConfig();
-  const profile = await ensureProjectProfile({ config });
+  const projectId = options.project || config.defaultProject;
+  const profile = await ensureProjectProfile({ config, project: projectId });
   const lane = options.lane || profile.plannerDefaults.lane || config.defaultLane;
-  const lanePaths = buildLanePaths(lane, { config });
+  const lanePaths = buildLanePaths(lane, { config, project: projectId });
   const matrix = loadComponentCutoverMatrix({ laneProfile: lanePaths.laneProfile });
   const bundleIndex = loadContext7BundleIndex(lanePaths.context7BundleIndexPath);
   const plannerExecutorProfile =
@@ -2794,7 +2796,7 @@ async function runAgenticDraftFlow(options = {}) {
         lane: lanePaths.lane,
       },
     }),
-    { config },
+    { config, project: projectId },
   );
   return resultPayload;
 }
@@ -2810,7 +2812,12 @@ async function runApplyPlannerRun(options = {}) {
     );
   }
   const config = options.config || loadWaveConfig();
-  const lanePaths = buildLanePaths(bundle.request.lane, { config });
+  const projectId =
+    cleanText(options.project) ||
+    cleanText(bundle.request.project) ||
+    cleanText(bundle.result?.project) ||
+    config.defaultProject;
+  const lanePaths = buildLanePaths(bundle.request.lane, { config, project: projectId });
   const selectedWaves = parsePlannerWaveSelection(options.waves, bundle.plan?.waveOrder || []);
   if (selectedWaves.length === 0) {
     throw new Error("No waves selected for apply");
@@ -2894,12 +2901,13 @@ function showPlannerRun(options = {}) {
 
 async function ensureProjectProfile(options = {}) {
   const config = options.config || loadWaveConfig();
-  const existing = readProjectProfile({ config });
+  const existing = readProjectProfile({ config, project: options.project });
   if (existing) {
     return existing;
   }
   return runProjectSetupFlow({
     config,
+    project: options.project,
     json: false,
     fromDraft: true,
   });
@@ -2907,12 +2915,14 @@ async function ensureProjectProfile(options = {}) {
 
 async function runProjectSetupFlow(options = {}) {
   const config = options.config || loadWaveConfig();
-  const existing = readProjectProfile({ config });
+  const projectId = cleanText(options.project || config.defaultProject);
+  const existing = readProjectProfile({ config, project: projectId });
   const base = existing || buildDefaultProjectProfile(config);
   const prompt = new PromptSession();
   try {
+    const projectLanes = Object.keys(config.projects?.[projectId]?.lanes || {});
     const laneChoices = Array.from(
-      new Set([config.defaultLane, ...Object.keys(config.lanes || {})].filter(Boolean)),
+      new Set([config.defaultLane, ...projectLanes, ...Object.keys(config.lanes || {})].filter(Boolean)),
     );
     const newProject = await prompt.askBoolean("Treat this repository as a new project?", base.newProject);
     const defaultOversightMode = normalizeOversightMode(
@@ -2994,7 +3004,7 @@ async function runProjectSetupFlow(options = {}) {
           lane,
         },
       },
-      { config },
+      { config, project: projectId },
     );
     return profile;
   } finally {
@@ -3284,10 +3294,11 @@ async function collectEvalTargets({ prompt }) {
 
 async function runDraftFlow(options = {}) {
   const config = options.config || loadWaveConfig();
-  const profile = await ensureProjectProfile({ config });
+  const projectId = options.project || config.defaultProject;
+  const profile = await ensureProjectProfile({ config, project: projectId });
   const waveNumber = options.wave;
   const lane = options.lane || profile.plannerDefaults.lane || config.defaultLane;
-  const lanePaths = buildLanePaths(lane, { config });
+  const lanePaths = buildLanePaths(lane, { config, project: projectId });
   const matrix = loadComponentCutoverMatrix({ laneProfile: lanePaths.laneProfile });
   const bundleIndex = loadContext7BundleIndex(lanePaths.context7BundleIndexPath);
   const context7BundleChoices = Object.keys(bundleIndex.bundles || {}).sort((left, right) =>
@@ -3409,9 +3420,10 @@ async function runDraftFlow(options = {}) {
           lane: lanePaths.lane,
         },
       }),
-      { config },
+      { config, project: projectId },
     );
     return {
+      project: projectId,
       wave: waveNumber,
       lane: lanePaths.lane,
       template,
@@ -3419,7 +3431,7 @@ async function runDraftFlow(options = {}) {
       specPath: path.relative(REPO_ROOT, specPath),
       matrixJsonPath: path.relative(REPO_ROOT, path.resolve(REPO_ROOT, lanePaths.componentCutoverMatrixJsonPath)),
       matrixDocPath: path.relative(REPO_ROOT, path.resolve(REPO_ROOT, lanePaths.componentCutoverMatrixDocPath)),
-      profilePath: path.relative(REPO_ROOT, PROJECT_PROFILE_PATH),
+      profilePath: path.relative(REPO_ROOT, projectProfilePath(projectId)),
     };
   } finally {
     await prompt.close();
@@ -3428,12 +3440,12 @@ async function runDraftFlow(options = {}) {
 
 function printPlannerHelp() {
   console.log(`Usage:
-  wave project setup [--json]
-  wave project show [--json]
-  wave draft --wave <n> [--lane <lane>] [--template implementation|qa|infra|release] [--force] [--json]
-  wave draft --agentic --task "<text>" --from-wave <n> [--lane <lane>] [--max-waves <n>] [--planner-executor <profile>] [--json]
+  wave project setup [--project <id>] [--json]
+  wave project show [--project <id>] [--json]
+  wave draft --wave <n> [--project <id>] [--lane <lane>] [--template implementation|qa|infra|release] [--force] [--json]
+  wave draft --agentic --task "<text>" --from-wave <n> [--project <id>] [--lane <lane>] [--max-waves <n>] [--planner-executor <profile>] [--json]
   wave draft --show-run <run-id> [--json]
-  wave draft --apply-run <run-id> [--waves <list>|all] [--force] [--json]
+  wave draft --apply-run <run-id> [--project <id>] [--waves <list>|all] [--force] [--json]
 `);
 }
 
@@ -3444,6 +3456,7 @@ export async function runPlannerCli(argv) {
     json: false,
     force: false,
     wave: null,
+    project: null,
     lane: null,
     template: null,
     agentic: false,
@@ -3464,6 +3477,8 @@ export async function runPlannerCli(argv) {
     for (const arg of args) {
       if (arg === "--json") {
         options.json = true;
+      } else if (arg === "--project") {
+        options.project = cleanText(args.shift());
       } else if (arg === "--help" || arg === "-h") {
         printPlannerHelp();
         return;
@@ -3472,15 +3487,17 @@ export async function runPlannerCli(argv) {
       }
     }
     if (action === "setup") {
-      const profile = await runProjectSetupFlow({ json: options.json });
+      const projectId = options.project || loadWaveConfig().defaultProject;
+      const profile = await runProjectSetupFlow({ json: options.json, project: projectId });
       if (options.json) {
         printJson({
-          profilePath: path.relative(REPO_ROOT, PROJECT_PROFILE_PATH),
+          profilePath: path.relative(REPO_ROOT, projectProfilePath(projectId)),
           profile,
         });
         return;
       }
-      console.log(`[wave:project] profile: ${path.relative(REPO_ROOT, PROJECT_PROFILE_PATH)}`);
+      console.log(`[wave:project] profile: ${path.relative(REPO_ROOT, projectProfilePath(projectId))}`);
+      console.log(`[wave:project] project_id=${projectId}`);
       console.log(`[wave:project] lane=${profile.plannerDefaults.lane}`);
       console.log(`[wave:project] template=${profile.plannerDefaults.template}`);
       console.log(`[wave:project] oversight=${profile.defaultOversightMode}`);
@@ -3488,19 +3505,21 @@ export async function runPlannerCli(argv) {
       return;
     }
     if (action === "show") {
-      const profile = readProjectProfile();
+      const projectId = options.project || loadWaveConfig().defaultProject;
+      const profile = readProjectProfile({ project: projectId });
       if (options.json) {
         printJson({
-          profilePath: path.relative(REPO_ROOT, PROJECT_PROFILE_PATH),
+          profilePath: path.relative(REPO_ROOT, projectProfilePath(projectId)),
           profile,
         });
         return;
       }
       if (!profile) {
-        console.log(`[wave:project] no saved profile at ${path.relative(REPO_ROOT, PROJECT_PROFILE_PATH)}`);
+        console.log(`[wave:project] no saved profile at ${path.relative(REPO_ROOT, projectProfilePath(projectId))}`);
         return;
       }
-      console.log(`[wave:project] profile: ${path.relative(REPO_ROOT, PROJECT_PROFILE_PATH)}`);
+      console.log(`[wave:project] profile: ${path.relative(REPO_ROOT, projectProfilePath(projectId))}`);
+      console.log(`[wave:project] project_id=${projectId}`);
       console.log(`[wave:project] project=${profile.source.projectName}`);
       console.log(`[wave:project] lane=${profile.plannerDefaults.lane}`);
       console.log(`[wave:project] template=${profile.plannerDefaults.template}`);
@@ -3537,6 +3556,8 @@ export async function runPlannerCli(argv) {
       options.waves = cleanText(args[++index]);
     } else if (arg === "--wave") {
       options.wave = Number.parseInt(String(args[++index] || ""), 10);
+    } else if (arg === "--project") {
+      options.project = cleanText(args[++index]);
     } else if (arg === "--lane") {
       options.lane = cleanText(args[++index]);
     } else if (arg === "--template") {