@chllming/wave-orchestration 0.8.3 → 0.8.4

package/scripts/wave-orchestrator/human-input-resolution.mjs

@@ -15,14 +15,15 @@ import {
   waveControlPlaneLogPath,
 } from "./control-plane.mjs";
 import { readWaveLedger } from "./ledger.mjs";
-import { readRunExecutionSummary } from "./launcher-gates.mjs";
-import { buildResumePlan, clearWaveRelaunchPlan } from "./launcher-retry.mjs";
+import { readRunResultEnvelope } from "./gate-engine.mjs";
+import { buildResumePlan, clearWaveRelaunchPlan } from "./retry-engine.mjs";
 import { readWaveProofRegistry } from "./proof-registry.mjs";
 import { buildDependencySnapshot, buildRequestAssignments, syncAssignmentRecords } from "./routing-state.mjs";
 import { buildLanePaths } from "./shared.mjs";
 import { reduceWaveState } from "./wave-state-reducer.mjs";
 import { parseWaveFiles } from "./wave-files.mjs";
 import { writeWaveRetryOverride } from "./retry-control.mjs";
+import { resolveWaveRoleBindings } from "./role-helpers.mjs";
 
 function coordinationLogPath(lanePaths, waveNumber) {
   return path.join(lanePaths.coordinationDir, `wave-${waveNumber}.jsonl`);
@@ -67,6 +68,9 @@ function taskRunInfoForAgent(lanePaths, wave, agent, proofRegistry) {
   const safeName = `wave-${wave.wave}-${agent.slug}`;
   return {
     agent,
+    lane: lanePaths.lane,
+    wave: wave.wave,
+    resultsDir: lanePaths.resultsDir,
     logPath: path.join(lanePaths.logsDir, `${safeName}.log`),
     statusPath: path.join(lanePaths.statusDir, `${safeName}.status`),
     proofRegistry,
@@ -207,10 +211,13 @@ export function buildResumePlanFromDisk({ lanePaths, wave }) {
   const agentRuns = wave.agents.map((agent) =>
     taskRunInfoForAgent(lanePaths, wave, agent, proofRegistry),
   );
-  const agentResults = Object.fromEntries(
+  const agentEnvelopes = Object.fromEntries(
     agentRuns
-      .map((runInfo) => [runInfo.agent.agentId, readRunExecutionSummary(runInfo, wave)])
-      .filter(([, summary]) => Boolean(summary)),
+      .map((runInfo) => {
+        const envelopeResult = readRunResultEnvelope(runInfo, wave, { mode: "compat" });
+        return [runInfo.agent.agentId, envelopeResult?.valid ? envelopeResult.envelope : null];
+      })
+      .filter(([, envelope]) => Boolean(envelope)),
   );
   const coordinationState = readMaterializedCoordinationState(coordinationLogPath(lanePaths, wave.wave));
   const feedbackRequests = readWaveHumanFeedbackRequests({
@@ -232,16 +239,13 @@ export function buildResumePlanFromDisk({ lanePaths, wave }) {
   const reducerState = reduceWaveState({
     controlPlaneEvents: readControlPlaneEvents(waveControlPlaneLogPath(lanePaths, wave.wave)),
     coordinationRecords: coordinationState.latestRecords || [],
-    agentResults,
+    agentEnvelopes,
     waveDefinition: wave,
     dependencyTickets: dependencySnapshot,
     feedbackRequests,
     laneConfig: {
       lane: lanePaths.lane,
-      contQaAgentId: lanePaths.contQaAgentId || "A0",
-      contEvalAgentId: lanePaths.contEvalAgentId || "E0",
-      integrationAgentId: lanePaths.integrationAgentId || "A8",
-      documentationAgentId: lanePaths.documentationAgentId || "A9",
+      ...resolveWaveRoleBindings(wave, lanePaths, wave.agents),
       validationMode: "live",
       evalTargets: wave.evalTargets,
       benchmarkCatalogPath: lanePaths.laneProfile?.paths?.benchmarkCatalogPath,

package/scripts/wave-orchestrator/human-input-workflow.mjs

@@ -287,3 +287,107 @@ export function computeHumanInputMetrics(requests) {
       : null,
   };
 }
+
+export function buildHumanFeedbackWorkflowUpdate({
+  request,
+  lane,
+  waveNumber,
+  existingEscalation = null,
+}) {
+  const question = request?.question || "n/a";
+  const context = request?.context ? `; context=${request.context}` : "";
+  const agentId = request?.agentId || "human";
+  const responseOperator = request?.responseOperator || "human-operator";
+  const responseText = request?.responseText || "(empty response)";
+  if (request?.status === "pending") {
+    return {
+      combinedEvent: {
+        level: "warn",
+        agentId: request.agentId,
+        message: `Human feedback requested (${request.id}): ${question}`,
+      },
+      coordinationNotice: {
+        event: "human_feedback_requested",
+        waves: [waveNumber],
+        status: "waiting-human",
+        details: `request_id=${request.id}; agent=${request.agentId}; question=${question}${context}`,
+        actionRequested:
+          `Launcher operator should ask or answer in the parent session, then run: pnpm exec wave control task act answer --lane ${lane} --wave ${waveNumber} --id ${request.id} --response "<answer>" --operator "<name>"`,
+      },
+      consoleLines: [
+        `[human-feedback] wave=${waveNumber} agent=${request.agentId} request=${request.id} pending: ${question}`,
+        `[human-feedback] respond with: pnpm exec wave control task act answer --lane ${lane} --wave ${waveNumber} --id ${request.id} --response "<answer>" --operator "<name>"`,
+      ],
+      coordinationUpdates: [
+        {
+          id: request.id,
+          lane,
+          wave: waveNumber,
+          agentId,
+          kind: "human-feedback",
+          targets: request.agentId ? [`agent:${request.agentId}`] : [],
+          priority: "high",
+          summary: question,
+          detail: request.context || "",
+          status: "open",
+          source: "feedback",
+        },
+      ],
+      triageUpdates: [],
+    };
+  }
+  if (request?.status === "answered") {
+    const escalationId = `escalation-${request.id}`;
+    const escalationRecord = {
+      id: escalationId,
+      lane,
+      wave: waveNumber,
+      agentId,
+      kind: "human-escalation",
+      targets:
+        existingEscalation?.targets ||
+        (request.agentId ? [`agent:${request.agentId}`] : []),
+      dependsOn: existingEscalation?.dependsOn || [],
+      closureCondition: existingEscalation?.closureCondition || "",
+      priority: "high",
+      summary: question,
+      detail: responseText,
+      artifactRefs: [request.id],
+      status: "resolved",
+      source: "feedback",
+    };
+    return {
+      combinedEvent: {
+        level: "info",
+        agentId: request.agentId,
+        message: `Human feedback answered (${request.id}) by ${responseOperator}: ${responseText}`,
+      },
+      coordinationNotice: {
+        event: "human_feedback_answered",
+        waves: [waveNumber],
+        status: "resolved",
+        details: `request_id=${request.id}; agent=${request.agentId}; operator=${responseOperator}; response=${responseText}`,
+        actionRequested: "None",
+      },
+      consoleLines: [],
+      coordinationUpdates: [
+        escalationRecord,
+        {
+          id: request.id,
+          lane,
+          wave: waveNumber,
+          agentId,
+          kind: "human-feedback",
+          targets: request.agentId ? [`agent:${request.agentId}`] : [],
+          priority: "high",
+          summary: question,
+          detail: responseText,
+          status: "resolved",
+          source: "feedback",
+        },
+      ],
+      triageUpdates: [escalationRecord],
+    };
+  }
+  return null;
+}

package/scripts/wave-orchestrator/implementation-engine.mjs

@@ -0,0 +1,120 @@
+import { readStatusCodeIfPresent } from "./dashboard-state.mjs";
+import { resolveRetryOverrideRuns } from "./retry-control.mjs";
+import {
+  applyPersistedRelaunchPlan,
+  persistedRelaunchPlanMatchesCurrentState,
+  resolveRelaunchRuns,
+  selectInitialWaveRuns,
+  selectReusablePreCompletedAgentIds,
+} from "./retry-engine.mjs";
+
+export function planInitialWaveAttempt({
+  agentRuns,
+  lanePaths,
+  wave,
+  derivedState,
+  proofRegistry,
+  retryOverride,
+  persistedRelaunchPlan,
+}) {
+  const preCompletedAgentIds = selectReusablePreCompletedAgentIds(agentRuns, lanePaths, {
+    retryOverride,
+    wave,
+    derivedState,
+    proofRegistry,
+  });
+  const staleCompletedAgentIds = agentRuns
+    .filter(
+      (run) =>
+        !preCompletedAgentIds.has(run.agent.agentId) &&
+        readStatusCodeIfPresent(run.statusPath) === 0,
+    )
+    .map((run) => run.agent.agentId);
+
+  const persistedPlanIsCurrent =
+    !persistedRelaunchPlan ||
+    persistedRelaunchPlanMatchesCurrentState(
+      agentRuns,
+      persistedRelaunchPlan,
+      lanePaths,
+      wave,
+    );
+  const effectivePersistedPlan = persistedPlanIsCurrent ? persistedRelaunchPlan : null;
+  const availableRuns = agentRuns.filter((run) => !preCompletedAgentIds.has(run.agent.agentId));
+  const persistedRuns = applyPersistedRelaunchPlan(
+    availableRuns,
+    effectivePersistedPlan,
+    lanePaths,
+    wave,
+  );
+  const overrideResolution = resolveRetryOverrideRuns(availableRuns, retryOverride, lanePaths, wave);
+
+  let selectedRuns = [];
+  let source = "initial";
+  if (overrideResolution.unknownAgentIds.length === 0 && overrideResolution.runs.length > 0) {
+    selectedRuns = overrideResolution.runs;
+    source = "override";
+  } else if (persistedRuns.length > 0) {
+    selectedRuns = persistedRuns;
+    source = "persisted-relaunch";
+  } else {
+    selectedRuns = selectInitialWaveRuns(availableRuns, lanePaths, wave);
+  }
+
+  return {
+    preCompletedAgentIds,
+    staleCompletedAgentIds,
+    availableRuns,
+    selectedRuns,
+    source,
+    overrideResolution,
+    persistedPlanIsCurrent,
+    shouldClearPersistedRelaunchPlan: Boolean(
+      persistedRelaunchPlan && !persistedPlanIsCurrent,
+    ),
+  };
+}
+
+export function planRetryWaveAttempt({
+  agentRuns,
+  failures,
+  derivedState,
+  lanePaths,
+  wave,
+  retryOverride,
+  waveState = null,
+}) {
+  const relaunchResolution = resolveRelaunchRuns(
+    agentRuns,
+    failures,
+    derivedState,
+    lanePaths,
+    wave,
+    waveState ? { waveState } : {},
+  );
+  const overrideResolution = resolveRetryOverrideRuns(
+    agentRuns,
+    retryOverride,
+    lanePaths,
+    wave,
+  );
+
+  let selectedRuns = [];
+  let source = "retry";
+  let barrier = relaunchResolution.barrier || null;
+  if (overrideResolution.unknownAgentIds.length === 0 && overrideResolution.runs.length > 0) {
+    selectedRuns = overrideResolution.runs;
+    barrier = null;
+    source = "override";
+  } else if (!barrier) {
+    selectedRuns = relaunchResolution.runs;
+  }
+
+  return {
+    selectedRuns,
+    source,
+    barrier,
+    relaunchResolution,
+    overrideResolution,
+  };
+}

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

@@ -14,6 +14,7 @@ import { readStatusCodeIfPresent } from "./dashboard-state.mjs";
 import { buildExecutorLaunchSpec } from "./executors.mjs";
 import { hashAgentPromptFingerprint, prefetchContext7ForSelection } from "./context7.mjs";
 import { killTmuxSessionIfExists } from "./terminals.mjs";
+import { resolveWaveRoleBindings } from "./role-helpers.mjs";
 import {
   resolveAgentSkills,
   summarizeResolvedSkills,
@@ -71,6 +72,7 @@ export async function launchAgentSession(lanePaths, params, { runTmuxFn }) {
     inboxText,
     promptOverride = "",
     orchestratorId,
+    attempt = 1,
     agentRateLimitRetries,
     agentRateLimitBaseDelaySeconds,
     agentRateLimitMaxDelaySeconds,
@@ -105,6 +107,7 @@ export async function launchAgentSession(lanePaths, params, { runTmuxFn }) {
   const prompt =
     String(promptOverride || "").trim() ||
     buildExecutionPrompt({
+      ...resolveWaveRoleBindings(resolvedWaveDefinition, lanePaths),
       lane: lanePaths.lane,
       wave,
       agent,
@@ -120,10 +123,6 @@ export async function launchAgentSession(lanePaths, params, { runTmuxFn }) {
       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");
@@ -216,8 +215,8 @@ export async function launchAgentSession(lanePaths, params, { runTmuxFn }) {
     `export WAVE_EXECUTOR_MODE=${shellQuote(resolvedExecutorMode)}`,
     ...executionLines,
     `node -e ${shellQuote(
-      "const fs=require('node:fs'); const statusPath=process.argv[1]; const payload={code:Number(process.argv[2]),promptHash:process.argv[3]||null,orchestratorId:process.argv[4]||null,completedAt:new Date().toISOString()}; fs.writeFileSync(statusPath, JSON.stringify(payload, null, 2)+'\\n', 'utf8');",
-    )} ${shellQuote(statusPath)} "$status" ${shellQuote(promptHash)} ${shellQuote(orchestratorId || "")}`,
+      "const fs=require('node:fs'); const statusPath=process.argv[1]; const payload={code:Number(process.argv[2]),promptHash:process.argv[3]||null,orchestratorId:process.argv[4]||null,attempt:Number(process.argv[5])||1,completedAt:new Date().toISOString()}; fs.writeFileSync(statusPath, JSON.stringify(payload, null, 2)+'\\n', 'utf8');",
+    )} ${shellQuote(statusPath)} "$status" ${shellQuote(promptHash)} ${shellQuote(orchestratorId || "")} ${shellQuote(String(attempt || 1))}`,
     `echo "[${lanePaths.lane}-wave-launcher] ${sessionName} finished with code $status"`,
     "exec bash -l",
   ].join("\n");