@chllming/wave-orchestration 0.6.2 → 0.7.0

package/scripts/wave-orchestrator/feedback.mjs

@@ -21,6 +21,7 @@ import {
   truncate,
   writeJsonAtomic,
 } from "./shared.mjs";
+import { safeQueueWaveControlEvent } from "./wave-control-client.mjs";
 
 function sanitizeToken(value) {
   const token = String(value || "")
@@ -59,6 +60,7 @@ export function createFeedbackRequest({
   orchestratorId,
   question,
   context,
+  recordTelemetry = false,
 }) {
   ensureDirectory(feedbackRequestsDir);
   const requestId = buildRequestId({ lane, wave, agentId });
@@ -83,6 +85,31 @@ export function createFeedbackRequest({
     }
     writeJsonAtomic(filePath, payload);
   });
+  if (recordTelemetry) {
+    try {
+      const lanePaths = buildLanePaths(lane);
+      safeQueueWaveControlEvent(lanePaths, {
+        category: "feedback",
+        entityType: "human_input",
+        entityId: requestId,
+        action: "requested",
+        source: "orchestrator",
+        actor: orchestratorId || "orchestrator",
+        recordedAt: now,
+        identity: {
+          lane,
+          wave,
+          agentId,
+          runKind: lanePaths.runKind,
+          runId: lanePaths.runId,
+        },
+        tags: ["feedback", "human-input"],
+        data: payload,
+      });
+    } catch {
+      // Best-effort telemetry only.
+    }
+  }
   return { requestId, filePath, payload };
 }
 
@@ -93,6 +120,7 @@ export function answerFeedbackRequest({
   response,
   operator = "human-operator",
   force = false,
+  recordTelemetry = false,
 }) {
   const lockPath = path.join(feedbackStateDir, "requests.lock");
   let answeredPayload = null;
@@ -117,6 +145,31 @@ export function answerFeedbackRequest({
     };
     writeJsonAtomic(filePath, answeredPayload);
   });
+  if (recordTelemetry) {
+    try {
+      const lanePaths = buildLanePaths(answeredPayload?.lane || DEFAULT_WAVE_LANE);
+      safeQueueWaveControlEvent(lanePaths, {
+        category: "feedback",
+        entityType: "human_input",
+        entityId: answeredPayload.id,
+        action: "answered",
+        source: "operator",
+        actor: operator,
+        recordedAt: answeredPayload?.updatedAt || toIsoTimestamp(),
+        identity: {
+          lane: answeredPayload?.lane || DEFAULT_WAVE_LANE,
+          wave: answeredPayload?.wave ?? null,
+          agentId: answeredPayload?.agentId || null,
+          runKind: lanePaths.runKind,
+          runId: lanePaths.runId,
+        },
+        tags: ["feedback", "human-input", "answered"],
+        data: answeredPayload,
+      });
+    } catch {
+      // Best-effort telemetry only.
+    }
+  }
   return answeredPayload;
 }
 
@@ -292,6 +345,7 @@ export async function runFeedbackCli(argv) {
       orchestratorId: options.orchestratorId,
       question: options.question,
       context: options.context,
+      recordTelemetry: true,
     });
     console.log(`[wave-human-feedback] created ${result.requestId}`);
     console.log(`file: ${path.relative(REPO_ROOT, result.filePath)}`);
@@ -316,6 +370,7 @@ export async function runFeedbackCli(argv) {
       response: options.response,
       operator: options.operator,
       force: options.force,
+      recordTelemetry: true,
     });
     console.log(`[wave-human-feedback] answered ${options.id}`);
     return;

package/scripts/wave-orchestrator/install.mjs

@@ -1,10 +1,20 @@
 import fs from "node:fs";
 import path from "node:path";
+import { spawnSync } from "node:child_process";
 import {
   applyContext7SelectionsToWave,
   loadContext7BundleIndex,
 } from "./context7.mjs";
+import {
+  PLANNER_CONTEXT7_TEMPLATE_PATHS,
+} from "./planner-context.mjs";
 import { buildLanePaths, ensureDirectory, PACKAGE_ROOT, readJsonOrNull, REPO_ROOT, writeJsonAtomic } from "./shared.mjs";
+import { fetchLatestPackageVersion } from "./package-update-notice.mjs";
+import {
+  compareVersions,
+  readInstalledPackageMetadata,
+  WAVE_PACKAGE_NAME,
+} from "./package-version.mjs";
 import { loadWaveConfig } from "./config.mjs";
 import { applyExecutorSelectionsToWave, parseWaveFiles, validateWaveDefinition } from "./wave-files.mjs";
 import { validateLaneSkillConfiguration } from "./skills.mjs";
