@the-open-engine/zeroshot 6.37.0 → 6.38.0

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,
@@ -2060,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),
       });
     },
   };
@@ -2734,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();
       }
@@ -2760,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,
@@ -2797,6 +2840,7 @@ function settleIsolatedTerminalStatus({
   taskId,
   providerName,
   status,
+  statusOutput = '',
   isNotFound = false,
   state,
   cleanup,
@@ -2805,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;
@@ -2842,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,
@@ -2850,6 +2902,7 @@ function settleIsolatedTerminalStatus({
       providerName,
       state,
       status,
+      statusOutput,
       isNotFound,
       clusterId,
       logFilePath,
@@ -2860,7 +2913,6 @@ function settleIsolatedTerminalStatus({
         ? state._cachedParsedResult
         : await agent._parseResultOutput(state.fullOutput);
     }
-
     settleIsolatedFollower({
       agent,
       state,
@@ -2872,7 +2924,7 @@ function settleIsolatedTerminalStatus({
         taskId,
         parsedResult,
         error: errorContext,
-        tokenUsage: extractTokenUsage(state.fullOutput, providerName),
+        tokenUsage: extractTokenUsage(state.fullOutput, providerName, state),
         providerFailure,
         vertexModelError,
       },
@@ -2908,7 +2960,7 @@ function buildIsolatedLifecycleHandle({
         error: reason,
         code: details.code || null,
         taskId,
-        tokenUsage: extractTokenUsage(state.fullOutput, providerName),
+        tokenUsage: extractTokenUsage(state.fullOutput, providerName, state),
       },
     });
   };
@@ -2971,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) {
@@ -2996,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,
@@ -3008,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)
   );
@@ -3134,6 +3192,7 @@ async function checkIsolatedStatus({
     taskId,
     providerName,
     status,
+    statusOutput,
     isNotFound,
     state,
     cleanup,

package/src/agent/output-extraction.js

@@ -347,6 +347,7 @@ function extractClaudeVertexModelError(output, { useVertex = false } = {}) {
  * - Codex:  {type:"turn.failed", error:{message:"msg"}}
  * - Gemini: {type:"result", status:"error", error:{message:"msg"}} or {type:"error", severity:"error"}
  * - Opencode: {type:"session.error", error:{message:"msg"}}
+ * - Pi: latest assistant message_end, finalized only by a later agent_settled
  *
  * @param {string} providerName - Active provider whose terminal errors may be inspected
  * @returns {{error: string, provider: string}|null} Error info or null
@@ -397,6 +398,22 @@ function opencodeFailureFromObject(obj) {
   };
 }
 
+function piFailureFromMessage(message) {
+  const stopReason = message.stopReason;
+  const errorMessage = message.errorMessage;
+  if (stopReason === 'deferred') {
+    return {
+      ...cliErrorDetail('Pi turn deferred without completing.', 'Pi turn deferred'),
+      provider: 'pi',
+    };
+  }
+  if (stopReason !== 'error' && stopReason !== 'aborted' && !errorMessage) return null;
+  return {
+    ...cliErrorDetail(errorMessage || stopReason, 'Pi turn failed'),
+    provider: 'pi',
+  };
+}
+
 function failureFromProviderObject(obj, providerName) {
   if (providerName === 'claude') return claudeFailureFromObject(obj);
   if (providerName === 'codex') return codexFailureFromObject(obj);
@@ -405,7 +422,105 @@ function failureFromProviderObject(obj, providerName) {
   return null;
 }
 
+function piProtocolFailure(message) {
+  return { ...cliErrorDetail(message, message), provider: 'pi' };
+}
+
+const PI_STOP_REASONS = new Set(['stop', 'length', 'toolUse', 'error', 'aborted', 'deferred']);
+const PI_USAGE_FIELDS = ['input', 'output', 'cacheRead', 'cacheWrite', 'totalTokens'];
+const PI_COST_FIELDS = ['input', 'output', 'cacheRead', 'cacheWrite', 'total'];
+
+function parsePiProtocolObject(content) {
+  if (!content.startsWith('{')) return null;
+  try {
+    const parsed = JSON.parse(content);
+    return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+function isPiRecord(value) {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+function hasPiNumericFields(value, fields) {
+  return isPiRecord(value) && fields.every((field) => typeof value[field] === 'number');
+}
+
+function isValidPiUsage(usage) {
+  if (!hasPiNumericFields(usage, PI_USAGE_FIELDS)) return false;
+  if (!hasPiNumericFields(usage.cost, PI_COST_FIELDS)) return false;
+  return (
+    (usage.cacheWrite1h === undefined || typeof usage.cacheWrite1h === 'number') &&
+    (usage.reasoning === undefined || typeof usage.reasoning === 'number')
+  );
+}
+
+function isValidPiAssistantMessage(message) {
+  return (
+    isPiRecord(message) &&
+    message.role === 'assistant' &&
+    Array.isArray(message.content) &&
+    isValidPiUsage(message.usage) &&
+    PI_STOP_REASONS.has(message.stopReason)
+  );
+}
+
+function piMessageRole(message) {
+  if (!message || typeof message !== 'object' || Array.isArray(message)) return null;
+  return typeof message.role === 'string' ? message.role : null;
+}
+
+function applyPiProtocolLine(content, state) {
+  if (!content) return null;
+  if (
+    content.startsWith('[ZEROSHOT] Earlier provider output omitted') ||
+    content.startsWith('[ZEROSHOT] Provider output record retained') ||
+    content.startsWith('[ZEROSHOT][PROVIDER_STDERR] ')
+  ) {
+    return null;
+  }
+  if (state.settled) return piProtocolFailure('Pi emitted output after agent_settled.');
+  const parsed = parsePiProtocolObject(content);
+  if (parsed === null) return piProtocolFailure('Pi JSON stream contained malformed output.');
+  if (typeof parsed.type !== 'string') {
+    return piProtocolFailure('Pi JSON stream contained an event without a valid type.');
+  }
+  if (parsed.type === 'message_end') {
+    const role = piMessageRole(parsed.message);
+    if (role === null) return piProtocolFailure('Pi message_end did not contain a valid message.');
+    if (role !== 'assistant') return null;
+    if (!isValidPiAssistantMessage(parsed.message)) {
+      return piProtocolFailure('Pi message_end did not contain a valid assistant message.');
+    }
+    state.latestAssistant = parsed.message;
+  } else if (parsed.type === 'agent_settled') {
+    state.settled = true;
+  }
+  return null;
+}
+
+function extractSettledPiFailure(lines) {
+  const state = { latestAssistant: null, settled: false };
+  for (const line of lines) {
+    const content = stripTimestamp(line);
+    const failure = applyPiProtocolLine(content, state);
+    if (failure) return failure;
+  }
+
+  if (!state.settled) return piProtocolFailure('Pi JSON stream ended before agent_settled.');
+  if (state.latestAssistant === null) {
+    return piProtocolFailure('Pi settled without a valid assistant message_end.');
+  }
+  return piFailureFromMessage(state.latestAssistant);
+}
+
 function extractCliFailure(output, providerName = 'claude') {
+  if (providerName === 'pi') {
+    const lines = typeof output === 'string' ? output.split('\n') : [];
+    return extractSettledPiFailure(lines);
+  }
   if (!output || typeof output !== 'string') return null;
 
   const lines = output.split('\n');

package/src/agent/pi-terminal-lifecycle.js

@@ -0,0 +1,242 @@
+// @ts-nocheck
+
+const { parseProviderEvent, providerFailureFields } = require('./provider-control-plane');
+
+const ZEROSHOT_PI_METADATA_PREFIXES = [
+  '[ZEROSHOT] Earlier provider output omitted',
+  '[ZEROSHOT][PROVIDER_STDERR] ',
+  '[ZEROSHOT][FATAL] ',
+];
+const ZEROSHOT_RETAINED_RECORD_PREFIX = '[ZEROSHOT] Provider output record retained';
+const PI_STOP_REASONS = new Set(['stop', 'length', 'toolUse', 'error', 'aborted', 'deferred']);
+const PI_REQUIRED_TOKEN_FIELDS = ['input', 'output', 'cacheRead', 'cacheWrite', 'totalTokens'];
+const PI_OPTIONAL_TOKEN_FIELDS = ['cacheWrite1h', 'reasoning'];
+const PI_TOKEN_FIELDS = [...PI_REQUIRED_TOKEN_FIELDS, ...PI_OPTIONAL_TOKEN_FIELDS];
+const PI_COST_FIELDS = ['input', 'output', 'cacheRead', 'cacheWrite', 'total'];
+const PI_PENDING_EVENT_TYPES = new Set([
+  'turn_end',
+  'agent_end',
+  'auto_retry_start',
+  'auto_retry_end',
+]);
+
+function pendingFailureMetadata(failure) {
+  return {
+    zeroshot_pending_failure: {
+      provider: failure.provider,
+      category: failure.category,
+      kind: failure.classification.kind,
+      retryable: failure.classification.retryable,
+      diagnostic: failure.diagnostic,
+    },
+  };
+}
+
+function numericFields(fields, source) {
+  return Object.fromEntries(
+    fields.map((field) => [field, typeof source[field] === 'number' ? source[field] : 0])
+  );
+}
+
+function redactedUsage(usage) {
+  const value = usage && typeof usage === 'object' && !Array.isArray(usage) ? usage : {};
+  return {
+    ...numericFields(PI_REQUIRED_TOKEN_FIELDS, value),
+    ...(typeof value.cacheWrite1h === 'number' ? { cacheWrite1h: value.cacheWrite1h } : {}),
+    ...(typeof value.reasoning === 'number' ? { reasoning: value.reasoning } : {}),
+    cost: numericFields(PI_COST_FIELDS, isRecord(value.cost) ? value.cost : {}),
+  };
+}
+
+function isRecord(value) {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+function hasNumericFields(value, fields) {
+  return isRecord(value) && fields.every((field) => typeof value[field] === 'number');
+}
+
+function addNumericFields(target, source, fields) {
+  for (const field of fields) {
+    if (typeof source[field] === 'number') target[field] = (target[field] || 0) + source[field];
+  }
+}
+
+function rememberTokenUsage(state, usage) {
+  if (!hasNumericFields(usage, PI_REQUIRED_TOKEN_FIELDS)) return false;
+  if (!hasNumericFields(usage.cost, PI_COST_FIELDS)) return false;
+  if (
+    !PI_OPTIONAL_TOKEN_FIELDS.every(
+      (field) => usage[field] === undefined || typeof usage[field] === 'number'
+    )
+  ) {
+    return false;
+  }
+  state.piUsage = state.piUsage || { tokens: {}, cost: {} };
+  addNumericFields(state.piUsage.tokens, usage, PI_TOKEN_FIELDS);
+  addNumericFields(state.piUsage.cost, usage.cost, PI_COST_FIELDS);
+  return true;
+}
+
+function getPiTokenUsage(state) {
+  if (!state?.piUsage) return null;
+  const { tokens, cost } = state.piUsage;
+  return {
+    inputTokens: tokens.input || 0,
+    outputTokens: tokens.output || 0,
+    cacheReadInputTokens: tokens.cacheRead || 0,
+    cacheCreationInputTokens: tokens.cacheWrite || 0,
+    totalCostUsd: cost.total || 0,
+    durationMs: null,
+    modelUsage: { ...tokens, cost: { ...cost } },
+  };
+}
+
+function isValidAssistantMessage(message) {
+  return Array.isArray(message?.content) && PI_STOP_REASONS.has(message.stopReason);
+}
+
+function redactPendingFailure(failure, parsed) {
+  const pending = pendingFailureMetadata(failure);
+  if (parsed.type === 'agent_end') {
+    return JSON.stringify({
+      type: parsed.type,
+      messages: [],
+      willRetry: parsed.willRetry === true,
+      ...pending,
+    });
+  }
+  if (parsed.type === 'auto_retry_end') {
+    return JSON.stringify({ type: parsed.type, success: false, ...pending });
+  }
+  if (parsed.type === 'auto_retry_start') {
+    return JSON.stringify({
+      type: parsed.type,
+      ...numericFields(
+        ['attempt', 'maxAttempts', 'delayMs'].filter((field) => typeof parsed[field] === 'number'),
+        parsed
+      ),
+      ...pending,
+    });
+  }
+  return JSON.stringify({
+    type: parsed.type,
+    message: {
+      role: 'assistant',
+      content: [],
+      usage: redactedUsage(parsed.message?.usage),
+      stopReason: 'error',
+      errorMessage: 'Pi provider turn failed; awaiting agent settlement.',
+    },
+    ...(parsed.type === 'turn_end' ? { toolResults: [] } : {}),
+    ...pending,
+  });
+}
+
+function finalFailureEnvelope(failure) {
+  return JSON.stringify({
+    type: 'agent_settled',
+    ...providerFailureFields(failure),
+  });
+}
+
+function rememberProtocolFailure(state, content, extractProviderFailure) {
+  const failure = extractProviderFailure(content, 'pi');
+  if (failure) {
+    state.piProtocolFailure = failure;
+    state.providerFailure = failure;
+  }
+  return failure;
+}
+
+function failProtocolLine(state, content, extractProviderFailure) {
+  const failure = rememberProtocolFailure(state, content, extractProviderFailure);
+  return failure ? finalFailureEnvelope(failure) : content;
+}
+
+function handleMessageEnd(state, content, parsed, extractProviderFailure) {
+  const role = parsed.message?.role;
+  if (typeof role !== 'string') return failProtocolLine(state, content, extractProviderFailure);
+  const hasCountedUsage = role === 'assistant' || parsed.message?.usage !== undefined;
+  if (
+    ['assistant', 'toolResult'].includes(role) &&
+    hasCountedUsage &&
+    !rememberTokenUsage(state, parsed.message?.usage)
+  ) {
+    return failProtocolLine(state, 'invalid Pi usage', extractProviderFailure);
+  }
+  if (role !== 'assistant') return content;
+  if (!isValidAssistantMessage(parsed.message)) {
+    return failProtocolLine(state, content, extractProviderFailure);
+  }
+  const failure = extractProviderFailure(
+    `${content}\n${JSON.stringify({ type: 'agent_settled' })}`,
+    'pi'
+  );
+  state.piLatestAssistantObserved = true;
+  state.pendingPiFailure = failure;
+  if (failure) return redactPendingFailure(failure, parsed);
+  if (!state.piProtocolFailure) state.providerFailure = null;
+  return content;
+}
+
+function usageForEvent(parsed) {
+  if (parsed.type === 'compaction_end' && parsed.result?.usage !== undefined) {
+    return parsed.result.usage;
+  }
+  if (
+    parsed.type === 'entry_appended' &&
+    parsed.entry?.type === 'branch_summary' &&
+    parsed.entry.usage !== undefined
+  ) {
+    return parsed.entry.usage;
+  }
+  return undefined;
+}
+
+function handleSettlement(state, content, extractProviderFailure) {
+  state.piProtocolSettled = true;
+  const missingAssistantFailure = state.piLatestAssistantObserved
+    ? null
+    : extractProviderFailure(JSON.stringify({ type: 'agent_settled' }), 'pi');
+  const failure = state.piProtocolFailure || state.pendingPiFailure || missingAssistantFailure;
+  state.pendingPiFailure = null;
+  state.providerFailure = failure || null;
+  return failure ? finalFailureEnvelope(failure) : content;
+}
+
+function redactPiFailureForControlPlane(state, content, extractProviderFailure) {
+  if (content.startsWith(ZEROSHOT_RETAINED_RECORD_PREFIX)) {
+    state.piProtocolPrefixOmitted = true;
+    return content;
+  }
+  if (ZEROSHOT_PI_METADATA_PREFIXES.some((prefix) => content.startsWith(prefix))) return content;
+  const parsed = parseProviderEvent(content);
+  if (parsed === null || typeof parsed.type !== 'string') {
+    return failProtocolLine(state, content, extractProviderFailure);
+  }
+  if (state.piProtocolSettled) {
+    return failProtocolLine(
+      state,
+      `${JSON.stringify({ type: 'agent_settled' })}\n${content}`,
+      extractProviderFailure
+    );
+  }
+  state.piProtocolObserved = true;
+
+  if (parsed.type === 'message_end') {
+    return handleMessageEnd(state, content, parsed, extractProviderFailure);
+  }
+  const usage = usageForEvent(parsed);
+  if (usage !== undefined && !rememberTokenUsage(state, usage)) {
+    return failProtocolLine(state, 'invalid Pi usage', extractProviderFailure);
+  }
+  if (state.pendingPiFailure && PI_PENDING_EVENT_TYPES.has(parsed.type)) {
+    return redactPendingFailure(state.pendingPiFailure, parsed);
+  }
+  return parsed.type === 'agent_settled'
+    ? handleSettlement(state, content, extractProviderFailure)
+    : content;
+}
+
+module.exports = { getPiTokenUsage, redactPiFailureForControlPlane };

package/src/agent/provider-control-plane.js

@@ -0,0 +1,26 @@
+// @ts-nocheck
+
+function parseProviderEvent(content) {
+  try {
+    const parsed = JSON.parse(content);
+    return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+function providerFailureFields(failure) {
+  return {
+    error: { message: failure.error },
+    zeroshot_failure: {
+      provider: failure.provider,
+      event: failure.event,
+      category: failure.category,
+      kind: failure.classification.kind,
+      retryable: failure.classification.retryable,
+      diagnostic: failure.diagnostic,
+    },
+  };
+}
+
+module.exports = { parseProviderEvent, providerFailureFields };