@chllming/wave-orchestration 0.8.9 → 0.9.1

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

@@ -35,22 +35,21 @@ import { writeAssignmentSnapshot, writeDependencySnapshot } from "./artifact-sch
 import {
   buildLanePaths,
   ensureDirectory,
+  findAdhocRunRecord,
   parseNonNegativeInt,
-  readJsonOrNull,
-  REPO_ROOT,
   sanitizeAdhocRunId,
 } from "./shared.mjs";
 import { parseWaveFiles } from "./wave-files.mjs";
 
 function printUsage() {
   console.log(`Usage:
-  wave coord post --lane <lane> --wave <n> --agent <id> --kind <kind> --summary <text> [--dry-run] [options]
-  wave coord show --lane <lane> --wave <n> [--dry-run] [--json]
-  wave coord render --lane <lane> --wave <n> [--dry-run]
-  wave coord inbox --lane <lane> --wave <n> --agent <id> [--dry-run]
-  wave coord explain --lane <lane> --wave <n> [--agent <id>] [--json]
-  wave coord act <resolve|dismiss|reroute|reassign|escalate|answer-human> --lane <lane> --wave <n> [options]
-  wave coord <subcommand> --run <id> [--wave 0] ...
+  wave coord post --project <id> --lane <lane> --wave <n> --agent <id> --kind <kind> --summary <text> [--dry-run] [options]
+  wave coord show --project <id> --lane <lane> --wave <n> [--dry-run] [--json]
+  wave coord render --project <id> --lane <lane> --wave <n> [--dry-run]
+  wave coord inbox --project <id> --lane <lane> --wave <n> --agent <id> [--dry-run]
+  wave coord explain --project <id> --lane <lane> --wave <n> [--agent <id>] [--json]
+  wave coord act <resolve|dismiss|reroute|reassign|escalate|answer-human> --project <id> --lane <lane> --wave <n> [options]
+  wave coord <subcommand> --run <id> [--project <id>] [--wave 0] ...
 `);
 }
 
