@chllming/wave-orchestration 0.6.2 → 0.7.0

package/scripts/wave-autonomous.mjs

@@ -5,9 +5,7 @@ import { bootstrapWaveArgs } from "./wave-cli-bootstrap.mjs";
 const argv = bootstrapWaveArgs(process.argv.slice(2));
 const { runAutonomousCli } = await import("./wave-orchestrator/autonomous.mjs");
 
-try {
-  runAutonomousCli(argv);
-} catch (error) {
+runAutonomousCli(argv).catch((error) => {
   console.error(`[wave-autonomous] ${error instanceof Error ? error.message : String(error)}`);
   process.exit(1);
-}
+});

package/scripts/wave-orchestrator/adhoc.mjs

@@ -8,6 +8,10 @@ import {
   buildDefaultProjectProfile,
   readProjectProfile,
 } from "./project-profile.mjs";
+import {
+  maybeAnnouncePackageUpdate,
+  WAVE_SUPPRESS_UPDATE_NOTICE_ENV,
+} from "./package-update-notice.mjs";
 import { runLauncherCli } from "./launcher.mjs";
 import { renderWaveMarkdown } from "./planner.mjs";
 import {
@@ -187,6 +191,20 @@ function buildAdhocRunId() {
   return sanitizeAdhocRunId(`adhoc-${stamp}-${random}`);
 }
 
+async function withSuppressedNestedUpdateNotice(fn) {
+  const previousValue = process.env[WAVE_SUPPRESS_UPDATE_NOTICE_ENV];
+  process.env[WAVE_SUPPRESS_UPDATE_NOTICE_ENV] = "1";
+  try {
+    return await fn();
+  } finally {
+    if (previousValue === undefined) {
+      delete process.env[WAVE_SUPPRESS_UPDATE_NOTICE_ENV];
+    } else {
+      process.env[WAVE_SUPPRESS_UPDATE_NOTICE_ENV] = previousValue;
+    }
+  }
+}
+
 function readEffectiveProjectProfile(config) {
   return readProjectProfile({ config }) || buildDefaultProjectProfile(config);
 }
@@ -1135,6 +1153,7 @@ export async function runAdhocCli(argv) {
     if (options.tasks.length === 0) {
       throw new Error("At least one --task is required for `wave adhoc run`.");
     }
+    await maybeAnnouncePackageUpdate();
     const stored = createStoredRun({ config, options });
     const summary = summarizePlan(stored.spec, stored.lanePaths);
     if (options.json) {
@@ -1157,17 +1176,19 @@ export async function runAdhocCli(argv) {
     writeJsonAtomic(stored.lanePaths.adhocResultPath, runningResult);
     upsertAdhocIndexEntry(stored.lanePaths.adhocIndexPath, runningResult);
     try {
-      await runLauncherCli([
-        "--lane",
-        stored.lanePaths.lane,
-        "--adhoc-run",
-        stored.lanePaths.runId,
-        "--start-wave",
-        String(ADHOC_WAVE_NUMBER),
-        "--end-wave",
-        String(ADHOC_WAVE_NUMBER),
-        ...options.launcherArgs,
-      ]);
+      await withSuppressedNestedUpdateNotice(() =>
+        runLauncherCli([
+          "--lane",
+          stored.lanePaths.lane,
+          "--adhoc-run",
+          stored.lanePaths.runId,
+          "--start-wave",
+          String(ADHOC_WAVE_NUMBER),
+          "--end-wave",
+          String(ADHOC_WAVE_NUMBER),
+          ...options.launcherArgs,
+        ]),
+      );
       const completedResult = buildResultRecord(
         stored.lanePaths,
         stored.request,

package/scripts/wave-orchestrator/artifact-schemas.mjs

@@ -1,20 +1,30 @@
 import { readJsonOrNull, toIsoTimestamp, writeJsonAtomic } from "./shared.mjs";
+import {
+  normalizeWaveControlReportMode,
+  normalizeWaveControlRunKind,
+} from "./wave-control-schema.mjs";
 
 export const MANIFEST_SCHEMA_VERSION = 1;
 export const GLOBAL_DASHBOARD_SCHEMA_VERSION = 1;
 export const WAVE_DASHBOARD_SCHEMA_VERSION = 1;
 export const RELAUNCH_PLAN_SCHEMA_VERSION = 1;
+export const RETRY_OVERRIDE_SCHEMA_VERSION = 1;
 export const ASSIGNMENT_SNAPSHOT_SCHEMA_VERSION = 1;
 export const DEPENDENCY_SNAPSHOT_SCHEMA_VERSION = 1;
+export const PROOF_REGISTRY_SCHEMA_VERSION = 1;
 export const RUN_STATE_SCHEMA_VERSION = 2;
+export const WAVE_CONTROL_DELIVERY_STATE_SCHEMA_VERSION = 1;
 
 export const MANIFEST_KIND = "wave-manifest";
 export const GLOBAL_DASHBOARD_KIND = "global-dashboard";
 export const WAVE_DASHBOARD_KIND = "wave-dashboard";
 export const RELAUNCH_PLAN_KIND = "wave-relaunch-plan";
+export const RETRY_OVERRIDE_KIND = "wave-retry-override";
 export const ASSIGNMENT_SNAPSHOT_KIND = "wave-assignment-snapshot";
 export const DEPENDENCY_SNAPSHOT_KIND = "wave-dependency-snapshot";
+export const PROOF_REGISTRY_KIND = "wave-proof-registry";
 export const RUN_STATE_KIND = "wave-run-state";
+export const WAVE_CONTROL_DELIVERY_STATE_KIND = "wave-control-delivery-state";
 
 function isPlainObject(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
@@ -25,6 +35,11 @@ function normalizeInteger(value, fallback = null) {
   return Number.isFinite(parsed) ? parsed : fallback;
 }
 
+function normalizeNonNegativeInteger(value, fallback = 0) {
+  const parsed = Number.parseInt(String(value ?? ""), 10);
+  return Number.isFinite(parsed) && parsed >= 0 ? parsed : fallback;
+}
+
 function normalizeText(value, fallback = null) {
   const normalized = String(value ?? "").trim();
   return normalized || fallback;
@@ -34,6 +49,19 @@ function cloneJson(value) {
   return value === undefined ? undefined : JSON.parse(JSON.stringify(value));
 }
 
+function normalizeStringArray(values) {
+  if (!Array.isArray(values)) {
+    return [];
+  }
+  return Array.from(
+    new Set(
+      values
+        .map((value) => normalizeText(value, null))
+        .filter(Boolean),
+    ),
+  );
+}
+
 export function normalizeManifest(payload) {
   const source = isPlainObject(payload) ? payload : {};
   return {
@@ -94,6 +122,42 @@ export function writeRelaunchPlan(filePath, payload, defaults = {}) {
   return normalized;
 }
 
+export function normalizeRetryOverride(payload, defaults = {}) {
+  const source = isPlainObject(payload) ? payload : {};
+  return {
+    schemaVersion: RETRY_OVERRIDE_SCHEMA_VERSION,
+    kind: RETRY_OVERRIDE_KIND,
+    lane: normalizeText(source.lane, normalizeText(defaults.lane, null)),
+    wave: normalizeInteger(source.wave, normalizeInteger(defaults.wave, null)),
+    selectedAgentIds: normalizeStringArray(source.selectedAgentIds),
+    reuseAttemptIds: normalizeStringArray(source.reuseAttemptIds),
+    reuseProofBundleIds: normalizeStringArray(source.reuseProofBundleIds),
+    reuseDerivedSummaries: source.reuseDerivedSummaries !== false,
+    invalidateComponentIds: normalizeStringArray(source.invalidateComponentIds),
+    clearReusableAgentIds: normalizeStringArray(source.clearReusableAgentIds),
+    preserveReusableAgentIds: normalizeStringArray(source.preserveReusableAgentIds),
+    resumePhase: normalizeText(source.resumePhase, null),
+    requestedBy: normalizeText(source.requestedBy, normalizeText(defaults.requestedBy, null)),
+    reason: normalizeText(source.reason, null),
+    applyOnce: source.applyOnce !== false,
+    createdAt: normalizeText(source.createdAt, toIsoTimestamp()),
+  };
+}
+
+export function readRetryOverride(filePath, defaults = {}) {
+  const payload = readJsonOrNull(filePath);
+  if (!payload) {
+    return null;
+  }
+  return normalizeRetryOverride(payload, defaults);
+}
+
+export function writeRetryOverride(filePath, payload, defaults = {}) {
+  const normalized = normalizeRetryOverride(payload, defaults);
+  writeJsonAtomic(filePath, normalized);
+  return normalized;
+}
+
 export function normalizeAssignmentSnapshot(payload, defaults = {}) {
   if (Array.isArray(payload)) {
     return {
@@ -168,6 +232,174 @@ export function writeDependencySnapshot(filePath, payload, defaults = {}) {
   return normalized;
 }
 
+function normalizeProofArtifactEntry(entry) {
+  const source = isPlainObject(entry) ? entry : {};
+  return {
+    path: normalizeText(source.path, null),
+    kind: normalizeText(source.kind, null),
+    requiredFor: normalizeStringArray(source.requiredFor),
+    exists: source.exists === true,
+    sha256: normalizeText(source.sha256, null),
+  };
+}
+
+function normalizeProofComponentEntry(entry) {
+  const source = isPlainObject(entry) ? entry : {};
+  return {
+    componentId: normalizeText(source.componentId, null),
+    level: normalizeText(source.level, null),
+    state: normalizeText(source.state, null),
+    detail: normalizeText(source.detail, null),
+  };
+}
+
+function normalizeProofSummaryEntry(entry) {
+  const source = isPlainObject(entry) ? entry : {};
+  const state = normalizeText(source.state, null);
+  const completion = normalizeText(source.completion, null);
+  const durability = normalizeText(source.durability, null);
+  const proof = normalizeText(source.proof, null);
+  if (!state && !completion && !durability && !proof) {
+    return null;
+  }
+  return {
+    state,
+    completion,
+    durability,
+    proof,
+    detail: normalizeText(source.detail, null),
+  };
+}
+
+function normalizeDocDeltaEntry(entry) {
+  const source = isPlainObject(entry) ? entry : {};
+  const state = normalizeText(source.state, null);
+  if (!state) {
+    return null;
+  }
+  return {
+    state,
+    detail: normalizeText(source.detail, null),
+  };
+}
+
+function normalizeProofRegistryEntry(entry) {
+  const source = isPlainObject(entry) ? entry : {};
+  return {
+    id: normalizeText(source.id, null),
+    agentId: normalizeText(source.agentId, null),
+    state: normalizeText(source.state, null),
+    authoritative: source.authoritative === true,
+    recordedAt: normalizeText(source.recordedAt, toIsoTimestamp()),
+    recordedBy: normalizeText(source.recordedBy, null),
+    detail: normalizeText(source.detail, null),
+    summary: normalizeText(source.summary, null),
+    satisfyOwnedComponents: source.satisfyOwnedComponents === true,
+    proof: normalizeProofSummaryEntry(source.proof),
+    docDelta: normalizeDocDeltaEntry(source.docDelta),
+    components: (Array.isArray(source.components) ? source.components : [])
+      .map((item) => normalizeProofComponentEntry(item))
+      .filter((item) => item.componentId),
+    artifacts: (Array.isArray(source.artifacts) ? source.artifacts : [])
+      .map((item) => normalizeProofArtifactEntry(item))
+      .filter((item) => item.path),
+    scope: normalizeText(source.scope, null),
+    attestation: isPlainObject(source.attestation) ? cloneJson(source.attestation) : null,
+    satisfies: normalizeStringArray(source.satisfies),
+    supersedes: normalizeText(source.supersedes, null),
+    supersededBy: normalizeText(source.supersededBy, null),
+  };
+}
+
+export function normalizeProofRegistry(payload, defaults = {}) {
+  const source = isPlainObject(payload) ? payload : {};
+  return {
+    schemaVersion: PROOF_REGISTRY_SCHEMA_VERSION,
+    kind: PROOF_REGISTRY_KIND,
+    lane: normalizeText(source.lane, normalizeText(defaults.lane, null)),
+    wave: normalizeInteger(source.wave, normalizeInteger(defaults.wave, null)),
+    updatedAt: normalizeText(source.updatedAt, toIsoTimestamp()),
+    entries: (Array.isArray(source.entries) ? source.entries : [])
+      .map((entry) => normalizeProofRegistryEntry(entry))
+      .filter((entry) => entry.id && entry.agentId),
+  };
+}
+
+export function readProofRegistry(filePath, defaults = {}) {
+  const payload = readJsonOrNull(filePath);
+  if (!payload) {
+    return null;
+  }
+  return normalizeProofRegistry(payload, defaults);
+}
+
+export function writeProofRegistry(filePath, payload, defaults = {}) {
+  const normalized = normalizeProofRegistry(payload, defaults);
+  writeJsonAtomic(filePath, normalized);
+  return normalized;
+}
+
+export function normalizeWaveControlDeliveryState(payload, defaults = {}) {
+  const source = isPlainObject(payload) ? payload : {};
+  return {
+    schemaVersion: WAVE_CONTROL_DELIVERY_STATE_SCHEMA_VERSION,
+    kind: WAVE_CONTROL_DELIVERY_STATE_KIND,
+    workspaceId: normalizeText(source.workspaceId, normalizeText(defaults.workspaceId, null)),
+    lane: normalizeText(source.lane, normalizeText(defaults.lane, null)),
+    runId: normalizeText(source.runId, normalizeText(defaults.runId, null)),
+    runKind: normalizeWaveControlRunKind(
+      source.runKind,
+      "waveControlDeliveryState.runKind",
+      normalizeText(defaults.runKind, "unknown"),
+    ),
+    reportMode: normalizeWaveControlReportMode(
+      source.reportMode,
+      "waveControlDeliveryState.reportMode",
+      normalizeText(defaults.reportMode, "metadata-plus-selected"),
+    ),
+    endpoint: normalizeText(source.endpoint, normalizeText(defaults.endpoint, null)),
+    queuePath: normalizeText(source.queuePath, normalizeText(defaults.queuePath, null)),
+    eventsPath: normalizeText(source.eventsPath, normalizeText(defaults.eventsPath, null)),
+    pendingCount: normalizeNonNegativeInteger(
+      source.pendingCount,
+      normalizeNonNegativeInteger(defaults.pendingCount, 0),
+    ),
+    sentCount: normalizeNonNegativeInteger(
+      source.sentCount,
+      normalizeNonNegativeInteger(defaults.sentCount, 0),
+    ),
+    failedCount: normalizeNonNegativeInteger(
+      source.failedCount,
+      normalizeNonNegativeInteger(defaults.failedCount, 0),
+    ),
+    lastEnqueuedAt: normalizeText(source.lastEnqueuedAt, normalizeText(defaults.lastEnqueuedAt, null)),
+    lastFlushAt: normalizeText(source.lastFlushAt, normalizeText(defaults.lastFlushAt, null)),
+    lastSuccessAt: normalizeText(source.lastSuccessAt, normalizeText(defaults.lastSuccessAt, null)),
+    lastError:
+      source.lastError === undefined
+        ? defaults.lastError ?? null
+        : isPlainObject(source.lastError)
+          ? source.lastError
+          : normalizeText(source.lastError, null),
+    recentEventIds: normalizeStringArray(source.recentEventIds ?? defaults.recentEventIds),
+    updatedAt: normalizeText(source.updatedAt, normalizeText(defaults.updatedAt, toIsoTimestamp())),
+  };
+}
+
+export function readWaveControlDeliveryState(filePath, defaults = {}) {
+  const payload = readJsonOrNull(filePath);
+  if (!payload) {
+    return null;
+  }
+  return normalizeWaveControlDeliveryState(payload, defaults);
+}
+
+export function writeWaveControlDeliveryState(filePath, payload, defaults = {}) {
+  const normalized = normalizeWaveControlDeliveryState(payload, defaults);
+  writeJsonAtomic(filePath, normalized);
+  return normalized;
+}
+
 export function cloneArtifactPayload(value) {
   return cloneJson(value);
 }

package/scripts/wave-orchestrator/autonomous.mjs

@@ -21,6 +21,10 @@ import {
   DEFAULT_CODEX_SANDBOX_MODE,
   normalizeCodexSandboxMode,
 } from "./launcher.mjs";
+import {
+  maybeAnnouncePackageUpdate,
+  WAVE_SUPPRESS_UPDATE_NOTICE_ENV,
+} from "./package-update-notice.mjs";
 import { readRunState } from "./wave-files.mjs";
 import { readDependencyTickets } from "./coordination-store.mjs";
 import { readWaveLedger } from "./ledger.mjs";
@@ -41,6 +45,7 @@ Options:
                                 Max backoff delay for 429 retries (default: ${DEFAULT_AGENT_RATE_LIMIT_MAX_DELAY_SECONDS})
   --agent-launch-stagger-ms <n> Delay between agent launches (default: ${DEFAULT_AGENT_LAUNCH_STAGGER_MS})
   --orchestrator-id <id>        Orchestrator ID for coordination board
+  --resident-orchestrator       Launch a resident orchestrator session for each live wave
   --executor <mode>             Default executor passed to launcher: ${SUPPORTED_EXECUTOR_MODES.join(" | ")} (default: lane config)
   --codex-sandbox <mode>        Default Codex sandbox mode passed to launcher (default: ${DEFAULT_CODEX_SANDBOX_MODE})
   --dashboard                   Enable dashboards (default: disabled)
@@ -60,6 +65,7 @@ export function parseArgs(argv) {
     agentRateLimitMaxDelaySeconds: DEFAULT_AGENT_RATE_LIMIT_MAX_DELAY_SECONDS,
     agentLaunchStaggerMs: DEFAULT_AGENT_LAUNCH_STAGGER_MS,
     orchestratorId: null,
+    residentOrchestrator: false,
     executorMode: DEFAULT_EXECUTOR_MODE,
     codexSandboxMode: DEFAULT_CODEX_SANDBOX_MODE,
     noDashboard: true,
@@ -99,6 +105,8 @@ export function parseArgs(argv) {
       options.agentLaunchStaggerMs = parseNonNegativeInt(argv[++i], "--agent-launch-stagger-ms");
     } else if (arg === "--orchestrator-id") {
       options.orchestratorId = String(argv[++i] || "").trim();
+    } else if (arg === "--resident-orchestrator") {
+      options.residentOrchestrator = true;
     } else if (arg === "--executor") {
       options.executorMode = normalizeExecutorMode(argv[++i], "--executor");
       executorProvided = true;
@@ -155,21 +163,30 @@ export function nextIncompleteWave(allWaves, completed) {
   return null;
 }
 
-function runCommand(args) {
+function runCommand(args, envOverrides = {}) {
   const result = spawnSync("node", args, {
     cwd: REPO_ROOT,
     stdio: "inherit",
-    env: process.env,
+    env: {
+      ...process.env,
+      ...envOverrides,
+    },
   });
   return Number.isInteger(result.status) ? result.status : 1;
 }
 
 function reconcile(lane) {
-  return runCommand([path.join(PACKAGE_ROOT, "scripts", "wave-launcher.mjs"), "--lane", lane, "--reconcile-status"]);
+  return runCommand(
+    [path.join(PACKAGE_ROOT, "scripts", "wave-launcher.mjs"), "--lane", lane, "--reconcile-status"],
+    { [WAVE_SUPPRESS_UPDATE_NOTICE_ENV]: "1" },
+  );
 }
 
 function dryRun(lane) {
-  return runCommand([path.join(PACKAGE_ROOT, "scripts", "wave-launcher.mjs"), "--lane", lane, "--dry-run", "--no-dashboard"]);
+  return runCommand(
+    [path.join(PACKAGE_ROOT, "scripts", "wave-launcher.mjs"), "--lane", lane, "--dry-run", "--no-dashboard"],
+    { [WAVE_SUPPRESS_UPDATE_NOTICE_ENV]: "1" },
+  );
 }
 
 function listPendingFeedback(lane) {
@@ -215,7 +232,10 @@ function launchSingleWave(params) {
   if (params.keepTerminals) {
     args.push("--keep-terminals");
   }
-  return runCommand(args);
+  if (params.residentOrchestrator) {
+    args.push("--resident-orchestrator");
+  }
+  return runCommand(args, { [WAVE_SUPPRESS_UPDATE_NOTICE_ENV]: "1" });
 }
 
 function requiredInboundDependenciesOpen(lanePaths, lane) {
@@ -291,12 +311,13 @@ export function readAutonomousBarrier(lanePaths, lane, wave = null) {
   return null;
 }
 
-export function runAutonomousCli(argv) {
+export async function runAutonomousCli(argv) {
   const parsed = parseArgs(argv);
   if (parsed.help) {
     printUsage();
     return;
   }
+  await maybeAnnouncePackageUpdate();
   const options = parsed.options;
   const allWaves = getWaveNumbers(options.lane);
   console.log(`[autonomous] lane=${options.lane} orchestrator=${options.orchestratorId}`);