@chllming/wave-orchestration 0.5.3 → 0.6.0

package/scripts/wave-orchestrator/project-profile.mjs

@@ -0,0 +1,190 @@
+import path from "node:path";
+import { loadWaveConfig } from "./config.mjs";
+import { REPO_ROOT, ensureDirectory, readJsonOrNull, writeJsonAtomic } from "./shared.mjs";
+import { normalizeTerminalSurface } from "./terminals.mjs";
+
+export const PROJECT_PROFILE_SCHEMA_VERSION = 1;
+export const PROJECT_PROFILE_PATH = path.join(REPO_ROOT, ".wave", "project-profile.json");
+export const PROJECT_OVERSIGHT_MODES = ["oversight", "dark-factory"];
+export const PROJECT_PROFILE_TERMINAL_SURFACES = ["vscode", "tmux"];
+export const DEPLOY_ENVIRONMENT_KINDS = [
+  "railway-mcp",
+  "railway-cli",
+  "docker-compose",
+  "kubernetes",
+  "ssh-manual",
+  "custom",
+];
+export const DRAFT_TEMPLATES = ["implementation", "qa", "infra", "release"];
+
+function cleanText(value) {
+  return String(value ?? "").trim();
+}
+
+function normalizePathForProfile(value) {
+  const normalized = cleanText(value).replaceAll("\\", "/");
+  if (!normalized) {
+    return null;
+  }
+  return path.isAbsolute(normalized) ? path.relative(REPO_ROOT, normalized) : normalized;
+}
+
+function normalizeProjectTerminalSurface(value, label = "defaultTerminalSurface") {
+  const normalized = normalizeTerminalSurface(value, label);
+  return normalized === "none" ? "vscode" : normalized;
+}
+
+export function normalizeOversightMode(value, label = "oversight mode") {
+  const normalized = cleanText(value).toLowerCase();
+  if (!PROJECT_OVERSIGHT_MODES.includes(normalized)) {
+    throw new Error(`${label} must be one of: ${PROJECT_OVERSIGHT_MODES.join(", ")}`);
+  }
+  return normalized;
+}
+
+export function normalizeDraftTemplate(value, label = "draft template") {
+  const normalized = cleanText(value).toLowerCase();
+  if (!DRAFT_TEMPLATES.includes(normalized)) {
+    throw new Error(`${label} must be one of: ${DRAFT_TEMPLATES.join(", ")}`);
+  }
+  return normalized;
+}
+
+function normalizeDeployEnvironment(rawEnvironment, index) {
+  if (!rawEnvironment || typeof rawEnvironment !== "object" || Array.isArray(rawEnvironment)) {
+    throw new Error(`deployEnvironments[${index}] must be an object`);
+  }
+  const id = cleanText(rawEnvironment.id).toLowerCase();
+  if (!/^[a-z0-9][a-z0-9._-]*$/.test(id)) {
+    throw new Error(`deployEnvironments[${index}].id must be a lowercase repo-safe identifier`);
+  }
+  const kind = cleanText(rawEnvironment.kind).toLowerCase();
+  if (!DEPLOY_ENVIRONMENT_KINDS.includes(kind)) {
+    throw new Error(
+      `deployEnvironments[${index}].kind must be one of: ${DEPLOY_ENVIRONMENT_KINDS.join(", ")}`,
+    );
+  }
+  return {
+    id,
+    name: cleanText(rawEnvironment.name) || id,
+    kind,
+    isDefault: rawEnvironment.isDefault === true,
+    notes: cleanText(rawEnvironment.notes) || null,
+  };
+}
+
+export function buildDefaultProjectProfile(config = loadWaveConfig()) {
+  const now = new Date().toISOString();
+  return {
+    schemaVersion: PROJECT_PROFILE_SCHEMA_VERSION,
+    initializedAt: now,
+    updatedAt: now,
+    newProject: false,
+    defaultOversightMode: "oversight",
+    defaultTerminalSurface: "vscode",
+    deployEnvironments: [],
+    plannerDefaults: {
+      template: "implementation",
+      lane: cleanText(config.defaultLane) || "main",
+    },
+    source: {
+      projectName: cleanText(config.projectName) || "Wave Orchestrator",
+      configPath: normalizePathForProfile(config.configPath || "wave.config.json"),
+    },
+  };
+}
+
+export function normalizeProjectProfile(rawProfile, options = {}) {
+  if (!rawProfile || typeof rawProfile !== "object" || Array.isArray(rawProfile)) {
+    throw new Error(`Project profile is invalid: ${path.relative(REPO_ROOT, PROJECT_PROFILE_PATH)}`);
+  }
+  const config = options.config || loadWaveConfig();
+  const base = buildDefaultProjectProfile(config);
+  const deployEnvironments = Array.isArray(rawProfile.deployEnvironments)
+    ? rawProfile.deployEnvironments.map((entry, index) => normalizeDeployEnvironment(entry, index))
+    : [];
+  const defaultEnvironmentIndex = deployEnvironments.findIndex((entry) => entry.isDefault);
+  if (defaultEnvironmentIndex === -1 && deployEnvironments.length > 0) {
+    deployEnvironments[0].isDefault = true;
+  } else if (defaultEnvironmentIndex > -1) {
+    deployEnvironments.forEach((entry, index) => {
+      entry.isDefault = index === defaultEnvironmentIndex;
+    });
+  }
+  const plannerDefaults =
+    rawProfile.plannerDefaults && typeof rawProfile.plannerDefaults === "object"
+      ? rawProfile.plannerDefaults
+      : {};
+  return {
+    schemaVersion: PROJECT_PROFILE_SCHEMA_VERSION,
+    initializedAt: cleanText(rawProfile.initializedAt) || base.initializedAt,
+    updatedAt: cleanText(rawProfile.updatedAt) || base.updatedAt,
+    newProject: rawProfile.newProject === true,
+    defaultOversightMode: normalizeOversightMode(
+      rawProfile.defaultOversightMode || base.defaultOversightMode,
+      "defaultOversightMode",
+    ),
+    defaultTerminalSurface: normalizeProjectTerminalSurface(
+      rawProfile.defaultTerminalSurface || base.defaultTerminalSurface,
+      "defaultTerminalSurface",
+    ),
+    deployEnvironments,
+    plannerDefaults: {
+      template: normalizeDraftTemplate(
+        plannerDefaults.template || base.plannerDefaults.template,
+        "plannerDefaults.template",
+      ),
+      lane: cleanText(plannerDefaults.lane) || base.plannerDefaults.lane,
+    },
+    source: {
+      projectName: cleanText(rawProfile.source?.projectName) || base.source.projectName,
+      configPath: normalizePathForProfile(rawProfile.source?.configPath) || base.source.configPath,
+    },
+  };
+}
+
+export function readProjectProfile(options = {}) {
+  const payload = readJsonOrNull(PROJECT_PROFILE_PATH);
+  if (!payload) {
+    return null;
+  }
+  return normalizeProjectProfile(payload, options);
+}
+
+export function writeProjectProfile(profile, options = {}) {
+  const config = options.config || loadWaveConfig();
+  const now = new Date().toISOString();
+  const normalized = normalizeProjectProfile(
+    {
+      ...profile,
+      initializedAt: profile?.initializedAt || now,
+      updatedAt: now,
+      source: {
+        projectName: profile?.source?.projectName || config.projectName,
+        configPath: normalizePathForProfile(config.configPath || "wave.config.json"),
+      },
+    },
+    { config },
+  );
+  ensureDirectory(path.dirname(PROJECT_PROFILE_PATH));
+  writeJsonAtomic(PROJECT_PROFILE_PATH, normalized);
+  return normalized;
+}
+
+export function updateProjectProfile(mutator, options = {}) {
+  const config = options.config || loadWaveConfig();
+  const current = readProjectProfile({ config }) || buildDefaultProjectProfile(config);
+  const next = typeof mutator === "function" ? mutator(current) : { ...current, ...(mutator || {}) };
+  return writeProjectProfile(
+    {
+      ...current,
+      ...(next || {}),
+      initializedAt: current.initializedAt,
+    },
+    { config },
+  );
+}
+
+export function resolveDefaultTerminalSurface(profile) {
+  return normalizeProjectTerminalSurface(profile?.defaultTerminalSurface || "vscode");
+}