@@ -58,6 +57,7 @@ function parseArgs(argv) {
   const args = argv[0] === "--" ? argv.slice(1) : argv;
   const subcommand = String(args[0] || "").trim().toLowerCase();
   const options = {
+    project: "",
     lane: "main",
     wave: null,
     runId: "",
@@ -85,7 +85,9 @@ function parseArgs(argv) {
   }
   for (let i = startIndex; i < args.length; i += 1) {
     const arg = args[i];
-    if (arg === "--lane") {
+    if (arg === "--project") {
+      options.project = String(args[++i] || "").trim();
+    } else if (arg === "--lane") {
       options.lane = String(args[++i] || "").trim();
     } else if (arg === "--run") {
       options.runId = sanitizeAdhocRunId(args[++i]);
@@ -131,9 +133,12 @@ function parseArgs(argv) {
   return { subcommand, options };
 }
 
-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 loadWave(lanePaths, waveNumber) {
@@ -329,9 +334,12 @@ export async function runCoordinationCli(argv) {
   }
   const { subcommand, options } = parseArgs(argv);
   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,
     runVariant: options.dryRun ? "dry-run" : undefined,
     adhocRunId: options.runId || null,
   });

package/scripts/wave-orchestrator/coordination-store.mjs

@@ -242,8 +242,11 @@ export function normalizeCoordinationRecord(rawRecord, defaults = {}) {
         : Number.parseInt(String(rawRecord.attempt), 10),
     source: normalizeString(rawRecord.source ?? defaults.source, "launcher"),
     executorId: normalizeString(rawRecord.executorId ?? defaults.executorId, ""),
+    project: normalizeString(rawRecord.project ?? defaults.project, ""),
     requesterLane: normalizeString(rawRecord.requesterLane ?? defaults.requesterLane, ""),
     ownerLane: normalizeString(rawRecord.ownerLane ?? defaults.ownerLane, ""),
+    requesterProject: normalizeString(rawRecord.requesterProject ?? defaults.requesterProject, ""),
+    ownerProject: normalizeString(rawRecord.ownerProject ?? defaults.ownerProject, ""),
     requesterWave:
       rawRecord.requesterWave === null || rawRecord.requesterWave === undefined || rawRecord.requesterWave === ""
         ? defaults.requesterWave ?? null
@@ -264,8 +267,10 @@ export function appendCoordinationRecord(filePath, rawRecord, defaults = {}) {
   ensureDirectory(path.dirname(filePath));
   fs.appendFileSync(filePath, `${JSON.stringify(record)}\n`, "utf8");
   const runIdHint = normalizeString(rawRecord?.runId ?? defaults.runId, "");
+  const projectHint = normalizeString(rawRecord?.project ?? defaults.project, "");
   try {
     const lanePaths = buildLanePaths(record.lane, {
+      ...(projectHint ? { project: projectHint } : {}),
       ...(runIdHint ? { adhocRunId: runIdHint } : {}),
     });
     if (lanePaths?.waveControl?.captureCoordinationRecords !== false) {
@@ -301,8 +306,11 @@ export function appendCoordinationRecord(filePath, rawRecord, defaults = {}) {
           closureCondition: record.closureCondition,
           required: record.required,
           executorId: record.executorId || null,
+          project: record.project || null,
           requesterLane: record.requesterLane || null,
           ownerLane: record.ownerLane || null,
+          requesterProject: record.requesterProject || null,
+          ownerProject: record.ownerProject || null,
         },
       });
     }

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

@@ -1,4 +1,3 @@
-import { spawnSync } from "node:child_process";
 import fs from "node:fs";
 import path from "node:path";
 import { loadWaveConfig } from "./config.mjs";
@@ -14,6 +13,7 @@ import {
   formatAgeFromTimestamp,
   formatElapsed,
   pad,
+  readJsonOrNull,
   sleep,
   truncate,
 } from "./shared.mjs";
@@ -21,6 +21,10 @@ import {
   createCurrentWaveDashboardTerminalEntry,
   createGlobalDashboardTerminalEntry,
 } from "./terminals.mjs";
+import {
+  attachSession as attachTmuxSession,
+  hasSession as hasTmuxSession,
+} from "./tmux-adapter.mjs";
 
 const DASHBOARD_ATTACH_TARGETS = ["current", "global"];
 
@@ -36,6 +40,7 @@ function normalizeDashboardAttachTarget(value) {
 
 export function parseDashboardArgs(argv) {
   const options = {
+    project: null,
     lane: DEFAULT_WAVE_LANE,
     dashboardFile: null,
     messageBoard: null,
@@ -50,6 +55,8 @@ export function parseDashboardArgs(argv) {
     }
     if (arg === "--watch") {
       options.watch = true;
+    } else if (arg === "--project") {
+      options.project = String(argv[++i] || "").trim() || null;
     } else if (arg === "--lane") {
       options.lane =
         String(argv[++i] || "")
@@ -75,55 +82,122 @@ export function parseDashboardArgs(argv) {
   return { help: false, options };
 }
 
-function tmuxSessionExists(socketName, sessionName) {
-  const result = spawnSync("tmux", ["-L", socketName, "has-session", "-t", sessionName], {
-    cwd: REPO_ROOT,
-    encoding: "utf8",
-    env: { ...process.env, TMUX: "" },
-  });
-  if (result.error) {
-    throw new Error(`tmux session lookup failed: ${result.error.message}`);
-  }
-  if (result.status === 0) {
-    return true;
-  }
-  const combined = `${String(result.stderr || "").toLowerCase()}\n${String(result.stdout || "").toLowerCase()}`;
-  if (
-    combined.includes("can't find session") ||
-    combined.includes("no server running") ||
-    combined.includes("error connecting")
-  ) {
-    return false;
-  }
-  throw new Error((result.stderr || result.stdout || "tmux has-session failed").trim());
-}
-
-function attachDashboardSession(lane, target) {
+async function attachDashboardSession(project, lane, target) {
   const config = loadWaveConfig();
-  const lanePaths = buildLanePaths(lane, { config });
+  const lanePaths = buildLanePaths(lane, {
+    config,
+    project: project || config.defaultProject,
+  });
   const entry =
     target === "global"
       ? createGlobalDashboardTerminalEntry(lanePaths, "current")
       : createCurrentWaveDashboardTerminalEntry(lanePaths);
-  if (!tmuxSessionExists(lanePaths.tmuxSocketName, entry.sessionName)) {
-    const dashboardsRel = path.relative(REPO_ROOT, path.dirname(lanePaths.globalDashboardPath));
-    throw new Error(
-      `No ${target} dashboard session is live for lane ${lanePaths.lane}. Launch a dashboarded run on that lane, then inspect ${dashboardsRel} if you need the last written dashboard state.`,
-    );
+  if (!await hasTmuxSession(lanePaths.tmuxSocketName, entry.sessionName, { allowMissingBinary: false })) {
+    const fallback = resolveDashboardAttachFallback(lanePaths, target);
+    if (fallback) {
+      return fallback;
+    }
+    throw new Error(buildMissingDashboardAttachError(lanePaths, target));
+  }
+  try {
+    await attachTmuxSession(lanePaths.tmuxSocketName, entry.sessionName);
+    return null;
+  } catch (error) {
+    if (error?.tmuxMissingSession) {
+      const fallback = resolveDashboardAttachFallback(lanePaths, target);
+      if (fallback) {
+        return fallback;
+      }
+      throw new Error(buildMissingDashboardAttachError(lanePaths, target));
+    }
+    throw error;
+  }
+}
+
+function buildMissingDashboardAttachError(lanePaths, target) {
+  const dashboardsRel = path.relative(REPO_ROOT, path.dirname(lanePaths.globalDashboardPath));
+  return `No ${target} dashboard session is live for lane ${lanePaths.lane}. Launch a dashboarded run on that lane, then inspect ${dashboardsRel} if you need the last written dashboard state.`;
+}
+
+function waveDashboardPathForNumber(lanePaths, waveNumber) {
+  if (!Number.isFinite(Number(waveNumber))) {
+    return null;
   }
-  const result = spawnSync("tmux", ["-L", lanePaths.tmuxSocketName, "attach", "-t", entry.sessionName], {
-    cwd: REPO_ROOT,
-    stdio: "inherit",
-    env: { ...process.env, TMUX: "" },
+  const candidate = path.join(lanePaths.dashboardsDir, `wave-${Number(waveNumber)}.json`);
+  return fs.existsSync(candidate) ? candidate : null;
+}
+
+function selectCurrentWaveFromGlobalDashboard(globalState) {
+  const waves = Array.isArray(globalState?.waves) ? globalState.waves : [];
+  const candidates = waves
+    .map((wave) => ({
+      waveNumber: Number.parseInt(String(wave?.wave ?? ""), 10),
+      status: String(wave?.status || "").trim().toLowerCase(),
+      updatedAt: Date.parse(
+        String(wave?.updatedAt || wave?.completedAt || wave?.startedAt || ""),
+      ),
+    }))
+    .filter((entry) => Number.isFinite(entry.waveNumber));
+  if (candidates.length === 0) {
+    return null;
+  }
+  candidates.sort((left, right) => {
+    const leftTerminal = TERMINAL_STATES.has(left.status);
+    const rightTerminal = TERMINAL_STATES.has(right.status);
+    if (leftTerminal !== rightTerminal) {
+      return leftTerminal ? 1 : -1;
+    }
+    const leftUpdatedAt = Number.isFinite(left.updatedAt) ? left.updatedAt : 0;
+    const rightUpdatedAt = Number.isFinite(right.updatedAt) ? right.updatedAt : 0;
+    if (leftUpdatedAt !== rightUpdatedAt) {
+      return rightUpdatedAt - leftUpdatedAt;
+    }
+    return right.waveNumber - left.waveNumber;
   });
-  if (result.error) {
-    throw new Error(`tmux attach failed: ${result.error.message}`);
+  return candidates[0].waveNumber;
+}
+
+export function resolveDashboardAttachFallback(lanePaths, target) {
+  if (target === "global") {
+    return fs.existsSync(lanePaths.globalDashboardPath)
+      ? { dashboardFile: lanePaths.globalDashboardPath }
+      : null;
   }
-  if (result.status !== 0) {
-    throw new Error(
-      `tmux attach exited ${result.status} for lane ${lanePaths.lane} ${target} dashboard session ${entry.sessionName}.`,
-    );
+  const globalState = readJsonOrNull(lanePaths.globalDashboardPath);
+  const preferredWaveNumber = selectCurrentWaveFromGlobalDashboard(globalState);
+  const preferredWavePath = waveDashboardPathForNumber(lanePaths, preferredWaveNumber);
+  if (preferredWavePath) {
+    return { dashboardFile: preferredWavePath };
   }
+  if (!fs.existsSync(lanePaths.dashboardsDir)) {
+    return fs.existsSync(lanePaths.globalDashboardPath)
+      ? { dashboardFile: lanePaths.globalDashboardPath }
+      : null;
+  }
+  const candidates = fs.readdirSync(lanePaths.dashboardsDir, { withFileTypes: true })
+    .filter((entry) => entry.isFile())
+    .map((entry) => ({
+      filePath: path.join(lanePaths.dashboardsDir, entry.name),
+      match: entry.name.match(/^wave-(\d+)\.json$/),
+    }))
+    .filter((entry) => entry.match)
+    .map((entry) => ({
+      dashboardFile: entry.filePath,
+      waveNumber: Number.parseInt(entry.match[1], 10),
+      mtimeMs: fs.statSync(entry.filePath).mtimeMs,
+    }))
+    .sort((left, right) => {
+      if (left.mtimeMs !== right.mtimeMs) {
+        return right.mtimeMs - left.mtimeMs;
+      }
+      return right.waveNumber - left.waveNumber;
+    });
+  if (candidates.length > 0) {
+    return { dashboardFile: candidates[0].dashboardFile };
+  }
+  return fs.existsSync(lanePaths.globalDashboardPath)
+    ? { dashboardFile: lanePaths.globalDashboardPath }
+    : null;
 }
 
 function readMessageBoardTail(messageBoardPath, maxLines = 24) {
@@ -449,11 +523,12 @@ export async function runDashboardCli(argv) {
     console.log(`Usage: pnpm exec wave dashboard --dashboard-file <path> [options]
 
 Options:
+  --project <id>          Project id (default: config default)
   --lane <name>            Wave lane name (default: ${DEFAULT_WAVE_LANE})
   --dashboard-file <path>  Path to wave/global dashboard JSON
   --message-board <path>   Optional message board path override
   --attach <current|global>
-                          Attach to the stable tmux-backed dashboard session for the lane
+                          Attach to the stable dashboard session for the lane, or follow the last written dashboard file when no live session exists
   --watch                  Refresh continuously
   --refresh-ms <n>         Refresh interval in ms (default: ${DEFAULT_REFRESH_MS})
 `);
@@ -461,8 +536,12 @@ Options:
   }
 
   if (options.attach) {
-    attachDashboardSession(options.lane, options.attach);
-    return;
+    const fallback = await attachDashboardSession(options.project, options.lane, options.attach);
+    if (!fallback) {
+      return;
+    }
+    options.dashboardFile = fallback.dashboardFile;
+    options.watch = true;
   }
 
   let terminalStateReachedAt = null;

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/derived-state-engine.mjs

@@ -26,7 +26,7 @@ import { deriveWaveLedger, readWaveLedger } from "./ledger.mjs";
 import { buildDocsQueue, readDocsQueue } from "./docs-queue.mjs";
 import { parseStructuredSignalsFromLog } from "./dashboard-state.mjs";
 import {
-  isSecurityReviewAgent,
+  isSecurityReviewAgentForLane,
   resolveSecurityReviewReportPath,
   isContEvalImplementationOwningAgent,
   resolveWaveRoleBindings,
@@ -214,7 +214,9 @@ export function buildWaveSecuritySummary({
   summariesByAgentId = {},
 }) {
   const createdAt = toIsoTimestamp();
-  const securityAgents = (wave.agents || []).filter((agent) => isSecurityReviewAgent(agent));
+  const securityAgents = (wave.agents || []).filter((agent) =>
+    isSecurityReviewAgentForLane(agent, lanePaths),
+  );
   if (securityAgents.length === 0) {
     return {
       wave: wave.wave,
@@ -377,7 +379,7 @@ function buildIntegrationEvidence({
       isContEvalImplementationOwningAgent(agent, {
         contEvalAgentId: roleBindings.contEvalAgentId,
       });
-    if (isSecurityReviewAgent(agent)) {
+    if (isSecurityReviewAgentForLane(agent, lanePaths)) {
       continue;
     }
     if (agent.agentId === roleBindings.contEvalAgentId) {
@@ -710,6 +712,7 @@ export function buildWaveDerivedState({
     benchmarkCatalogPath: lanePaths.laneProfile?.paths?.benchmarkCatalogPath,
     capabilityAssignments,
     dependencySnapshot,
+    securityRolePromptPath: lanePaths.securityRolePromptPath,
   });
   const inboxDir = waveInboxDir(lanePaths, wave.wave);
   const sharedSummary = compileSharedSummary({

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,