@@ -14,7 +24,7 @@ export const INSTALL_STATE_DIR = ".wave";
 export const INSTALL_STATE_PATH = path.join(REPO_ROOT, INSTALL_STATE_DIR, "install-state.json");
 export const UPGRADE_HISTORY_DIR = path.join(REPO_ROOT, INSTALL_STATE_DIR, "upgrade-history");
 export const CHANGELOG_MANIFEST_PATH = path.join(PACKAGE_ROOT, "releases", "manifest.json");
-export const PACKAGE_METADATA_PATH = path.join(PACKAGE_ROOT, "package.json");
+export const WORKSPACE_PACKAGE_JSON_PATH = path.join(REPO_ROOT, "package.json");
 export const STARTER_TEMPLATE_PATHS = [
   "wave.config.json",
   "docs/README.md",
@@ -22,6 +32,7 @@ export const STARTER_TEMPLATE_PATHS = [
   "docs/agents/wave-cont-qa-role.md",
   "docs/agents/wave-cont-eval-role.md",
   "docs/agents/wave-integration-role.md",
+  "docs/agents/wave-planner-role.md",
   "docs/agents/wave-security-role.md",
   "docs/concepts/context7-vs-skills.md",
   "docs/concepts/operating-modes.md",
@@ -29,23 +40,48 @@ export const STARTER_TEMPLATE_PATHS = [
   "docs/concepts/what-is-a-wave.md",
   "docs/context7/bundles.json",
   "docs/evals/benchmark-catalog.json",
+  "docs/evals/external-benchmarks.json",
+  "docs/evals/external-command-config.sample.json",
+  "docs/evals/external-command-config.swe-bench-pro.json",
+  "docs/evals/wave-benchmark-program.md",
+  "docs/evals/pilots/README.md",
+  "docs/evals/pilots/swe-bench-pro-public-pilot.json",
+  "docs/evals/pilots/swe-bench-pro-public-full-wave-review-10.json",
+  "docs/evals/arm-templates/README.md",
+  "docs/evals/arm-templates/single-agent.json",
+  "docs/evals/arm-templates/full-wave.json",
+  "docs/evals/cases/README.md",
+  "docs/evals/cases/wave-hidden-profile-private-evidence.json",
+  "docs/evals/cases/wave-premature-closure-guard.json",
+  "docs/evals/cases/wave-silo-cross-agent-state.json",
+  "docs/evals/cases/wave-blackboard-inbox-targeting.json",
+  "docs/evals/cases/wave-contradiction-conflict.json",
+  "docs/evals/cases/wave-simultaneous-lockstep.json",
+  "docs/evals/cases/wave-expert-routing-preservation.json",
   "docs/guides/planner.md",
   "docs/guides/terminal-surfaces.md",
   "docs/plans/component-cutover-matrix.json",
   "docs/plans/component-cutover-matrix.md",
   "docs/plans/context7-wave-orchestrator.md",
   "docs/plans/current-state.md",
+  "docs/plans/examples/wave-example-live-proof.md",
   "docs/plans/master-plan.md",
   "docs/plans/migration.md",
   "docs/plans/wave-orchestrator.md",
   "docs/plans/waves/wave-0.md",
+  "docs/reference/live-proof-waves.md",
   "docs/reference/repository-guidance.md",
+  "docs/reference/sample-waves.md",
   "docs/reference/skills.md",
+  "docs/reference/wave-planning-lessons.md",
   "docs/reference/runtime-config/README.md",
   "docs/reference/runtime-config/codex.md",
   "docs/reference/runtime-config/claude.md",
   "docs/reference/runtime-config/opencode.md",
+  "docs/research/coordination-failure-review.md",
   "docs/research/agent-context-sources.md",
+  "docs/plans/examples/wave-benchmark-improvement.md",
+  ...PLANNER_CONTEXT7_TEMPLATE_PATHS,
 ];
 const REQUIRED_GITIGNORE_ENTRIES = [
   ".tmp/",
@@ -69,11 +105,7 @@ function collectDeclaredDeployKinds(waves = []) {
 }
 
 function packageMetadata() {
-  const payload = readJsonOrNull(PACKAGE_METADATA_PATH);
-  if (!payload?.name || !payload?.version) {
-    throw new Error(`Invalid package metadata: ${PACKAGE_METADATA_PATH}`);
-  }
-  return payload;
+  return readInstalledPackageMetadata();
 }
 
 function readInstallState() {
@@ -149,25 +181,6 @@ function nextHistoryRecord(existingState, entry) {
   return history;
 }
 
-function normalizeVersionParts(version) {
-  return String(version || "")
-    .split(".")
-    .map((part) => Number.parseInt(part.replace(/[^0-9].*$/, ""), 10) || 0);
-}
-
-function compareVersions(a, b) {
-  const left = normalizeVersionParts(a);
-  const right = normalizeVersionParts(b);
-  const length = Math.max(left.length, right.length);
-  for (let index = 0; index < length; index += 1) {
-    const diff = (left[index] || 0) - (right[index] || 0);
-    if (diff !== 0) {
-      return diff;
-    }
-  }
-  return 0;
-}
-
 function readChangelogManifest() {
   const payload = readJsonOrNull(CHANGELOG_MANIFEST_PATH);
   if (!payload?.releases || !Array.isArray(payload.releases)) {
@@ -249,6 +262,19 @@ function gitignoreWarnings() {
   );
 }
 
+function plannerRequiredPaths() {
+  return Array.from(
+    new Set(
+      [
+        "docs/agents/wave-planner-role.md",
+        "docs/reference/wave-planning-lessons.md",
+        "skills/role-planner/SKILL.md",
+        ...PLANNER_CONTEXT7_TEMPLATE_PATHS,
+      ].filter(Boolean),
+    ),
+  ).sort();
+}
+
 export function runDoctor() {
   const errors = [];
   const warnings = [];
@@ -293,9 +319,21 @@ export function runDoctor() {
           errors.push(`Missing required Wave file: ${relPath}`);
         }
       }
+      const context7BundleIndex = loadContext7BundleIndex(lanePaths.context7BundleIndexPath);
+      const plannerPaths = plannerRequiredPaths();
+      for (const relPath of plannerPaths) {
+        if (!fs.existsSync(path.join(REPO_ROOT, relPath))) {
+          errors.push(`Missing planner file: ${relPath}`);
+        }
+      }
+      const plannerBundleId = String(config.planner?.agentic?.context7Bundle || "").trim();
+      if (plannerBundleId && !context7BundleIndex.bundles[plannerBundleId]) {
+        errors.push(
+          `planner.agentic.context7Bundle references unknown bundle "${plannerBundleId}".`,
+        );
+      }
       let parsedWaves = [];
       if (fs.existsSync(lanePaths.wavesDir)) {
-        const context7BundleIndex = loadContext7BundleIndex(lanePaths.context7BundleIndexPath);
         parsedWaves = parseWaveFiles(lanePaths.wavesDir, { laneProfile: lanePaths.laneProfile })
           .map((wave) =>
             applyExecutorSelectionsToWave(wave, {
@@ -478,6 +516,186 @@ export function upgradeWorkspace() {
   };
 }
 
+function readWorkspacePackageManifest(workspaceRoot = REPO_ROOT) {
+  const payload = readJsonOrNull(path.join(workspaceRoot, "package.json"));
+  if (!payload || typeof payload !== "object") {
+    throw new Error(`Missing package.json at ${path.join(workspaceRoot, "package.json")}`);
+  }
+  return payload;
+}
+
+function readInstallStateForWorkspace(workspaceRoot = REPO_ROOT) {
+  const payload = readJsonOrNull(path.join(workspaceRoot, INSTALL_STATE_DIR, "install-state.json"));
+  return payload && typeof payload === "object" ? payload : null;
+}
+
+function parsePackageManagerId(value) {
+  const normalized = String(value || "")
+    .trim()
+    .toLowerCase();
+  if (!normalized) {
+    return null;
+  }
+  if (normalized.startsWith("pnpm@")) {
+    return "pnpm";
+  }
+  if (normalized.startsWith("npm@")) {
+    return "npm";
+  }
+  if (normalized.startsWith("yarn@")) {
+    return "yarn";
+  }
+  if (normalized.startsWith("bun@")) {
+    return "bun";
+  }
+  return null;
+}
+
+export function detectWorkspacePackageManager(workspaceRoot = REPO_ROOT) {
+  const manifest = readWorkspacePackageManifest(workspaceRoot);
+  const packageManagerFromManifest = parsePackageManagerId(manifest.packageManager);
+  if (packageManagerFromManifest) {
+    return {
+      id: packageManagerFromManifest,
+      source: "packageManager",
+      raw: manifest.packageManager,
+    };
+  }
+  for (const [fileName, id] of [
+    ["pnpm-lock.yaml", "pnpm"],
+    ["package-lock.json", "npm"],
+    ["npm-shrinkwrap.json", "npm"],
+    ["yarn.lock", "yarn"],
+    ["bun.lockb", "bun"],
+    ["bun.lock", "bun"],
+  ]) {
+    if (fs.existsSync(path.join(workspaceRoot, fileName))) {
+      return {
+        id,
+        source: "lockfile",
+        raw: fileName,
+      };
+    }
+  }
+  return {
+    id: "npm",
+    source: "default",
+    raw: null,
+  };
+}
+
+function packageManagerCommands(managerId, packageName = WAVE_PACKAGE_NAME) {
+  if (managerId === "pnpm") {
+    return {
+      install: ["pnpm", ["add", "-D", `${packageName}@latest`]],
+      execWave: (args) => ["pnpm", ["exec", "wave", ...args]],
+    };
+  }
+  if (managerId === "npm") {
+    return {
+      install: ["npm", ["install", "--save-dev", `${packageName}@latest`]],
+      execWave: (args) => ["npm", ["exec", "--", "wave", ...args]],
+    };
+  }
+  if (managerId === "yarn") {
+    return {
+      install: ["yarn", ["add", "-D", `${packageName}@latest`]],
+      execWave: (args) => ["yarn", ["exec", "wave", ...args]],
+    };
+  }
+  if (managerId === "bun") {
+    return {
+      install: ["bun", ["add", "-d", `${packageName}@latest`]],
+      execWave: (args) => ["bun", ["x", "wave", ...args]],
+    };
+  }
+  throw new Error(`Unsupported package manager: ${managerId}`);
+}
+
+function runCommandOrThrow(command, args, options = {}) {
+  const spawnImpl = options.spawnImpl || spawnSync;
+  const result = spawnImpl(command, args, {
+    cwd: options.workspaceRoot || REPO_ROOT,
+    stdio: options.stdio || "inherit",
+    env: options.env || process.env,
+    encoding: "utf8",
+  });
+  const status = Number.isInteger(result?.status) ? result.status : 1;
+  if (status !== 0) {
+    throw new Error(`${command} ${args.join(" ")} failed with status ${status}`);
+  }
+  return result;
+}
+
+export async function selfUpdateWorkspace(options = {}) {
+  const workspaceRoot = options.workspaceRoot || REPO_ROOT;
+  const metadata = options.packageMetadata || packageMetadata();
+  const installState = readInstallStateForWorkspace(workspaceRoot);
+  const packageManager = detectWorkspacePackageManager(workspaceRoot);
+  const commands = packageManagerCommands(packageManager.id, metadata.name || WAVE_PACKAGE_NAME);
+  const emit = options.emit || console.log;
+  let latestVersion = null;
+
+  try {
+    latestVersion = await fetchLatestPackageVersion(metadata.name || WAVE_PACKAGE_NAME, {
+      fetchImpl: options.fetchImpl,
+      timeoutMs: options.timeoutMs,
+    });
+  } catch {
+    latestVersion = null;
+  }
+
+  const currentVersion = String(metadata.version || "").trim();
+  const recordedVersion = String(installState?.installedVersion || "").trim() || null;
+  const needsUpgradeOnly = recordedVersion && compareVersions(currentVersion, recordedVersion) !== 0;
+
+  emit(`[wave:self-update] package_manager=${packageManager.id}`);
+
+  if (latestVersion && compareVersions(latestVersion, currentVersion) <= 0) {
+    if (!needsUpgradeOnly) {
+      emit(`[wave:self-update] ${metadata.name} is already current at ${currentVersion}.`);
+      return {
+        mode: "already-current",
+        packageManager: packageManager.id,
+        currentVersion,
+        latestVersion,
+      };
+    }
+    emit(
+      `[wave:self-update] dependency is already at ${currentVersion}; recording workspace upgrade state.`,
+    );
+    const [upgradeCommand, upgradeArgs] = commands.execWave(["upgrade"]);
+    runCommandOrThrow(upgradeCommand, upgradeArgs, options);
+    return {
+      mode: "upgrade-only",
+      packageManager: packageManager.id,
+      currentVersion,
+      latestVersion,
+    };
+  }
+
+  emit(
+    `[wave:self-update] updating ${metadata.name} from ${currentVersion}${latestVersion ? ` to ${latestVersion}` : " to the latest published version"}.`,
+  );
+  const [installCommand, installArgs] = commands.install;
+  runCommandOrThrow(installCommand, installArgs, options);
+
+  emit("[wave:self-update] release notes since the recorded install:");
+  const [changelogCommand, changelogArgs] = commands.execWave(["changelog", "--since-installed"]);
+  runCommandOrThrow(changelogCommand, changelogArgs, options);
+
+  emit("[wave:self-update] recording install-state and upgrade report:");
+  const [upgradeCommand, upgradeArgs] = commands.execWave(["upgrade"]);
+  runCommandOrThrow(upgradeCommand, upgradeArgs, options);
+
+  return {
+    mode: "updated",
+    packageManager: packageManager.id,
+    currentVersion,
+    latestVersion,
+  };
+}
+
 function printJson(payload) {
   console.log(JSON.stringify(payload, null, 2));
 }
@@ -486,6 +704,7 @@ function printHelp() {
   console.log(`Usage:
   wave init [--adopt-existing] [--json]
   wave upgrade [--json]
+  wave self-update
   wave changelog [--since-installed] [--json]
   wave doctor [--json]
 `);
@@ -562,6 +781,14 @@ export async function runInstallCli(argv) {
     return;
   }
 
+  if (subcommand === "self-update") {
+    if (options.json) {
+      throw new Error("`wave self-update` does not support --json.");
+    }
+    await selfUpdateWorkspace();
+    return;
+  }
+
   if (subcommand === "changelog") {
     const result = readChangelog({ sinceInstalled: options.sinceInstalled });
     if (options.json) {

package/scripts/wave-orchestrator/launcher-closure.mjs

@@ -201,7 +201,7 @@ export async function runClosureSweepPhase({
           refreshWaveDashboardAgentStates(dashboardState, [runInfo], pendingAgentIds, (event) =>
             recordCombinedEvent(event),
           );
-          monitorWaveHumanFeedbackFn({
+          const feedbackChanged = monitorWaveHumanFeedbackFn({
             lanePaths,
             waveNumber: wave.wave,
             agentRuns: [runInfo],
@@ -211,6 +211,9 @@ export async function runClosureSweepPhase({
             recordCombinedEvent,
             appendCoordination,
           });
+          if (feedbackChanged) {
+            refreshDerivedState?.(dashboardState?.attempt || 0);
+          }
           updateWaveDashboardMessageBoard(dashboardState, runInfo.messageBoardPath);
           flushDashboards();
         },

package/scripts/wave-orchestrator/launcher-runtime.mjs

@@ -69,6 +69,7 @@ export async function launchAgentSession(lanePaths, params, { runTmuxFn }) {
     sharedSummaryText,
     inboxPath,
     inboxText,
+    promptOverride = "",
     orchestratorId,
     agentRateLimitRetries,
     agentRateLimitBaseDelaySeconds,
@@ -101,27 +102,29 @@ export async function launchAgentSession(lanePaths, params, { runTmuxFn }) {
       artifacts: skillArtifacts,
     };
   }
-  const prompt = buildExecutionPrompt({
-    lane: lanePaths.lane,
-    wave,
-    agent,
-    orchestratorId,
-    messageBoardPath,
-    messageBoardSnapshot,
-    sharedSummaryPath,
-    sharedSummaryText,
-    inboxPath,
-    inboxText,
-    context7,
-    componentPromotions: resolvedWaveDefinition.componentPromotions,
-    evalTargets: resolvedWaveDefinition.evalTargets,
-    benchmarkCatalogPath: lanePaths.laneProfile?.paths?.benchmarkCatalogPath,
-    sharedPlanDocs: lanePaths.sharedPlanDocs,
-    contQaAgentId: lanePaths.contQaAgentId,
-    contEvalAgentId: lanePaths.contEvalAgentId,
-    integrationAgentId: lanePaths.integrationAgentId,
-    documentationAgentId: lanePaths.documentationAgentId,
-  });
+  const prompt =
+    String(promptOverride || "").trim() ||
+    buildExecutionPrompt({
+      lane: lanePaths.lane,
+      wave,
+      agent,
+      orchestratorId,
+      messageBoardPath,
+      messageBoardSnapshot,
+      sharedSummaryPath,
+      sharedSummaryText,
+      inboxPath,
+      inboxText,
+      context7,
+      componentPromotions: resolvedWaveDefinition.componentPromotions,
+      evalTargets: resolvedWaveDefinition.evalTargets,
+      benchmarkCatalogPath: lanePaths.laneProfile?.paths?.benchmarkCatalogPath,
+      sharedPlanDocs: lanePaths.sharedPlanDocs,
+      contQaAgentId: lanePaths.contQaAgentId,
+      contEvalAgentId: lanePaths.contEvalAgentId,
+      integrationAgentId: lanePaths.integrationAgentId,
+      documentationAgentId: lanePaths.documentationAgentId,
+    });
   const promptHash = hashAgentPromptFingerprint(agent);
   fs.writeFileSync(promptPath, `${prompt}\n`, "utf8");
   const launchSpec = buildExecutorLaunchSpec({