@the-open-engine/zeroshot 6.34.0 → 6.34.2

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

@@ -11,8 +11,10 @@
  */
 
 const { spawn, spawnSync } = require('child_process');
+const { createHash } = require('crypto');
 const path = require('path');
 const fs = require('fs');
+const { StringDecoder } = require('string_decoder');
 const { getNestedExecutionRegistry, TaskExecutionHandle } = require('./task-execution-handle');
 const os = require('os');
 const { parseProviderChunk, getProvider } = require('../providers');
@@ -57,6 +59,13 @@ const {
   isStructuredOutputInvalidError,
 } = require('./structured-output-error');
 const TASK_TERMINAL_STATUSES = new Set(['completed', 'failed', 'killed', 'stale']);
+const MAX_CONTROL_PLANE_RECORD_BYTES = 1024 * 1024;
+const MAX_CONTROL_PLANE_OUTPUT_BYTES = 2 * 1024 * 1024;
+const MAX_CONTROL_PLANE_OUTPUT_RECORDS = 1024;
+const MAX_LIVE_OUTPUT_BYTES = 512 * 1024;
+const MAX_LIVE_OUTPUT_RECORDS = 512;
+const CONTROL_PLANE_OMISSION_MARKER_BYTES = 1024;
+const LOG_READ_CHUNK_BYTES = 64 * 1024;
 function runCommandWithTimeout(command, args, options = {}, callback = null) {
   const timeout = options.timeout ?? 30000;
   if (timeout <= 0) {
@@ -1218,16 +1227,194 @@ async function waitForTaskReady(agent, taskId, maxRetries = 10, delayMs = 200) {
 const MAX_STATUS_FAILURES = 30;
 
 function createLogFollowState() {
-  return {
-    output: '',
+  const state = {
+    controlPlaneOutput: createControlPlaneOutputState(),
     logFilePath: null,
     lastSize: 0,
     pollInterval: null,
     statusCheckInterval: null,
     resolved: false,
-    lineBuffer: '',
+    lineBuffer: createLogRecordBuffer(),
+    logDecoder: new StringDecoder('utf8'),
     consecutiveExecFailures: 0,
   };
+  defineControlPlaneOutputAccessor(state, 'output');
+  return state;
+}
+
+function createControlPlaneOutputState(options = {}) {
+  const maxBytes = options.maxBytes || MAX_CONTROL_PLANE_OUTPUT_BYTES;
+  const maxRecords = options.maxRecords || MAX_CONTROL_PLANE_OUTPUT_RECORDS;
+  const liveByteLimit = options.liveByteLimit || MAX_LIVE_OUTPUT_BYTES;
+  const liveRecordLimit = options.liveRecordLimit || MAX_LIVE_OUTPUT_RECORDS;
+  if (maxBytes <= CONTROL_PLANE_OMISSION_MARKER_BYTES || maxRecords < 1) {
+    throw new Error('Control-plane output bounds must retain space for at least one record');
+  }
+  return {
+    records: [],
+    head: 0,
+    byteLength: 0,
+    maxBytes,
+    maxRecords,
+    liveByteLimit,
+    liveRecordLimit,
+    liveBytes: 0,
+    liveRecords: 0,
+    nextSequence: 0,
+    lastLiveSequence: -1,
+    liveSuppressed: false,
+    terminalFlushed: false,
+    omittedBytes: 0,
+    omittedRecords: 0,
+    omittedDigest: createHash('sha256'),
+    prefixOmitted: false,
+  };
+}
+
+function defineControlPlaneOutputAccessor(state, property) {
+  Object.defineProperty(state, property, {
+    configurable: true,
+    enumerable: true,
+    get: () => snapshotControlPlaneOutput(state.controlPlaneOutput),
+  });
+}
+
+function ensureControlPlaneOutputState(state = {}) {
+  if (state.controlPlaneOutput) return state;
+  let existingOutput = '';
+  if (typeof state.output === 'string') {
+    existingOutput = state.output;
+  } else if (typeof state.fullOutput === 'string') {
+    existingOutput = state.fullOutput;
+  }
+  state.controlPlaneOutput = createControlPlaneOutputState();
+  if (Object.hasOwn(state, 'output')) delete state.output;
+  if (Object.hasOwn(state, 'fullOutput')) delete state.fullOutput;
+  defineControlPlaneOutputAccessor(state, 'output');
+  if (existingOutput) {
+    replayCompleteLogContent(existingOutput, (content) =>
+      appendControlPlaneRecord(state.controlPlaneOutput, {
+        content,
+        timestamp: Date.now(),
+        type: isValidJsonLine(content) ? 'json' : 'text',
+      })
+    );
+  }
+  return state;
+}
+
+function retainedControlPlaneRecords(outputState) {
+  return outputState.records.slice(outputState.head);
+}
+
+function compactControlPlaneRecords(outputState) {
+  if (outputState.head >= 64 && outputState.head * 2 >= outputState.records.length) {
+    outputState.records = outputState.records.slice(outputState.head);
+    outputState.head = 0;
+  }
+}
+
+function omitOldestControlPlaneRecord(outputState) {
+  const record = outputState.records[outputState.head++];
+  outputState.byteLength -= record.byteLength;
+  outputState.omittedBytes += record.byteLength;
+  outputState.omittedRecords++;
+  outputState.omittedDigest.update(record.text);
+  compactControlPlaneRecords(outputState);
+}
+
+function appendControlPlaneRecord(outputState, { content, timestamp, type }) {
+  const text = `${content}\n`;
+  const record = {
+    sequence: outputState.nextSequence++,
+    content,
+    timestamp,
+    type,
+    text,
+    byteLength: Buffer.byteLength(text),
+  };
+  outputState.records.push(record);
+  outputState.byteLength += record.byteLength;
+
+  const payloadLimit = outputState.maxBytes - CONTROL_PLANE_OMISSION_MARKER_BYTES;
+  while (
+    outputState.byteLength > payloadLimit ||
+    outputState.records.length - outputState.head > outputState.maxRecords
+  ) {
+    omitOldestControlPlaneRecord(outputState);
+  }
+  return record;
+}
+
+function controlPlaneOmissionRecord(outputState) {
+  if (!outputState.prefixOmitted && outputState.omittedRecords === 0) return null;
+  const digest = outputState.omittedRecords
+    ? `, sha256=${outputState.omittedDigest.copy().digest('hex')}`
+    : '';
+  const known = outputState.omittedRecords
+    ? `records=${outputState.omittedRecords}, byte_length=${outputState.omittedBytes}${digest}`
+    : 'byte_length=unknown';
+  const content =
+    `[ZEROSHOT] Earlier provider output omitted from the bounded control-plane tail (${known}). ` +
+    'Complete output remains in the task log.';
+  return {
+    content,
+    timestamp: Date.now(),
+    type: 'text',
+    text: `${content}\n`,
+    byteLength: Buffer.byteLength(`${content}\n`),
+  };
+}
+
+function snapshotControlPlaneOutput(outputState) {
+  const omission = controlPlaneOmissionRecord(outputState);
+  const records = retainedControlPlaneRecords(outputState);
+  return `${omission ? omission.text : ''}${records.map((record) => record.text).join('')}`;
+}
+
+function resetControlPlaneTail(outputState, { prefixOmitted = false } = {}) {
+  outputState.records = [];
+  outputState.head = 0;
+  outputState.byteLength = 0;
+  outputState.omittedBytes = 0;
+  outputState.omittedRecords = 0;
+  outputState.omittedDigest = createHash('sha256');
+  outputState.prefixOmitted = prefixOmitted;
+}
+
+function publishLiveControlPlaneRecord(outputState, record, publish) {
+  if (
+    outputState.liveSuppressed ||
+    outputState.liveBytes + record.byteLength > outputState.liveByteLimit ||
+    outputState.liveRecords + 1 > outputState.liveRecordLimit
+  ) {
+    outputState.liveSuppressed = true;
+    return;
+  }
+  publish(record);
+  outputState.liveBytes += record.byteLength;
+  outputState.liveRecords++;
+  outputState.lastLiveSequence = record.sequence;
+}
+
+function flushTerminalControlPlaneOutput(outputState, publish) {
+  if (outputState.terminalFlushed) return;
+  outputState.terminalFlushed = true;
+  if (outputState.liveSuppressed) {
+    const omission = controlPlaneOmissionRecord(outputState);
+    if (omission) publish(omission);
+  }
+  for (const record of retainedControlPlaneRecords(outputState)) {
+    if (record.sequence > outputState.lastLiveSequence) publish(record);
+  }
+}
+
+function createLogRecordBuffer() {
+  return {
+    byteLength: 0,
+    fragments: [],
+    oversized: null,
+  };
 }
 
 function lookupLogFilePath(ctPath, taskId) {
@@ -1276,31 +1463,16 @@ function isValidJsonLine(content) {
   }
 }
 
-function broadcastAgentLine({ agent, providerName, state, line }) {
-  if (!line.trim()) return;
-
-  const { timestamp, content } = parseTimestampedLine(line);
-  if (shouldSkipLogLine(content)) {
-    return;
-  }
-
-  const isValidJson = isValidJsonLine(content);
-  state.output += content + '\n';
-
-  if (!state.nested) {
-    agent.lastOutputTime = Date.now();
-  }
-
+function publishAgentOutputRecord(agent, providerName, record) {
   agent._publish({
     topic: 'AGENT_OUTPUT',
     receiver: 'broadcast',
     metadata: buildRawLogOnlyMetadata(),
-    timestamp,
+    timestamp: record.timestamp,
     content: {
-      text: content,
       data: {
-        type: isValidJson ? 'json' : 'text',
-        line: content,
+        type: record.type,
+        line: record.content,
         agent: agent.id,
         role: agent.role,
         iteration: agent.iteration,
@@ -1310,15 +1482,114 @@ function broadcastAgentLine({ agent, providerName, state, line }) {
   });
 }
 
-function appendContentToBuffer(state, content, onLine) {
-  state.lineBuffer += content;
-  const lines = state.lineBuffer.split('\n');
+function broadcastAgentLine({ agent, providerName, state, line }) {
+  const followerState = ensureControlPlaneOutputState(state);
+  if (!line.trim()) return;
+
+  const { timestamp, content } = parseTimestampedLine(line);
+  if (shouldSkipLogLine(content)) {
+    return;
+  }
+
+  const isValidJson = isValidJsonLine(content);
+  const record = appendControlPlaneRecord(followerState.controlPlaneOutput, {
+    content,
+    timestamp,
+    type: isValidJson ? 'json' : 'text',
+  });
+
+  if (!followerState.nested) {
+    agent.lastOutputTime = Date.now();
+  }
+
+  publishLiveControlPlaneRecord(followerState.controlPlaneOutput, record, (item) =>
+    publishAgentOutputRecord(agent, providerName, item)
+  );
+}
+
+function flushAgentOutput(agent, providerName, state) {
+  const followerState = ensureControlPlaneOutputState(state);
+  flushTerminalControlPlaneOutput(followerState.controlPlaneOutput, (record) =>
+    publishAgentOutputRecord(agent, providerName, record)
+  );
+}
+
+function appendLogRecordFragment(buffer, fragment) {
+  const fragmentBytes = Buffer.byteLength(fragment);
+  buffer.byteLength += fragmentBytes;
+  if (buffer.oversized) {
+    buffer.oversized.digest.update(fragment);
+    return;
+  }
+  if (buffer.byteLength <= MAX_CONTROL_PLANE_RECORD_BYTES) {
+    buffer.fragments.push(fragment);
+    return;
+  }
+
+  const retainedPrefix = buffer.fragments.join('');
+  const prefixProbe = `${retainedPrefix}${fragment.slice(0, Math.max(0, 32 - retainedPrefix.length))}`;
+  const timestampPrefix = prefixProbe.match(/^\[\d{13}\]/)?.[0] || '';
+  const digest = createHash('sha256');
+  for (const retained of buffer.fragments) digest.update(retained);
+  digest.update(fragment);
+  buffer.fragments = [];
+  buffer.oversized = { digest, timestampPrefix };
+}
+
+function completeLogRecord(buffer, onLine, skipEmpty = false) {
+  let line;
+  if (buffer.oversized) {
+    const digest = buffer.oversized.digest.digest('hex');
+    line =
+      `${buffer.oversized.timestampPrefix}[ZEROSHOT] Provider output record retained in task log ` +
+      `but omitted from the control plane (byte_length=${buffer.byteLength}, sha256=${digest})`;
+  } else {
+    line = buffer.fragments.join('');
+  }
+  buffer.byteLength = 0;
+  buffer.fragments = [];
+  buffer.oversized = null;
+  if (!skipEmpty || line.trim()) onLine(line);
+}
+
+function appendContentToBuffer(state, content, onLine, skipEmpty = false) {
+  let offset = 0;
+  while (offset < content.length) {
+    const newline = content.indexOf('\n', offset);
+    if (newline === -1) {
+      appendLogRecordFragment(state.lineBuffer, content.slice(offset));
+      return;
+    }
+    appendLogRecordFragment(state.lineBuffer, content.slice(offset, newline));
+    completeLogRecord(state.lineBuffer, onLine, skipEmpty);
+    offset = newline + 1;
+  }
+}
 
-  for (let i = 0; i < lines.length - 1; i++) {
-    onLine(lines[i]);
+function replayCompleteLogContent(content, onLine) {
+  const replayState = { lineBuffer: createLogRecordBuffer() };
+  appendContentToBuffer(replayState, content, onLine, true);
+  if (replayState.lineBuffer.byteLength > 0) {
+    completeLogRecord(replayState.lineBuffer, onLine, true);
   }
+}
 
-  state.lineBuffer = lines[lines.length - 1];
+function readLogFileDelta({ fsModule, logFilePath, state, currentSize, onNewContent }) {
+  const fd = fsModule.openSync(logFilePath, 'r');
+  try {
+    let offset = state.lastSize;
+    const buffer = Buffer.allocUnsafe(LOG_READ_CHUNK_BYTES);
+    while (offset < currentSize) {
+      const requested = Math.min(buffer.length, currentSize - offset);
+      const bytesRead = fsModule.readSync(fd, buffer, 0, requested, offset);
+      if (bytesRead === 0) break;
+      onNewContent(state.logDecoder.write(buffer.subarray(0, bytesRead)));
+      offset += bytesRead;
+    }
+    state.lastSize = offset;
+  } finally {
+    fsModule.closeSync(fd);
+  }
 }
 
 function pollLogFileForUpdates({ agent, fsModule, ctPath, taskId, state, onNewContent }) {
@@ -1340,13 +1611,13 @@ function pollLogFileForUpdates({ agent, fsModule, ctPath, taskId, state, onNewCo
     const currentSize = stats.size;
 
     if (currentSize > state.lastSize) {
-      const fd = fsModule.openSync(state.logFilePath, 'r');
-      const buffer = Buffer.alloc(currentSize - state.lastSize);
-      fsModule.readSync(fd, buffer, 0, buffer.length, state.lastSize);
-      fsModule.closeSync(fd);
-
-      onNewContent(buffer.toString('utf-8'));
-      state.lastSize = currentSize;
+      readLogFileDelta({
+        fsModule,
+        logFilePath: state.logFilePath,
+        state,
+        currentSize,
+        onNewContent,
+      });
     }
   } catch (err) {
     const error = /** @type {Error} */ (err);
@@ -1536,7 +1807,29 @@ function finalizeLogFollow(agent, state) {
   }
 }
 
-function handleStatusExecError({ agent, state, ctPath, taskId, error, stderr, resolve }) {
+function settleHostStatusFailure({ agent, providerName, state, resolve, text, data, error }) {
+  if (state.resolved) return;
+  state.resolved = true;
+  finalizeLogFollow(agent, state);
+  flushAgentOutput(agent, providerName, state);
+  agent._publish({
+    topic: 'AGENT_ERROR',
+    receiver: 'broadcast',
+    content: { text, data },
+  });
+  resolve({ success: false, output: state.output, error });
+}
+
+function handleStatusExecError({
+  agent,
+  providerName,
+  state,
+  ctPath,
+  taskId,
+  error,
+  stderr,
+  resolve,
+}) {
   if (!error) {
     return false;
   }
@@ -1561,30 +1854,20 @@ function handleStatusExecError({ agent, state, ctPath, taskId, error, stderr, re
       `[Agent ${agent.id}] ⚠️ Task ${taskId} not found - will restart to ensure completion`
     );
 
-    if (!state.resolved) {
-      state.resolved = true;
-      finalizeLogFollow(agent, state);
-
-      agent._publish({
-        topic: 'AGENT_ERROR',
-        receiver: 'broadcast',
-        content: {
-          text: `Task ${taskId} not found - restarting for safety`,
-          data: {
-            taskId,
-            error: 'task_not_found',
-            role: agent.role,
-            iteration: agent.iteration,
-          },
-        },
-      });
-
-      resolve({
-        success: false,
-        output: state.output,
-        error: `Task not found - restarting for safety`,
-      });
-    }
+    settleHostStatusFailure({
+      agent,
+      providerName,
+      state,
+      resolve,
+      text: `Task ${taskId} not found - restarting for safety`,
+      data: {
+        taskId,
+        error: 'task_not_found',
+        role: agent.role,
+        iteration: agent.iteration,
+      },
+      error: 'Task not found - restarting for safety',
+    });
 
     return true;
   }
@@ -1602,31 +1885,21 @@ function handleStatusExecError({ agent, state, ctPath, taskId, error, stderr, re
   console.error(`  Stderr: ${stderr || 'none'}`);
   console.error(`  This may indicate zeroshot is not in PATH or task storage is corrupted.`);
 
-  if (!state.resolved) {
-    state.resolved = true;
-    finalizeLogFollow(agent, state);
-
-    agent._publish({
-      topic: 'AGENT_ERROR',
-      receiver: 'broadcast',
-      content: {
-        text: `Task ${taskId} polling failed after ${MAX_STATUS_FAILURES} consecutive failures`,
-        data: {
-          taskId,
-          error: 'polling_timeout',
-          attempts: state.consecutiveExecFailures,
-          role: agent.role,
-          iteration: agent.iteration,
-        },
-      },
-    });
-
-    resolve({
-      success: false,
-      output: state.output,
-      error: `Status polling failed ${MAX_STATUS_FAILURES} times - task may not exist`,
-    });
-  }
+  settleHostStatusFailure({
+    agent,
+    providerName,
+    state,
+    resolve,
+    text: `Task ${taskId} polling failed after ${MAX_STATUS_FAILURES} consecutive failures`,
+    data: {
+      taskId,
+      error: 'polling_timeout',
+      attempts: state.consecutiveExecFailures,
+      role: agent.role,
+      iteration: agent.iteration,
+    },
+    error: `Status polling failed ${MAX_STATUS_FAILURES} times - task may not exist`,
+  });
 
   return true;
 }
@@ -1681,6 +1954,7 @@ function handleStatusCompletion({
     state.resolved = true;
 
     finalizeLogFollow(agent, state);
+    flushAgentOutput(agent, providerName, state);
 
     buildCompletionResult({
       agent,
@@ -1703,6 +1977,7 @@ function buildKillHandler({ agent, taskId, state, providerName, resolve }) {
       if (state.resolved) return;
       state.resolved = true;
       finalizeLogFollow(agent, state);
+      flushAgentOutput(agent, providerName, state);
       if (!state.nested) {
         agent._stopLivenessCheck();
       }
@@ -1762,7 +2037,18 @@ function createLogFollower({
         (error, stdout, stderr) => {
           if (state.resolved) return;
 
-          if (handleStatusExecError({ agent, state, ctPath, taskId, error, stderr, resolve })) {
+          if (
+            handleStatusExecError({
+              agent,
+              providerName,
+              state,
+              ctPath,
+              taskId,
+              error,
+              stderr,
+              resolve,
+            })
+          ) {
             return;
           }
 
@@ -2203,7 +2489,7 @@ async function spawnClaudeTaskIsolatedExecution(agent, context, options = {}) {
  * - Result: 10-20% overall latency reduction
  */
 function createIsolatedLogState(skipStructuredResultCheck = false, nested = false) {
-  return {
+  const state = {
     taskExited: false,
     resolved: false,
     terminationPromise: null,
@@ -2211,14 +2497,20 @@ function createIsolatedLogState(skipStructuredResultCheck = false, nested = fals
     durableTaskStatus: null,
     lifecycleHandle: null,
     logFilePath: null,
-    fullOutput: '',
+    controlPlaneOutput: createControlPlaneOutputState(),
     tailProcess: null,
+    rawBytesSeen: 0,
+    ignoreTailOutput: false,
     statusCheckInterval: null,
     timeoutTimer: null,
-    lineBuffer: '',
+    lineBuffer: createLogRecordBuffer(),
+    tailDecoder: new StringDecoder('utf8'),
     skipStructuredResultCheck,
     nested,
   };
+  defineControlPlaneOutputAccessor(state, 'output');
+  defineControlPlaneOutputAccessor(state, 'fullOutput');
+  return state;
 }
 
 function buildIsolatedCleanup(state) {
@@ -2341,6 +2633,41 @@ async function resolveIsolatedLogFilePath(manager, clusterId, taskId, state) {
   return state.logFilePath;
 }
 
+async function captureIsolatedFinalOutputTail(manager, clusterId, logFilePath, state) {
+  stopIsolatedTailForSettlement(state);
+  const sizeResult = await manager.execInContainer(clusterId, [
+    'sh',
+    '-c',
+    `wc -c < "${logFilePath}" 2>/dev/null || echo 0`,
+  ]);
+  const fileSize = Number.parseInt(sizeResult.stdout.trim(), 10);
+  const missingBytes = Number.isSafeInteger(fileSize)
+    ? Math.max(0, fileSize - state.rawBytesSeen)
+    : 0;
+
+  if (missingBytes > 0) {
+    const readBytes = Math.min(missingBytes, MAX_CONTROL_PLANE_OUTPUT_BYTES);
+    const finalReadResult = await manager.execInContainer(clusterId, [
+      'sh',
+      '-c',
+      `tail -c ${readBytes} "${logFilePath}" 2>/dev/null || echo ""`,
+    ]);
+    if (finalReadResult.code === 0 && finalReadResult.stdout) {
+      if (missingBytes > readBytes) {
+        resetControlPlaneTail(state.controlPlaneOutput, { prefixOmitted: true });
+        state.lineBuffer = createLogRecordBuffer();
+      }
+      appendIsolatedContent(state, finalReadResult.stdout, (line) =>
+        retainIsolatedLine(state, line)
+      );
+    }
+  }
+
+  if (state.lineBuffer.byteLength > 0) {
+    completeLogRecord(state.lineBuffer, (line) => retainIsolatedLine(state, line), true);
+  }
+}
+
 function settleIsolatedTerminalStatus({
   agent,
   manager,
@@ -2353,7 +2680,6 @@ function settleIsolatedTerminalStatus({
   cleanup,
   resolve,
   reject,
-  onLine,
 }) {
   if (state.resolved) return Promise.resolve();
   if (state.terminalSettlementPromise) return state.terminalSettlementPromise;
@@ -2367,19 +2693,9 @@ function settleIsolatedTerminalStatus({
     const logFilePath = await resolveIsolatedLogFilePath(manager, clusterId, taskId, state);
     await new Promise((settle) => setTimeout(settle, 200));
     if (state.resolved) return;
-    const finalReadResult = await manager.execInContainer(clusterId, [
-      'sh',
-      '-c',
-      `cat "${logFilePath}" 2>/dev/null || echo ""`,
-    ]);
+    await captureIsolatedFinalOutputTail(manager, clusterId, logFilePath, state);
     if (state.resolved) return;
-
-    if (finalReadResult.code === 0 && finalReadResult.stdout) {
-      state.fullOutput = finalReadResult.stdout;
-      for (const line of state.fullOutput.split('\n')) {
-        if (line.trim()) onLine(line);
-      }
-    }
+    flushIsolatedOutput(agent, providerName, taskId, state);
 
     const vertexModelError =
       providerName === 'claude'
@@ -2463,9 +2779,9 @@ function buildIsolatedLifecycleHandle({
   cleanup,
   resolve,
   reject,
-  onLine,
 }) {
-  const settleCancellation = (reason, details) =>
+  const settleCancellation = (reason, details) => {
+    flushIsolatedOutput(agent, providerName, taskId, state);
     settleIsolatedFollower({
       agent,
       state,
@@ -2480,6 +2796,7 @@ function buildIsolatedLifecycleHandle({
         tokenUsage: extractTokenUsage(state.fullOutput, providerName),
       },
     });
+  };
   const terminate = (reason = 'Task killed', details = {}) => {
     if (state.durableTaskTerminal) {
       if (state.nested) settleCancellation(reason, details);
@@ -2511,7 +2828,6 @@ function buildIsolatedLifecycleHandle({
           cleanup,
           resolve,
           reject,
-          onLine,
         });
         return termination;
       }
@@ -2539,11 +2855,14 @@ function buildIsolatedLifecycleHandle({
   };
 }
 
-function broadcastIsolatedLine({ agent, providerName, taskId, state, line }) {
+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 content = timestampMatch ? timestampMatch[2] : line;
+  return { timestamp, content };
+}
 
+function publishIsolatedOutputRecord(agent, providerName, taskId, record) {
   agent.messageBus.publish({
     cluster_id: agent.cluster.id,
     topic: 'AGENT_OUTPUT',
@@ -2551,31 +2870,64 @@ function broadcastIsolatedLine({ agent, providerName, taskId, state, line }) {
     metadata: buildRawLogOnlyMetadata(),
     content: {
       data: {
-        line: content,
+        line: record.content,
         taskId,
         iteration: agent.iteration,
         provider: providerName,
       },
     },
+    timestamp: record.timestamp,
+  });
+}
+
+function retainIsolatedLine(state, line) {
+  const { timestamp, content } = parseIsolatedLogLine(line);
+  return appendControlPlaneRecord(state.controlPlaneOutput, {
+    content,
     timestamp,
+    type: isValidJsonLine(content) ? 'json' : 'text',
   });
+}
+
+function broadcastIsolatedLine({ agent, providerName, taskId, state, line }) {
+  const followerState = ensureControlPlaneOutputState(state);
+  const record = retainIsolatedLine(followerState, line);
+  publishLiveControlPlaneRecord(followerState.controlPlaneOutput, record, (item) =>
+    publishIsolatedOutputRecord(agent, providerName, taskId, item)
+  );
 
-  if (!state?.nested) {
+  if (!followerState.nested) {
     agent.lastOutputTime = Date.now();
   }
 }
 
+function flushIsolatedOutput(agent, providerName, taskId, state) {
+  const followerState = ensureControlPlaneOutputState(state);
+  flushTerminalControlPlaneOutput(followerState.controlPlaneOutput, (record) =>
+    publishIsolatedOutputRecord(agent, providerName, taskId, record)
+  );
+}
+
 function appendIsolatedContent(state, content, onLine) {
-  state.lineBuffer += content;
-  const lines = state.lineBuffer.split('\n');
+  appendContentToBuffer(state, content, onLine, true);
+}
 
-  for (let i = 0; i < lines.length - 1; i++) {
-    if (lines[i].trim()) {
-      onLine(lines[i]);
-    }
-  }
+function consumeIsolatedTailChunk(state, data, onLine) {
+  const chunk = typeof data === 'string' ? data : state.tailDecoder.write(data);
+  if (!chunk || state.ignoreTailOutput) return;
+  state.rawBytesSeen += Buffer.byteLength(chunk);
+  appendIsolatedContent(state, chunk, onLine);
+}
 
-  state.lineBuffer = lines[lines.length - 1];
+function stopIsolatedTailForSettlement(state) {
+  state.ignoreTailOutput = true;
+  if (!state.tailProcess) return;
+  try {
+    state.tailProcess.kill('SIGTERM');
+  } catch {
+    // Ignore - process may already be dead.
+  }
+  state.tailProcess = null;
 }
 
 function startIsolatedTail({ agent, manager, clusterId, logFilePath, state, onLine }) {
@@ -2586,9 +2938,7 @@ function startIsolatedTail({ agent, manager, clusterId, logFilePath, state, onLi
   ]);
 
   state.tailProcess.stdout.on('data', (data) => {
-    const chunk = data.toString();
-    state.fullOutput += chunk;
-    appendIsolatedContent(state, chunk, onLine);
+    consumeIsolatedTailChunk(state, data, onLine);
   });
 
   state.tailProcess.stderr.on('data', (data) => {
@@ -2599,6 +2949,7 @@ function startIsolatedTail({ agent, manager, clusterId, logFilePath, state, onLi
   });
 
   state.tailProcess.on('close', (exitCode) => {
+    consumeIsolatedTailChunk(state, state.tailDecoder.end(), onLine);
     if (!state.taskExited) {
       agent._log(`[${agent.id}] tail process exited with code ${exitCode}`);
     }
@@ -2620,7 +2971,6 @@ async function checkIsolatedStatus({
   cleanup,
   resolve,
   reject,
-  onLine,
 }) {
   if (state.taskExited) return;
 
@@ -2673,7 +3023,6 @@ async function checkIsolatedStatus({
     cleanup,
     resolve,
     reject,
-    onLine,
   });
 }
 
@@ -2688,7 +3037,6 @@ function startIsolatedStatusChecks({
   cleanup,
   resolve,
   reject,
-  onLine,
 }) {
   state.statusCheckInterval = setInterval(() => {
     checkIsolatedStatus({
@@ -2702,7 +3050,6 @@ function startIsolatedStatusChecks({
       cleanup,
       resolve,
       reject,
-      onLine,
     }).catch((statusErr) => {
       agent._log(`[${agent.id}] Status check error (will retry): ${statusErr.message}`);
     });
@@ -2736,7 +3083,6 @@ function followClaudeTaskLogsIsolated(agent, taskId, options = {}) {
       cleanup,
       resolve,
       reject,
-      onLine,
     });
     // Only register the lifecycle handle on the agent for top-level tasks.
     if (!options.nested) {
@@ -2807,7 +3153,6 @@ function followClaudeTaskLogsIsolated(agent, taskId, options = {}) {
           cleanup,
           resolve,
           reject,
-          onLine,
         });
 
         if (agent.timeout > 0 && !agent.enableLivenessCheck && !options.nested) {
@@ -3091,4 +3436,19 @@ module.exports = {
   buildTaskRunArgs,
   rebuildProviderSessionAfterCommit,
   killTask,
+  createLogFollowState,
+  createIsolatedLogState,
+  createControlPlaneOutputState,
+  appendControlPlaneRecord,
+  createLogRecordBuffer,
+  appendContentToBuffer,
+  consumeIsolatedTailChunk,
+  flushAgentOutput,
+  flushIsolatedOutput,
+  CONTROL_PLANE_OUTPUT_LIMITS: Object.freeze({
+    maxBytes: MAX_CONTROL_PLANE_OUTPUT_BYTES,
+    maxRecords: MAX_CONTROL_PLANE_OUTPUT_RECORDS,
+    liveBytes: MAX_LIVE_OUTPUT_BYTES,
+    liveRecords: MAX_LIVE_OUTPUT_RECORDS,
+  }),
 };