polygram 0.38.3 → 0.38.5

package/lib/db.js

@@ -7,7 +7,11 @@
 const fs = require('fs');
 const path = require('path');
 const crypto = require('crypto');
+const { isDeepStrictEqual } = require('node:util');
 const Database = require('better-sqlite3');
+const {
+  classifyCodexRecoveryEvidence,
+} = require('./db/auto-resume');
 const {
   pruneCodexOperationalData,
 } = require('./db/codex-retention');
@@ -26,6 +30,9 @@ const {
 const {
   sanitizeCodexFaultProvenance,
 } = require('./codex/fault-provenance');
+const {
+  codexDispatchReservationId,
+} = require('./codex/dispatch-reservation-id');
 const {
   sanitizeForDurableWrite,
   sanitizeDurableStructured,
@@ -87,7 +94,7 @@ const durableJson = (value) => {
 //
 // 0.15: bumped 13 → 14. Adds migration 014-secret-redactions.sql
 // (secret_redactions audit table + messages.secret_scanned_at).
-const SCHEMA_VERSION = 20;
+const SCHEMA_VERSION = 21;
 
 // Sentinel `error` value for outbound rows whose API call may or may not
 // have reached Telegram. markStalePending writes it; hasOutboundReplyTo
@@ -384,6 +391,25 @@ function wrap(db) {
     };
   }
 
+  const codexProviderIdentityFields = [
+    'session_key',
+    'namespace',
+    'provider',
+    'provider_session_id',
+    'agent',
+    'cwd',
+    'model',
+    'effort',
+    'pm_backend',
+    'spawn_profile_id',
+  ];
+
+  function hasExactCodexProviderIdentity(actual, expected) {
+    return actual != null && codexProviderIdentityFields.every(
+      (field) => actual[field] === expected[field],
+    );
+  }
+
   function legacySessionParams(row) {
     return {
       session_key: row.session_key,
@@ -1020,7 +1046,7 @@ function wrap(db) {
   }
 
   function assertCodexCheckpointOwner(generation, kind) {
-    if (['request-prepared', 'queued-send-cancelled'].includes(kind)) return;
+    if (kind === 'request-prepared') return;
     const lease = db.prepare(`
       SELECT generation_id, stable_host_id, boot_session_id, status
         FROM codex_daemon_lease
@@ -1385,6 +1411,62 @@ function wrap(db) {
     `).run(ts, ts, generationId, generationId, generationId);
   }
 
+  function insertCodexPreparedCheckpoint({
+    generation,
+    generationId,
+    attemptId,
+    method,
+    threadId,
+    turnId,
+    requestId,
+    itemId,
+    sourceId,
+    clientUserMessageId,
+    detailJson,
+    ts,
+  }) {
+    db.prepare(`
+      INSERT INTO codex_turn_attempts (
+        attempt_id, generation_id, session_key, method,
+        thread_id, turn_id, telegram_source_message_id,
+        client_user_message_id, delivery_state, recovery_state,
+        created_ts, updated_ts
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, 'prepared', 'prepared', ?, ?)
+    `).run(
+      attemptId,
+      generationId,
+      generation.session_key,
+      method,
+      threadId,
+      turnId,
+      sourceId,
+      clientUserMessageId,
+      ts,
+      ts,
+    );
+    requireCodexAttempt(attemptId, generationId);
+    db.prepare(`
+      INSERT INTO codex_attempt_checkpoints (
+        generation_id, attempt_id, kind, thread_id, turn_id,
+        request_id, item_id, detail_json, ts
+      ) VALUES (?, ?, 'request-prepared', ?, ?, ?, ?, ?, ?)
+    `).run(
+      generationId,
+      attemptId,
+      threadId,
+      turnId,
+      requestId,
+      itemId,
+      detailJson,
+      ts,
+    );
+    return {
+      changes: 1,
+      attemptId,
+      kind: 'request-prepared',
+    };
+  }
+
   function recordCodexCheckpoint(input) {
     const kind = requiredCodexString(input?.kind, 'checkpoint kind');
     if (!codexCheckpointKinds.has(kind)) {
@@ -1499,27 +1581,33 @@ function wrap(db) {
             'CODEX_ATTEMPT_ID_REUSED',
           );
         }
-        db.prepare(`
-          INSERT INTO codex_turn_attempts (
-            attempt_id, generation_id, session_key, method,
-            thread_id, turn_id, telegram_source_message_id,
-            client_user_message_id, delivery_state, recovery_state,
-            created_ts, updated_ts
-          ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, 'prepared', 'prepared', ?, ?)
-        `).run(
-          attemptId,
+        return insertCodexPreparedCheckpoint({
+          generation,
           generationId,
-          generation.session_key,
+          attemptId,
           method,
           threadId,
           turnId,
+          requestId,
+          itemId,
           sourceId,
           clientUserMessageId,
+          detailJson,
           ts,
-          ts,
-        );
-        attempt = requireCodexAttempt(attemptId, generationId);
+        });
       } else if (kind === 'queued-send-cancelled' && attemptId && !attempt) {
+        if (
+          method !== 'queued/send'
+          || !threadId
+          || turnId != null
+          || !sourceId
+          || !clientUserMessageId
+        ) {
+          throw codexError(
+            'Codex queued cancellation requires exact pre-write identity',
+            'CODEX_CHECKPOINT_INPUT_INVALID',
+          );
+        }
         db.prepare(`
           INSERT INTO codex_turn_attempts (
             attempt_id, generation_id, session_key, method,
@@ -1966,6 +2054,217 @@ function wrap(db) {
     })();
   }
 
+  function recordCodexTurnStartPrepared({
+    checkpoint,
+    provider,
+    expectedProviderGenerationId = null,
+  } = {}) {
+    if (
+      checkpoint?.kind !== 'request-prepared'
+      || checkpoint?.method !== 'turn/start'
+    ) {
+      throw codexError(
+        'Codex turn preparation requires a turn/start prepared checkpoint',
+        'CODEX_CHECKPOINT_INPUT_INVALID',
+      );
+    }
+    const generationId = requiredCodexString(
+      checkpoint.generationId ?? checkpoint.generation_id,
+      'generation ID',
+    );
+    const stableHostId = requiredCodexString(
+      checkpoint.stable_host_id ?? checkpoint.hostIdentity,
+      'stable host identity',
+    );
+    const bootSessionId = requiredCodexString(
+      checkpoint.boot_session_id ?? checkpoint.bootSessionIdentity,
+      'boot-session identity',
+    );
+    const attemptId = requiredCodexString(
+      checkpoint.attemptId ?? checkpoint.attempt_id,
+      'attempt ID',
+    );
+    const threadId = requiredCodexString(
+      checkpoint.threadId ?? checkpoint.thread_id,
+      'thread ID',
+    );
+    const sourceId = optionalCodexString(
+      checkpoint.source,
+      'source message ID',
+    );
+    const clientUserMessageId = requiredCodexString(
+      checkpoint.clientUserMessageId ?? checkpoint.client_user_message_id,
+      'client user message ID',
+    );
+    const turnId = optionalCodexString(
+      checkpoint.turnId ?? checkpoint.turn_id,
+      'turn ID',
+    );
+    const requestId = optionalCodexRequestId(
+      checkpoint.requestId ?? checkpoint.request_id,
+    );
+    const itemId = optionalCodexString(
+      checkpoint.itemId ?? checkpoint.item_id,
+      'item ID',
+    );
+    const ts = requiredTimestamp(
+      checkpoint.ts ?? Date.now(),
+      'checkpoint timestamp',
+    );
+    const detailJson = checkpointDetail(checkpoint);
+    const expectedLineage = expectedProviderGenerationId == null
+      ? null
+      : requiredCodexString(
+        expectedProviderGenerationId,
+        'provider-session lineage',
+      );
+    const providerSession = providerSessionParams({
+      ...provider,
+      session_key: requiredCodexString(provider?.session_key, 'session key'),
+      cwd: requiredCodexString(provider?.cwd, 'provider cwd'),
+      model: requiredCodexString(provider?.model, 'provider model'),
+      effort: requiredCodexString(provider?.effort, 'provider effort'),
+      spawn_profile_id: requiredCodexString(
+        provider?.spawn_profile_id,
+        'provider spawn profile ID',
+      ),
+    });
+    if (
+      providerSession.namespace !== CODEX_APP_SERVER_NAMESPACE
+      || providerSession.provider !== 'codex'
+      || providerSession.pm_backend !== 'codex'
+      || providerSession.provider_session_id !== threadId
+      || providerSession.agent !== null
+    ) {
+      throw codexError(
+        'Codex turn preparation provider identity is inconsistent',
+        'CODEX_CHECKPOINT_INPUT_INVALID',
+      );
+    }
+
+    return db.transaction(() => {
+      const generation = assertCodexGenerationIdentity(
+        generationId,
+        stableHostId,
+        bootSessionId,
+      );
+      assertCodexCheckpointOwner(generation, 'turn-start-prepared');
+      if (
+        generation.session_key !== providerSession.session_key
+        || generation.thread_id !== threadId
+        || !db.prepare(`
+          SELECT 1
+            FROM codex_attempt_checkpoints
+           WHERE generation_id = ?
+             AND kind = 'thread-initialized'
+             AND thread_id = ?
+           LIMIT 1
+        `).get(generationId, threadId)
+      ) {
+        throw codexError(
+          'Codex turn preparation does not match the initialized generation',
+          'CODEX_CHECKPOINT_STALE_GENERATION',
+        );
+      }
+
+      const currentProvider = getProviderSessionStmt.get(
+        providerSession.session_key,
+        CODEX_APP_SERVER_NAMESPACE,
+      );
+      const attempt = db.prepare(`
+        SELECT * FROM codex_turn_attempts WHERE attempt_id = ?
+      `).get(attemptId);
+      if (attempt) {
+        assertCodexAttemptIdentity(attempt, {
+          method: 'turn/start',
+          thread_id: threadId,
+          telegram_source_message_id: sourceId,
+          client_user_message_id: clientUserMessageId,
+        });
+        const exactCheckpoint = hasExactCodexCheckpoint({
+          generationId,
+          attemptId,
+          kind: 'request-prepared',
+          threadId,
+          turnId: null,
+          requestId: null,
+          itemId: null,
+          detailJson,
+        });
+        if (!exactCheckpoint) {
+          throw codexError(
+            'Codex attempt ID was reused with different metadata',
+            'CODEX_ATTEMPT_ID_REUSED',
+          );
+        }
+        if (
+          !hasExactCodexProviderIdentity(currentProvider, providerSession)
+          || (
+            expectedLineage !== null
+            && currentProvider.generation_id !== expectedLineage
+          )
+        ) {
+          throw codexError(
+            'Codex prepared turn replay no longer matches provider identity',
+            expectedLineage === null
+              ? 'CODEX_TURN_PREPARATION_STALE'
+              : 'CODEX_PROVIDER_LINEAGE_MISMATCH',
+          );
+        }
+        return {
+          changes: 0,
+          attemptId,
+          kind: 'request-prepared',
+        };
+      }
+
+      if (
+        expectedLineage !== null
+        && (
+          !hasExactCodexProviderIdentity(currentProvider, providerSession)
+          || currentProvider.generation_id !== expectedLineage
+        )
+      ) {
+        throw codexError(
+          'Codex strict resume provider lineage changed before turn preparation',
+          'CODEX_PROVIDER_LINEAGE_MISMATCH',
+        );
+      }
+
+      upsertProviderSessionStmt.run(providerSession);
+      const checkpointResult = insertCodexPreparedCheckpoint({
+        generation,
+        generationId,
+        attemptId,
+        method: 'turn/start',
+        threadId,
+        turnId,
+        requestId,
+        itemId,
+        sourceId,
+        clientUserMessageId,
+        detailJson,
+        ts,
+      });
+      if (expectedLineage !== null) {
+        const committedProvider = getProviderSessionStmt.get(
+          providerSession.session_key,
+          CODEX_APP_SERVER_NAMESPACE,
+        );
+        if (
+          !hasExactCodexProviderIdentity(committedProvider, providerSession)
+          || committedProvider.generation_id !== expectedLineage
+        ) {
+          throw codexError(
+            'Codex strict resume provider lineage rotated during turn preparation',
+            'CODEX_PROVIDER_LINEAGE_MISMATCH',
+          );
+        }
+      }
+      return checkpointResult;
+    })();
+  }
+
   function isCleanRetirementDelivery(attempt) {
     if (
       attempt?.method !== 'turn/start'
@@ -2292,6 +2591,77 @@ function wrap(db) {
     };
   }
 
+  function cleanRestartCancellationProof(attempt) {
+    if (
+      !attempt
+      || attempt.delivery_state !== 'prepared'
+      || attempt.recovery_state !== 'cancelled'
+      || attempt.turn_id != null
+      || attempt.terminal_status != null
+      || !['turn/start', 'queued/send'].includes(attempt.method)
+      || typeof attempt.thread_id !== 'string'
+      || attempt.thread_id.length === 0
+      || typeof attempt.telegram_source_message_id !== 'string'
+      || attempt.telegram_source_message_id.length === 0
+      || typeof attempt.client_user_message_id !== 'string'
+      || attempt.client_user_message_id.length === 0
+    ) {
+      return null;
+    }
+    const expectedKind = attempt.method === 'turn/start'
+      ? 'active-start-cancelled'
+      : 'queued-send-cancelled';
+    const checkpoints = db.prepare(`
+      SELECT kind, thread_id, turn_id, detail_json
+        FROM codex_attempt_checkpoints
+       WHERE generation_id = ?
+         AND attempt_id = ?
+       ORDER BY id
+       LIMIT 3
+    `).all(attempt.generation_id, attempt.attempt_id);
+    const allowedKinds = attempt.method === 'turn/start'
+      ? new Set(['request-prepared', expectedKind])
+      : new Set([expectedKind]);
+    if (
+      checkpoints.some((checkpoint) => !allowedKinds.has(checkpoint.kind))
+      || checkpoints.filter((checkpoint) => checkpoint.kind === expectedKind)
+        .length !== 1
+      || (
+        attempt.method === 'turn/start'
+        && checkpoints.filter((checkpoint) => checkpoint.kind === 'request-prepared')
+          .length !== 1
+      )
+    ) {
+      return null;
+    }
+    const cancellation = checkpoints.find(
+      (checkpoint) => checkpoint.kind === expectedKind,
+    );
+    let detail;
+    try {
+      detail = JSON.parse(cancellation.detail_json);
+    } catch {
+      return null;
+    }
+    if (
+      detail == null
+      || Array.isArray(detail)
+      || typeof detail !== 'object'
+      || detail.reason !== 'clean-restart'
+      || cancellation.thread_id !== attempt.thread_id
+      || cancellation.turn_id != null
+      || detail.method !== attempt.method
+      || detail.source !== attempt.telegram_source_message_id
+      || detail.clientUserMessageId !== attempt.client_user_message_id
+    ) {
+      return null;
+    }
+    return {
+      kind: expectedKind,
+      reason: 'clean-restart',
+    };
+  }
+
   function getReplayProviderRecovery(input) {
     const allowed = new Set([
       'sessionKey',
@@ -2338,11 +2708,10 @@ function wrap(db) {
     const attempts = db.prepare(`
       SELECT attempt.*
         FROM codex_turn_attempts attempt
-        JOIN codex_generations generation
-          ON generation.generation_id = attempt.generation_id
-       WHERE generation.session_key = ?
+       WHERE attempt.session_key = ?
          AND attempt.telegram_source_message_id = ?
        ORDER BY attempt.created_ts, attempt.attempt_id
+       LIMIT 2
     `).all(sessionKey, telegramMessageId);
     const linkedInputs = db.prepare(`
       SELECT linked.*
@@ -2353,6 +2722,7 @@ function wrap(db) {
          AND linked.telegram_chat_id = ?
          AND linked.telegram_message_id = ?
        ORDER BY linked.created_ts, linked.linked_input_id
+       LIMIT 2
     `).all(sessionKey, telegramChatId, telegramMessageId);
     const hasCodexEvidence = (
       reservations.length > 0
@@ -2393,7 +2763,14 @@ function wrap(db) {
     }
     if (
       attempt
-      && !['turn/start', 'turn/steer'].includes(attempt.method)
+      && !['turn/start', 'turn/steer', 'queued/send'].includes(attempt.method)
+    ) {
+      return unknown('codex-evidence-conflict');
+    }
+    if (
+      reservation
+      && ['reserved', 'queue-authorized'].includes(reservation.state)
+      && reservation.settled_ts != null
     ) {
       return unknown('codex-evidence-conflict');
     }
@@ -2454,17 +2831,26 @@ function wrap(db) {
       if (reservation.target_attempt_id != null) {
         targetAttempt = attempt;
       }
-      if (attempt && attempt.method !== 'turn/start') {
-        return unknown('codex-evidence-conflict');
+      if (attempt?.method === 'queued/send') {
+        kind = 'queued-send';
+      } else {
+        if (attempt && attempt.method !== 'turn/start') {
+          return unknown('codex-evidence-conflict');
+        }
+        kind = 'dispatch-reservation';
       }
-      kind = 'dispatch-reservation';
     } else if (attempt) {
-      if (attempt.method !== 'turn/start') {
+      if (attempt.method === 'queued/send') {
+        kind = 'queued-send';
+      } else if (attempt.method !== 'turn/start') {
         return unknown('codex-evidence-conflict');
+      } else {
+        kind = 'primary-turn';
       }
-      kind = 'primary-turn';
     }
 
+    const cancellationProof = cleanRestartCancellationProof(attempt);
+
     return {
       provider: 'codex',
       kind,
@@ -2474,6 +2860,7 @@ function wrap(db) {
           reservationId: reservation.reservation_id,
           generationId: reservation.generation_id,
           state: reservation.state,
+          steerAttemptId: reservation.steer_attempt_id,
           targetAttemptId: reservation.target_attempt_id,
         }
         : null,
@@ -2487,9 +2874,237 @@ function wrap(db) {
         }
         : null,
       targetAttempt: publicCodexAttempt(targetAttempt),
+      ...(cancellationProof ? { cancellationProof } : {}),
     };
   }
 
+  function prepareCodexCleanReplay(input = {}) {
+    assertExactKeys(
+      input,
+      new Set([
+        'source',
+        'sessionKey',
+        'currentGeneration',
+        'expectedEvidence',
+        'owner',
+        'ts',
+      ]),
+      'CODEX_CLEAN_REPLAY_PAYLOAD_REJECTED',
+      'clean replay',
+    );
+    assertExactKeys(
+      input.source,
+      new Set(['botName', 'telegramChatId', 'telegramMessageId']),
+      'CODEX_CLEAN_REPLAY_PAYLOAD_REJECTED',
+      'clean replay source',
+    );
+    assertExactKeys(
+      input.currentGeneration,
+      new Set(['generationId']),
+      'CODEX_CLEAN_REPLAY_PAYLOAD_REJECTED',
+      'clean replay generation',
+    );
+    assertExactKeys(
+      input.owner,
+      new Set(['stableHostId', 'bootSessionId']),
+      'CODEX_CLEAN_REPLAY_PAYLOAD_REJECTED',
+      'clean replay owner',
+    );
+    const sessionKey = requiredCodexString(
+      input.sessionKey,
+      'clean replay session key',
+    );
+    const botName = requiredCodexString(
+      input.source?.botName,
+      'clean replay bot name',
+    );
+    const telegramChatId = requiredCodexString(
+      input.source?.telegramChatId,
+      'clean replay Telegram chat ID',
+    );
+    const telegramMessageId = requiredCodexString(
+      input.source?.telegramMessageId,
+      'clean replay Telegram message ID',
+    );
+    const generationId = requiredCodexString(
+      input.currentGeneration?.generationId,
+      'clean replay generation ID',
+    );
+    const stableHostId = requiredCodexString(
+      input.owner?.stableHostId,
+      'clean replay stable host identity',
+    );
+    const bootSessionId = requiredCodexString(
+      input.owner?.bootSessionId,
+      'clean replay boot-session identity',
+    );
+    const ts = requiredTimestamp(
+      input.ts ?? Date.now(),
+      'clean replay timestamp',
+    );
+    const expectedEvidence = input.expectedEvidence;
+    if (expectedEvidence == null || typeof expectedEvidence !== 'object') {
+      throw codexError(
+        'Codex clean replay expected evidence is required',
+        'CODEX_CLEAN_REPLAY_EVIDENCE_INVALID',
+      );
+    }
+    const reservationId = codexDispatchReservationId({
+      botName,
+      telegramChatId,
+      telegramMessageId,
+    });
+
+    return db.transaction(() => {
+      const actualEvidence = getReplayProviderRecovery({
+        sessionKey,
+        botName,
+        telegramChatId,
+        telegramMessageId,
+      });
+      const disposition = classifyCodexRecoveryEvidence(actualEvidence);
+      if (
+        !isDeepStrictEqual(actualEvidence, expectedEvidence)
+        || disposition.action !== 'recover'
+        || disposition.cleanRestartSafe !== true
+      ) {
+        throw codexError(
+          'Codex clean replay evidence changed or is not safe',
+          'CODEX_CLEAN_REPLAY_EVIDENCE_CHANGED',
+        );
+      }
+
+      const generation = db.prepare(`
+        SELECT *
+          FROM codex_generations
+         WHERE generation_id = ?
+      `).get(generationId);
+      const lease = db.prepare(`
+        SELECT * FROM codex_daemon_lease WHERE singleton = 1
+      `).get();
+      if (
+        !generation
+        || generation.session_key !== sessionKey
+        || generation.stable_host_id !== stableHostId
+        || generation.boot_session_id !== bootSessionId
+        || generation.state !== 'active'
+        || lease?.generation_id !== generationId
+        || lease.stable_host_id !== stableHostId
+        || lease.boot_session_id !== bootSessionId
+        || lease.status !== 'active'
+      ) {
+        throw codexError(
+          'Codex clean replay generation does not own the active lease',
+          'CODEX_CLEAN_REPLAY_GENERATION_MISMATCH',
+        );
+      }
+
+      const inboundRows = db.prepare(`
+        SELECT id, handler_status
+          FROM messages
+         WHERE direction = 'in'
+           AND bot_name = ?
+           AND chat_id = ?
+           AND CAST(msg_id AS TEXT) = ?
+      `).all(botName, telegramChatId, telegramMessageId);
+      if (
+        inboundRows.length !== 1
+        || inboundRows[0].handler_status !== 'replay-pending'
+      ) {
+        throw codexError(
+          'Codex clean replay no longer owns one replay-pending input',
+          'CODEX_CLEAN_REPLAY_INBOUND_MISMATCH',
+        );
+      }
+
+      const reservationRows = db.prepare(`
+        SELECT *
+          FROM codex_dispatch_reservations
+         WHERE reservation_id = ?
+            OR (
+              bot_name = ?
+              AND telegram_chat_id = ?
+              AND telegram_message_id = ?
+            )
+         ORDER BY reservation_id
+      `).all(
+        reservationId,
+        botName,
+        telegramChatId,
+        telegramMessageId,
+      );
+      if (reservationRows.length === 0) {
+        db.prepare(`
+          INSERT INTO codex_dispatch_reservations (
+            reservation_id, generation_id, session_key,
+            bot_name, telegram_chat_id, telegram_message_id, state,
+            steer_attempt_id, target_attempt_id,
+            created_ts, updated_ts, settled_ts
+          ) VALUES (?, ?, ?, ?, ?, ?, 'reserved', NULL, NULL, ?, ?, NULL)
+        `).run(
+          reservationId,
+          generationId,
+          sessionKey,
+          botName,
+          telegramChatId,
+          telegramMessageId,
+          ts,
+          ts,
+        );
+      } else {
+        const reservation = reservationRows[0];
+        if (
+          reservationRows.length !== 1
+          || reservation.reservation_id !== reservationId
+          || reservation.session_key !== sessionKey
+          || reservation.bot_name !== botName
+          || reservation.telegram_chat_id !== telegramChatId
+          || reservation.telegram_message_id !== telegramMessageId
+        ) {
+          throw codexError(
+            'Codex clean replay reservation identity conflicts',
+            'CODEX_CLEAN_REPLAY_RESERVATION_CONFLICT',
+          );
+        }
+        const rebound = db.prepare(`
+          UPDATE codex_dispatch_reservations
+             SET generation_id = ?,
+                 state = 'reserved',
+                 steer_attempt_id = NULL,
+                 target_attempt_id = NULL,
+                 updated_ts = ?,
+                 settled_ts = NULL
+           WHERE reservation_id = ?
+        `).run(generationId, ts, reservationId);
+        if (rebound.changes !== 1) {
+          throw codexError(
+            'Codex clean replay reservation could not be rebound',
+            'CODEX_CLEAN_REPLAY_RESERVATION_CONFLICT',
+          );
+        }
+      }
+
+      const consumed = db.prepare(`
+        UPDATE messages
+           SET handler_status = 'replay-attempted'
+         WHERE id = ?
+           AND handler_status = 'replay-pending'
+      `).run(inboundRows[0].id);
+      if (consumed.changes !== 1) {
+        throw codexError(
+          'Codex clean replay input could not be consumed',
+          'CODEX_CLEAN_REPLAY_INBOUND_MISMATCH',
+        );
+      }
+      const reservation = readCodexDispatchReservation(reservationId);
+      return {
+        reservationId,
+        generationId,
+        reservation,
+      };
+    })();
+  }
+
   function assertCodexDispatchReservationIdentity(
     reservation,
     generationId,
@@ -4117,6 +4732,7 @@ function wrap(db) {
     createCodexGeneration,
     prepareCodexCleanRetirement,
     recordCodexCheckpoint,
+    recordCodexTurnStartPrepared,
     recordCodexDeliveryCheckpoint,
     getCodexAttempt(attemptId) {
       return db.prepare(`
@@ -4134,6 +4750,7 @@ function wrap(db) {
     claimCodexDispatchReservation,
     recordInboundRuntimeSelection,
     getReplayProviderRecovery,
+    prepareCodexCleanReplay,
     getCodexDispatchReservation(reservationId) {
       return readCodexDispatchReservation(requiredCodexString(
         reservationId,
@@ -4517,7 +5134,7 @@ function wrap(db) {
            AND handler_status IN ('dispatched', 'processing', 'replay-pending')
            AND chat_id IN (${placeholders})
            AND ts > ?
-         ORDER BY ts ASC
+         ORDER BY ts ASC, id ASC
          LIMIT ?
       `).all(...chatIds, cutoff, limit);
     },