@brunobracaioli/aibrain 0.3.0-beta.7 → 0.4.0-beta.10

package/dist/assets/claude/hooks/context-compaction.ts

@@ -107,6 +107,7 @@ type HookApi = {
   };
 };
 type HookOptions = Record<string, unknown>;
+type MonotonicClock = () => number | undefined;
 type PreservationMode = 'preserve_internal' | 'upstream_compatible';
 type CompactionStrategy = 'direct_experimental' | 'native_summary_notes';
 type ToolPolicy = 'read_only' | 'compatible';
@@ -150,7 +151,7 @@ type Register = (
 ) => void;
 
 const MAX_RESULT_BYTES = 256 * 1024;
-const CLAUDE_HOOK_VERSION = '0.3.0-beta.7';
+const CLAUDE_HOOK_VERSION = '0.4.0-beta.7';
 const MAX_DIAGNOSTIC_BYTE_COUNT = 128 * 1024 * 1024;
 const COOLDOWN_MS = 60_000;
 const MAX_TRUNCATED_CODE_POINTS = 300;
@@ -176,6 +177,7 @@ const NATIVE_SUMMARY_PENDING_KEY_PREFIX = 'context-compaction/native-summary-pen
 const NATIVE_SUMMARY_PENDING_INDEX_KEY = 'context-compaction/native-summary-pending-index';
 const MAX_NATIVE_SUMMARY_PENDING = 4;
 const MAX_NATIVE_NOTE_BYTES = 96 * 1024 - 256;
+const MAX_NATIVE_SUMMARY_MESSAGE_HASHES = 256;
 const MAX_CHECKPOINTS = 4;
 const MAX_CHECKPOINT_KEYS = 128;
 const CHECKPOINT_KEY_PREFIX = 'context-compaction/checkpoint/';
