@the-open-engine/zeroshot 6.34.2 → 6.35.0

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

@@ -54,6 +54,10 @@ const {
   validateCompletedResumeIdentity,
 } = require('./provider-session');
 const { extractClaudeVertexModelError } = require('./output-extraction');
+const {
+  extractProviderFailure,
+  redactTerminalFailureForControlPlane,
+} = require('./provider-terminal-failure');
 const {
   createStructuredOutputInvalidError,
   isStructuredOutputInvalidError,
@@ -66,6 +70,8 @@ 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;
+const MAX_FAILURE_ERROR_BYTES = 4096;
+const FAILURE_ERROR_TRUNCATION_SUFFIX = '… [truncated]';
 function runCommandWithTimeout(command, args, options = {}, callback = null) {
   const timeout = options.timeout ?? 30000;
   if (timeout <= 0) {
@@ -175,6 +181,22 @@ function buildClaudeEnv(modelSpec, options = {}) {
 function sanitizeErrorMessage(error) {
   if (!error) return null;
 
+  const original = String(error);
+  const suffixBytes = Buffer.byteLength(FAILURE_ERROR_TRUNCATION_SUFFIX);
+  const contentBudget = MAX_FAILURE_ERROR_BYTES - suffixBytes;
+  let boundedError = original;
+  if (Buffer.byteLength(original) > MAX_FAILURE_ERROR_BYTES) {
+    let bytes = 0;
+    let prefix = '';
+    for (const character of original) {
+      const characterBytes = Buffer.byteLength(character);
+      if (bytes + characterBytes > contentBudget) break;
+      prefix += character;
+      bytes += characterBytes;
+    }
+    boundedError = `${prefix}${FAILURE_ERROR_TRUNCATION_SUFFIX}`;
+  }
+
   // Patterns that look like TypeScript type annotations (not real error messages)
   const typeAnnotationPatterns = [
     /^string\s*\|\s*null$/i,
@@ -187,7 +209,7 @@ function sanitizeErrorMessage(error) {
     /^[A-Z][a-zA-Z]*\s*\|\s*(?:null|undefined)$/, // e.g., "Error | null"
   ];
 
-  const trimmedError = error.trim();
+  const trimmedError = boundedError.trim();
 
   // Check if it's a union type like "string | number | boolean" (ReDoS-safe approach)
   const unionParts = trimmedError.split(/\s*\|\s*/);
@@ -196,14 +218,16 @@ function sanitizeErrorMessage(error) {
   for (const pattern of typeAnnotationPatterns) {
     if (pattern.test(trimmedError) || isUnionType) {
       console.warn(
-        `[agent-task-executor] WARNING: Error message looks like a TypeScript type annotation: "${error}". ` +
+        `[agent-task-executor] WARNING: Error message looks like a TypeScript type annotation: "${boundedError}". ` +
           `This indicates corrupted data. Replacing with generic error.`
       );
-      return `Task failed with corrupted error data (original: "${error}")`;
+      return sanitizeErrorMessage(
+        `Task failed with corrupted error data (original: "${boundedError}")`
+      );
     }
   }
 
-  return error;
+  return boundedError;
 }
 
 function safeTail(text, maxChars) {
@@ -295,6 +319,30 @@ function logNoMessagesReturned({ taskId, output, statusOutput, debug }) {
   console.error('[AgentTaskExecutor] Claude CLI returned no messages', payload);
 }
 
+function extractKnownCliFailure({ fullOutput, taskId, statusOutput, debug }) {
+  if (fullOutput.includes('exceeds maximum allowed size') || fullOutput.includes('256KB')) {
+    return sanitizeErrorMessage(
+      `FILE TOO LARGE (Claude Code 256KB limit). ` +
+        `Use offset and limit parameters when reading large files. ` +
+        `Example: Read tool with offset=0, limit=1000 to read first 1000 lines.`
+    );
+  }
+  if (fullOutput.includes('only prompt commands are supported in streaming mode')) {
+    return sanitizeErrorMessage(
+      `STREAMING MODE ERROR: Agent tried to use interactive tools in streaming mode. ` +
+        `This usually happens with AskUserQuestion or interactive prompts. ` +
+        `Zeroshot agents must run non-interactively.`
+    );
+  }
+  if (fullOutput.includes('No messages returned')) {
+    logNoMessagesReturned({ taskId, output: fullOutput, statusOutput, debug });
+    return sanitizeErrorMessage(
+      `Claude CLI returned no messages. This is usually transient; retry the task or resume the cluster.`
+    );
+  }
+  return null;
+}
+
 /**
  * Extract error context from task output.
  * Shared by both isolated and non-isolated modes.
@@ -307,7 +355,15 @@ function logNoMessagesReturned({ taskId, output, statusOutput, debug }) {
  * @param {Object} [params.debug] - Additional debug context for logging
  * @returns {string|null} Sanitized error context or null if extraction failed
  */
-function extractErrorContext({ output, statusOutput, taskId, isNotFound = false, debug }) {
+function extractErrorContext({
+  output,
+  statusOutput,
+  taskId,
+  isNotFound = false,
+  providerName = getDefaultProviderId(),
+  providerFailure = null,
+  debug,
+}) {
   // Task not found - explicit error
   if (isNotFound) {
     return sanitizeErrorMessage(`Task ${taskId} not found (may have crashed or been killed)`);
@@ -321,37 +377,15 @@ function extractErrorContext({ output, statusOutput, taskId, isNotFound = false,
     }
   }
 
-  // KNOWN CLAUDE CODE LIMITATIONS - detect and provide actionable guidance
-  const fullOutput = output || '';
-
-  // 256KB file limit error
-  if (fullOutput.includes('exceeds maximum allowed size') || fullOutput.includes('256KB')) {
-    return sanitizeErrorMessage(
-      `FILE TOO LARGE (Claude Code 256KB limit). ` +
-        `Use offset and limit parameters when reading large files. ` +
-        `Example: Read tool with offset=0, limit=1000 to read first 1000 lines.`
-    );
+  const terminalFailure = providerFailure || extractProviderFailure(output, providerName);
+  if (terminalFailure) {
+    return sanitizeErrorMessage(terminalFailure.error);
   }
 
-  // Streaming mode error (interactive tools in non-interactive mode)
-  if (fullOutput.includes('only prompt commands are supported in streaming mode')) {
-    return sanitizeErrorMessage(
-      `STREAMING MODE ERROR: Agent tried to use interactive tools in streaming mode. ` +
-        `This usually happens with AskUserQuestion or interactive prompts. ` +
-        `Zeroshot agents must run non-interactively.`
-    );
-  }
-
-  // Claude CLI transient failure: no messages returned
-  if (fullOutput.includes('No messages returned')) {
-    logNoMessagesReturned({ taskId, output: fullOutput, statusOutput, debug });
-    return sanitizeErrorMessage(
-      `Claude CLI returned no messages. This is usually transient; retry the task or resume the cluster.`
-    );
-  }
+  const fullOutput = output || '';
+  const knownFailure = extractKnownCliFailure({ fullOutput, taskId, statusOutput, debug });
+  if (knownFailure) return knownFailure;
 
-  // NEVER TRUNCATE OUTPUT - truncation corrupts structured JSON and causes false "crash" status
-  // If output is too verbose, that's a prompt problem - fix the prompts, not the data
   const trimmedOutput = (output || '').trim();
   if (!trimmedOutput) {
     return sanitizeErrorMessage(
@@ -1490,10 +1524,15 @@ function broadcastAgentLine({ agent, providerName, state, line }) {
   if (shouldSkipLogLine(content)) {
     return;
   }
+  const controlPlaneContent = redactTerminalFailureForControlPlane(
+    followerState,
+    providerName,
+    content
+  );
 
-  const isValidJson = isValidJsonLine(content);
+  const isValidJson = isValidJsonLine(controlPlaneContent);
   const record = appendControlPlaneRecord(followerState.controlPlaneOutput, {
-    content,
+    content: controlPlaneContent,
     timestamp,
     type: isValidJson ? 'json' : 'text',
   });
@@ -1703,11 +1742,13 @@ async function evaluateStructuredSuccess({ agent, taskId, state, success, allowR
   }
 }
 
-function buildFailureContext({ agent, taskId, providerName, state, stdout }) {
+function buildFailureContext({ agent, taskId, providerName, state, stdout, providerFailure }) {
   return extractErrorContext({
     output: state.output,
     statusOutput: stdout,
     taskId,
+    providerName,
+    providerFailure,
     debug: {
       agentId: agent.id,
       providerName,
@@ -1720,6 +1761,19 @@ function buildFailureContext({ agent, taskId, providerName, state, stdout }) {
   });
 }
 
+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);
+  return {
+    providerFailure,
+    errorContext:
+      providerFailure?.error ||
+      classified.error ||
+      buildFailureContext({ agent, taskId, providerName, state, stdout, providerFailure }),
+  };
+}
+
 async function buildCompletionResult({
   agent,
   taskId,
@@ -1753,10 +1807,14 @@ async function buildCompletionResult({
   if (vertexModelError) {
     classified.success = false;
   }
-  let errorContext = classified.error;
-  if (!errorContext && !classified.success) {
-    errorContext = buildFailureContext({ agent, taskId, providerName, state, stdout });
-  }
+  const { providerFailure, errorContext } = resolveCompletionFailure({
+    classified,
+    agent,
+    taskId,
+    providerName,
+    state,
+    stdout,
+  });
 
   return {
     success: classified.success,
@@ -1772,6 +1830,7 @@ async function buildCompletionResult({
       taskInfo,
       logicalSuccess: classified.success,
     }),
+    providerFailure,
     vertexModelError,
   };
 }
@@ -2633,7 +2692,13 @@ async function resolveIsolatedLogFilePath(manager, clusterId, taskId, state) {
   return state.logFilePath;
 }
 
-async function captureIsolatedFinalOutputTail(manager, clusterId, logFilePath, state) {
+async function captureIsolatedFinalOutputTail(
+  manager,
+  clusterId,
+  logFilePath,
+  state,
+  providerName
+) {
   stopIsolatedTailForSettlement(state);
   const sizeResult = await manager.execInContainer(clusterId, [
     'sh',
@@ -2658,16 +2723,58 @@ async function captureIsolatedFinalOutputTail(manager, clusterId, logFilePath, s
         state.lineBuffer = createLogRecordBuffer();
       }
       appendIsolatedContent(state, finalReadResult.stdout, (line) =>
-        retainIsolatedLine(state, line)
+        retainIsolatedLine(state, providerName, line)
       );
     }
   }
 
   if (state.lineBuffer.byteLength > 0) {
-    completeLogRecord(state.lineBuffer, (line) => retainIsolatedLine(state, line), true);
+    completeLogRecord(
+      state.lineBuffer,
+      (line) => retainIsolatedLine(state, providerName, line),
+      true
+    );
   }
 }
 
+function resolveIsolatedFailure({
+  success,
+  structuredError,
+  agent,
+  taskId,
+  providerName,
+  state,
+  status,
+  isNotFound,
+  clusterId,
+  logFilePath,
+}) {
+  if (success) return { providerFailure: null, errorContext: structuredError };
+  const providerFailure =
+    state.providerFailure || extractProviderFailure(state.fullOutput, providerName);
+  const errorContext =
+    providerFailure?.error ||
+    structuredError ||
+    extractErrorContext({
+      output: state.fullOutput,
+      statusOutput: status ? `Status: ${status}` : '',
+      taskId,
+      isNotFound,
+      providerName,
+      debug: {
+        agentId: agent.id,
+        providerName,
+        pid: agent.processPid,
+        cwd: agent.config.cwd || process.cwd(),
+        worktreePath: agent.worktree?.path || null,
+        isolation: true,
+        clusterId,
+        logFilePath,
+      },
+    });
+  return { providerFailure, errorContext };
+}
+
 function settleIsolatedTerminalStatus({
   agent,
   manager,
@@ -2693,7 +2800,7 @@ function settleIsolatedTerminalStatus({
     const logFilePath = await resolveIsolatedLogFilePath(manager, clusterId, taskId, state);
     await new Promise((settle) => setTimeout(settle, 200));
     if (state.resolved) return;
-    await captureIsolatedFinalOutputTail(manager, clusterId, logFilePath, state);
+    await captureIsolatedFinalOutputTail(manager, clusterId, logFilePath, state, providerName);
     if (state.resolved) return;
     flushIsolatedOutput(agent, providerName, taskId, state);
 
@@ -2720,26 +2827,18 @@ function settleIsolatedTerminalStatus({
       success = evaluated.success;
       structuredError = evaluated.error;
     }
-    const errorContext =
-      structuredError ||
-      (!success
-        ? extractErrorContext({
-            output: state.fullOutput,
-            statusOutput: status ? `Status: ${status}` : '',
-            taskId,
-            isNotFound,
-            debug: {
-              agentId: agent.id,
-              providerName,
-              pid: agent.processPid,
-              cwd: agent.config.cwd || process.cwd(),
-              worktreePath: agent.worktree?.path || null,
-              isolation: true,
-              clusterId,
-              logFilePath,
-            },
-          })
-        : null);
+    const { providerFailure, errorContext } = resolveIsolatedFailure({
+      success,
+      structuredError,
+      agent,
+      taskId,
+      providerName,
+      state,
+      status,
+      isNotFound,
+      clusterId,
+      logFilePath,
+    });
     let parsedResult = null;
     if (success && !state.skipStructuredResultCheck && !vertexModelError) {
       parsedResult = staleCandidate
@@ -2759,6 +2858,7 @@ function settleIsolatedTerminalStatus({
         parsedResult,
         error: errorContext,
         tokenUsage: extractTokenUsage(state.fullOutput, providerName),
+        providerFailure,
         vertexModelError,
       },
     });
@@ -2880,18 +2980,19 @@ function publishIsolatedOutputRecord(agent, providerName, taskId, record) {
   });
 }
 
-function retainIsolatedLine(state, line) {
+function retainIsolatedLine(state, providerName, line) {
   const { timestamp, content } = parseIsolatedLogLine(line);
+  const controlPlaneContent = redactTerminalFailureForControlPlane(state, providerName, content);
   return appendControlPlaneRecord(state.controlPlaneOutput, {
-    content,
+    content: controlPlaneContent,
     timestamp,
-    type: isValidJsonLine(content) ? 'json' : 'text',
+    type: isValidJsonLine(controlPlaneContent) ? 'json' : 'text',
   });
 }
 
 function broadcastIsolatedLine({ agent, providerName, taskId, state, line }) {
   const followerState = ensureControlPlaneOutputState(state);
-  const record = retainIsolatedLine(followerState, line);
+  const record = retainIsolatedLine(followerState, providerName, line);
   publishLiveControlPlaneRecord(followerState.controlPlaneOutput, record, (item) =>
     publishIsolatedOutputRecord(agent, providerName, taskId, item)
   );

package/src/agent/output-extraction.js

@@ -16,8 +16,51 @@
  * 4. Direct JSON parse of entire output
  */
 
+const { createHash } = require('node:crypto');
 const { parseProviderChunk } = require('../providers');
 
+const MAX_CLI_ERROR_BYTES = 4096;
+const CLI_ERROR_TRUNCATION_SUFFIX = '… [truncated]';
+
+function truncateUtf8(text, maxBytes = MAX_CLI_ERROR_BYTES) {
+  if (Buffer.byteLength(text) <= maxBytes) return text;
+
+  const suffixBytes = Buffer.byteLength(CLI_ERROR_TRUNCATION_SUFFIX);
+  const contentBudget = Math.max(0, maxBytes - suffixBytes);
+  let bytes = 0;
+  let truncated = '';
+  for (const character of text) {
+    const characterBytes = Buffer.byteLength(character);
+    if (bytes + characterBytes > contentBudget) break;
+    truncated += character;
+    bytes += characterBytes;
+  }
+  return `${truncated}${CLI_ERROR_TRUNCATION_SUFFIX}`;
+}
+
+function primitiveErrorText(value) {
+  return typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean'
+    ? String(value)
+    : '';
+}
+
+function cliErrorDetail(value, fallback) {
+  const candidate = Array.isArray(value)
+    ? value
+        .map(primitiveErrorText)
+        .filter((message) => message.trim())
+        .join('; ')
+    : primitiveErrorText(value);
+  const raw = candidate.trim() ? candidate : fallback;
+  return {
+    error: truncateUtf8(raw.trim()),
+    diagnostic: {
+      byteLength: Buffer.byteLength(raw),
+      sha256: createHash('sha256').update(raw).digest('hex'),
+    },
+  };
+}
+
 /**
  * Strip timestamp prefix from log lines.
  * Format: [epochMs]content or [epochMs]{json...}
@@ -308,60 +351,87 @@ function extractClaudeVertexModelError(output, { useVertex = false } = {}) {
  * @param {string} providerName - Active provider whose terminal errors may be inspected
  * @returns {{error: string, provider: string}|null} Error info or null
  */
-function extractCliError(output, providerName = 'claude') {
+function claudeFailureFromObject(obj) {
+  if (obj.type !== 'result') return null;
+  if (obj.is_error === true) {
+    const detail = cliErrorDetail(
+      Array.isArray(obj.errors) ? obj.errors : obj.error || obj.result,
+      'Unknown CLI error'
+    );
+    return { ...detail, provider: 'claude' };
+  }
+  if (obj.subtype !== 'error') return null;
+  return {
+    ...cliErrorDetail(obj.error || obj.result, 'CLI returned error'),
+    provider: 'claude',
+  };
+}
+
+function codexFailureFromObject(obj) {
+  if (obj.type !== 'turn.failed') return null;
+  return {
+    ...cliErrorDetail(obj.error?.message || obj.error?.code || obj.error, 'Turn failed'),
+    provider: 'codex',
+  };
+}
+
+function geminiFailureFromObject(obj) {
+  const geminiFailure =
+    (obj.type === 'result' && obj.status === 'error') ||
+    (obj.type === 'error' && obj.severity === 'error');
+  if (!geminiFailure) return null;
+  return {
+    ...cliErrorDetail(obj.error?.message || obj.message, 'Gemini CLI error'),
+    provider: 'gemini',
+  };
+}
+
+function opencodeFailureFromObject(obj) {
+  if (obj.type !== 'session.error' && obj.type !== 'error') return null;
+  return {
+    ...cliErrorDetail(
+      obj.error?.data?.message || obj.error?.message || obj.error?.name,
+      'Session error'
+    ),
+    provider: 'opencode',
+  };
+}
+
+function failureFromProviderObject(obj, providerName) {
+  if (providerName === 'claude') return claudeFailureFromObject(obj);
+  if (providerName === 'codex') return codexFailureFromObject(obj);
+  if (providerName === 'gemini') return geminiFailureFromObject(obj);
+  if (providerName === 'opencode') return opencodeFailureFromObject(obj);
+  return null;
+}
+
+function extractCliFailure(output, providerName = 'claude') {
   if (!output || typeof output !== 'string') return null;
 
   const lines = output.split('\n');
+  // Codex terminal truth is a turn.failed record at the newest end of JSONL output.
+  // Search it newest-first so a preserved terminal tail wins over older provider chatter.
+  if (providerName === 'codex') lines.reverse();
 
   for (const line of lines) {
     const content = stripTimestamp(line);
     if (!content.startsWith('{')) continue;
-
-    let obj;
     try {
-      obj = JSON.parse(content);
+      const failure = failureFromProviderObject(JSON.parse(content), providerName);
+      if (failure) return failure;
     } catch {
-      continue;
-    }
-
-    if (providerName === 'claude' && obj.type === 'result' && obj.is_error === true) {
-      const errorMsg = Array.isArray(obj.errors)
-        ? obj.errors.join('; ')
-        : obj.error || obj.result || 'Unknown CLI error';
-      return { error: errorMsg, provider: 'claude' };
-    }
-
-    if (providerName === 'claude' && obj.type === 'result' && obj.subtype === 'error') {
-      const errorMsg = obj.error || obj.result || 'CLI returned error';
-      return { error: errorMsg, provider: 'claude' };
-    }
-
-    if (providerName === 'codex' && obj.type === 'turn.failed') {
-      const errorMsg = obj.error?.message || obj.error || 'Turn failed';
-      return { error: errorMsg, provider: 'codex' };
-    }
-
-    if (
-      providerName === 'gemini' &&
-      ((obj.type === 'result' && obj.status === 'error') ||
-        (obj.type === 'error' && obj.severity === 'error'))
-    ) {
-      return {
-        error: obj.error?.message || obj.message || 'Gemini CLI error',
-        provider: 'gemini',
-      };
-    }
-
-    if (providerName === 'opencode' && (obj.type === 'session.error' || obj.type === 'error')) {
-      const errorMsg =
-        obj.error?.data?.message || obj.error?.message || obj.error?.name || 'Session error';
-      return { error: errorMsg, provider: 'opencode' };
+      // Ignore non-JSON output lines.
     }
   }
 
   return null;
 }
 
+function extractCliError(output, providerName = 'claude') {
+  const failure = extractCliFailure(output, providerName);
+  return failure ? { error: failure.error, provider: failure.provider } : null;
+}
+
 /**
  * Detects fatal standalone output lines that indicate no task output was produced.
  * Only matches when the line itself is the fatal message (not when it appears inside JSON).
@@ -419,8 +489,10 @@ function extractJsonFromOutput(output, providerName = 'claude') {
 }
 
 module.exports = {
+  MAX_CLI_ERROR_BYTES,
   extractJsonFromOutput,
   extractModelTextFromOutput,
+  extractCliFailure,
   extractCliError,
   extractClaudeVertexModelError,
   extractFromResultWrapper,

package/src/agent/pr-verification.js

@@ -46,7 +46,7 @@ const VERIFICATION_ADAPTERS = {
           'view',
           ...(prNumber ? [String(prNumber)] : []),
           '--json',
-          'state,mergedAt,url,number',
+          'state,mergedAt,url,number,autoMergeRequest,mergeStateStatus',
         ],
       };
     },
@@ -57,6 +57,8 @@ const VERIFICATION_ADAPTERS = {
         state: String(data.state || '').toUpperCase(),
         mergedAt: data.mergedAt || null,
         url: data.url || null,
+        autoMergeRequest: data.autoMergeRequest || null,
+        mergeStateStatus: data.mergeStateStatus || null,
       };
     },
     isNotFoundError(err) {
@@ -289,6 +291,8 @@ function normalizeFetchedPrData(prData, adapter) {
     state: String(prData?.state || '').toUpperCase(),
     mergedAt: prData?.mergedAt || null,
     url: prData?.url || null,
+    autoMergeRequest: prData?.autoMergeRequest || null,
+    mergeStateStatus: prData?.mergeStateStatus || null,
   };
 }
 
@@ -431,7 +435,7 @@ function isStatusOnlyPusherReason(reason) {
   return hasPendingSignal && !hasFailureSignal;
 }
 
-function handleBlockedPusherOutcome({ claims, platform, agent }) {
+function handleBlockedPusherOutcome({ claims, platform, agent, requireMerge }) {
   const structuredOutput = claims.structuredOutput || {};
   if (!isTrue(structuredOutput.blocked)) return false;
 
@@ -445,7 +449,7 @@ function handleBlockedPusherOutcome({ claims, platform, agent }) {
     reason: 'git-pusher-blocked',
   });
 
-  if (isStatusOnlyPusherReason(blockedReason)) {
+  if (isStatusOnlyPusherReason(blockedReason) && !requireMerge) {
     agent._log(`⚠️  git-pusher status pending: ${blockedReason}`);
     publishClusterComplete(agent, {
       ...payload,
@@ -507,30 +511,32 @@ function handleUnmergedPr({ adapter, platform, prData, agent }) {
   const windowSeconds = (pollAttempts * pollIntervalMs) / 1000;
   const itemLabel = adapter.itemName;
 
-  if (adapter.isOpenState(prData.state)) {
-    const reason =
-      `${itemLabel} merge not yet visible via ${adapter.displayName} API after polling window; ` +
-      'verification deferred.';
+  if (
+    adapter.platform === 'github' &&
+    prData.autoMergeRequest?.mergeMethod === 'MERGE' &&
+    prData.autoMergeRequest?.enabledAt
+  ) {
+    const reason = `${itemLabel} accepted by authoritative GitHub auto-merge policy.`;
     agent._log(
-      `⚠️  VERIFICATION PENDING: ${reason} ${itemLabel} #${prData.number}, state="${prData.state}"`
+      `✅ VERIFICATION PASSED: ${reason} ${itemLabel} #${prData.number}, state="${prData.state}"`
     );
     publishClusterComplete(agent, {
       ...buildVerificationPayload({
         platform,
         prData,
-        reason: 'git-pusher-complete-verification-pending',
+        reason: 'git-pusher-complete-auto-merge-accepted',
       }),
-      verification_pending: true,
+      auto_merge_accepted: true,
       verification_state: prData.state,
       verification_polls: pollAttempts,
       verification_window_seconds: windowSeconds,
-      verification_message: reason,
     });
     return;
   }
 
   throw new Error(
-    `VERIFICATION FAILED: ${itemLabel} #${prData.number} exists but is not merged ` +
+    `VERIFICATION FAILED: ${itemLabel} #${prData.number} exists but is neither merged nor ` +
+      'authoritatively accepted for merge-method auto-merge ' +
       `(state="${prData.state}") after ${pollAttempts} polls over ${windowSeconds}s.`
   );
 }
@@ -599,7 +605,7 @@ async function verifyPullRequest({ result, agent, autoMerge }) {
     adapter,
   });
 
-  if (handleBlockedPusherOutcome({ claims, platform, agent })) {
+  if (handleBlockedPusherOutcome({ claims, platform, agent, requireMerge })) {
     return;
   }