@the-open-engine/zeroshot 6.6.0 → 6.7.1

package/src/orchestrator.js

@@ -48,6 +48,7 @@ const TemplateResolver = require('./template-resolver');
 const { loadSettings } = require('../lib/settings');
 const { normalizeProviderName } = require('../lib/provider-names');
 const { resolveRunPlan } = require('../lib/run-plan');
+const { isProcessRunning } = require('../lib/process-liveness');
 const { getProvider } = require('./providers');
 const StateSnapshotter = require('./state-snapshotter');
 const { resolveClusterRequiredQualityGates } = require('./quality-gates');
@@ -581,7 +582,9 @@ class Orchestrator {
         isolationManager,
         containerId: isolation?.containerId || null,
       });
-      this._startSnapshotter(clusterContext);
+      if (clusterContext.state === 'running' && this._isProcessRunning(clusterContext.pid)) {
+        this._startSnapshotter(clusterContext);
+      }
     }
     this._log(`[Orchestrator] Loaded cluster: ${clusterId} with ${agents.length} agents`);
 
@@ -626,8 +629,13 @@ class Orchestrator {
       id: clusterId,
       quiet: this.quiet,
       modelOverride: clusterData.modelOverride || null,
+      testMode: Boolean(this.taskRunner),
     };
 