@@ -215,6 +217,74 @@ function canonicalJson(value: unknown): string {
     .join(',')}}`;
 }
 
+export type PlanBindingFailureReason =
+  | 'plan_session_mismatch'
+  | 'plan_revision_mismatch'
+  | 'plan_projection_mismatch'
+  | 'plan_options_mismatch'
+  | 'plan_expired'
+  | 'plan_parse_envelope_invalid'
+  | 'plan_parse_metadata_invalid'
+  | 'plan_parse_decisions_invalid'
+  | 'plan_parse_fitting_invalid'
+  | 'plan_parse_stats_invalid'
+  | 'plan_parse_response_too_large'
+  | 'plan_parse_failed'
+  | 'session_changed_during_planning'
+  | 'snapshot_changed_during_planning'
+  | 'historical_notes_changed_during_planning';
+
+const PLAN_BINDING_FAILURE_REASONS: ReadonlySet<string> = new Set([
+  'plan_session_mismatch',
+  'plan_revision_mismatch',
+  'plan_projection_mismatch',
+  'plan_options_mismatch',
+  'plan_expired',
+  'plan_parse_envelope_invalid',
+  'plan_parse_metadata_invalid',
+  'plan_parse_decisions_invalid',
+  'plan_parse_fitting_invalid',
+  'plan_parse_stats_invalid',
+  'plan_parse_response_too_large',
+  'plan_parse_failed',
+  'session_changed_during_planning',
+  'snapshot_changed_during_planning',
+  'historical_notes_changed_during_planning',
+]);
+
+function isPlanBindingFailureReason(value: unknown): value is PlanBindingFailureReason {
+  return typeof value === 'string' && PLAN_BINDING_FAILURE_REASONS.has(value);
+}
+
+export function planParseFailureReason(error: unknown): PlanBindingFailureReason {
+  const message = error instanceof Error ? error.message : '';
+  if (message === 'AI Brain response is too large') return 'plan_parse_response_too_large';
+  if (message.includes('decision') || message.includes('probability'))
+    return 'plan_parse_decisions_invalid';
+  if (message.includes('fitting')) return 'plan_parse_fitting_invalid';
+  if (message.includes('statistic') || message.includes('reduction'))
+    return 'plan_parse_stats_invalid';
+  if (message.includes('metadata')) return 'plan_parse_metadata_invalid';
+  if (
+    message.includes('structured plan') ||
+    message.includes('plan envelope') ||
+    message.includes('unknown fields')
+  )
+    return 'plan_parse_envelope_invalid';
+  return 'plan_parse_failed';
+}
+
+function planBindingFailure(
+  reason: PlanBindingFailureReason,
+  message: string,
+): Error & { readonly planBindingFailureReason: PlanBindingFailureReason } {
+  const error = new Error(message) as Error & {
+    planBindingFailureReason: PlanBindingFailureReason;
+  };
+  error.planBindingFailureReason = reason;
+  return error;
+}
+
 async function sha256(value: string): Promise<string> {
   if (globalThis.crypto?.subtle === undefined) throw new Error('host crypto is unavailable');
   const digest = await globalThis.crypto.subtle.digest('SHA-256', new TextEncoder().encode(value));
@@ -224,6 +294,58 @@ async function sha256(value: string): Promise<string> {
 function byteLength(value: string): number {
   return new TextEncoder().encode(value).byteLength;
 }
+
+function providerResponseMetadata(
+  response: McpResult,
+): Pick<ObservationRecord, 'provider_response_format' | 'byte_count' | 'item_count'> {
+  const hasStructured = response.structuredContent !== undefined;
+  const textBlocks =
+    response.content?.filter(
+      (block): block is { readonly type: string; readonly text: string } =>
+        block.type === 'text' && typeof block.text === 'string',
+    ) ?? [];
+  const format = hasStructured
+    ? textBlocks.length > 0
+      ? 'both'
+      : 'structured'
+    : textBlocks.length > 0
+      ? 'text'
+      : 'missing';
+  let byteCount = 0;
+  if (hasStructured) {
+    const serialized = JSON.stringify(response.structuredContent);
+    if (serialized !== undefined) byteCount += byteLength(serialized);
+  }
+  for (const block of textBlocks) byteCount += byteLength(block.text);
+  return {
+    provider_response_format: format,
+    byte_count: Math.min(byteCount, MAX_DIAGNOSTIC_BYTE_COUNT),
+    item_count: Math.min(response.content?.length ?? 0, 10_000_000),
+  };
+}
+
+export function planBindingFailureReason(
+  plan: Readonly<Record<string, unknown>>,
+  expected: Readonly<{
+    sessionRef: string;
+    revision: string;
+    projectionHash: string;
+    optionsHash?: string | null;
+    now?: number;
+  }>,
+): PlanBindingFailureReason | undefined {
+  if (plan.sessionRef !== expected.sessionRef) return 'plan_session_mismatch';
+  if (plan.revision !== expected.revision) return 'plan_revision_mismatch';
+  if (plan.projectionHash !== expected.projectionHash) return 'plan_projection_mismatch';
+  if (expected.optionsHash === null) return 'plan_options_mismatch';
+  if (expected.optionsHash !== undefined && plan.optionsHash !== expected.optionsHash)
+    return 'plan_options_mismatch';
+  const expiresAt = Date.parse(String(plan.expiresAt));
+  if (!Number.isFinite(expiresAt) || expiresAt <= (expected.now ?? Date.now()))
+    return 'plan_expired';
+  return undefined;
+}
+
 function unique(values: readonly string[]): string[] {
   return [...new Set(values)];
 }
@@ -341,6 +463,10 @@ function v2WireOptions(options: V2Options): Record<string, unknown> {
 
 function safeErrorCategory(error: unknown): string {
   const record = isRecord(error) ? error : {};
+  // A coded error names its own reason; the keyword guess below would read
+  // "AI Brain plan does not meet the minimum estimated reduction" as invalid_plan.
+  if (COMPACT_ERROR_CODES.includes(record.compactErrorCode as CompactErrorCode))
+    return record.compactErrorCode as CompactErrorCode;
   const code = typeof record.code === 'string' ? record.code.toLowerCase() : '';
   const name = typeof record.name === 'string' ? record.name.toLowerCase() : '';
   const message = typeof record.message === 'string' ? record.message.toLowerCase() : '';
@@ -565,6 +691,8 @@ type ContextBudgetSnapshot = {
   readonly accountInFlight: boolean;
   readonly retryAfterMs: number;
   readonly expiresAt: string;
+  readonly requestStartedAtMonotonic: number;
+  readonly lifetimeMs: number;
   readonly windowEnd: string;
   readonly correlationId: string;
 };
@@ -578,7 +706,25 @@ type ContextBudgetRead =
       readonly error?: Error | undefined;
     };
 
-function parseContextBudget(value: unknown, now = Date.now()): ContextBudgetSnapshot | undefined {
+function monotonicNow(): number | undefined {
+  const host = globalThis as unknown as {
+    readonly performance?: { readonly now?: () => number };
+  };
+  const now = host.performance?.now;
+  if (typeof now !== 'function') return undefined;
+  try {
+    const value = now.call(host.performance);
+    return Number.isFinite(value) && value >= 0 ? value : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+export function parseContextBudget(
+  value: unknown,
+  requestStartedAt: number,
+  responseReceivedAt: number,
+): ContextBudgetSnapshot | undefined {
   if (!isRecord(value)) return undefined;
   const allowed = [
     'schema_version',
@@ -606,9 +752,22 @@ function parseContextBudget(value: unknown, now = Date.now()): ContextBudgetSnap
     !Number.isFinite(Date.parse(value.window_end))
   )
     return undefined;
+  const serverTime = Date.parse(value.server_time);
   const expiresAt = Date.parse(value.expires_at);
   const windowEnd = Date.parse(value.window_end);
-  if (expiresAt <= now || expiresAt - now > BUDGET_SNAPSHOT_MAX_AGE_MS || windowEnd < expiresAt)
+  const snapshotLifetimeMs = expiresAt - serverTime;
+  const requestElapsedMs = responseReceivedAt - requestStartedAt;
+  if (
+    !Number.isFinite(requestStartedAt) ||
+    !Number.isFinite(responseReceivedAt) ||
+    requestStartedAt < 0 ||
+    requestElapsedMs < 0 ||
+    !Number.isSafeInteger(snapshotLifetimeMs) ||
+    snapshotLifetimeMs <= 0 ||
+    snapshotLifetimeMs > BUDGET_SNAPSHOT_MAX_AGE_MS ||
+    requestElapsedMs >= snapshotLifetimeMs ||
+    windowEnd < expiresAt
+  )
     return undefined;
   const nonnegative = (candidate: unknown): candidate is number =>
     typeof candidate === 'number' && Number.isSafeInteger(candidate) && candidate >= 0;
@@ -621,10 +780,8 @@ function parseContextBudget(value: unknown, now = Date.now()): ContextBudgetSnap
     !nonnegative(value.retry_after_ms) ||
     value.retry_after_ms > 3_600_000 ||
     typeof value.account_in_flight !== 'boolean' ||
-    !nonnegative(value.provider_batches) ||
-    value.provider_batches > 4 ||
-    (value.provider_model !== null &&
-      (typeof value.provider_model !== 'string' || value.provider_model.length > 128))
+    value.provider_batches !== 0 ||
+    value.provider_model !== null
   )
     return undefined;
   const correlationId = boundedSafeIdentifier(value.correlation_id);
@@ -637,18 +794,20 @@ function parseContextBudget(value: unknown, now = Date.now()): ContextBudgetSnap
     accountInFlight: value.account_in_flight,
     retryAfterMs: value.retry_after_ms,
     expiresAt: value.expires_at,
+    requestStartedAtMonotonic: requestStartedAt,
+    lifetimeMs: snapshotLifetimeMs,
     windowEnd: value.window_end,
     correlationId,
   };
 }
 
-function mcpStructuredValue(response: McpResult): unknown {
+function mcpStructuredValue(response: McpResult, maxTextBytes = 8 * 1024): unknown {
   if (response.structuredContent !== undefined) return response.structuredContent;
   const text = response.content?.find(
     (block): block is { readonly type: string; readonly text: string } =>
       block.type === 'text' && typeof block.text === 'string',
   )?.text;
-  if (text === undefined || byteLength(text) > 8 * 1024) return undefined;
+  if (text === undefined || byteLength(text) > maxTextBytes) return undefined;
   try {
     return JSON.parse(text);
   } catch {
@@ -656,8 +815,14 @@ function mcpStructuredValue(response: McpResult): unknown {
   }
 }
 
-async function readContextBudget(api: HookApi, server: string): Promise<ContextBudgetRead> {
+export async function readContextBudget(
+  api: HookApi,
+  server: string,
+  now: MonotonicClock = monotonicNow,
+): Promise<ContextBudgetRead> {
   try {
+    const requestStartedAt = now();
+    if (requestStartedAt === undefined) return { ok: false, kind: 'provider_unavailable' };
     const call = api.mcp.call(server, 'brain_context_budget', { schema_version: 1 });
     const hostTimers = globalThis as unknown as {
       setTimeout?: (callback: () => void, delay: number) => unknown;
@@ -671,8 +836,12 @@ async function readContextBudget(api: HookApi, server: string): Promise<ContextB
         resolve(undefined);
       }, BUDGET_PREFLIGHT_TIMEOUT_MS);
     });
-    const response = await Promise.race([call, timeout]);
-    if (timer !== undefined) hostTimers.clearTimeout?.(timer);
+    let response: McpResult | undefined;
+    try {
+      response = await Promise.race([call, timeout]);
+    } finally {
+      if (timer !== undefined) hostTimers.clearTimeout?.(timer);
+    }
     if (response === undefined)
       return { ok: false, kind: timedOut ? 'timeout' : 'invalid_response' };
     if (response.isError === true) {
@@ -683,7 +852,15 @@ async function readContextBudget(api: HookApi, server: string): Promise<ContextB
         error,
       };
     }
-    const snapshot = parseContextBudget(mcpStructuredValue(response));
+    const responseReceivedAt = now();
+    if (responseReceivedAt === undefined) return { ok: false, kind: 'provider_unavailable' };
+    if (responseReceivedAt - requestStartedAt > BUDGET_PREFLIGHT_TIMEOUT_MS)
+      return { ok: false, kind: 'timeout' };
+    const snapshot = parseContextBudget(
+      mcpStructuredValue(response),
+      requestStartedAt,
+      responseReceivedAt,
+    );
     return snapshot === undefined
       ? { ok: false, kind: 'invalid_response' }
       : { ok: true, snapshot };
@@ -702,6 +879,25 @@ async function readContextBudget(api: HookApi, server: string): Promise<ContextB
   }
 }
 
+export function contextBudgetIsFresh(
+  snapshot: ContextBudgetSnapshot,
+  now = monotonicNow(),
+): boolean {
+  const elapsedMs = now === undefined ? Number.NaN : now - snapshot.requestStartedAtMonotonic;
+  return (
+    now !== undefined &&
+    Number.isFinite(now) &&
+    Number.isFinite(snapshot.requestStartedAtMonotonic) &&
+    Number.isSafeInteger(snapshot.lifetimeMs) &&
+    snapshot.requestStartedAtMonotonic >= 0 &&
+    snapshot.lifetimeMs > 0 &&
+    snapshot.lifetimeMs <= BUDGET_SNAPSHOT_MAX_AGE_MS &&
+    Number.isFinite(elapsedMs) &&
+    elapsedMs >= 0 &&
+    elapsedMs < snapshot.lifetimeMs
+  );
+}
+
 function safeRpcStatus(error: unknown): number | undefined {
   const record = isRecord(error) ? error : {};
   const candidate = record.rpc_status ?? record.status ?? record.code;
@@ -809,6 +1005,7 @@ const CHECKPOINT_ERRORS: readonly CheckpointError[] = [
 type CompactErrorCode =
   | 'state_budget_exceeded'
   | 'shared_admission_exceeded'
+  | 'budget_response_invalid'
   | 'provider_budget_exceeded'
   | 'provider_unavailable'
   | 'provider_auth_denied'
@@ -823,6 +1020,7 @@ type CompactErrorCode =
 const COMPACT_ERROR_CODES: readonly CompactErrorCode[] = [
   'state_budget_exceeded',
   'shared_admission_exceeded',
+  'budget_response_invalid',
   'provider_budget_exceeded',
   'provider_unavailable',
   'provider_auth_denied',
@@ -852,6 +1050,8 @@ type ObservationRecord = {
     | 'fallback'
     | 'compact_entry'
     | 'compact_exit'
+    | 'native_summary_proof'
+    | 'native_fallback_proof'
     | 'native_error';
   readonly category:
     | 'observed'
@@ -886,11 +1086,21 @@ type ObservationRecord = {
   readonly selected_count?: number;
   readonly deferred_count?: number;
   readonly rpc_status?: number;
+  readonly provider_response_format?: 'structured' | 'text' | 'both' | 'missing';
   readonly admission_detail?: string;
   readonly admission_reason?: string;
   readonly request_id?: string;
   readonly correlation_id?: string;
   readonly retry_after_ms?: number;
+  readonly proof_expected_count?: number;
+  readonly proof_actual_count?: number;
+  readonly proof_match?: 'exact' | 'active_suffix' | 'mismatch' | 'ambiguous';
+  readonly proof_match_offset?: number;
+  readonly proof_view_source?: 'default' | 'api';
+  readonly proof_api_view_match?: 'exact' | 'mismatch' | 'unavailable' | 'not_checked';
+  readonly proof_api_count?: number;
+  readonly proof_delivery_source?: 'atomic_result' | 'legacy_append';
+  readonly proof_delivery_match_count?: number;
   readonly reason?:
     | 'all_recent'
     | 'goal_missing'
@@ -905,7 +1115,14 @@ type ObservationRecord = {
     | 'provider_not_attempted'
     | 'proof_expired'
     | 'proof_mismatch'
-    | 'native_fallback_unconfirmed';
+    | 'native_fallback_unconfirmed'
+    | 'native_summary_proof_expired'
+    | 'native_summary_host_view_mismatch'
+    | 'native_summary_host_view_ambiguous'
+    | 'native_summary_host_view_unavailable'
+    | 'native_summary_note_read_failed'
+    | 'native_summary_attachment_uncertain'
+    | PlanBindingFailureReason;
 };
 
 function observationConfiguration(options: HookOptions): ObservationOptions {
@@ -1507,6 +1724,17 @@ function observationRecord(
     | 'request_id'
     | 'correlation_id'
     | 'retry_after_ms'
+    | 'provider_response_format'
+    | 'proof_expected_count'
+    | 'proof_actual_count'
+    | 'proof_match'
+    | 'proof_match_offset'
+    | 'proof_view_source'
+    | 'proof_api_view_match'
+    | 'proof_api_count'
+    | 'proof_delivery_source'
+    | 'proof_delivery_match_count'
+    | 'reason'
   > = {},
   reason?: ObservationRecord['reason'],
   mode: ObservationRecord['mode'] = 'compact',
@@ -1550,6 +1778,33 @@ function observationRecord(
     ...(fields.request_id === undefined ? {} : { request_id: fields.request_id }),
     ...(fields.correlation_id === undefined ? {} : { correlation_id: fields.correlation_id }),
     ...(fields.retry_after_ms === undefined ? {} : { retry_after_ms: fields.retry_after_ms }),
+    ...(fields.provider_response_format === undefined
+      ? {}
+      : { provider_response_format: fields.provider_response_format }),
+    ...(fields.proof_expected_count === undefined
+      ? {}
+      : { proof_expected_count: fields.proof_expected_count }),
+    ...(fields.proof_actual_count === undefined
+      ? {}
+      : { proof_actual_count: fields.proof_actual_count }),
+    ...(fields.proof_match === undefined ? {} : { proof_match: fields.proof_match }),
+    ...(fields.proof_match_offset === undefined
+      ? {}
+      : { proof_match_offset: fields.proof_match_offset }),
+    ...(fields.proof_view_source === undefined
+      ? {}
+      : { proof_view_source: fields.proof_view_source }),
+    ...(fields.proof_api_view_match === undefined
+      ? {}
+      : { proof_api_view_match: fields.proof_api_view_match }),
+    ...(fields.proof_api_count === undefined ? {} : { proof_api_count: fields.proof_api_count }),
+    ...(fields.proof_delivery_source === undefined
+      ? {}
+      : { proof_delivery_source: fields.proof_delivery_source }),
+    ...(fields.proof_delivery_match_count === undefined
+      ? {}
+      : { proof_delivery_match_count: fields.proof_delivery_match_count }),
+    ...(fields.reason === undefined ? {} : { reason: fields.reason }),
     ...(reason === undefined ? {} : { reason }),
   };
 }
@@ -1585,7 +1840,19 @@ async function flushProofDiagnostic(
   sessionId: string,
   instanceId: string,
   clientVersion: string,
-  reason: 'proof_expired' | 'proof_mismatch' | 'native_fallback_unconfirmed',
+  reason: NonNullable<ObservationRecord['reason']>,
+  fields: Pick<
+    ObservationRecord,
+    | 'proof_expected_count'
+    | 'proof_actual_count'
+    | 'proof_match'
+    | 'proof_match_offset'
+    | 'proof_view_source'
+    | 'proof_api_view_match'
+    | 'proof_api_count'
+    | 'proof_delivery_source'
+    | 'proof_delivery_match_count'
+  > = {},
 ): Promise<void> {
   if (!options.diagnosticsEnabled) return;
   await flushObservationDiagnostics(api, options, operationId, sessionId, instanceId, [
@@ -1595,12 +1862,76 @@ async function flushProofDiagnostic(
       'native_error',
       clientVersion,
       undefined,
-      {},
+      fields,
       reason,
     ),
   ]);
 }
 
+async function flushNativeFallbackProofDiagnostic(
+  api: HookApi,
+  options: ObservationOptions,
+  operationId: string,
+  sessionId: string,
+  instanceId: string,
+  clientVersion: string,
+  fields: Pick<
+    ObservationRecord,
+    | 'proof_expected_count'
+    | 'proof_actual_count'
+    | 'proof_match'
+    | 'proof_match_offset'
+    | 'proof_view_source'
+    | 'proof_api_view_match'
+    | 'proof_api_count'
+  >,
+): Promise<void> {
+  if (!options.diagnosticsEnabled) return;
+  await flushObservationDiagnostics(api, options, operationId, sessionId, instanceId, [
+    observationRecord(
+      operationId,
+      'native_fallback_proof',
+      'observed',
+      clientVersion,
+      undefined,
+      fields,
+    ),
+  ]);
+}
+
+async function flushNativeSummaryProofDiagnostic(
+  api: HookApi,
+  options: ObservationOptions,
+  operationId: string,
+  sessionId: string,
+  instanceId: string,
+  clientVersion: string,
+  fields: Pick<
+    ObservationRecord,
+    | 'proof_expected_count'
+    | 'proof_actual_count'
+    | 'proof_match'
+    | 'proof_match_offset'
+    | 'proof_view_source'
+    | 'proof_api_view_match'
+    | 'proof_api_count'
+    | 'proof_delivery_source'
+    | 'proof_delivery_match_count'
+  >,
+): Promise<void> {
+  if (!options.diagnosticsEnabled) return;
+  await flushObservationDiagnostics(api, options, operationId, sessionId, instanceId, [
+    observationRecord(
+      operationId,
+      'native_summary_proof',
+      'observed',
+      clientVersion,
+      undefined,
+      fields,
+    ),
+  ]);
+}
+
 function logDiagnostic(
   api: HookApi,
   hook: 'turn.complete' | 'session.compact',
@@ -1681,11 +2012,11 @@ function visibleSnapshotsMatch(
   rereadMessages: readonly ClaudeMessage[],
   trigger: HookEvent['trigger'],
   instructions: string | undefined,
-): boolean {
-  if (eventMessages.length === 0) return rereadMessages.length === 0;
+): number | undefined {
+  if (eventMessages.length === 0) return rereadMessages.length === 0 ? 0 : undefined;
   const eventSignatures = visibleSignatures(eventMessages);
   const rereadSignatures = visibleSignatures(rereadMessages);
-  if (sameSequence(eventSignatures, rereadSignatures)) return true;
+  if (sameSequence(eventSignatures, rereadSignatures)) return 0;
   if (
     trigger === 'manual' &&
     instructions === undefined &&
@@ -1717,10 +2048,10 @@ function visibleSnapshotsMatch(
         matches.length === 1 &&
         matches[0] === precedingSignatures.length - eventSignatures.length
       )
-        return true;
+        return matches[0];
     }
   }
-  if (rereadMessages.length < eventMessages.length) return false;
+  if (rereadMessages.length < eventMessages.length) return undefined;
   const eventShape = eventSignatures;
   const matches: number[] = [];
   for (let index = 0; index <= rereadSignatures.length - eventSignatures.length; index++) {
@@ -1728,7 +2059,9 @@ function visibleSnapshotsMatch(
       matches.push(index);
     if (matches.length > 1) break;
   }
-  return matches.length === 1 && matches[0] === rereadMessages.length - eventMessages.length;
+  return matches.length === 1 && matches[0] === rereadMessages.length - eventMessages.length
+    ? matches[0]
+    : undefined;
 }
 
 function diagnosticShape(messages: readonly ClaudeMessage[]): Record<string, unknown> {
@@ -2330,6 +2663,10 @@ type NativeSummaryPending = {
   readonly noteSha256: string;
   readonly expectedPrefixHash: string;
   readonly expectedCount: number;
+  readonly expectedMessageHashes?: readonly string[];
+  readonly deliveryMode?: 'atomic_result' | 'legacy_append';
+  readonly anchorCounts?: readonly number[];
+  readonly anchorHashes?: readonly string[];
   readonly expiresAt: string;
   readonly appendAttempted: boolean;
   readonly nativeCompletedReported: boolean;
@@ -2577,6 +2914,10 @@ function structurallyValidNativeSummaryPending(
     'noteSha256',
     'expectedPrefixHash',
     'expectedCount',
+    'expectedMessageHashes',
+    'deliveryMode',
+    'anchorCounts',
+    'anchorHashes',
     'expiresAt',
     'appendAttempted',
     'nativeCompletedReported',
@@ -2603,6 +2944,28 @@ function structurallyValidNativeSummaryPending(
     Number.isSafeInteger(value.expectedCount) &&
     (value.expectedCount as number) > 0 &&
     (value.expectedCount as number) <= 10_000 &&
+    (value.expectedMessageHashes === undefined ||
+      (Array.isArray(value.expectedMessageHashes) &&
+        value.expectedMessageHashes.length === value.expectedCount &&
+        value.expectedMessageHashes.length <= MAX_NATIVE_SUMMARY_MESSAGE_HASHES &&
+        value.expectedMessageHashes.every(
+          (hash): hash is string => typeof hash === 'string' && /^[a-f0-9]{16}$/u.test(hash),
+        ))) &&
+    (value.deliveryMode === undefined ||
+      value.deliveryMode === 'atomic_result' ||
+      value.deliveryMode === 'legacy_append') &&
+    ((value.anchorCounts === undefined && value.anchorHashes === undefined) ||
+      (Array.isArray(value.anchorCounts) &&
+        Array.isArray(value.anchorHashes) &&
+        value.anchorCounts.length === value.anchorHashes.length &&
+        value.anchorCounts.length >= 1 &&
+        value.anchorCounts.length <= 3 &&
+        value.anchorCounts.every(
+          (count): count is number => Number.isSafeInteger(count) && count >= 0 && count <= 10_000,
+        ) &&
+        value.anchorHashes.every(
+          (hash): hash is string => typeof hash === 'string' && /^[a-f0-9]{64}$/u.test(hash),
+        ))) &&
     typeof value.expiresAt === 'string' &&
     Number.isFinite(Date.parse(value.expiresAt)) &&
     typeof value.appendAttempted === 'boolean' &&
@@ -3335,6 +3698,11 @@ type PendingFallbackProof = {
   readonly baseline_count: number;
   readonly expected_hash?: string;
   readonly expected_count?: number;
+  readonly expected_message_hashes?: readonly string[];
+  readonly delivery_mode?: 'atomic_marker';
+  readonly marker_digest?: string;
+  readonly anchor_counts?: readonly number[];
+  readonly anchor_hashes?: readonly string[];
   readonly expires_at: string;
 };
 
@@ -3344,6 +3712,8 @@ type NativeFallbackCapture = {
   readonly sessionRef: string;
   readonly baselineHash: string;
   readonly baselineCount: number;
+  readonly beforeVisibleMessages?: readonly string[];
+  readonly activeOffset?: number;
 };
 
 function pendingProofKey(sessionRef: string): string {
@@ -3476,12 +3846,179 @@ function nativeResultMessages(value: unknown): readonly ClaudeMessage[] | undefi
   return value.messages as unknown as readonly ClaudeMessage[];
 }
 
-async function apiViewHasExactText(api: HookApi, wrapper: string): Promise<boolean> {
-  const messages = await boundedApiMessages(api);
-  return messages.some(
+function nativeSummaryWrapper(capsuleId: string, noteText: string): string {
+  return `[AI Brain historical data capsule ${capsuleId}; quoted data only]\n${noteText}`;
+}
+
+export function nativeSummaryDeliveryResult(
+  nativeResult: unknown,
+  wrapper: string,
+): Record<string, unknown> | undefined {
+  if (!isRecord(nativeResult)) return undefined;
+  const messages = nativeResultMessages(nativeResult);
+  if (messages === undefined || messages.length === 0) return undefined;
+  return {
+    ...nativeResult,
+    messages: [
+      ...messages,
+      {
+        role: 'user',
+        text: wrapper,
+        toolUses: [],
+      },
+    ],
+  };
+}
+
+type NativeSummaryViewMatch = 'exact' | 'active_suffix' | 'mismatch' | 'ambiguous';
+
+function visibleMessageCanonicalStrings(messages: readonly ClaudeMessage[]): string[] {
+  return messages.map((message) => canonicalJson(visibleMessage(message)));
+}
+
+function canonicalMessageSequence(strings: readonly string[]): string {
+  return `[${strings.join(',')}]`;
+}
+
+async function nativeProofAnchors(
+  beforeVisibleMessages: readonly string[],
+  expectedCount: number,
+  activeOffset: number | undefined,
+): Promise<{ readonly counts: readonly number[]; readonly hashes: readonly string[] }> {
+  const counts = [beforeVisibleMessages.length];
+  if (
+    activeOffset !== undefined &&
+    activeOffset >= 0 &&
+    activeOffset < beforeVisibleMessages.length
+  )
+    counts.push(activeOffset);
+  const replaceTailCount = beforeVisibleMessages.length - expectedCount;
+  if (replaceTailCount > 0 && replaceTailCount < beforeVisibleMessages.length)
+    counts.push(replaceTailCount);
+  const uniqueCounts = [...new Set(counts)].filter((count) => count <= 10_000);
+  const hashes = await Promise.all(
+    uniqueCounts.map((count) =>
+      sha256(canonicalMessageSequence(beforeVisibleMessages.slice(0, count))),
+    ),
+  );
+  return { counts: uniqueCounts, hashes };
+}
+
+/**
+ * Claude keeps the retired transcript prefix in session.messages() after a
+ * native compaction, while the hook result describes the active summary
+ * segment. Accept only the exact prefix or one uniquely matching active
+ * suffix. A repeated match remains ambiguous and fails closed.
+ */
+export async function nativeSummaryViewMatch(
+  actualMessages: readonly ClaudeMessage[],
+  expectedCount: number,
+  expectedHash: string,
+  expectedMessageHashes: readonly string[] | undefined,
+  anchorCounts: readonly number[] | undefined,
+  anchorHashes: readonly string[] | undefined,
+): Promise<NativeSummaryViewMatch> {
+  if (expectedCount === 0 || actualMessages.length < expectedCount) return 'mismatch';
+  const matchingStarts: number[] = [];
+  if (expectedMessageHashes === undefined) {
+    const prefixHash = await sha256(
+      canonicalJson(visibleMessages(actualMessages.slice(0, expectedCount))),
+    );
+    return prefixHash === expectedHash ? 'exact' : 'mismatch';
+  }
+  if (expectedMessageHashes.length !== expectedCount) return 'mismatch';
+  const actualMessageHashes: string[] = [];
+  for (const message of actualMessages)
+    actualMessageHashes.push((await sha256(canonicalJson(visibleMessage(message)))).slice(0, 16));
+  for (let index = 0; index <= actualMessages.length - expectedCount; index += 1) {
+    if (
+      expectedMessageHashes.every((hash, offset) => hash === actualMessageHashes[index + offset])
+    ) {
+      const candidateHash = await sha256(
+        canonicalJson(visibleMessages(actualMessages.slice(index, index + expectedCount))),
+      );
+      if (candidateHash === expectedHash) matchingStarts.push(index);
+    }
+    if (matchingStarts.length > 1) return 'ambiguous';
+  }
+  if (matchingStarts.length !== 1) return 'mismatch';
+  const start = matchingStarts[0] ?? -1;
+  if (start === 0 && actualMessages.length === expectedCount) return 'exact';
+  if (start === 0) return 'exact';
+  if (await pendingAnchorMatches(actualMessages, start, anchorCounts, anchorHashes))
+    return 'active_suffix';
+  return 'mismatch';
+}
+
+async function pendingAnchorMatches(
+  actualMessages: readonly ClaudeMessage[],
+  actualOffset: number,
+  anchorCounts: readonly number[] | undefined,
+  anchorHashes: readonly string[] | undefined,
+): Promise<boolean> {
+  if (
+    anchorCounts === undefined ||
+    anchorHashes === undefined ||
+    anchorCounts.length !== anchorHashes.length
+  )
+    return false;
+  const anchorIndex = anchorCounts.indexOf(actualOffset);
+  if (anchorIndex < 0) return false;
+  return (
+    (await sha256(canonicalJson(visibleMessages(actualMessages.slice(0, actualOffset))))) ===
+    anchorHashes[anchorIndex]
+  );
+}
+
+async function nativeSummaryMatchedOffset(
+  actualMessages: readonly ClaudeMessage[],
+  expectedCount: number,
+  expectedHash: string,
+  expectedMessageHashes: readonly string[] | undefined,
+  anchorCounts: readonly number[] | undefined,
+  anchorHashes: readonly string[] | undefined,
+): Promise<number | undefined> {
+  if (
+    expectedMessageHashes === undefined ||
+    anchorCounts === undefined ||
+    anchorHashes === undefined
+  )
+    return undefined;
+  const actualMessageHashes = await Promise.all(
+    actualMessages.map(async (message) =>
+      (await sha256(canonicalJson(visibleMessage(message)))).slice(0, 16),
+    ),
+  );
+  const matches: number[] = [];
+  for (const offset of anchorCounts) {
+    if (offset + expectedCount > actualMessages.length) continue;
+    if (!expectedMessageHashes.every((hash, index) => hash === actualMessageHashes[offset + index]))
+      continue;
+    if (
+      (await sha256(
+        canonicalJson(visibleMessages(actualMessages.slice(offset, offset + expectedCount))),
+      )) !== expectedHash
+    )
+      continue;
+    if (!(await pendingAnchorMatches(actualMessages, offset, anchorCounts, anchorHashes))) continue;
+    matches.push(offset);
+  }
+  return matches.length === 1 ? matches[0] : undefined;
+}
+
+function exactTextCount(
+  messages: readonly { readonly role: 'user' | 'assistant'; readonly text: string }[],
+  wrapper: string,
+): number {
+  return messages.filter(
     (message) =>
       message.role === 'user' && (message.text === wrapper || message.text === `${wrapper}\n`),
-  );
+  ).length;
+}
+
+async function apiViewExactTextCount(api: HookApi, wrapper: string): Promise<number> {
+  const messages = await boundedApiMessages(api);
+  return exactTextCount(messages, wrapper);
 }
 
 async function boundedApiMessages(
@@ -3704,6 +4241,11 @@ function structurallyValidPendingProof(value: unknown): value is PendingProof {
           'baseline_count',
           'expected_hash',
           'expected_count',
+          'expected_message_hashes',
+          'delivery_mode',
+          'marker_digest',
+          'anchor_counts',
+          'anchor_hashes',
           'expires_at',
         ]);
   if (Object.keys(value).some((key) => !allowedRootKeys.has(key))) return false;
@@ -3724,7 +4266,31 @@ function structurallyValidPendingProof(value: unknown): value is PendingProof {
       (value.baseline_count as number) >= 0 &&
       (value.expected_hash === undefined || /^[a-f0-9]{64}$/u.test(String(value.expected_hash))) &&
       (value.expected_count === undefined ||
-        (Number.isSafeInteger(value.expected_count) && (value.expected_count as number) >= 0))
+        (Number.isSafeInteger(value.expected_count) && (value.expected_count as number) >= 0)) &&
+      (value.expected_message_hashes === undefined ||
+        (Array.isArray(value.expected_message_hashes) &&
+          value.expected_message_hashes.length === value.expected_count &&
+          value.expected_message_hashes.length <= MAX_NATIVE_SUMMARY_MESSAGE_HASHES &&
+          value.expected_message_hashes.every(
+            (hash): hash is string => typeof hash === 'string' && /^[a-f0-9]{16}$/u.test(hash),
+          ))) &&
+      (value.delivery_mode === undefined || value.delivery_mode === 'atomic_marker') &&
+      (value.marker_digest === undefined || /^[a-f0-9]{64}$/u.test(String(value.marker_digest))) &&
+      ((value.delivery_mode === undefined && value.marker_digest === undefined) ||
+        (value.delivery_mode === 'atomic_marker' && typeof value.marker_digest === 'string')) &&
+      ((value.anchor_counts === undefined && value.anchor_hashes === undefined) ||
+        (Array.isArray(value.anchor_counts) &&
+          Array.isArray(value.anchor_hashes) &&
+          value.anchor_counts.length === value.anchor_hashes.length &&
+          value.anchor_counts.length >= 1 &&
+          value.anchor_counts.length <= 3 &&
+          value.anchor_counts.every(
+            (count): count is number =>
+              Number.isSafeInteger(count) && count >= 0 && count <= 10_000,
+          ) &&
+          value.anchor_hashes.every(
+            (hash): hash is string => typeof hash === 'string' && /^[a-f0-9]{64}$/u.test(hash),
+          )))
     );
   if (
     value.kind !== 'custom' ||
@@ -4354,6 +4920,26 @@ function getTelemetry(
   return state.current;
 }
 
+async function nativeFallbackMarker(
+  operationId: string,
+  sessionRef: string,
+  baselineHash: string,
+): Promise<{ readonly text: string; readonly digest: string }> {
+  const digest = await sha256(
+    `aibrain-native-fallback-v1|${operationId}|${sessionRef}|${baselineHash}`,
+  );
+  return { digest, text: `[AI Brain native fallback receipt v1:${digest}]` };
+}
+
+function nativeFallbackDeliveryResult(nativeResult: unknown, marker: string): unknown {
+  const messages = nativeResultMessages(nativeResult);
+  if (messages === undefined || messages.length === 0) return nativeResult;
+  return {
+    ...(nativeResult as Record<string, unknown>),
+    messages: [...messages, { role: 'user', text: marker, toolUses: [] }],
+  };
+}
+
 async function queueNativeFallbackProof(
   api: HookApi,
   runtime: ProofRuntimeState,
@@ -4362,12 +4948,30 @@ async function queueNativeFallbackProof(
   baselineHash: string,
   baselineCount: number,
   nativeResult: unknown,
-): Promise<void> {
+  beforeVisibleMessages: readonly string[] | undefined,
+  activeOffset: number | undefined,
+): Promise<unknown> {
   const expectedMessages = nativeResultMessages(nativeResult);
   const expectedHash =
     expectedMessages === undefined
       ? undefined
       : await sha256(canonicalJson(visibleMessages(expectedMessages)));
+  const expectedMessageHashes =
+    expectedMessages !== undefined && expectedMessages.length <= MAX_NATIVE_SUMMARY_MESSAGE_HASHES
+      ? await Promise.all(
+          expectedMessages.map(async (message) =>
+            (await sha256(canonicalJson(visibleMessage(message)))).slice(0, 16),
+          ),
+        )
+      : undefined;
+  const anchors =
+    beforeVisibleMessages === undefined || expectedMessages === undefined
+      ? undefined
+      : await nativeProofAnchors(beforeVisibleMessages, expectedMessages.length, activeOffset);
+  const marker =
+    expectedMessages === undefined
+      ? undefined
+      : await nativeFallbackMarker(operationId, sessionRef, baselineHash);
   const proof: PendingFallbackProof = {
     schema_version: 1,
     kind: 'native_fallback',
@@ -4378,10 +4982,25 @@ async function queueNativeFallbackProof(
     ...(expectedHash === undefined
       ? {}
       : { expected_hash: expectedHash, expected_count: expectedMessages?.length ?? 0 }),
-    expires_at: new Date(Date.now() + 120_000).toISOString(),
+    ...(expectedMessageHashes === undefined
+      ? {}
+      : { expected_message_hashes: expectedMessageHashes }),
+    ...(marker === undefined
+      ? {}
+      : { delivery_mode: 'atomic_marker' as const, marker_digest: marker.digest }),
+    ...(anchors === undefined
+      ? {}
+      : { anchor_counts: anchors.counts, anchor_hashes: anchors.hashes }),
+    // Native fallback confirmation may occur after a long host compaction.
+    // Keep its proof lifetime aligned with the durable proof bound instead of
+    // expiring it after two minutes while Claude is still processing.
+    expires_at: new Date(Date.now() + PENDING_PROOF_TTL_MS).toISOString(),
   };
   runtime.pendingProofMemory = proof;
   runtime.pendingProofPersistenceFailed = !(await savePendingProof(api, proof));
+  return runtime.pendingProofPersistenceFailed || marker === undefined
+    ? nativeResult
+    : nativeFallbackDeliveryResult(nativeResult, marker.text);
 }
 
 async function confirmPendingProof(
@@ -4447,21 +5066,101 @@ async function confirmPendingProof(
     return;
   }
   let verified = proof.kind === 'custom' ? await verifyCustomProof(proof, messages) : false;
+  let fallbackMatch: NativeSummaryViewMatch | undefined;
+  let fallbackProofFields: Pick<
+    ObservationRecord,
+    | 'proof_expected_count'
+    | 'proof_actual_count'
+    | 'proof_match'
+    | 'proof_match_offset'
+    | 'proof_view_source'
+    | 'proof_api_view_match'
+    | 'proof_api_count'
+  > = {};
   if (proof.kind === 'native_fallback') {
     const expectedCount = proof.expected_count;
-    const actualPrefix = expectedCount === undefined ? messages : messages.slice(0, expectedCount);
-    const latestHash = await sha256(canonicalJson(visibleMessages(actualPrefix)));
-    verified =
-      proof.expected_hash !== undefined &&
-      expectedCount !== undefined &&
-      messages.length >= expectedCount &&
-      latestHash === proof.expected_hash &&
-      actualPrefix.length === expectedCount;
+    fallbackProofFields = {
+      ...(expectedCount === undefined ? {} : { proof_expected_count: expectedCount }),
+      proof_actual_count: messages.length,
+    };
+    if (proof.expected_hash !== undefined && expectedCount !== undefined) {
+      if (proof.delivery_mode === 'atomic_marker' && proof.marker_digest !== undefined) {
+        try {
+          const apiView = await boundedApiMessages(api);
+          const marker = await nativeFallbackMarker(
+            proof.operation_id,
+            sessionRef,
+            proof.baseline_hash,
+          );
+          const markerValid = marker.digest === proof.marker_digest;
+          const markerCount = exactTextCount(apiView, marker.text);
+          fallbackProofFields = {
+            ...fallbackProofFields,
+            proof_view_source: 'api',
+            proof_api_view_match: markerValid && markerCount === 1 ? 'exact' : 'mismatch',
+            proof_api_count: apiView.length,
+          };
+          if (markerValid && markerCount === 1) {
+            fallbackMatch = 'exact';
+            fallbackProofFields = {
+              ...fallbackProofFields,
+              proof_match: 'exact',
+              proof_match_offset: 0,
+            };
+            verified = true;
+          }
+        } catch {
+          fallbackProofFields = {
+            ...fallbackProofFields,
+            proof_view_source: 'api',
+            proof_api_view_match: 'unavailable',
+          };
+        }
+      } else {
+        // Compatibility with proofs written by beta15 and earlier. These
+        // proofs predate the API-view fingerprint and retain the old strict
+        // default-view check.
+        fallbackMatch = await nativeSummaryViewMatch(
+          messages,
+          expectedCount,
+          proof.expected_hash,
+          proof.expected_message_hashes,
+          proof.anchor_counts,
+          proof.anchor_hashes,
+        );
+        const fallbackOffset =
+          fallbackMatch === 'active_suffix'
+            ? await nativeSummaryMatchedOffset(
+                messages,
+                expectedCount,
+                proof.expected_hash,
+                proof.expected_message_hashes,
+                proof.anchor_counts,
+                proof.anchor_hashes,
+              )
+            : undefined;
+        fallbackProofFields = {
+          ...fallbackProofFields,
+          proof_view_source: 'default',
+          proof_match: fallbackMatch,
+          ...(fallbackMatch === 'exact' ? { proof_match_offset: 0 } : {}),
+          ...(fallbackOffset === undefined ? {} : { proof_match_offset: fallbackOffset }),
+        };
+        verified = fallbackMatch === 'exact' || fallbackMatch === 'active_suffix';
+      }
+    }
   }
   if (runtime.pendingProofPersistenceFailed) verified = false;
   const telemetry = getTelemetry(api, runtime.brainServer, runtime.options, runtime.telemetryState);
   if (!verified) {
-    if (deferMismatch) return;
+    // Only the atomic native fallback marker may wait for the host's active
+    // API view. A prepared JEV capsule remains strict at every callback.
+    if (
+      deferMismatch &&
+      proof.kind === 'native_fallback' &&
+      proof.delivery_mode === 'atomic_marker'
+    )
+      return;
     runtime.pendingProofMemory = undefined;
     runtime.pendingProofPersistenceFailed = false;
     await clearPendingProof(api, sessionRef);
@@ -4474,6 +5173,7 @@ async function confirmPendingProof(
       runtime.observationInstanceId,
       nativeClientVersion(runtime.options),
       reason,
+      fallbackProofFields,
     );
     if (runtime.diagnosticMode)
       api.ui.log(
@@ -4485,6 +5185,16 @@ async function confirmPendingProof(
   runtime.pendingProofMemory = undefined;
   runtime.pendingProofPersistenceFailed = false;
   await clearPendingProof(api, sessionRef);
+  if (proof.kind === 'native_fallback')
+    await flushNativeFallbackProofDiagnostic(
+      api,
+      runtime.observation,
+      proof.operation_id,
+      sessionRef,
+      runtime.observationInstanceId,
+      nativeClientVersion(runtime.options),
+      fallbackProofFields,
+    );
   if (proof.kind === 'custom') {
     const dropped = proof.pairs.filter((pair) => pair.action === 'drop_pair').length;
     const reduced = proof.pairs.filter((pair) => pair.action === 'truncate_result').length;
@@ -4517,9 +5227,43 @@ async function recoverNativeSummaryNote(
   }
   const pendingOperationId = pending.operationId;
   const telemetry = getTelemetry(api, runtime.brainServer, runtime.options, runtime.telemetryState);
+  let proofFields: Pick<
+    ObservationRecord,
+    | 'proof_expected_count'
+    | 'proof_actual_count'
+    | 'proof_match'
+    | 'proof_match_offset'
+    | 'proof_view_source'
+    | 'proof_api_view_match'
+    | 'proof_api_count'
+    | 'proof_delivery_source'
+    | 'proof_delivery_match_count'
+  > = {
+    proof_expected_count: pending.deliveryMode === 'atomic_result' ? 1 : pending.expectedCount,
+  };
+  proofFields = {
+    ...proofFields,
+    proof_delivery_source: pending.deliveryMode ?? 'legacy_append',
+    proof_view_source: pending.deliveryMode === 'atomic_result' ? 'api' : 'default',
+    proof_api_view_match: 'not_checked',
+  };
   const uncertain = async (reason: string): Promise<void> => {
     runtime.pendingNativeSummary = undefined;
     await clearNativeSummaryPending(api, sessionRef).catch(() => undefined);
+    const diagnosticReason: ObservationRecord['reason'] =
+      reason === 'pending_expired'
+        ? 'native_summary_proof_expired'
+        : reason === 'native_view_ambiguous'
+          ? 'native_summary_host_view_ambiguous'
+          : reason === 'native_prefix_mismatch'
+            ? 'native_summary_host_view_mismatch'
+            : reason === 'messages_unavailable' ||
+                reason === 'api_view_unavailable' ||
+                reason === 'api_view_reread_failed'
+              ? 'native_summary_host_view_unavailable'
+              : reason === 'note_read_failed'
+                ? 'native_summary_note_read_failed'
+                : 'native_summary_attachment_uncertain';
     await flushProofDiagnostic(
       api,
       runtime.observation,
@@ -4527,7 +5271,8 @@ async function recoverNativeSummaryNote(
       sessionRef,
       runtime.observationInstanceId,
       nativeClientVersion(runtime.options),
-      'proof_mismatch',
+      diagnosticReason,
+      proofFields,
     );
     if (runtime.diagnosticMode)
       api.ui.log(
@@ -4539,6 +5284,71 @@ async function recoverNativeSummaryNote(
     await uncertain('pending_expired');
     return;
   }
+  if (pending.deliveryMode === 'atomic_result') {
+    let noteText: string;
+    try {
+      noteText = await readNativeSummaryNote(
+        api,
+        runtime.options,
+        pending.operationId,
+        sessionRef,
+        pending.noteSha256,
+      );
+    } catch {
+      await uncertain('note_read_failed');
+      return;
+    }
+    const wrapper = nativeSummaryWrapper(pending.capsuleId, noteText);
+    let apiCount: number;
+    let matchCount: number;
+    try {
+      const apiView = await boundedApiMessages(api);
+      apiCount = apiView.length;
+      matchCount = exactTextCount(apiView, wrapper);
+    } catch {
+      proofFields = { ...proofFields, proof_api_view_match: 'unavailable' };
+      if (!allowAppend) return;
+      await uncertain('api_view_unavailable');
+      return;
+    }
+    proofFields = {
+      ...proofFields,
+      proof_api_count: apiCount,
+      proof_delivery_match_count: matchCount,
+      proof_api_view_match: matchCount === 1 ? 'exact' : 'mismatch',
+      proof_match: matchCount === 1 ? 'exact' : 'mismatch',
+    };
+    if (matchCount !== 1) {
+      if (matchCount === 0 && !allowAppend) return;
+      await uncertain('native_summary_attachment_uncertain');
+      return;
+    }
+    await flushNativeSummaryProofDiagnostic(
+      api,
+      runtime.observation,
+      pendingOperationId,
+      sessionRef,
+      runtime.observationInstanceId,
+      nativeClientVersion(runtime.options),
+      proofFields,
+    );
+    if (!pending.nativeCompletedReported) {
+      const marked: NativeSummaryPending = { ...pending, nativeCompletedReported: true };
+      try {
+        await saveNativeSummaryPending(api, marked);
+        pending = marked;
+        runtime.pendingNativeSummary = marked;
+      } catch {
+        runtime.pendingNativeSummary = marked;
+        pending = marked;
+      }
+      telemetry.nativeSummaryCompleted(pending.operationId);
+    }
+    runtime.pendingNativeSummary = undefined;
+    await clearNativeSummaryPending(api, sessionRef);
+    telemetry.recoveryAttached(pending.operationId);
+    return;
+  }
   let messages: ClaudeMessage[];
   try {
     messages = await api.session.messages();
@@ -4546,10 +5356,60 @@ async function recoverNativeSummaryNote(
     await uncertain('messages_unavailable');
     return;
   }
-  const prefix = messages.slice(0, pending.expectedCount);
-  const prefixHash = await sha256(canonicalJson(visibleMessages(prefix)));
-  if (messages.length < pending.expectedCount || prefixHash !== pending.expectedPrefixHash) {
-    await uncertain('native_prefix_mismatch');
+  proofFields = { ...proofFields, proof_actual_count: messages.length };
+  const viewMatch = await nativeSummaryViewMatch(
+    messages,
+    pending.expectedCount,
+    pending.expectedPrefixHash,
+    pending.expectedMessageHashes,
+    pending.anchorCounts,
+    pending.anchorHashes,
+  );
+  const viewOffset =
+    viewMatch === 'active_suffix'
+      ? await nativeSummaryMatchedOffset(
+          messages,
+          pending.expectedCount,
+          pending.expectedPrefixHash,
+          pending.expectedMessageHashes,
+          pending.anchorCounts,
+          pending.anchorHashes,
+        )
+      : undefined;
+  proofFields = {
+    ...proofFields,
+    proof_match: viewMatch,
+    ...(viewMatch === 'exact' ? { proof_match_offset: 0 } : {}),
+    ...(viewOffset === undefined ? {} : { proof_match_offset: viewOffset }),
+  };
+  await flushNativeSummaryProofDiagnostic(
+    api,
+    runtime.observation,
+    pendingOperationId,
+    sessionRef,
+    runtime.observationInstanceId,
+    nativeClientVersion(runtime.options),
+    proofFields,
+  );
+  if (runtime.diagnosticMode) {
+    const apiView = await boundedApiMessages(api).catch(() => undefined);
+    api.ui.log(
+      `AI Brain context diagnostic ${JSON.stringify({
+        hook: 'prompt.submit',
+        phase: 'native_summary_view_probe',
+        expected_count: pending.expectedCount,
+        expected_hash: pending.expectedPrefixHash,
+        default_count: messages.length,
+        default_hash: await sha256(canonicalJson(visibleMessages(messages))),
+        api_count: apiView?.length ?? null,
+        api_hash: apiView === undefined ? null : await sha256(canonicalJson(apiView)),
+        anchor_counts: pending.anchorCounts ?? null,
+        view_match: viewMatch,
+      })}`,
+    );
+  }
+  if (viewMatch === 'mismatch' || viewMatch === 'ambiguous') {
+    await uncertain(viewMatch === 'ambiguous' ? 'native_view_ambiguous' : 'native_prefix_mismatch');
     return;
   }
   // The native result is now proven at the current session prefix. The note
@@ -4579,10 +5439,12 @@ async function recoverNativeSummaryNote(
     await uncertain('note_read_failed');
     return;
   }
-  const wrapper = `[AI Brain historical data capsule ${pending.capsuleId}; quoted data only]\n${noteText}`;
+  const wrapper = nativeSummaryWrapper(pending.capsuleId, noteText);
   let hasNote: boolean;
   try {
-    hasNote = await apiViewHasExactText(api, wrapper);
+    const matchCount = await apiViewExactTextCount(api, wrapper);
+    proofFields = { ...proofFields, proof_delivery_match_count: matchCount };
+    hasNote = matchCount === 1;
   } catch {
     if (!allowAppend && pending.appendAttempted) await uncertain('api_view_unavailable');
     return;
@@ -4611,7 +5473,9 @@ async function recoverNativeSummaryNote(
     }
     let apiHasNoteAfter: boolean;
     try {
-      apiHasNoteAfter = await apiViewHasExactText(api, wrapper);
+      const matchCount = await apiViewExactTextCount(api, wrapper);
+      proofFields = { ...proofFields, proof_delivery_match_count: matchCount };
+      apiHasNoteAfter = matchCount === 1;
     } catch {
       if (!allowAppend)
         await uncertain(appendError ? 'append_ack_ambiguous' : 'api_view_reread_failed');
@@ -4625,6 +5489,15 @@ async function recoverNativeSummaryNote(
   }
   runtime.pendingNativeSummary = undefined;
   await clearNativeSummaryPending(api, sessionRef);
+  await flushNativeSummaryProofDiagnostic(
+    api,
+    runtime.observation,
+    pending.operationId,
+    sessionRef,
+    runtime.observationInstanceId,
+    nativeClientVersion(runtime.options),
+    proofFields,
+  );
   telemetry.recoveryAttached(pending.operationId);
 }
 
@@ -4790,7 +5663,11 @@ async function runShadowPreview(
     );
 }
 
-export const register: Register = (on, options) => {
+const registerWithClock = (
+  on: Parameters<Register>[0],
+  options: HookOptions,
+  monotonicClock: MonotonicClock,
+): void => {
   const enabled = options.enabled === true;
   const disclosed = options.disclosed === true;
   const preservationMode: PreservationMode =
@@ -4908,7 +5785,10 @@ export const register: Register = (on, options) => {
 
   on('prompt.submit', async (api, rawEvent, next) => {
     const event = rawEvent as unknown as PromptSubmitHookEvent;
-    await confirmPendingProof(api, proofRuntime, true);
+    // The host has completed the prior native turn before accepting a new
+    // prompt. This is the final proof opportunity for a fallback whose first
+    // turn.complete callback observed the retired/default view.
+    await confirmPendingProof(api, proofRuntime);
     if (
       proofRuntime.compactionStrategy === 'native_summary_notes' &&
       enabled &&
@@ -4983,7 +5863,10 @@ export const register: Register = (on, options) => {
   });
 
   on('turn.complete', async (api, event, next) => {
-    await confirmPendingProof(api, proofRuntime);
+    // The native host can publish the result before its active API view catches
+    // up. Keep only the atomic fallback marker pending through this lifecycle
+    // edge; prompt.submit performs the strict confirmation on the next turn.
+    await confirmPendingProof(api, proofRuntime, true);
     if (
       proofRuntime.compactionStrategy === 'native_summary_notes' &&
       enabled &&
@@ -5155,7 +6038,7 @@ export const register: Register = (on, options) => {
       nativeContinuationStarted = true;
       const nativeResult = await next(event);
       if (fallbackCapture !== undefined)
-        await queueNativeFallbackProof(
+        return queueNativeFallbackProof(
           api,
           proofRuntime,
           fallbackCapture.operationId,
@@ -5163,6 +6046,8 @@ export const register: Register = (on, options) => {
           fallbackCapture.baselineHash,
           fallbackCapture.baselineCount,
           nativeResult,
+          fallbackCapture.beforeVisibleMessages,
+          fallbackCapture.activeOffset,
         );
       return nativeResult;
     };
@@ -5225,6 +6110,8 @@ export const register: Register = (on, options) => {
           | 'request_id'
           | 'correlation_id'
           | 'retry_after_ms'
+          | 'provider_response_format'
+          | 'reason'
         > = {},
       ): void => {
         if (!observation.diagnosticsEnabled || diagnosticRecords.length >= 64) return;
@@ -5285,6 +6172,8 @@ export const register: Register = (on, options) => {
       let proofSessionRef: string | undefined;
       let proofBaselineHash: string | undefined;
       let proofBaselineCount = 0;
+      let baselineActiveOffset: number | undefined;
+      let proofBaselineVisibleMessages: readonly string[] | undefined;
       let historicalNotes: readonly VerifiedHistoricalNote[] = [];
       try {
         const current = event.messages;
@@ -5303,14 +6192,22 @@ export const register: Register = (on, options) => {
         });
         const rereadBaselineHash = await sha256(canonicalJson(reread));
         proofBaselineHash = rereadBaselineHash;
-        proofBaselineCount = current.length;
-        if (!visibleSnapshotsMatch(current, reread, event.trigger, event.instructions)) {
+        proofBaselineCount = reread.length;
+        const rereadActiveOffset = visibleSnapshotsMatch(
+          current,
+          reread,
+          event.trigger,
+          event.instructions,
+        );
+        if (rereadActiveOffset === undefined) {
           await diagnosticMismatch(api, diagnosticMode, 'reread_before', current, reread);
           markDiagnostic('snapshot', 'invalid_response');
           markDiagnostic('fallback', 'invalid_response');
           logFallback(api, 'reread_before', undefined, policyVersion === 2);
           return continueWithTelemetryFlush();
         }
+        baselineActiveOffset = rereadActiveOffset;
+        proofBaselineVisibleMessages = visibleMessageCanonicalStrings(reread);
         stage = 'projection';
         const built = buildProjection(
           current,
@@ -5359,7 +6256,7 @@ export const register: Register = (on, options) => {
         markDiagnostic('budget', 'provider_not_attempted', {
           item_count: built.pairs.filter((pair) => !pair.protectedPair).length,
         });
-        const budgetRead = await readContextBudget(api, brainServer);
+        const budgetRead = await readContextBudget(api, brainServer, monotonicClock);
         if (!budgetRead.ok) {
           const admission = budgetRead.kind === 'admission_denied';
           const category: ObservationRecord['category'] = admission
@@ -5374,8 +6271,13 @@ export const register: Register = (on, options) => {
           const errorMetadata: Partial<ContextErrorMetadata> = isRecord(budgetRead.error)
             ? (budgetRead.error as ContextErrorMetadata)
             : {};
+          const budgetErrorCode = admission
+            ? 'shared_admission_exceeded'
+            : budgetRead.kind === 'invalid_response'
+              ? 'budget_response_invalid'
+              : 'provider_unavailable';
           markDiagnostic('budget', category, {
-            compact_error_code: admission ? 'shared_admission_exceeded' : 'provider_unavailable',
+            compact_error_code: budgetErrorCode,
             ...(typeof errorMetadata.admissionDetail === 'string'
               ? { admission_detail: errorMetadata.admissionDetail }
               : {}),
@@ -5390,7 +6292,7 @@ export const register: Register = (on, options) => {
               : {}),
           });
           markDiagnostic('fallback', category, {
-            compact_error_code: admission ? 'shared_admission_exceeded' : 'provider_unavailable',
+            compact_error_code: budgetErrorCode,
           });
           logFallback(
             api,
@@ -5406,7 +6308,9 @@ export const register: Register = (on, options) => {
             operationId,
             sessionRef,
             baselineHash: rereadBaselineHash,
-            baselineCount: current.length,
+            baselineCount: reread.length,
+            beforeVisibleMessages: visibleMessageCanonicalStrings(reread),
+            activeOffset: baselineActiveOffset,
           });
         }
         const budget = budgetRead.snapshot;
@@ -5431,7 +6335,9 @@ export const register: Register = (on, options) => {
             operationId,
             sessionRef,
             baselineHash: rereadBaselineHash,
-            baselineCount: current.length,
+            baselineCount: reread.length,
+            beforeVisibleMessages: visibleMessageCanonicalStrings(reread),
+            activeOffset: baselineActiveOffset,
           });
         }
         let providerProjection = built.projection;
@@ -5506,7 +6412,9 @@ export const register: Register = (on, options) => {
               operationId,
               sessionRef,
               baselineHash: rereadBaselineHash,
-              baselineCount: current.length,
+              baselineCount: reread.length,
+              beforeVisibleMessages: visibleMessageCanonicalStrings(reread),
+              activeOffset: baselineActiveOffset,
             });
           }
           providerProjection = window.projection;
@@ -5552,18 +6460,42 @@ export const register: Register = (on, options) => {
           projection: providerProjection,
           ...(policyVersion === 2 ? { schema_version: 2, options: wireOptions } : {}),
         };
+        await persistDiagnostics();
+        if (!contextBudgetIsFresh(budget, monotonicClock())) {
+          markDiagnostic('budget', 'invalid_response', {
+            compact_error_code: 'budget_response_invalid',
+          });
+          markDiagnostic('fallback', 'invalid_response', {
+            compact_error_code: 'budget_response_invalid',
+          });
+          logFallback(api, 'budget_unavailable', undefined, policyVersion === 2);
+          getTelemetry(api, brainServer, options, telemetryState).fallback(
+            operationId,
+            'budget_unavailable',
+          );
+          return continueWithTelemetryFlush({
+            operationId,
+            sessionRef,
+            baselineHash: rereadBaselineHash,
+            baselineCount: reread.length,
+            beforeVisibleMessages: visibleMessageCanonicalStrings(reread),
+            activeOffset: baselineActiveOffset,
+          });
+        }
         stage = 'mcp_call';
         markDiagnostic('provider_request', 'request_attempted', {
           item_count: providerPairs.filter((pair) => !pair.protectedPair).length,
           byte_count: byteLength(JSON.stringify(input)),
         });
-        await persistDiagnostics();
         if (diagnosticMode)
           api.ui.log(
             `AI Brain context diagnostic ${JSON.stringify({ hook: 'session.compact', phase: 'mcp_started' })}`,
           );
         const call = api.mcp.call(brainServer, 'brain_context_compact', input);
         pendingMcp = call;
+        // The request has started, so persist its attempt without delaying the
+        // budget freshness check or extending the provider deadline.
+        void persistDiagnostics();
         let timedOut = false;
         const hostTimers = globalThis as unknown as {
           setTimeout?: (callback: () => void, delay: number) => unknown;
@@ -5610,13 +6542,41 @@ export const register: Register = (on, options) => {
         markDiagnostic(
           'provider_response',
           response.isError === true ? 'native_error' : 'response_obtained',
+          providerResponseMetadata(response),
         );
         if (response.isError === true) throw providerResponseError(response);
         stage = 'parse_plan';
-        const structured = mcpStructuredValue(response);
-        if (byteLength(JSON.stringify(structured)) > MAX_RESULT_BYTES)
-          throw new Error('AI Brain response is too large');
-        const plan = parsePlan(structured, policyVersion, v2Options);
+        const structured = mcpStructuredValue(response, MAX_RESULT_BYTES);
+        let plan: Record<string, unknown>;
+        try {
+          const serialized = JSON.stringify(structured);
+          const responseText = response.content?.find(
+            (block): block is { readonly type: string; readonly text: string } =>
+              block.type === 'text' && typeof block.text === 'string',
+          )?.text;
+          if (
+            (serialized === undefined &&
+              response.structuredContent === undefined &&
+              responseText === undefined) ||
+            (response.structuredContent === undefined &&
+              responseText !== undefined &&
+              byteLength(responseText) > MAX_RESULT_BYTES) ||
+            (serialized !== undefined && byteLength(serialized) > MAX_RESULT_BYTES)
+          )
+            throw new Error(
+              serialized === undefined &&
+                response.structuredContent === undefined &&
+                responseText === undefined
+                ? 'AI Brain plan envelope is missing'
+                : 'AI Brain response is too large',
+            );
+          plan = parsePlan(structured, policyVersion, v2Options);
+        } catch (error) {
+          throw planBindingFailure(
+            planParseFailureReason(error),
+            'AI Brain plan failed validation',
+          );
+        }
         const planDecisions = plan.decisions;
         const planStats = plan.stats;
         markDiagnostic('plan_validation', 'provider_decision', {
@@ -5627,22 +6587,30 @@ export const register: Register = (on, options) => {
             `AI Brain context diagnostic ${JSON.stringify({ hook: 'session.compact', phase: 'plan_ready', status: plan.status, eligible_count: isRecord(planStats) && typeof planStats.eligible_count === 'number' ? planStats.eligible_count : 0, batch_count: isRecord(planStats) && typeof planStats.batch_count === 'number' ? planStats.batch_count : 0 })}`,
           );
         stage = 'match_plan';
-        if (
-          plan.sessionRef !== sessionRef ||
-          plan.revision !== revision ||
-          plan.projectionHash !== (await sha256(canonicalJson(providerProjection))) ||
-          (policyVersion === 2 && plan.optionsHash !== optionsHash) ||
-          Date.parse(String(plan.expiresAt)) <= Date.now()
-        )
-          throw new Error('AI Brain plan is stale');
+        const bindingReason = planBindingFailureReason(plan, {
+          sessionRef,
+          revision,
+          projectionHash: await sha256(canonicalJson(providerProjection)),
+          ...(policyVersion === 2 ? { optionsHash: optionsHash ?? null } : {}),
+        });
+        if (policyVersion === 2 && optionsHash === undefined)
+          throw planBindingFailure('plan_options_mismatch', 'AI Brain plan options are missing');
+        if (bindingReason !== undefined)
+          throw planBindingFailure(bindingReason, 'AI Brain plan binding was rejected');
         if ((await api.session.id()) !== sessionRef)
-          throw new Error('Claude session changed during planning');
+          throw planBindingFailure(
+            'session_changed_during_planning',
+            'Claude session changed during planning',
+          );
         stage = 'reread_after';
         const latestVisible = await api.session.messages();
         if ((await sha256(canonicalJson(latestVisible))) !== rereadBaselineHash) {
           await diagnosticMismatch(api, diagnosticMode, 'reread_after', current, latestVisible);
           logFallback(api, 'reread_after', undefined, policyVersion === 2);
-          throw new Error('Claude transcript changed during planning');
+          throw planBindingFailure(
+            'snapshot_changed_during_planning',
+            'Claude transcript changed during planning',
+          );
         }
         if (compactionStrategy === 'native_summary_notes') {
           const latestHistoricalNotes = await collectVerifiedHistoricalNotes(
@@ -5655,7 +6623,10 @@ export const register: Register = (on, options) => {
               latestHistoricalNotes.map((note) => [note.capsuleId, note.noteSha256]),
             ) !== canonicalJson(historicalNotes.map((note) => [note.capsuleId, note.noteSha256]))
           )
-            throw new Error('native_note_capsule_changed');
+            throw planBindingFailure(
+              'historical_notes_changed_during_planning',
+              'Claude historical notes changed during planning',
+            );
         }
         if (plan.status === 'noop') {
           markDiagnostic('candidate_preparation', 'skipped');
@@ -5729,6 +6700,7 @@ export const register: Register = (on, options) => {
             transformed,
           );
           getTelemetry(api, brainServer, options, telemetryState).notesWritten(operationId);
+          const beforeVisibleMessages = visibleMessageCanonicalStrings(reread);
           nativeContinuationStarted = true;
           const nativeInput = appendHistoricalNotes(transformed, historicalNotes);
           const nativeResult = await next({ ...event, messages: nativeInput });
@@ -5738,6 +6710,29 @@ export const register: Register = (on, options) => {
             throw new Error('native_summary_result_missing');
           const configuration = fileCheckpointConfiguration(options);
           if (configuration.mode !== 'helper') throw new Error('native_note_helper_unavailable');
+          const expectedMessageHashes =
+            expectedMessages.length <= MAX_NATIVE_SUMMARY_MESSAGE_HASHES
+              ? await Promise.all(
+                  expectedMessages.map(async (message) =>
+                    (await sha256(canonicalJson(visibleMessage(message)))).slice(0, 16),
+                  ),
+                )
+              : undefined;
+          const wrapper = nativeSummaryWrapper(note.capsuleId, note.noteText);
+          const deliveredResult = nativeSummaryDeliveryResult(nativeResult, wrapper);
+          if (deliveredResult === undefined) {
+            getTelemetry(api, brainServer, options, telemetryState).uncertain(
+              operationId,
+              'native_summary_recovery',
+            );
+            return nativeResult;
+          }
+          const deliveryMode: NativeSummaryPending['deliveryMode'] = 'atomic_result';
+          const anchors = await nativeProofAnchors(
+            beforeVisibleMessages,
+            expectedMessages.length,
+            baselineActiveOffset,
+          );
           const pendingNativeSummary: NativeSummaryPending = {
             schemaVersion: 1,
             operationId,
@@ -5747,13 +6742,19 @@ export const register: Register = (on, options) => {
             noteSha256: note.noteSha256,
             expectedPrefixHash: await sha256(canonicalJson(visibleMessages(expectedMessages))),
             expectedCount: expectedMessages.length,
+            ...(expectedMessageHashes === undefined ? {} : { expectedMessageHashes }),
+            deliveryMode,
+            anchorCounts: anchors.counts,
+            anchorHashes: anchors.hashes,
             expiresAt: new Date(Date.now() + PENDING_PROOF_TTL_MS).toISOString(),
             appendAttempted: false,
             nativeCompletedReported: false,
           };
+          let deliveryIntentSaved = false;
           try {
             await saveNativeSummaryPending(api, pendingNativeSummary);
             proofRuntime.pendingNativeSummary = pendingNativeSummary;
+            deliveryIntentSaved = true;
           } catch {
             if (nativeSessionRef !== undefined)
               await flushProofDiagnostic(
@@ -5763,7 +6764,7 @@ export const register: Register = (on, options) => {
                 nativeSessionRef,
                 observationInstanceId,
                 nativeClientVersion(options),
-                'proof_mismatch',
+                'native_summary_attachment_uncertain',
               );
             getTelemetry(api, brainServer, options, telemetryState).uncertain(
               operationId,
@@ -5772,7 +6773,7 @@ export const register: Register = (on, options) => {
           }
           if (options.telemetryEnabled === true && options.telemetryDisclosed === true)
             await getTelemetry(api, brainServer, options, telemetryState).flush();
-          return nativeResult;
+          return deliveryIntentSaved ? (deliveredResult ?? nativeResult) : nativeResult;
         }
         return { messages: transformed };
       } catch (error) {
@@ -5791,7 +6792,7 @@ export const register: Register = (on, options) => {
                 nativeSessionRef,
                 observationInstanceId,
                 nativeClientVersion(options),
-                'proof_mismatch',
+                'native_summary_attachment_uncertain',
               );
           }
           throw error;
@@ -5817,6 +6818,14 @@ export const register: Register = (on, options) => {
         const rpcStatus = safeRpcStatus(error);
         const checkpoint = failureStage === 'checkpoint' ? checkpointFailure(error) : undefined;
         const errorMetadata = isRecord(error) ? error : {};
+        const planReason =
+          failureStage === 'parse_plan' ||
+          failureStage === 'match_plan' ||
+          failureStage === 'reread_after'
+            ? isPlanBindingFailureReason(errorMetadata.planBindingFailureReason)
+              ? errorMetadata.planBindingFailureReason
+              : undefined
+            : undefined;
         const admissionFallback = isAdmissionFallback(error);
         const compactCode =
           isRecord(error) &&
@@ -5855,6 +6864,7 @@ export const register: Register = (on, options) => {
           ...(typeof errorMetadata.retryAfterMs === 'number'
             ? { retry_after_ms: errorMetadata.retryAfterMs }
             : {}),
+          ...(planReason === undefined ? {} : { reason: planReason }),
           ...(checkpoint === undefined
             ? {}
             : { checkpoint_phase: checkpoint.phase, checkpoint_error: checkpoint.code }),
@@ -5867,6 +6877,7 @@ export const register: Register = (on, options) => {
         markDiagnostic('fallback', failureCategory, {
           ...(rpcStatus === undefined ? {} : { rpc_status: rpcStatus }),
           ...(compactCode === undefined ? {} : { compact_error_code: compactCode }),
+          ...(planReason === undefined ? {} : { reason: planReason }),
         });
         const telemetry = getTelemetry(api, brainServer, options, telemetryState);
         telemetry.fallback(operationId, admissionFallback ? 'admission_denied' : stage);
@@ -5878,6 +6889,12 @@ export const register: Register = (on, options) => {
                 sessionRef: proofSessionRef,
                 baselineHash: proofBaselineHash,
                 baselineCount: proofBaselineCount,
+                ...(proofBaselineVisibleMessages === undefined
+                  ? {}
+                  : { beforeVisibleMessages: proofBaselineVisibleMessages }),
+                ...(baselineActiveOffset === undefined
+                  ? {}
+                  : { activeOffset: baselineActiveOffset }),
               }
             : undefined,
         );
@@ -5905,3 +6922,13 @@ export const register: Register = (on, options) => {
     });
   });
 };
+
+export const register: Register = (on, options) => registerWithClock(on, options, monotonicNow);
+
+export function registerForTesting(
+  on: Parameters<Register>[0],
+  options: HookOptions,
+  monotonicClock: MonotonicClock,
+): void {
+  registerWithClock(on, options, monotonicClock);
+}