package/scripts/wave-orchestrator/replay.mjs

@@ -22,19 +22,22 @@ function buildReplayLanePaths(metadata) {
       : null;
   const roles = replayContext?.roles || metadata?.roles || {};
   const validation = replayContext?.validation || metadata?.validation || {};
-  const evaluatorAgentId = roles.evaluatorAgentId || "A0";
+  const contQaAgentId = roles.contQaAgentId || roles.evaluatorAgentId || "A0";
+  const contEvalAgentId = roles.contEvalAgentId || "E0";
   const integrationAgentId = roles.integrationAgentId || "A8";
   const documentationAgentId = roles.documentationAgentId || "A9";
   return {
     lane: replayContext?.lane || metadata?.lane || "main",
-    evaluatorAgentId,
+    contQaAgentId,
+    contEvalAgentId,
     integrationAgentId,
     documentationAgentId,
     requireIntegrationStewardFromWave:
       validation.requireIntegrationStewardFromWave ?? null,
     laneProfile: {
       roles: {
-        evaluatorAgentId,
+        contQaAgentId,
+        contEvalAgentId,
         integrationAgentId,
         documentationAgentId,
       },

package/scripts/wave-orchestrator/role-helpers.mjs

@@ -0,0 +1,84 @@
+import {
+  DEFAULT_CONT_EVAL_AGENT_ID,
+  DEFAULT_SECURITY_ROLE_PROMPT_PATH,
+} from "./config.mjs";
+
+function cleanPath(value) {
+  return String(value || "")
+    .trim()
+    .replaceAll("\\", "/");
+}
+
+export function isContQaReportPath(relPath) {
+  return /(?:^|\/)(?:reviews?|.*cont[-_]?qa).*\.(?:md|txt)$/i.test(cleanPath(relPath));
+}
+
+export function isContEvalReportPath(relPath) {
+  return /(?:^|\/)(?:reviews?|.*cont[-_]?eval|.*eval).*\.(?:md|txt)$/i.test(cleanPath(relPath));
+}
+
+export function isSecurityRolePromptPath(
+  relPath,
+  securityRolePromptPath = DEFAULT_SECURITY_ROLE_PROMPT_PATH,
+) {
+  const normalized = cleanPath(relPath);
+  const configured = cleanPath(securityRolePromptPath);
+  return (
+    normalized === configured ||
+    normalized === DEFAULT_SECURITY_ROLE_PROMPT_PATH ||
+    normalized.endsWith("/wave-security-role.md")
+  );
+}
+
+export function isSecurityReportPath(relPath) {
+  return /(?:^|\/).*security.*\.(?:md|txt)$/i.test(cleanPath(relPath));
+}
+
+export function isContEvalImplementationOwningAgent(
+  agent,
+  { contEvalAgentId = DEFAULT_CONT_EVAL_AGENT_ID } = {},
+) {
+  if (!agent || agent.agentId !== contEvalAgentId) {
+    return false;
+  }
+  const ownedPaths = Array.isArray(agent.ownedPaths) ? agent.ownedPaths.map(cleanPath).filter(Boolean) : [];
+  if (ownedPaths.length === 0) {
+    return false;
+  }
+  return ownedPaths.some((ownedPath) => !isContEvalReportPath(ownedPath));
+}
+
+export function isContEvalReportOnlyAgent(
+  agent,
+  { contEvalAgentId = DEFAULT_CONT_EVAL_AGENT_ID } = {},
+) {
+  return agent?.agentId === contEvalAgentId && !isContEvalImplementationOwningAgent(agent, {
+    contEvalAgentId,
+  });
+}
+
+export function isSecurityReviewAgent(
+  agent,
+  { securityRolePromptPath = DEFAULT_SECURITY_ROLE_PROMPT_PATH } = {},
+) {
+  if (!agent || typeof agent !== "object") {
+    return false;
+  }
+  const rolePromptPaths = Array.isArray(agent.rolePromptPaths) ? agent.rolePromptPaths : [];
+  if (
+    rolePromptPaths.some((rolePromptPath) =>
+      isSecurityRolePromptPath(rolePromptPath, securityRolePromptPath),
+    )
+  ) {
+    return true;
+  }
+  const capabilities = Array.isArray(agent.capabilities)
+    ? agent.capabilities.map((entry) => String(entry || "").trim().toLowerCase())
+    : [];
+  return capabilities.includes("security-review");
+}
+
+export function resolveSecurityReviewReportPath(agent) {
+  const ownedPaths = Array.isArray(agent?.ownedPaths) ? agent.ownedPaths.map(cleanPath).filter(Boolean) : [];
+  return ownedPaths.find((ownedPath) => isSecurityReportPath(ownedPath)) || null;
+}

package/scripts/wave-orchestrator/shared.mjs

@@ -77,22 +77,71 @@ export function sanitizeOrchestratorId(value) {
   return id.slice(0, 64);
 }
 
+export function sanitizeAdhocRunId(value) {
+  const id = String(value || "")
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9._-]+/g, "-")
+    .replace(/-+/g, "-")
+    .replace(/^-+|-+$/g, "");
+  if (!id) {
+    throw new Error("Ad-hoc run ID is required");
+  }
+  if (!/^[a-z0-9][a-z0-9._-]*$/.test(id)) {
+    throw new Error(`Invalid ad-hoc run ID: ${value}`);
+  }
+  return id;
+}
+
+export function buildWorkspaceTmuxToken(workspaceRoot = REPO_ROOT) {
+  const repoBase =
+    path
+      .basename(path.resolve(String(workspaceRoot || REPO_ROOT)))
+      .toLowerCase()
+      .replace(/[^a-z0-9]+/g, "_")
+      .replace(/^_+|_+$/g, "")
+      .slice(0, 12) || "repo";
+  const repoHash = crypto
+    .createHash("sha1")
+    .update(path.resolve(String(workspaceRoot || REPO_ROOT)))
+    .digest("hex")
+    .slice(0, 8);
+  return `${repoBase}_${repoHash}`;
+}
+
 export function buildLanePaths(laneInput = DEFAULT_WAVE_LANE, options = {}) {
   const config = options.config || loadWaveConfig();
-  const laneProfile = resolveLaneProfile(config, laneInput || config.defaultLane);
+  const baseLaneProfile = resolveLaneProfile(config, laneInput || config.defaultLane);
+  const adhocRunId = options.adhocRunId ? sanitizeAdhocRunId(options.adhocRunId) : null;
+  const laneProfile = adhocRunId
+    ? {
+        ...baseLaneProfile,
+        validation: {
+          ...baseLaneProfile.validation,
+          requireComponentPromotionsFromWave: null,
+          requireAgentComponentsFromWave: null,
+        },
+      }
+    : baseLaneProfile;
   const lane = laneProfile.lane;
   const laneTmux = lane.replace(/-/g, "_");
+  const runKind = adhocRunId ? "adhoc" : "roadmap";
   const runVariant = String(options.runVariant || "")
     .trim()
     .toLowerCase();
   if (runVariant && runVariant !== "dry-run") {
     throw new Error(`Unsupported lane path variant: ${options.runVariant}`);
   }
+  const workspaceTmuxToken = buildWorkspaceTmuxToken(REPO_ROOT);
   const docsDir = path.join(REPO_ROOT, laneProfile.docsDir);
   const plansDir = path.join(REPO_ROOT, laneProfile.plansDir);
   const preferredWavesDir = path.join(REPO_ROOT, laneProfile.wavesDir);
   const legacyWavesDir = path.join(docsDir, "waves");
-  const baseStateDir = path.join(REPO_ROOT, laneProfile.paths.stateRoot, `${lane}-wave-launcher`);
+  const adhocRootDir = path.join(REPO_ROOT, ".wave", "adhoc");
+  const adhocRunDir = adhocRunId ? path.join(adhocRootDir, "runs", adhocRunId) : null;
+  const baseStateDir = adhocRunId
+    ? path.join(REPO_ROOT, laneProfile.paths.stateRoot, `${lane}-wave-launcher`, "adhoc", adhocRunId)
+    : path.join(REPO_ROOT, laneProfile.paths.stateRoot, `${lane}-wave-launcher`);
   const stateDir = runVariant === "dry-run" ? path.join(baseStateDir, "dry-run") : baseStateDir;
   const orchestratorStateDir =
     runVariant === "dry-run"
@@ -103,14 +152,24 @@ export function buildLanePaths(laneInput = DEFAULT_WAVE_LANE, options = {}) {
     config,
     laneProfile,
     lane,
+    runKind,
+    runId: adhocRunId,
     runVariant,
     docsDir,
     plansDir,
     wavesDir:
-      fs.existsSync(preferredWavesDir) || !fs.existsSync(legacyWavesDir)
+      adhocRunDir ||
+      (fs.existsSync(preferredWavesDir) || !fs.existsSync(legacyWavesDir)
         ? preferredWavesDir
-        : legacyWavesDir,
+        : legacyWavesDir),
     legacyWavesDir,
+    adhocRootDir,
+    adhocRunDir,
+    adhocIndexPath: path.join(adhocRootDir, "index.json"),
+    adhocRequestPath: adhocRunDir ? path.join(adhocRunDir, "request.json") : null,
+    adhocSpecPath: adhocRunDir ? path.join(adhocRunDir, "spec.json") : null,
+    adhocWavePath: adhocRunDir ? path.join(adhocRunDir, "wave-0.md") : null,
+    adhocResultPath: adhocRunDir ? path.join(adhocRunDir, "result.json") : null,
     promptsDir: path.join(stateDir, "prompts"),
     logsDir: path.join(stateDir, "logs"),
     statusDir: path.join(stateDir, "status"),
@@ -121,6 +180,7 @@ export function buildLanePaths(laneInput = DEFAULT_WAVE_LANE, options = {}) {
     inboxesDir: path.join(stateDir, "inboxes"),
     ledgerDir: path.join(stateDir, "ledger"),
     integrationDir: path.join(stateDir, "integration"),
+    securityDir: path.join(stateDir, "security"),
     dependencySnapshotsDir: path.join(stateDir, "dependencies"),
     docsQueueDir: path.join(stateDir, "docs-queue"),
     tracesDir: path.join(stateDir, "traces"),
@@ -128,7 +188,9 @@ export function buildLanePaths(laneInput = DEFAULT_WAVE_LANE, options = {}) {
     executorOverlaysDir: path.join(stateDir, "executors"),
     stateDir,
     terminalsPath: path.join(REPO_ROOT, laneProfile.paths.terminalsPath),
+    skillsDir: path.join(REPO_ROOT, laneProfile.skills?.dir || "skills"),
     context7BundleIndexPath: path.join(REPO_ROOT, laneProfile.paths.context7BundleIndexPath),
+    benchmarkCatalogPath: path.join(REPO_ROOT, laneProfile.paths.benchmarkCatalogPath),
     componentCutoverMatrixDocPath: path.join(
       REPO_ROOT,
       laneProfile.paths.componentCutoverMatrixDocPath,
@@ -137,15 +199,18 @@ export function buildLanePaths(laneInput = DEFAULT_WAVE_LANE, options = {}) {
       REPO_ROOT,
       laneProfile.paths.componentCutoverMatrixJsonPath,
     ),
-    sharedPlanDocs: laneProfile.sharedPlanDocs,
+    sharedPlanDocs: laneProfile.sharedPlanDocs || [],
     requiredPromptReferences: laneProfile.validation.requiredPromptReferences,
     rolePromptDir: laneProfile.roles.rolePromptDir,
-    evaluatorAgentId: laneProfile.roles.evaluatorAgentId,
+    contQaAgentId: laneProfile.roles.contQaAgentId,
+    contEvalAgentId: laneProfile.roles.contEvalAgentId,
     integrationAgentId: laneProfile.roles.integrationAgentId,
     documentationAgentId: laneProfile.roles.documentationAgentId,
-    evaluatorRolePromptPath: laneProfile.roles.evaluatorRolePromptPath,
+    contQaRolePromptPath: laneProfile.roles.contQaRolePromptPath,
+    contEvalRolePromptPath: laneProfile.roles.contEvalRolePromptPath,
     integrationRolePromptPath: laneProfile.roles.integrationRolePromptPath,
     documentationRolePromptPath: laneProfile.roles.documentationRolePromptPath,
+    securityRolePromptPath: laneProfile.roles.securityRolePromptPath,
     requireDocumentationStewardFromWave:
       laneProfile.validation.requireDocumentationStewardFromWave,
     requireContext7DeclarationsFromWave:
@@ -157,6 +222,7 @@ export function buildLanePaths(laneInput = DEFAULT_WAVE_LANE, options = {}) {
       laneProfile.validation.requireComponentPromotionsFromWave,
     requireAgentComponentsFromWave: laneProfile.validation.requireAgentComponentsFromWave,
     executors: laneProfile.executors,
+    skills: laneProfile.skills,
     capabilityRouting: laneProfile.capabilityRouting,
     defaultManifestPath: path.join(stateDir, "waves.manifest.json"),
     defaultRunStatePath: path.join(stateDir, "run-state.json"),
@@ -165,10 +231,10 @@ export function buildLanePaths(laneInput = DEFAULT_WAVE_LANE, options = {}) {
     terminalNamePrefix: `${lane}-wave`,
     dashboardTerminalNamePrefix: `${lane}-wave-dashboard`,
     globalDashboardTerminalName: `${lane}-wave-dashboard-global`,
-    tmuxSessionPrefix: `oc_${laneTmux}_wave`,
-    tmuxDashboardSessionPrefix: `oc_${laneTmux}_wave_dashboard`,
-    tmuxGlobalDashboardSessionPrefix: `oc_${laneTmux}_wave_dashboard_global`,
-    tmuxSocketName: `oc_${laneTmux}_waves`,
+    tmuxSessionPrefix: `oc_${laneTmux}_${workspaceTmuxToken}_wave`,
+    tmuxDashboardSessionPrefix: `oc_${laneTmux}_${workspaceTmuxToken}_wave_dashboard`,
+    tmuxGlobalDashboardSessionPrefix: `oc_${laneTmux}_${workspaceTmuxToken}_wave_dashboard_global`,
+    tmuxSocketName: `oc_${laneTmux}_${workspaceTmuxToken}_waves`,
     orchestratorStateDir,
     defaultOrchestratorBoardPath: path.join(
       orchestratorStateDir,