+    if (this.taskRunner) {
+      agentOptions.taskRunner = this.taskRunner;
+    }
+
     if (isolation?.enabled && isolationManager) {
       agentOptions.isolation = {
         enabled: true,
@@ -758,21 +766,13 @@ class Orchestrator {
       if (inactiveStates.includes(cluster.state)) continue;
 
       // Check if process is still running (zombie detection)
-      if (cluster.pid) {
-        try {
-          // process.kill with signal 0 checks if process exists
-          process.kill(cluster.pid, 0);
-          // Process exists - cluster is active
-          activeClusters.push({
-            id: clusterId,
-            state: cluster.state,
-            createdAt: cluster.createdAt,
-            pid: cluster.pid,
-          });
-        } catch {
-          // Process doesn't exist - cluster is a zombie (stale entry)
-          // Don't include in active list
-        }
+      if (cluster.pid && this._isProcessRunning(cluster.pid)) {
+        activeClusters.push({
+          id: clusterId,
+          state: cluster.state,
+          createdAt: cluster.createdAt,
+          pid: cluster.pid,
+        });
       }
     }
 
@@ -1126,11 +1126,7 @@ class Orchestrator {
     // Resolve input (issue/file/text) and reject duplicate active runs on the same issue
     // BEFORE allocating any resources. A duplicate-run rejection must have zero side
     // effects: no ledger db file, no worktree/container, no clusters.json entry.
-    const { inputData, issueProviderId } = await this._resolveClusterInput(
-      input,
-      options,
-      clusterId
-    );
+    let { inputData, issueProviderId } = await this._resolveClusterInput(input, options, clusterId);
 
     // Create ledger and message bus with persistent storage
     const dbPath = config.dbPath || path.join(this.storageDir, `${clusterId}.db`);
@@ -1220,6 +1216,34 @@ class Orchestrator {
     });
 
     try {
+      if (typeof options.prepareIsolatedInput === 'function') {
+        const dockerWorkspace =
+          isolationManager?.isolatedDirs?.get(clusterId)?.path || options.cwd || process.cwd();
+        const isolation = worktreeInfo
+          ? Object.freeze({
+              kind: 'worktree',
+              hostRoot: worktreeInfo.path,
+              runtimeRoot: worktreeInfo.path,
+            })
+          : containerId && dockerWorkspace
+            ? Object.freeze({
+                kind: 'docker',
+                hostRoot: dockerWorkspace,
+                runtimeRoot: '/workspace',
+              })
+            : null;
+        if (!isolation) {
+          throw new Error('Prepared input requires an allocated worktree or Docker workspace');
+        }
+        const preparedText = await options.prepareIsolatedInput(
+          Object.freeze({ clusterId, isolation })
+        );
+        if (typeof preparedText !== 'string' || preparedText.trim().length === 0) {
+          throw new Error('Prepared isolated input must be a nonempty string');
+        }
+        inputData = InputHelpers.createTextInput(preparedText);
+      }
+
       // Input (issue/file/text) was already resolved and duplicate-checked in
       // _resolveClusterInput() before any resource was allocated (see above).
       commandProofs = mergeCommandProofs(
@@ -1511,6 +1535,7 @@ class Orchestrator {
       const agentRole = message.content?.data?.role;
       const attempts = message.content?.data?.attempts || 1;
       const hookFailure = message.content?.data?.hookFailure === true;
+      const restartExhausted = message.content?.data?.restartExhausted === true;
 
       await this._saveClusters();
 
@@ -1518,7 +1543,7 @@ class Orchestrator {
         agentRole === 'implementation' ||
         agentRole === 'coordinator' ||
         message.sender === 'consensus-coordinator';
-      const shouldStop = shouldStopForRole && (hookFailure || attempts >= 3);
+      const shouldStop = shouldStopForRole && (hookFailure || restartExhausted || attempts >= 3);
 
       if (shouldStop) {
         this._log(`\n${'='.repeat(80)}`);
@@ -1527,6 +1552,7 @@ class Orchestrator {
         this._log(
           `${message.sender} (${agentRole || 'unknown role'}) failed` +
             (hookFailure ? ` (hookFailure=true)` : ``) +
+            (restartExhausted ? ` (restartExhausted=true)` : ``) +
             ` after ${attempts} attempts`
         );
         this._log(`Error: ${message.content?.data?.error || 'unknown'}`);
@@ -1549,7 +1575,7 @@ class Orchestrator {
     });
   }
 
-  _registerAgentLifecycleHandlers(messageBus, clusterId) {
+  _registerAgentLifecycleHandlers(messageBus, _clusterId) {
     messageBus.on('topic:AGENT_LIFECYCLE', async (message) => {
       const event = message.content?.data?.event;
       if (
@@ -1572,13 +1598,14 @@ class Orchestrator {
       const timeSinceLastOutput = message.content?.data?.timeSinceLastOutput;
       const analysis = message.content?.data?.analysis || 'No analysis available';
 
+      const consecutiveWarnings = message.content?.data?.consecutiveWarnings;
+      const warningsBeforeKill = message.content?.data?.warningsBeforeKill;
       this._log(
-        `⚠️  Orchestrator: Agent ${agentId} appears stale (${Math.round(timeSinceLastOutput / 1000)}s no output) but will NOT be killed`
+        `⚠️  Orchestrator: Agent ${agentId} has produced no output for ${Math.round(timeSinceLastOutput / 1000)}s ` +
+          `(warning ${consecutiveWarnings}/${warningsBeforeKill})`
       );
       this._log(`    Analysis: ${analysis}`);
-      this._log(
-        `    Manual intervention may be needed - use 'zeroshot resume ${clusterId}' if stuck`
-      );
+      this._log(`    Zeroshot will terminate and restart the task if inactivity persists`);
     });
   }
 
@@ -2337,6 +2364,15 @@ class Orchestrator {
       return;
     }
     this.closed = true;
+
+    for (const cluster of this.clusters.values()) {
+      if (typeof cluster.snapshotter?.stop === 'function') {
+        cluster.snapshotter.stop();
+      }
+      if (typeof cluster.messageBus?.close === 'function') {
+        cluster.messageBus.close();
+      }
+    }
   }
 
   /**
@@ -2369,8 +2405,17 @@ class Orchestrator {
     }
 
     if (cluster.state === 'running') {
-      throw new Error(
-        `Cluster ${clusterId} is still running. Use 'zeroshot stop' first if you want to restart it.`
+      if (this._isProcessRunning(cluster.pid)) {
+        throw new Error(
+          `Cluster ${clusterId} is still running. Use 'zeroshot stop' first if you want to restart it.`
+        );
+      }
+      // state says running but the recorded PID is dead: this is the same
+      // zombie condition getStatus()/listClusters() already detect. Recover
+      // it here instead of forcing a manual `stop` for a process that no
+      // longer exists.
+      this._log(
+        `[Orchestrator] Cluster ${clusterId} was marked running with dead PID ${cluster.pid}; recovering as a zombie instead of rejecting resume.`
       );
     }
 
@@ -2388,19 +2433,28 @@ class Orchestrator {
     }
 
     const failureInfo = this._resolveFailureInfo(cluster, clusterId);
+    const recentMessages = this._loadRecentMessages(cluster, clusterId, 50);
+    const cleanResumePlan = failureInfo ? null : this._buildCleanResumePlan(clusterId, cluster);
+
+    if (cleanResumePlan?.kind === 'failure') {
+      return this._failResumeReconstruction(clusterId, cluster, cleanResumePlan);
+    }
+
+    if (failureInfo) {
+      this._requireFailedAgent(clusterId, cluster, failureInfo);
+    }
 
     await this._ensureIsolationForResume(clusterId, cluster);
     this._ensureWorktreeForResume(clusterId, cluster);
     this._startSnapshotter(cluster);
+    this._clearTransientAgentState(cluster);
     await this._restartClusterAgents(cluster);
 
-    const recentMessages = this._loadRecentMessages(cluster, clusterId, 50);
-
     if (failureInfo) {
       return this._resumeFailedCluster(clusterId, cluster, failureInfo, recentMessages, prompt);
     }
 
-    return this._resumeCleanCluster(clusterId, cluster, recentMessages, prompt);
+    return this._resumeCleanCluster(clusterId, cluster, recentMessages, prompt, cleanResumePlan);
   }
 
   _validateGuidanceAgentArgs(clusterId, agentId, text) {
@@ -2596,7 +2650,7 @@ class Orchestrator {
 
   _resolveFailureInfo(cluster, clusterId) {
     if (cluster.failureInfo) {
-      return cluster.failureInfo;
+      return cluster.failureInfo.agentId ? cluster.failureInfo : null;
     }
 
     const errors = cluster.messageBus.query({
@@ -2622,6 +2676,15 @@ class Orchestrator {
     return failureInfo;
   }
 
+  _requireFailedAgent(clusterId, cluster, failureInfo) {
+    const failedAgent = cluster.agents.find((agent) => agent.id === failureInfo.agentId);
+    if (!failedAgent) {
+      throw new Error(
+        `Cannot resume cluster ${clusterId}: Failed agent '${failureInfo.agentId}' is not present in the restored configuration.`
+      );
+    }
+  }
+
   _checkContainerExists(containerId) {
     const { spawn } = require('child_process');
     const checkContainer = spawn('docker', ['inspect', containerId], { stdio: 'ignore' });
@@ -2715,6 +2778,22 @@ class Orchestrator {
       .reverse();
   }
 
+  _findLastDurableWorkflowTrigger(cluster, clusterId) {
+    let latest = null;
+
+    for (const topic of WORKFLOW_TRIGGERS) {
+      const candidate = cluster.messageBus.findLast({
+        cluster_id: clusterId,
+        topic,
+      });
+      if (candidate && (!latest || candidate.timestamp > latest.timestamp)) {
+        latest = candidate;
+      }
+    }
+
+    return latest;
+  }
+
   _buildResumeContext(recentMessages, prompt, options) {
     const resumePrompt = prompt || 'Continue from where you left off. Complete the task.';
     let context = `${options.header}\n\n`;
@@ -2723,6 +2802,13 @@ class Orchestrator {
       context += `Previous error: ${options.error}\n\n`;
     }
 
+    if (options.durableMessages?.length > 0) {
+      context += `## Durable Workflow Context\n\n`;
+      for (const msg of options.durableMessages) {
+        context += `[${msg.topic}] [${msg.sender}]\n${msg.content?.text || ''}\n\n`;
+      }
+    }
+
     context += `## Recent Context\n\n`;
     for (const msg of recentMessages.slice(-10)) {
       if (options.topics.includes(msg.topic)) {
@@ -2745,7 +2831,8 @@ class Orchestrator {
   }
 
   _selectAgentsToResume(cluster, lastTrigger) {
-    const agentsToResume = [];
+    const matching = [];
+    const eligible = [];
 
     for (const agent of cluster.agents) {
       if (!agent.config.triggers) continue;
@@ -2755,15 +2842,365 @@ class Orchestrator {
       );
       if (!matchingTrigger) continue;
 
+      const candidate = { agent, message: lastTrigger, trigger: matchingTrigger };
+      matching.push(candidate);
+
       if (matchingTrigger.logic?.script) {
         const shouldTrigger = agent._evaluateTrigger(matchingTrigger, lastTrigger);
         if (!shouldTrigger) continue;
       }
 
-      agentsToResume.push({ agent, message: lastTrigger, trigger: matchingTrigger });
+      eligible.push(candidate);
+    }
+
+    return { matching, eligible };
+  }
+
+  _findDurableTriggerBefore(cluster, clusterId, topic, timestamp) {
+    if (!topic || topic === 'AGENT_RESUME') {
+      return null;
+    }
+
+    return cluster.messageBus.findLast({
+      cluster_id: clusterId,
+      topic,
+      until: timestamp - 1,
+    });
+  }
+
+  _collectDurableResumeContext(cluster, clusterId, messages = []) {
+    const durableMessages = [
+      cluster.messageBus.findLast({ cluster_id: clusterId, topic: 'ISSUE_OPENED' }),
+      cluster.messageBus.findLast({ cluster_id: clusterId, topic: 'PLAN_READY' }),
+      cluster.messageBus.findLast({ cluster_id: clusterId, topic: 'IMPLEMENTATION_READY' }),
+      ...messages,
+    ].filter(Boolean);
+    const uniqueById = new Map(durableMessages.map((message) => [message.id, message]));
+    return [...uniqueById.values()].sort((left, right) => left.timestamp - right.timestamp);
+  }
+
+  _findInterruptedResumeTargets(clusterId, cluster) {
+    const targets = [];
+    const invalid = [];
+    const issueMessage = cluster.messageBus.findLast({
+      cluster_id: clusterId,
+      topic: 'ISSUE_OPENED',
+    });
+
+    for (const agent of cluster.agents) {
+      if (agent.state !== 'executing_task') {
+        continue;
+      }
+
+      const lifecycle = cluster.messageBus.query({
+        cluster_id: clusterId,
+        topic: 'AGENT_LIFECYCLE',
+        sender: agent.id,
+      });
+      const startedIndex = lifecycle.findLastIndex(
+        (message) => message.content?.data?.event === 'TASK_STARTED'
+      );
+      const lastStarted = startedIndex >= 0 ? lifecycle[startedIndex] : null;
+      const lifecycleAfterStart = startedIndex >= 0 ? lifecycle.slice(startedIndex + 1) : [];
+      const completedAfterStart = lifecycleAfterStart.some(
+        (message) => message.content?.data?.event === 'TASK_COMPLETED'
+      );
+      const lastTaskIdAssigned = [...lifecycleAfterStart]
+        .reverse()
+        .find((message) => message.content?.data?.event === 'TASK_ID_ASSIGNED');
+      const assignedTaskId = lastTaskIdAssigned?.content?.data?.taskId || null;
+      const startedIteration = lastStarted?.content?.data?.iteration;
+      const triggeredBy = lastStarted?.content?.data?.triggeredBy;
+      const triggeringMessage = lastStarted
+        ? this._findDurableTriggerBefore(cluster, clusterId, triggeredBy, lastStarted.timestamp)
+        : null;
+
+      if (
+        !agent.currentTaskId ||
+        !lastStarted ||
+        completedAfterStart ||
+        startedIteration !== agent.iteration ||
+        !assignedTaskId ||
+        assignedTaskId !== agent.currentTaskId ||
+        !issueMessage
+      ) {
+        invalid.push({
+          agentId: agent.id,
+          reason: !issueMessage ? 'missing_durable_context' : 'ambiguous_task_identity',
+          state: agent.state,
+          iteration: agent.iteration,
+          currentTaskId: agent.currentTaskId || null,
+          assignedTaskId,
+          lastStartedIteration: startedIteration ?? null,
+          completedAfterStart: Boolean(completedAfterStart),
+        });
+        continue;
+      }
+
+      targets.push({
+        agent,
+        message: triggeringMessage || issueMessage,
+        lifecycleMessage: lastStarted,
+        issueMessage,
+        trigger: null,
+        reason: 'interrupted_task',
+      });
+    }
+
+    const interruptedRoles = new Set(targets.map(({ agent }) => agent.role));
+    if (interruptedRoles.size > 1) {
+      invalid.push({
+        reason: 'multiple_interrupted_phases',
+        agents: targets.map(({ agent }) => agent.id),
+      });
+    }
+
+    return { targets, invalid };
+  }
+
+  _findPartialValidationTargets(clusterId, cluster, lastTrigger) {
+    if (
+      !lastTrigger ||
+      !['IMPLEMENTATION_READY', 'VALIDATION_RESULT'].includes(lastTrigger.topic)
+    ) {
+      return null;
+    }
+
+    const implementationReady = cluster.messageBus.findLast({
+      cluster_id: clusterId,
+      topic: 'IMPLEMENTATION_READY',
+      until: lastTrigger.timestamp,
+    });
+    if (!implementationReady) {
+      return null;
+    }
+
+    const validators = cluster.agents.filter((agent) => agent.role === 'validator');
+    if (validators.length === 0) {
+      return null;
+    }
+
+    const validatorIds = new Set(validators.map((agent) => agent.id));
+    const validationResults = cluster.messageBus
+      .query({
+        cluster_id: clusterId,
+        topic: 'VALIDATION_RESULT',
+        since: implementationReady.timestamp,
+      })
+      .filter(
+        (message) =>
+          message.timestamp > implementationReady.timestamp && validatorIds.has(message.sender)
+      );
+    const responded = new Set(validationResults.map((message) => message.sender));
+    const missing = validators.filter((agent) => !responded.has(agent.id));
+    if (missing.length === 0) {
+      return { kind: 'complete', validationResults, implementationReady };
+    }
+
+    const missingIds = new Set(missing.map((agent) => agent.id));
+    const selection = this._selectAgentsToResume(cluster, implementationReady);
+    const matching = selection.matching.filter(({ agent }) => missingIds.has(agent.id));
+    const eligible = selection.eligible.filter(({ agent }) => missingIds.has(agent.id));
+
+    if (eligible.length !== missing.length) {
+      return {
+        kind: 'failure',
+        missingAgentIds: missing.map((agent) => agent.id),
+        matchingAgentIds: matching.map(({ agent }) => agent.id),
+        implementationReady,
+        validationResults,
+      };
+    }
+
+    return {
+      kind: 'agents',
+      agentsToResume: eligible.map((target) => ({
+        ...target,
+        reason: 'missing_validation_result',
+      })),
+      implementationReady,
+      validationResults,
+    };
+  }
+
+  _buildCleanResumePlan(clusterId, cluster) {
+    const interrupted = this._findInterruptedResumeTargets(clusterId, cluster);
+    if (interrupted.invalid.length > 0) {
+      const missingContext = interrupted.invalid.some(
+        (entry) => entry.reason === 'missing_durable_context'
+      );
+      return {
+        kind: 'failure',
+        error: missingContext
+          ? `Cannot resume cluster ${clusterId}: interrupted work has no durable workflow context. ` +
+            `No agents were started and the preserved cluster remains stopped. ` +
+            `Inspect it with 'zeroshot export ${clusterId}' before repairing its persisted state; do not launch a duplicate run.`
+          : `Cannot resume cluster ${clusterId}: persisted interrupted-task state is ambiguous. ` +
+            `No agents were started; inspect failureInfo for reconstruction details.`,
+        details: {
+          reason: missingContext ? 'missing_workflow_history' : 'ambiguous_interrupted_task',
+          interrupted: interrupted.invalid,
+        },
+      };
+    }
+
+    const lastTrigger = this._findLastDurableWorkflowTrigger(cluster, clusterId);
+    const partialValidation = this._findPartialValidationTargets(clusterId, cluster, lastTrigger);
+    if (partialValidation?.kind === 'failure') {
+      return {
+        kind: 'failure',
+        error:
+          `Cannot resume cluster ${clusterId}: validators ${partialValidation.missingAgentIds.join(
+            ', '
+          )} are missing results, but not every missing validator has an eligible IMPLEMENTATION_READY handler. ` +
+          `No agents were started.`,
+        details: {
+          reason: 'partial_validation_handlers_ineligible',
+          missingAgentIds: partialValidation.missingAgentIds,
+          matchingAgentIds: partialValidation.matchingAgentIds,
+        },
+      };
+    }
+
+    if (interrupted.targets.length > 0) {
+      const interruptedValidators = interrupted.targets.filter(
+        ({ agent }) => agent.role === 'validator'
+      );
+      if (interruptedValidators.length > 0 && partialValidation?.kind !== 'agents') {
+        return {
+          kind: 'failure',
+          error:
+            `Cannot resume cluster ${clusterId}: interrupted validator state does not match an active validation cycle. ` +
+            `No agents were started.`,
+          details: {
+            reason: 'ambiguous_validation_cycle',
+            interruptedAgentIds: interruptedValidators.map(({ agent }) => agent.id),
+          },
+        };
+      }
+
+      const targets =
+        interruptedValidators.length > 0 ? partialValidation.agentsToResume : interrupted.targets;
+      return {
+        kind: 'agents',
+        reason: interruptedValidators.length > 0 ? 'partial_validation' : 'interrupted_tasks',
+        agentsToResume: targets,
+        lastTrigger,
+        durableMessages: this._collectDurableResumeContext(
+          cluster,
+          clusterId,
+          targets.map(({ message }) => message)
+        ),
+      };
     }
 
-    return agentsToResume;
+    if (partialValidation?.kind === 'agents') {
+      return {
+        kind: 'agents',
+        reason: 'partial_validation',
+        agentsToResume: partialValidation.agentsToResume,
+        lastTrigger,
+        durableMessages: this._collectDurableResumeContext(
+          cluster,
+          clusterId,
+          partialValidation.validationResults
+        ),
+      };
+    }
+
+    if (!lastTrigger) {
+      const issueMessage = cluster.messageBus.findLast({
+        cluster_id: clusterId,
+        topic: 'ISSUE_OPENED',
+      });
+      if (issueMessage) {
+        return {
+          kind: 'bootstrap',
+          reason: 'missing_workflow_trigger',
+          issueMessage,
+          agentsToResume: [],
+          lastTrigger: null,
+          durableMessages: [issueMessage],
+        };
+      }
+
+      return {
+        kind: 'failure',
+        error:
+          `Cannot resume cluster ${clusterId}: no workflow trigger or ISSUE_OPENED message exists. ` +
+          `No agents were started and the preserved cluster remains stopped. ` +
+          `Inspect it with 'zeroshot export ${clusterId}' before repairing its persisted state; do not launch a duplicate run.`,
+        details: { reason: 'missing_workflow_history' },
+      };
+    }
+
+    const selection = this._selectAgentsToResume(cluster, lastTrigger);
+    if (selection.eligible.length > 0) {
+      return {
+        kind: 'agents',
+        reason: 'eligible_handlers',
+        agentsToResume: selection.eligible,
+        lastTrigger,
+        durableMessages: this._collectDurableResumeContext(
+          cluster,
+          clusterId,
+          selection.eligible.map(({ message }) => message)
+        ),
+      };
+    }
+
+    const matchingAgentIds = selection.matching.map(({ agent }) => agent.id);
+    if (matchingAgentIds.length > 0) {
+      return {
+        kind: 'failure',
+        error:
+          `Cannot resume cluster ${clusterId}: trigger ${lastTrigger.topic} is registered by ` +
+          `${matchingAgentIds.join(', ')}, but no handler is currently eligible and no interrupted task can be reconstructed. ` +
+          `No agents were started.`,
+        details: {
+          reason: 'registered_handlers_ineligible',
+          trigger: lastTrigger.topic,
+          matchingAgentIds,
+        },
+      };
+    }
+
+    return {
+      kind: 'failure',
+      error:
+        `Cannot resume cluster ${clusterId}: no restored agent registers trigger ${lastTrigger.topic}. ` +
+        `No agents were started; check the persisted agent configuration.`,
+      details: {
+        reason: 'unhandled_trigger',
+        trigger: lastTrigger.topic,
+      },
+    };
+  }
+
+  async _failResumeReconstruction(clusterId, cluster, plan) {
+    cluster.state = 'stopped';
+    cluster.pid = null;
+    cluster.failureInfo = {
+      type: 'resume_reconstruction',
+      error: plan.error,
+      ...plan.details,
+      timestamp: Date.now(),
+    };
+    await this._saveClusters();
+
+    const error = new Error(plan.error);
+    error.code = 'RESUME_RECONSTRUCTION_FAILED';
+    throw error;
+  }
+
+  _clearTransientAgentState(cluster) {
+    for (const agent of cluster.agents) {
+      agent.currentTask = null;
+      agent.currentTaskId = null;
+      agent.processPid = null;
+      agent._currentExecution = null;
+      agent.state = 'idle';
+    }
   }
 
   _resumeAgents(agentsToResume, context) {
@@ -2829,15 +3266,16 @@ class Orchestrator {
     };
   }
 
-  async _resumeCleanCluster(clusterId, cluster, recentMessages, prompt) {
+  async _resumeCleanCluster(clusterId, cluster, recentMessages, prompt, plan) {
     this._log(`[Orchestrator] Resuming stopped cluster ${clusterId} (no failure)`);
 
     const context = this._buildResumeContext(recentMessages, prompt, {
       header: 'Resuming cluster from previous session.',
       topics: ['AGENT_OUTPUT', 'VALIDATION_RESULT', 'ISSUE_OPENED'],
+      durableMessages: plan.durableMessages,
     });
 
-    const lastTrigger = this._findLastWorkflowTrigger(recentMessages);
+    const lastTrigger = plan.lastTrigger;
     if (lastTrigger) {
       this._log(
         `[Orchestrator] Last workflow trigger: ${lastTrigger.topic} (${new Date(lastTrigger.timestamp).toISOString()})`
@@ -2846,31 +3284,16 @@ class Orchestrator {
       this._log(`[Orchestrator] No workflow triggers found in ledger`);
     }
 
-    const agentsToResume = lastTrigger ? this._selectAgentsToResume(cluster, lastTrigger) : [];
-    if (agentsToResume.length === 0) {
-      if (!lastTrigger) {
-        this._log(
-          `[Orchestrator] WARNING: No workflow triggers in ledger. Cluster may not have started properly.`
-        );
-        this._log(`[Orchestrator] Publishing ISSUE_OPENED to bootstrap workflow...`);
-
-        if (!this._republishIssue(cluster, clusterId, recentMessages)) {
-          throw new Error(
-            `Cannot resume cluster ${clusterId}: No workflow triggers found and no ISSUE_OPENED message. ` +
-              `The cluster may not have started properly. Try: zeroshot run <issue> instead.`
-          );
-        }
-      } else {
-        throw new Error(
-          `Cannot resume cluster ${clusterId}: Found trigger ${lastTrigger.topic} but no agents handle it. ` +
-            `Check agent trigger configurations.`
-        );
-      }
+    const agentsToResume = plan.agentsToResume;
+    if (plan.kind === 'bootstrap') {
+      this._log(`[Orchestrator] Publishing ISSUE_OPENED to bootstrap workflow...`);
+      this._republishIssue(cluster, clusterId, [plan.issueMessage]);
     } else {
       this._log(`[Orchestrator] Resuming ${agentsToResume.length} agent(s) based on ledger state`);
       this._resumeAgents(agentsToResume, context);
     }
 
+    cluster.failureInfo = null;
     await this._saveClusters();
     this._log(`[Orchestrator] Cluster ${clusterId} resumed`);
 
@@ -3632,15 +4055,7 @@ Continue from where you left off. Review your previous output to understand what
    * @private
    */
   _isProcessRunning(pid) {
-    if (!pid) return false;
-    try {
-      // Signal 0 doesn't kill, just checks if process exists
-      process.kill(pid, 0);
-      return true;
-    } catch (e) {
-      // ESRCH = No such process, EPERM = process exists but no permission
-      return e.code === 'EPERM';
-    }
+    return isProcessRunning(pid);
   }
 
   /**