@chllming/wave-orchestration 0.6.1 → 0.6.3

package/scripts/wave-orchestrator/executors.mjs

@@ -217,6 +217,7 @@ function buildClaudeLaunchSpec({ agent, promptPath, logPath, overlayDir }) {
   appendSingleValueFlag(tokens, "--agent", executor.claude.agent);
   appendSingleValueFlag(tokens, "--permission-mode", executor.claude.permissionMode);
   appendSingleValueFlag(tokens, "--permission-prompt-tool", executor.claude.permissionPromptTool);
+  appendSingleValueFlag(tokens, "--effort", executor.claude.effort);
   appendSingleValueFlag(tokens, "--max-turns", executor.claude.maxTurns);
   appendRepeatedFlag(tokens, "--mcp-config", executor.claude.mcpConfig);
   appendSingleValueFlag(tokens, "--settings", settingsPath);
@@ -299,6 +300,55 @@ function buildLocalLaunchSpec({ promptPath, logPath }) {
   };
 }
 
+function buildLaunchLimitsMetadata(agent) {
+  const executor = agent?.executorResolved || {};
+  const executorId = normalizeExecutorMode(executor.id || DEFAULT_EXECUTOR_MODE);
+  const attemptTimeoutMinutes = executor?.budget?.minutes ?? null;
+  if (executorId === "claude") {
+    const source = executor?.claude?.maxTurnsSource || null;
+    return {
+      attemptTimeoutMinutes,
+      knownTurnLimit: executor?.claude?.maxTurns ?? null,
+      turnLimitSource: source,
+      notes:
+        source === "budget.turns"
+          ? ["Known turn limit was derived from generic budget.turns."]
+          : [],
+    };
+  }
+  if (executorId === "opencode") {
+    const source = executor?.opencode?.stepsSource || null;
+    return {
+      attemptTimeoutMinutes,
+      knownTurnLimit: executor?.opencode?.steps ?? null,
+      turnLimitSource: source,
+      notes:
+        source === "budget.turns"
+          ? ["Known turn limit was derived from generic budget.turns."]
+          : [],
+    };
+  }
+  if (executorId === "codex") {
+    const profileNote = executor?.codex?.profileName
+      ? ` via Codex profile ${executor.codex.profileName}`
+      : "";
+    return {
+      attemptTimeoutMinutes,
+      knownTurnLimit: null,
+      turnLimitSource: "not-set-by-wave",
+      notes: [
+        `Wave emits no Codex turn-limit flag; any effective ceiling may come from the selected Codex profile${profileNote} or the upstream Codex runtime.`,
+      ],
+    };
+  }
+  return {
+    attemptTimeoutMinutes,
+    knownTurnLimit: null,
+    turnLimitSource: "not-applicable",
+    notes: ["Local executor does not use model turn limits."],
+  };
+}
+
 function buildCodexLaunchSpec({ agent, promptPath, logPath, skillProjection }) {
   const executor = agent.executorResolved;
   return {
@@ -329,16 +379,29 @@ function buildCodexLaunchSpec({ agent, promptPath, logPath, skillProjection }) {
 export function buildExecutorLaunchSpec({ agent, promptPath, logPath, overlayDir, skillProjection }) {
   const executorId = normalizeExecutorMode(agent?.executorResolved?.id || DEFAULT_EXECUTOR_MODE);
   ensureDirectory(overlayDir);
+  const limits = buildLaunchLimitsMetadata(agent);
   if (executorId === "local") {
-    return buildLocalLaunchSpec({ promptPath, logPath });
+    return {
+      ...buildLocalLaunchSpec({ promptPath, logPath }),
+      limits,
+    };
   }
   if (executorId === "claude") {
-    return buildClaudeLaunchSpec({ agent, promptPath, logPath, overlayDir, skillProjection });
+    return {
+      ...buildClaudeLaunchSpec({ agent, promptPath, logPath, overlayDir, skillProjection }),
+      limits,
+    };
   }
   if (executorId === "opencode") {
-    return buildOpenCodeLaunchSpec({ agent, promptPath, logPath, overlayDir, skillProjection });
+    return {
+      ...buildOpenCodeLaunchSpec({ agent, promptPath, logPath, overlayDir, skillProjection }),
+      limits,
+    };
   }
-  return buildCodexLaunchSpec({ agent, promptPath, logPath, skillProjection });
+  return {
+    ...buildCodexLaunchSpec({ agent, promptPath, logPath, skillProjection }),
+    limits,
+  };
 }
 
 export function commandForExecutor(executor, executorId = executor?.id) {

package/scripts/wave-orchestrator/install.mjs

@@ -1,10 +1,17 @@
 import fs from "node:fs";
 import path from "node:path";
+import { spawnSync } from "node:child_process";
 import {
   applyContext7SelectionsToWave,
   loadContext7BundleIndex,
 } from "./context7.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 +21,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",
@@ -69,11 +76,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 +152,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)) {
@@ -478,6 +462,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 +650,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 +727,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-runtime.mjs

@@ -139,6 +139,7 @@ export async function launchAgentSession(lanePaths, params, { runTmuxFn }) {
       env: launchSpec.env || {},
       useRateLimitRetries: launchSpec.useRateLimitRetries === true,
       invocationLines: launchSpec.invocationLines,
+      limits: launchSpec.limits || null,
       skills: summarizeResolvedSkills(agent.skillsResolved),
     });
     return {