@probelabs/probe 0.6.0-rc335 → 0.6.0-rc336

package/src/agent/engines/codex.js

@@ -461,7 +461,11 @@ export async function createCodexEngine(options = {}) {
           try { collector.observe(event); } catch (error) { evidenceFailure ??= normalizeGovernedAnswerFailure(error, 'native_event_grammar'); }
         });
         if (opts.abortSignal) {
-          if (opts.abortSignal.aborted) throw new Error('Codex query cancelled');
+          if (opts.abortSignal.aborted) {
+            throw governedProfile
+              ? governedAnswerFailure('provider_engine', null, null, null, null, null, null, 'query')
+              : new Error('Codex query cancelled');
+          }
           abortHandler = () => { void cleanup(new Error('Codex query cancelled')).catch(() => {}); };
           opts.abortSignal.addEventListener('abort', abortHandler, { once: true });
         }
@@ -501,7 +505,8 @@ export async function createCodexEngine(options = {}) {
         try { result = await resultPromise; }
         catch (error) {
           throw governedProfile
-            ? governedAnswerFailure(evidenceFailure ? 'unknown' : 'provider_engine')
+            ? evidenceFailure || normalizeGovernedAnswerFailure(error, 'provider_engine', null, null, null,
+              null, null, 'query')
             : error;
         }
 
@@ -521,20 +526,31 @@ export async function createCodexEngine(options = {}) {
             internal = attestGovernedCodexSession({ profile: governedProfile,
               events: governedProfile.version === 'probe.governed-codex-profile/v2'
                 ? [collected.sessionEvent, collected.capabilities.nativeTools] : [collected.sessionEvent] });
+          } catch (error) {
+            throw normalizeGovernedAnswerFailure(error, 'native_event_grammar', 'live_envelope_session',
+              'attestation');
+          }
+          try {
             probeMcpCallCount = governedProfile.version === 'probe.governed-codex-profile/v2'
               ? governedProbeMcpCallCount(mcpServer?.getGovernedCallEvidence()) : 0;
           } catch (error) {
-            throw normalizeGovernedAnswerFailure(error, 'native_event_grammar', 'live_envelope_session', 'attestation');
+            throw normalizeGovernedAnswerFailure(error, 'native_event_grammar', 'live_envelope_session',
+              'attestation', null, null, null, null, 'native_capability_aggregate');
+          }
+          try {
+            attestation = hasInvocationDigest
+              ? externalBoundReceipt(internal, dispatch, invocationDigest, {
+                nativeCallCount: collected.capabilities.nativeTools.total,
+                probeMcpCallCount,
+              })
+              : externalReceipt(internal, {
+                nativeCallCount: collected.capabilities.nativeTools.total,
+                probeMcpCallCount,
+              });
+          } catch (error) {
+            throw normalizeGovernedAnswerFailure(error, 'native_event_grammar', 'live_envelope_session',
+              'attestation', null, null, null, null, 'invocation_attestation');
           }
-          attestation = hasInvocationDigest
-            ? externalBoundReceipt(internal, dispatch, invocationDigest, {
-              nativeCallCount: collected.capabilities.nativeTools.total,
-              probeMcpCallCount,
-            })
-            : externalReceipt(internal, {
-              nativeCallCount: collected.capabilities.nativeTools.total,
-              probeMcpCallCount,
-            });
           session.setConversationId(collected.sessionEvent.params.msg.session_id);
         }
 
