@the-open-engine/zeroshot 6.36.0 → 6.38.0

package/lib/start-cluster.js

@@ -326,6 +326,7 @@ function buildStartOptionsFromPlan({
   providerOverride,
   modelOverride,
   forceProvider,
+  preparedWorktree,
   environment,
 }) {
   const targetCwd = environment ? resolveTargetCwd() : options.cwd;
@@ -337,6 +338,7 @@ function buildStartOptionsFromPlan({
       ? firstTruthy(options.dockerImage, process.env.ZEROSHOT_DOCKER_IMAGE)
       : optionalValue(options.dockerImage),
     worktree: plan.isolation === 'worktree',
+    preparedWorktree: preparedWorktree || undefined,
     autoPr: plan.delivery !== 'none',
     autoMerge: plan.autoMerge,
     autoPush: environment ? process.env.ZEROSHOT_PUSH === '1' : options.autoPush === true,
@@ -368,6 +370,7 @@ function buildTrustedStartOptions({
   options = {},
   settings = {},
   providerOverride,
+  modelOverride,
   forceProvider,
 }) {
   if (!plan || !Object.isFrozen(plan)) {
@@ -389,13 +392,18 @@ function buildTrustedStartOptions({
   if (canonical.isolation === 'none') {
     throw new Error('Trusted worker start requires worktree or docker isolation');
   }
+  if (options.preparedWorktree && canonical.isolation !== 'worktree') {
+    throw new Error('Prepared worktree requires canonical worktree isolation');
+  }
   return buildStartOptionsFromPlan({
     clusterId,
     plan: canonical,
     options,
     settings,
     providerOverride,
+    modelOverride,
     forceProvider,
+    preparedWorktree: options.preparedWorktree,
     environment: false,
   });
 }

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@the-open-engine/zeroshot",
-  "version": "6.36.0",
+  "version": "6.38.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@the-open-engine/zeroshot",
-      "version": "6.36.0",
+      "version": "6.38.0",
       "hasInstallScript": true,
       "license": "MIT",
       "dependencies": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@the-open-engine/zeroshot",
-  "version": "6.36.0",
+  "version": "6.38.0",
   "description": "Independent executor–verifier orchestration for software changes.",
   "main": "src/orchestrator.js",
   "bin": {

package/src/agent/agent-lifecycle.js

@@ -17,7 +17,7 @@ const { executeHook } = require('./agent-hook-executor');
 const IsolationManager = require('../isolation-manager');
 const crypto = require('crypto');
 const { bufferMessage, scheduleDrain, drainBufferedMessages } = require('../message-buffer');
-const { isPlatformSupported } = require('./agent-stuck-detector');
+const { createLivenessPoll } = require('./agent-liveness-poll');
 const { normalizeProviderName, getDefaultProviderId } = require('../../lib/provider-names');
 const { loadSettings } = require('../../lib/settings');
 const { findPlatformMismatchReason } = require('./validation-platform');
@@ -223,7 +223,7 @@ async function stop(agent) {
   stopLivenessCheck(agent);
 
   const hasNestedExecutions = agent.nestedExecutions?.hasActive === true;
-  if (!agent.running && !agent.currentTask && !hasNestedExecutions) {
+  if (!agent.running && !agent.currentTask && !hasNestedExecutions && !agent._currentExecution) {
     return;
   }
 
@@ -242,26 +242,26 @@ async function stop(agent) {
       throw new Error(`Task shutdown could not confirm termination: ${termination.reason}`);
     }
   }
-
-  // Wait for in-flight execution to complete (up to 5 seconds)
-  // This prevents write-after-close race conditions
-  if (agent._currentExecution) {
+  const currentExecution = agent._currentExecution;
+  if (currentExecution) {
     let executionTimeout = null;
     try {
-      await Promise.race([
-        agent._currentExecution,
+      const outcome = await Promise.race([
+        Promise.resolve(currentExecution).then(
+          () => 'settled',
+          () => 'settled'
+        ),
         new Promise((resolve) => {
-          executionTimeout = setTimeout(resolve, 5000);
+          executionTimeout = setTimeout(() => resolve('timeout'), 5000);
         }),
       ]);
-    } catch {
-      // Ignore errors from cancelled execution
-    } finally {
-      if (executionTimeout) {
-        clearTimeout(executionTimeout);
+      if (outcome === 'timeout') {
+        throw new Error(`Agent ${agent.id} execution did not settle after task termination`);
       }
-      agent._currentExecution = null;
+    } finally {
+      if (executionTimeout) clearTimeout(executionTimeout);
     }
+    if (agent._currentExecution === currentExecution) agent._currentExecution = null;
   }
 
   agent._log(`Agent ${agent.id} stopped`);
@@ -1268,67 +1268,16 @@ function startLivenessCheck(agent) {
   agent.livenessTerminationAttempts = 0;
   agent.livenessTerminationRetryAt = 0;
 
-  agent.livenessCheckInterval = setInterval(() => {
-    const hasRecoverableTask =
-      Boolean(agent.currentTask) ||
-      Boolean(agent.isolation?.enabled && agent.currentTaskId) ||
-      agent.nestedExecutions?.hasActive === true;
-    if (!hasRecoverableTask || agent.livenessTerminationStarted) {
-      return;
-    }
-
-    const now = Date.now();
-    if (agent.livenessTerminationContext) {
-      if (now >= agent.livenessTerminationRetryAt) {
-        attemptLivenessTermination(agent, settings);
-      }
-      return;
-    }
-
-    const taskStartedAt = agent.taskStartedAt || agent.lastOutputTime || now;
-    const lastOutputTime = agent.lastOutputTime || taskStartedAt;
-    const taskRuntime = now - taskStartedAt;
-    const timeSinceLastOutput = now - lastOutputTime;
-
-    if (configuredTimeout && taskRuntime >= configuredTimeout) {
-      const reason = `Task timed out after ${configuredTimeout}ms`;
-      beginLivenessTermination(agent, settings, reason, 'AGENT_TASK_TIMEOUT', {
-        taskId: agent.currentTaskId,
-        taskRuntime,
-        timeout: configuredTimeout,
-      });
-      return;
-    }
-
-    if (timeSinceLastOutput < staleDuration) {
-      agent.consecutiveStaleWarnings = 0;
-      return;
-    }
-
-    agent.consecutiveStaleWarnings += 1;
-    agent._publishLifecycle('AGENT_STALE_WARNING', {
-      taskId: agent.currentTaskId,
-      timeSinceLastOutput,
-      staleDuration,
-      lastOutputTime,
-      consecutiveWarnings: agent.consecutiveStaleWarnings,
-      warningsBeforeKill,
-      processDiagnosticsAvailable: isPlatformSupported(),
-      analysis: `Provider produced no output for ${timeSinceLastOutput}ms`,
-    });
-
-    if (agent.consecutiveStaleWarnings < warningsBeforeKill) {
-      return;
-    }
-
-    const reason = `Provider produced no output for ${timeSinceLastOutput}ms`;
-    beginLivenessTermination(agent, settings, reason, 'PROVIDER_INACTIVITY_TIMEOUT', {
-      taskId: agent.currentTaskId,
-      timeSinceLastOutput,
-      staleDuration,
-      consecutiveWarnings: agent.consecutiveStaleWarnings,
-    });
-  }, checkIntervalMs);
+  const poll = createLivenessPoll({
+    agent,
+    settings,
+    configuredTimeout,
+    staleDuration,
+    warningsBeforeKill,
+    attemptTermination: attemptLivenessTermination,
+    beginTermination: beginLivenessTermination,
+  });
+  agent.livenessCheckInterval = setInterval(poll, checkIntervalMs);
 }
 
 const MAX_LIVENESS_TERMINATION_ATTEMPTS = 3;

package/src/agent/agent-liveness-poll.js

@@ -0,0 +1,93 @@
+const { isPlatformSupported } = require('./agent-stuck-detector');
+
+function hasRecoverableTask(agent) {
+  return (
+    Boolean(agent.currentTask) ||
+    Boolean(agent.isolation?.enabled && agent.currentTaskId) ||
+    agent.nestedExecutions?.hasActive === true
+  );
+}
+
+function handlePendingTermination(agent, settings, now, attemptTermination) {
+  if (!agent.livenessTerminationContext) return false;
+  if (now >= agent.livenessTerminationRetryAt) attemptTermination(agent, settings);
+  return true;
+}
+
+function taskTiming(agent, now) {
+  const taskStartedAt = agent.taskStartedAt || agent.lastOutputTime || now;
+  const lastOutputTime = agent.lastOutputTime || taskStartedAt;
+  return {
+    taskRuntime: now - taskStartedAt,
+    timeSinceLastOutput: now - lastOutputTime,
+    lastOutputTime,
+  };
+}
+
+function handleTaskTimeout(context, timing) {
+  const { agent, settings, configuredTimeout, beginTermination } = context;
+  if (!configuredTimeout || timing.taskRuntime < configuredTimeout) return false;
+  beginTermination(
+    agent,
+    settings,
+    `Task timed out after ${configuredTimeout}ms`,
+    'AGENT_TASK_TIMEOUT',
+    {
+      taskId: agent.currentTaskId,
+      taskRuntime: timing.taskRuntime,
+      timeout: configuredTimeout,
+    }
+  );
+  return true;
+}
+
+function publishStaleWarning(context, timing) {
+  const { agent, staleDuration, warningsBeforeKill } = context;
+  agent.consecutiveStaleWarnings += 1;
+  agent._publishLifecycle('AGENT_STALE_WARNING', {
+    taskId: agent.currentTaskId,
+    timeSinceLastOutput: timing.timeSinceLastOutput,
+    staleDuration,
+    lastOutputTime: timing.lastOutputTime,
+    consecutiveWarnings: agent.consecutiveStaleWarnings,
+    warningsBeforeKill,
+    processDiagnosticsAvailable: isPlatformSupported(),
+    analysis: `Provider produced no output for ${timing.timeSinceLastOutput}ms`,
+  });
+}
+
+function terminateForInactivity(context, timing) {
+  const { agent, settings, staleDuration, beginTermination } = context;
+  beginTermination(
+    agent,
+    settings,
+    `Provider produced no output for ${timing.timeSinceLastOutput}ms`,
+    'PROVIDER_INACTIVITY_TIMEOUT',
+    {
+      taskId: agent.currentTaskId,
+      timeSinceLastOutput: timing.timeSinceLastOutput,
+      staleDuration,
+      consecutiveWarnings: agent.consecutiveStaleWarnings,
+    }
+  );
+}
+
+function createLivenessPoll(context) {
+  const { agent, settings, staleDuration, warningsBeforeKill, attemptTermination } = context;
+  return () => {
+    if (!hasRecoverableTask(agent) || agent.livenessTerminationStarted) return;
+    const now = Date.now();
+    if (handlePendingTermination(agent, settings, now, attemptTermination)) return;
+    const timing = taskTiming(agent, now);
+    if (handleTaskTimeout(context, timing)) return;
+    if (timing.timeSinceLastOutput < staleDuration) {
+      agent.consecutiveStaleWarnings = 0;
+      return;
+    }
+    publishStaleWarning(context, timing);
+    if (agent.consecutiveStaleWarnings < warningsBeforeKill) return;
+    terminateForInactivity(context, timing);
+  };
+}
+
+module.exports = { createLivenessPoll };

package/src/agent/agent-task-executor.js

@@ -56,6 +56,8 @@ const {
 const { extractClaudeVertexModelError } = require('./output-extraction');
 const {
   extractProviderFailure,
+  extractProviderCompletionFailure,
+  getPiTokenUsage,
   redactTerminalFailureForControlPlane,
 } = require('./provider-terminal-failure');
 const {
@@ -377,7 +379,9 @@ function extractErrorContext({
     }
   }
 
-  const terminalFailure = providerFailure || extractProviderFailure(output, providerName);
+  const terminalFailure =
+    providerFailure ||
+    (providerName === 'pi' ? null : extractProviderFailure(output, providerName));
   if (terminalFailure) {
     return sanitizeErrorMessage(terminalFailure.error);
   }
@@ -449,8 +453,12 @@ function extractErrorContext({
  * @param {string} output - Full NDJSON output from Claude CLI
  * @returns {Object|null} Token usage data or null if not found
  */
-function extractTokenUsage(output, providerName = getDefaultProviderId()) {
+function extractTokenUsage(output, providerName = getDefaultProviderId(), state = null) {
   if (!output) return null;
+  if (providerName === 'pi') {
+    const retainedUsage = getPiTokenUsage(state);
+    if (retainedUsage !== null) return retainedUsage;
+  }
 
   const events = parseProviderChunk(providerName, output);
   const resultEvent = events.find((event) => event.type === 'result');
@@ -1465,21 +1473,38 @@ function lookupLogFilePath(ctPath, taskId) {
 function parseTimestampedLine(line) {
   let timestamp = Date.now();
   let content = line.replace(/\r$/, '');
+  let timestamped = false;
 
   const timestampMatch = content.match(/^\[(\d{13})\](.*)$/);
   if (timestampMatch) {
     timestamp = parseInt(timestampMatch[1], 10);
     content = timestampMatch[2];
+    timestamped = true;
   }
 
-  return { timestamp, content };
+  return { timestamp, content, timestamped };
 }
 
-function shouldSkipLogLine(content) {
+function shouldSkipLogLine(content, providerName, timestamped) {
+  if (providerName === 'pi') {
+    if (
+      content.startsWith('[ZEROSHOT][PROVIDER_STDERR] ') ||
+      content.startsWith('[ZEROSHOT][FATAL] ')
+    ) {
+      return true;
+    }
+    if (timestamped) return false;
+    return (
+      /^={50}$/.test(content) ||
+      /^Finished: \d{4}-\d{2}-\d{2}T[^\s]+Z$/.test(content) ||
+      /^Exit code: (?:null|-?\d+), Signal: (?:null|[A-Z0-9]+)$/.test(content)
+    );
+  }
   return (
     content.startsWith('===') ||
     content.startsWith('Finished:') ||
     content.startsWith('Exit code:') ||
+    content.startsWith('[ZEROSHOT][PROVIDER_STDERR] ') ||
     (content.includes('"type":"system"') && content.includes('"subtype":"init"'))
   );
 }
@@ -1520,8 +1545,8 @@ function broadcastAgentLine({ agent, providerName, state, line }) {
   const followerState = ensureControlPlaneOutputState(state);
   if (!line.trim()) return;
 
-  const { timestamp, content } = parseTimestampedLine(line);
-  if (shouldSkipLogLine(content)) {
+  const { timestamp, content, timestamped } = parseTimestampedLine(line);
+  if (shouldSkipLogLine(content, providerName, timestamped)) {
     return;
   }
   const controlPlaneContent = redactTerminalFailureForControlPlane(
@@ -1764,7 +1789,8 @@ function buildFailureContext({ agent, taskId, providerName, state, stdout, provi
 function resolveCompletionFailure({ classified, agent, taskId, providerName, state, stdout }) {
   if (classified.success) return { providerFailure: null, errorContext: classified.error };
   const providerFailure =
-    state.providerFailure || extractProviderFailure(state.output, providerName);
+    state.providerFailure ||
+    (providerName === 'pi' ? null : extractProviderFailure(state.output, providerName));
   return {
     providerFailure,
     errorContext:
@@ -1774,6 +1800,14 @@ function resolveCompletionFailure({ classified, agent, taskId, providerName, sta
   };
 }
 
+function enforceProviderCompletionTruth({ providerName, output, state, success, error }) {
+  if (providerName !== 'pi' || !success) return { success, error };
+  const failure = extractProviderCompletionFailure(output, providerName, state);
+  if (!failure) return { success, error };
+  state.providerFailure = failure;
+  return { success: false, error: failure.error };
+}
+
 async function buildCompletionResult({
   agent,
   taskId,
@@ -1784,7 +1818,7 @@ async function buildCompletionResult({
   taskInfo = getTask(taskId),
 }) {
   const { isCompleted } = parseStatusFlags(stripAnsiCodes(stdout));
-  const classified = state.skipStructuredResultCheck
+  let classified = state.skipStructuredResultCheck
     ? { success, error: null }
     : await evaluateStructuredSuccess({
         agent,
@@ -1793,6 +1827,12 @@ async function buildCompletionResult({
         success,
         allowRecovery: isCompleted,
       });
+  classified = enforceProviderCompletionTruth({
+    providerName,
+    output: state.output,
+    state,
+    ...classified,
+  });
   const resumeIdentityError = classified.success ? validateCompletedResumeIdentity(taskInfo) : null;
   if (resumeIdentityError) {
     classified.success = false;
@@ -1823,7 +1863,7 @@ async function buildCompletionResult({
     // so downstream hooks and {{result.*}} substitution never re-parse.
     parsedResult: state._cachedParsedResult || null,
     error: errorContext,
-    tokenUsage: extractTokenUsage(state.output, providerName),
+    tokenUsage: extractTokenUsage(state.output, providerName, state),
     providerSession: providerSessionFromCompletedTask({
       agent,
       providerName,
@@ -1866,6 +1906,19 @@ function finalizeLogFollow(agent, state) {
   }
 }
 
+function finishHostLogCapture(agent, state, pollLogFile, processNewContent, broadcastLine) {
+  // A task status can become terminal before the watcher has flushed its final
+  // filesystem write (observed on Modal). Stop the timers first, then take one
+  // authoritative catch-up read and finish any final UTF-8/non-newline record.
+  finalizeLogFollow(agent, state);
+  pollLogFile();
+  const decoderTail = state.logDecoder.end();
+  if (decoderTail) processNewContent(decoderTail);
+  if (state.lineBuffer.byteLength > 0) {
+    completeLogRecord(state.lineBuffer, broadcastLine, true);
+  }
+}
+
 function settleHostStatusFailure({ agent, providerName, state, resolve, text, data, error }) {
   if (state.resolved) return;
   state.resolved = true;
@@ -1986,6 +2039,7 @@ function handleStatusCompletion({
   state,
   stdout,
   pollLogFile,
+  finishLogCapture,
   resolve,
   reject,
 }) {
@@ -2012,7 +2066,7 @@ function handleStatusCompletion({
     if (state.resolved) return;
     state.resolved = true;
 
-    finalizeLogFollow(agent, state);
+    finishLogCapture();
     flushAgentOutput(agent, providerName, state);
 
     buildCompletionResult({
@@ -2046,7 +2100,7 @@ function buildKillHandler({ agent, taskId, state, providerName, resolve }) {
         error: reason,
         code: details.code || null,
         taskId,
-        tokenUsage: extractTokenUsage(state.output, providerName),
+        tokenUsage: extractTokenUsage(state.output, providerName, state),
       });
     },
   };
@@ -2066,14 +2120,12 @@ function createLogFollower({
     const state = createLogFollowState();
     state.skipStructuredResultCheck = skipStructuredResultCheck;
     state.nested = nested;
-
     state.logFilePath = lookupLogFilePath(ctPath, taskId);
     if (state.logFilePath) {
       agent._log(`📋 Agent ${agent.id}: Following ct logs for ${taskId}`);
     } else {
       agent._log(`⏳ Agent ${agent.id}: Waiting for log file...`);
     }
-
     const broadcastLine = (line) => broadcastAgentLine({ agent, providerName, state, line });
     const processNewContent = (content) => appendContentToBuffer(state, content, broadcastLine);
     const pollLogFile = () =>
@@ -2085,6 +2137,8 @@ function createLogFollower({
         state,
         onNewContent: processNewContent,
       });
+    const finishLogCapture = () =>
+      finishHostLogCapture(agent, state, pollLogFile, processNewContent, broadcastLine);
 
     state.pollInterval = setInterval(pollLogFile, 300);
 
@@ -2120,6 +2174,7 @@ function createLogFollower({
             state,
             stdout,
             pollLogFile,
+            finishLogCapture,
             resolve,
             reject,
           });
@@ -2719,6 +2774,7 @@ async function captureIsolatedFinalOutputTail(
     ]);
     if (finalReadResult.code === 0 && finalReadResult.stdout) {
       if (missingBytes > readBytes) {
+        if (providerName === 'pi') state.piProtocolPrefixOmitted = true;
         resetControlPlaneTail(state.controlPlaneOutput, { prefixOmitted: true });
         state.lineBuffer = createLogRecordBuffer();
       }
@@ -2745,19 +2801,21 @@ function resolveIsolatedFailure({
   providerName,
   state,
   status,
+  statusOutput,
   isNotFound,
   clusterId,
   logFilePath,
 }) {
   if (success) return { providerFailure: null, errorContext: structuredError };
   const providerFailure =
-    state.providerFailure || extractProviderFailure(state.fullOutput, providerName);
+    state.providerFailure ||
+    (providerName === 'pi' ? null : extractProviderFailure(state.fullOutput, providerName));
   const errorContext =
     providerFailure?.error ||
     structuredError ||
     extractErrorContext({
       output: state.fullOutput,
-      statusOutput: status ? `Status: ${status}` : '',
+      statusOutput: statusOutput || (status ? `Status: ${status}` : ''),
       taskId,
       isNotFound,
       providerName,
@@ -2782,6 +2840,7 @@ function settleIsolatedTerminalStatus({
   taskId,
   providerName,
   status,
+  statusOutput = '',
   isNotFound = false,
   state,
   cleanup,
@@ -2790,7 +2849,6 @@ function settleIsolatedTerminalStatus({
 }) {
   if (state.resolved) return Promise.resolve();
   if (state.terminalSettlementPromise) return state.terminalSettlementPromise;
-
   state.taskExited = true;
   if (status) {
     state.durableTaskTerminal = true;
@@ -2827,6 +2885,15 @@ function settleIsolatedTerminalStatus({
       success = evaluated.success;
       structuredError = evaluated.error;
     }
+    const completionTruth = enforceProviderCompletionTruth({
+      providerName,
+      output: state.fullOutput,
+      state,
+      success,
+      error: structuredError,
+    });
+    success = completionTruth.success;
+    structuredError = completionTruth.error;
     const { providerFailure, errorContext } = resolveIsolatedFailure({
       success,
       structuredError,
@@ -2835,6 +2902,7 @@ function settleIsolatedTerminalStatus({
       providerName,
       state,
       status,
+      statusOutput,
       isNotFound,
       clusterId,
       logFilePath,
@@ -2845,7 +2913,6 @@ function settleIsolatedTerminalStatus({
         ? state._cachedParsedResult
         : await agent._parseResultOutput(state.fullOutput);
     }
-
     settleIsolatedFollower({
       agent,
       state,
@@ -2857,7 +2924,7 @@ function settleIsolatedTerminalStatus({
         taskId,
         parsedResult,
         error: errorContext,
-        tokenUsage: extractTokenUsage(state.fullOutput, providerName),
+        tokenUsage: extractTokenUsage(state.fullOutput, providerName, state),
         providerFailure,
         vertexModelError,
       },
@@ -2893,7 +2960,7 @@ function buildIsolatedLifecycleHandle({
         error: reason,
         code: details.code || null,
         taskId,
-        tokenUsage: extractTokenUsage(state.fullOutput, providerName),
+        tokenUsage: extractTokenUsage(state.fullOutput, providerName, state),
       },
     });
   };
@@ -2956,10 +3023,14 @@ function buildIsolatedLifecycleHandle({
 }
 
 function parseIsolatedLogLine(line) {
-  const timestampMatch = line.match(/^\[(\d{4}-\d{2}-\d{2}T[^\]]+)\]\s*(.*)$/);
-  const timestamp = timestampMatch ? new Date(timestampMatch[1]).getTime() : Date.now();
+  const timestampMatch = line.match(/^\[(\d{13}|\d{4}-\d{2}-\d{2}T[^\]]+)\]\s*(.*)$/);
+  const timestamp = timestampMatch
+    ? /^\d{13}$/.test(timestampMatch[1])
+      ? Number.parseInt(timestampMatch[1], 10)
+      : new Date(timestampMatch[1]).getTime()
+    : Date.now();
   const content = timestampMatch ? timestampMatch[2] : line;
-  return { timestamp, content };
+  return { timestamp, content, timestamped: timestampMatch !== null };
 }
 
 function publishIsolatedOutputRecord(agent, providerName, taskId, record) {
@@ -2981,7 +3052,8 @@ function publishIsolatedOutputRecord(agent, providerName, taskId, record) {
 }
 
 function retainIsolatedLine(state, providerName, line) {
-  const { timestamp, content } = parseIsolatedLogLine(line);
+  const { timestamp, content, timestamped } = parseIsolatedLogLine(line);
+  if (!content.trim() || shouldSkipLogLine(content, providerName, timestamped)) return null;
   const controlPlaneContent = redactTerminalFailureForControlPlane(state, providerName, content);
   return appendControlPlaneRecord(state.controlPlaneOutput, {
     content: controlPlaneContent,
@@ -2993,6 +3065,7 @@ function retainIsolatedLine(state, providerName, line) {
 function broadcastIsolatedLine({ agent, providerName, taskId, state, line }) {
   const followerState = ensureControlPlaneOutputState(state);
   const record = retainIsolatedLine(followerState, providerName, line);
+  if (record === null) return;
   publishLiveControlPlaneRecord(followerState.controlPlaneOutput, record, (item) =>
     publishIsolatedOutputRecord(agent, providerName, taskId, item)
   );
@@ -3119,6 +3192,7 @@ async function checkIsolatedStatus({
     taskId,
     providerName,
     status,
+    statusOutput,
     isNotFound,
     state,
     cleanup,
@@ -3546,6 +3620,7 @@ module.exports = {
   consumeIsolatedTailChunk,
   flushAgentOutput,
   flushIsolatedOutput,
+  finishHostLogCapture,
   CONTROL_PLANE_OUTPUT_LIMITS: Object.freeze({
     maxBytes: MAX_CONTROL_PLANE_OUTPUT_BYTES,
     maxRecords: MAX_CONTROL_PLANE_OUTPUT_RECORDS,