@@ -576,7 +592,7 @@ export async function createCodexEngine(options = {}) {
         };
 
       } catch (error) {
-        if (governedProfile) error = normalizeGovernedAnswerFailure(error, 'unknown');
+        if (governedProfile) error = normalizeGovernedAnswerFailure(error, 'internal_contract');
         queryError = error;
         if (debug) {
           console.error('[DEBUG] Codex query error:', error);
@@ -589,7 +605,10 @@ export async function createCodexEngine(options = {}) {
         if (opts.abortSignal && abortHandler) opts.abortSignal.removeEventListener('abort', abortHandler);
         if (governedProfile) {
           try { await cleanup(); }
-          catch (cleanupError) { if (!queryError) throw cleanupError; }
+          catch (cleanupError) {
+            if (!queryError) throw normalizeGovernedAnswerFailure(cleanupError, 'provider_engine', null, null,
+              null, null, null, 'close');
+          }
         }
       }
     },

package/src/agent/engines/governed-answer-failure.js

@@ -1,6 +1,7 @@
 const GOVERNED_ANSWER_FAILURE_STAGES = new Set([
-  'native_event_grammar', 'provider_engine', 'schema_result_validation', 'unknown',
+  'native_event_grammar', 'provider_engine', 'schema_result_validation', 'internal_contract', 'unknown',
 ]);
+const GOVERNED_PROVIDER_ENGINE_FAILURE_BOUNDARIES = new Set(['acquire', 'query', 'close']);
 const GOVERNED_NATIVE_EVENT_FAILURE_BOUNDARIES = new Set([
   'raw_item_predicate', 'live_envelope_session',
 ]);
@@ -17,6 +18,7 @@ const GOVERNED_NATIVE_EVENT_FAILURE_ATTESTATION_PREDICATES = new Set([
   'network',
   'filesystem_shape', 'filesystem_type', 'entries', 'entry', 'access', 'path_shape',
   'path_type', 'value_shape', 'kind', 'native_tool_evidence', 'internal_contract',
+  'invocation_attestation', 'native_capability_aggregate',
 ]);
 const GOVERNED_SCHEMA_RESULT_VALIDATION_SUBREASONS = new Set([
   'response_json', 'schema_definition', 'schema_mismatch', 'result_identity',
@@ -73,7 +75,8 @@ function governedAttestationPredicate(error) {
 export class GovernedAnswerFailure extends Error {
   constructor(stage, nativeEventFailureBoundary = null, nativeEventFailureSubreason = null,
     nativeEventFailureCorrelationOperand = null, nativeEventFailureAttestationPredicate = null,
-    schemaResultValidationSubreason = null, schemaResultValidationKeyword = null) {
+    schemaResultValidationSubreason = null, schemaResultValidationKeyword = null,
+    providerEngineFailureBoundary = null) {
     super();
     delete this.stack;
     const answerFailureStage = GOVERNED_ANSWER_FAILURE_STAGES.has(stage) ? stage : 'unknown';
@@ -82,6 +85,11 @@ export class GovernedAnswerFailure extends Error {
       value: answerFailureStage,
       enumerable: true,
     });
+    if (answerFailureStage === 'provider_engine') Object.defineProperty(this, 'providerEngineFailureBoundary', {
+      value: GOVERNED_PROVIDER_ENGINE_FAILURE_BOUNDARIES.has(providerEngineFailureBoundary)
+        ? providerEngineFailureBoundary : null,
+      enumerable: true,
+    });
     if (answerFailureStage === 'native_event_grammar') Object.defineProperty(this, 'nativeEventFailureBoundary', {
       value: GOVERNED_NATIVE_EVENT_FAILURE_BOUNDARIES.has(nativeEventFailureBoundary)
         ? nativeEventFailureBoundary : null,
@@ -134,19 +142,22 @@ export class GovernedAnswerFailure extends Error {
 
 export function governedAnswerFailure(stage, nativeEventFailureBoundary = null, nativeEventFailureSubreason = null,
   nativeEventFailureCorrelationOperand = null, nativeEventFailureAttestationPredicate = null,
-  schemaResultValidationSubreason = null, schemaResultValidationKeyword = null) {
+  schemaResultValidationSubreason = null, schemaResultValidationKeyword = null,
+  providerEngineFailureBoundary = null) {
   return new GovernedAnswerFailure(stage, nativeEventFailureBoundary, nativeEventFailureSubreason,
     nativeEventFailureCorrelationOperand, nativeEventFailureAttestationPredicate,
-    schemaResultValidationSubreason, schemaResultValidationKeyword);
+    schemaResultValidationSubreason, schemaResultValidationKeyword, providerEngineFailureBoundary);
 }
 
 export function normalizeGovernedAnswerFailure(error, fallback = 'unknown', nativeEventFailureBoundary = null,
   nativeEventFailureSubreason = null, nativeEventFailureCorrelationOperand = null,
-  schemaResultValidationSubreason = null, schemaResultValidationKeyword = null) {
+  schemaResultValidationSubreason = null, schemaResultValidationKeyword = null,
+  providerEngineFailureBoundary = null, nativeEventFailureAttestationPredicate = null) {
   return error instanceof GovernedAnswerFailure ? error
     : governedAnswerFailure(fallback, nativeEventFailureBoundary, nativeEventFailureSubreason,
       nativeEventFailureCorrelationOperand,
       fallback === 'native_event_grammar' && nativeEventFailureBoundary === 'live_envelope_session' &&
-        nativeEventFailureSubreason === 'attestation' ? governedAttestationPredicate(error) : null,
-      schemaResultValidationSubreason, schemaResultValidationKeyword);
+        nativeEventFailureSubreason === 'attestation'
+        ? nativeEventFailureAttestationPredicate ?? governedAttestationPredicate(error) : null,
+      schemaResultValidationSubreason, schemaResultValidationKeyword, providerEngineFailureBoundary);
 }