@sentry/junior 0.144.0 → 0.146.0

package/dist/{chunk-BEGGFVFR.js → chunk-GDQEU4I7.js}

@@ -21,18 +21,21 @@ import {
   instructionProvenanceFor,
   sanitizePostgresJson,
   withConversationEventLock
-} from "./chunk-SBZP2J5Q.js";
+} from "./chunk-37EVZP66.js";
 import {
   SANDBOX_WORKSPACE_ROOT,
   sleep
 } from "./chunk-EM225ITJ.js";
 import {
-  getStateAdapter
-} from "./chunk-UDQMY6RS.js";
+  MUTATION_LOCK_TTL_MS,
+  fenceLock,
+  getStateAdapter,
+  withLock
+} from "./chunk-GYEKOX7N.js";
 import {
   botConfig,
   unwrapCurrentInstruction
-} from "./chunk-3GU4PWA3.js";
+} from "./chunk-MKRIZ4VG.js";
 import {
   toStoredSlackActor
 } from "./chunk-HZF5P5UN.js";
@@ -42,7 +45,7 @@ import {
   logException,
   toOptionalNumber,
   toOptionalString
-} from "./chunk-RIFJUJSI.js";
+} from "./chunk-B63BF443.js";
 
 // src/chat/turn-context-tag.ts
 var TURN_CONTEXT_TAG = "runtime-turn-context";
@@ -517,7 +520,52 @@ function connectedMcpProvidersFromEvents(events) {
 function isUserMessage(message) {
   return message.role === "user";
 }
-function countMatchingPrefix(left, right) {
+var AgentHistoryBranchError = class extends Error {
+  constructor(conversationId) {
+    super(
+      `Agent history for ${conversationId} changed before its committed boundary`
+    );
+    this.name = "AgentHistoryBranchError";
+  }
+};
+function normalizeDurableMessage(message) {
+  return piMessageSchema.parse(
+    JSON.parse(JSON.stringify(sanitizePostgresJson(message)))
+  );
+}
+function durableMessageIdentity(message) {
+  const record = message;
+  if (record.role === "toolResult") {
+    return {
+      role: "toolResult",
+      timestamp: record.timestamp,
+      toolCallId: record.toolCallId,
+      toolName: record.toolName,
+      isError: record.isError,
+      content: record.content
+    };
+  }
+  return {
+    role: record.role,
+    timestamp: record.timestamp,
+    content: record.content
+  };
+}
+function countDurablePrefix(current, next) {
+  if (next.length < current.length) {
+    return countMatchingDeepPrefix(current, next);
+  }
+  for (let index = 0; index < current.length; index += 1) {
+    if (!isDeepStrictEqual3(
+      durableMessageIdentity(current[index]),
+      durableMessageIdentity(next[index])
+    )) {
+      return index;
+    }
+  }
+  return current.length;
+}
+function countMatchingDeepPrefix(left, right) {
   const limit = Math.min(left.length, right.length);
   for (let index = 0; index < limit; index += 1) {
     if (!isDeepStrictEqual3(left[index], right[index])) {
@@ -526,11 +574,6 @@ function countMatchingPrefix(left, right) {
   }
   return limit;
 }
-function normalizeDurableMessage(message) {
-  return piMessageSchema.parse(
-    JSON.parse(JSON.stringify(sanitizePostgresJson(message)))
-  );
-}
 function resolveCommitProvenance(args) {
   if (args.explicitProvenance) {
     if (args.explicitProvenance.length !== args.nextMessages.length) {
@@ -672,7 +715,7 @@ async function commitMessagesLocked(args, executor) {
   const nextLocalMessages = stripRuntimeTurnContext(args.messages).map(
     normalizeDurableMessage
   );
-  const matchingPrefix = countMatchingPrefix(
+  const matchingPrefix = countDurablePrefix(
     current.messages,
     nextLocalMessages
   );
@@ -710,9 +753,7 @@ async function commitMessagesLocked(args, executor) {
       ...turnContextEvents
     ]);
   } else {
-    throw new Error(
-      `Agent history for ${args.conversationId} changed before its committed boundary`
-    );
+    throw new AgentHistoryBranchError(args.conversationId);
   }
   const committedEvents = await eventStore.loadCurrentHistory(
     args.conversationId
@@ -1056,7 +1097,25 @@ function getAssistantReplyText(message) {
   return decision.kind === "deliver" ? decision.text : void 0;
 }
 
-// src/chat/state/turn-session.ts
+// src/chat/services/persist-retry.ts
+var PERSIST_ATTEMPTS = 3;
+async function persistWithRetry(persist) {
+  let lastError;
+  for (let attempt = 1; attempt <= PERSIST_ATTEMPTS; attempt += 1) {
+    try {
+      await persist();
+      return;
+    } catch (error) {
+      lastError = error;
+      if (attempt < PERSIST_ATTEMPTS) {
+        await sleep(attempt * 100);
+      }
+    }
+  }
+  throw lastError;
+}
+
+// src/chat/task-execution/turn-cursor.ts
 import { z as z2 } from "zod";
 
 // src/chat/repository-instructions.ts
@@ -1407,40 +1466,63 @@ function isAgentsInstructionsMessage(message) {
   return Boolean(findVisibleAgentsInstructions([message]));
 }
 
-// src/chat/state/turn-session-keys.ts
-var AGENT_TURN_SESSION_PREFIX = "junior:agent_turn_session";
-function agentTurnSessionKey(conversationId, sessionId) {
-  return `${AGENT_TURN_SESSION_PREFIX}:${conversationId}:${sessionId}`;
+// src/chat/task-execution/turn-cursor-keys.ts
+var TURN_CURSOR_PREFIX = "junior:turn_cursor:v2";
+function turnCursorKey(conversationId, turnId) {
+  return `${TURN_CURSOR_PREFIX}:${conversationId}:${turnId}`;
+}
+function turnCursorIndexKey(conversationId) {
+  return `${TURN_CURSOR_PREFIX}:conversation:${conversationId}:index`;
 }
-function agentTurnSessionConversationIndexKey(conversationId) {
-  return `${AGENT_TURN_SESSION_PREFIX}:conversation:${conversationId}:index`;
+function turnCursorMutationKey(conversationId, turnId) {
+  return `${TURN_CURSOR_PREFIX}:mutation:${conversationId}:${turnId}`;
 }
 
-// src/chat/state/turn-session.ts
-var AGENT_TURN_SESSION_RESUME_TTL_MS = 24 * 60 * 60 * 1e3;
-var AGENT_TURN_SESSION_TERMINAL_TTL_MS = 60 * 60 * 1e3;
-function executionMetricsForSession(conversation, sessionId) {
-  return conversation?.executionMetrics?.runId === sessionId ? conversation.executionMetrics : void 0;
+// src/chat/task-execution/turn-cursor.ts
+var TURN_CURSOR_SCHEMA_VERSION = 2;
+var TURN_CURSOR_RESUME_TTL_MS = 24 * 60 * 60 * 1e3;
+var TURN_CURSOR_TERMINAL_TTL_MS = 60 * 60 * 1e3;
+var TURN_CURSOR_MUTATION_LOCK_WAIT_MS = 1e4;
+async function withTurnCursorMutation(conversationId, turnId, run) {
+  const state = getStateAdapter();
+  await state.connect();
+  const result = await withLock(
+    state,
+    turnCursorMutationKey(conversationId, turnId),
+    async (lock) => await run(async () => await fenceLock(state, lock)),
+    {
+      keepAlive: true,
+      ttlMs: MUTATION_LOCK_TTL_MS,
+      waitMs: TURN_CURSOR_MUTATION_LOCK_WAIT_MS
+    }
+  );
+  if (!result.acquired) {
+    throw new Error(`Could not acquire turn cursor lock for ${turnId}`);
+  }
+  return result.value;
+}
+function executionMetricsForTurn(conversation, turnId) {
+  return conversation?.executionMetrics?.runId === turnId ? conversation.executionMetrics : void 0;
 }
 function definedProps(values) {
   return Object.fromEntries(
     Object.entries(values).filter(([, value]) => value !== void 0)
   );
 }
-var agentTurnSessionStatusSchema = z2.enum([
+var turnStatusSchema = z2.enum([
   "running",
-  "awaiting_resume",
+  "paused",
   "completed",
   "failed",
   "abandoned"
 ]);
-var agentTurnSurfaceSchema = z2.enum([
+var turnSurfaceSchema = z2.enum([
   "slack",
   "api",
   "scheduler",
   "internal"
 ]);
-var agentTurnResumeReasonSchema = z2.enum([
+var turnPauseReasonSchema = z2.enum([
   "timeout",
   "auth",
   "yield",
@@ -1448,33 +1530,35 @@ var agentTurnResumeReasonSchema = z2.enum([
 ]);
 var nonNegativeNumberSchema = z2.number().finite().nonnegative();
 var seqCursorSchema = z2.number().int().min(-1);
-var agentTurnSessionSummarySchema = z2.object({
+var storedTurnSummarySchema = z2.object({
+  schemaVersion: z2.literal(TURN_CURSOR_SCHEMA_VERSION),
   version: z2.number().int().nonnegative(),
   conversationId: z2.string().min(1),
   dispatchId: z2.string().min(1).optional(),
   dispatchOutcome: z2.enum(["blocked", "completed", "failed"]).optional(),
   resultMessageId: z2.string().min(1).optional(),
-  resumeReason: agentTurnResumeReasonSchema.optional(),
-  sessionId: z2.string().min(1),
+  resumeReason: turnPauseReasonSchema.optional(),
+  turnId: z2.string().min(1),
   sliceId: z2.number().int().nonnegative(),
-  state: agentTurnSessionStatusSchema,
-  surface: agentTurnSurfaceSchema.optional(),
+  state: turnStatusSchema,
+  surface: turnSurfaceSchema.optional(),
   updatedAtMs: nonNegativeNumberSchema
 }).strip();
-var storedAgentTurnSessionRecordSchema = z2.object({
+var storedTurnRecordSchema = z2.object({
+  schemaVersion: z2.literal(TURN_CURSOR_SCHEMA_VERSION),
   version: z2.number().int().nonnegative(),
   conversationId: z2.string().min(1),
   dispatchId: z2.string().min(1).optional(),
   dispatchOutcome: z2.enum(["blocked", "completed", "failed"]).optional(),
   resultMessageId: z2.string().min(1).optional(),
   lastProgressAtMs: nonNegativeNumberSchema,
-  resumeReason: agentTurnResumeReasonSchema.optional(),
+  resumeReason: turnPauseReasonSchema.optional(),
   resumedFromSliceId: z2.number().int().nonnegative().optional(),
-  sessionId: z2.string().min(1),
+  turnId: z2.string().min(1),
   sliceId: z2.number().int().nonnegative(),
   startedAtMs: nonNegativeNumberSchema,
-  state: agentTurnSessionStatusSchema,
-  surface: agentTurnSurfaceSchema.optional(),
+  state: turnStatusSchema,
+  surface: turnSurfaceSchema.optional(),
   traceId: z2.string().optional(),
   updatedAtMs: nonNegativeNumberSchema,
   committedSeq: seqCursorSchema,
@@ -1487,36 +1571,39 @@ function conversationExecutionFromSummary(summary) {
   const status = summary.state === "completed" || summary.state === "abandoned" ? "idle" : summary.state;
   return {
     status,
-    runId: summary.sessionId,
+    runId: summary.turnId,
     updatedAtMs: summary.updatedAtMs
   };
 }
 function sessionLogActor(actor) {
   return actor?.platform === "slack" ? toStoredSlackActor(actor) : void 0;
 }
-function parseAgentTurnSessionRecord(value) {
-  return storedAgentTurnSessionRecordSchema.parse(value);
+function parseTurnRecord(value) {
+  return storedTurnRecordSchema.parse(value);
+}
+function parseTurnSummary(value) {
+  return storedTurnSummarySchema.parse(value);
 }
-function parseAgentTurnSessionSummary(value) {
-  return agentTurnSessionSummarySchema.parse(value);
+function storeTurnSummary(summary) {
+  return storedTurnSummarySchema.parse(summary);
 }
-function agentTurnSessionRecordTtlMs(state, ttlMs) {
+function turnCursorTtlMs(state, ttlMs) {
   if (ttlMs !== void 0) {
     return Math.max(1, ttlMs);
   }
-  return state === "running" || state === "awaiting_resume" ? AGENT_TURN_SESSION_RESUME_TTL_MS : AGENT_TURN_SESSION_TERMINAL_TTL_MS;
+  return state === "running" || state === "paused" ? TURN_CURSOR_RESUME_TTL_MS : TURN_CURSOR_TERMINAL_TTL_MS;
 }
-function agentTurnSessionIndexTtlMs(ttlMs) {
-  return Math.max(1, ttlMs ?? AGENT_TURN_SESSION_RESUME_TTL_MS);
+function turnCursorIndexTtlMs(ttlMs) {
+  return Math.max(1, ttlMs ?? TURN_CURSOR_RESUME_TTL_MS);
 }
-function projectAgentTurnSessionSummary(record) {
-  return agentTurnSessionSummarySchema.parse(record);
+function projectTurnSummary(record) {
+  return parseTurnSummary(record);
 }
-async function appendAgentTurnSessionSummary(summary, ttlMs) {
+async function appendTurnSummary(summary, ttlMs) {
   const stateAdapter = getStateAdapter();
   await stateAdapter.appendToList(
-    agentTurnSessionConversationIndexKey(summary.conversationId),
-    agentTurnSessionSummarySchema.parse(summary),
+    turnCursorIndexKey(summary.conversationId),
+    storeTurnSummary(summary),
     { ttlMs }
   );
 }
@@ -1556,12 +1643,13 @@ async function recordConversationActivityMetadata(args) {
     visibility: isChild ? void 0 : args.destinationVisibility
   });
 }
-function materializeAgentTurnSessionRecord(stored, piProjection, turnStartMessageIndex, restoreVolatileContext = true, runtimeMetadata) {
-  const restoredProjection = restoreVolatileContext && (stored.state === "running" || stored.state === "awaiting_resume") ? restoreRuntimeContext(piProjection, stored.runtimeContext) : piProjection;
+function materializeTurnRecord(stored, piProjection, turnStartMessageIndex, restoreVolatileContext = true, runtimeMetrics) {
+  const restoredProjection = restoreVolatileContext && (stored.state === "running" || stored.state === "paused") ? restoreRuntimeContext(piProjection, stored.runtimeContext) : piProjection;
   return {
+    schemaVersion: stored.schemaVersion,
     version: stored.version,
     conversationId: stored.conversationId,
-    sessionId: stored.sessionId,
+    turnId: stored.turnId,
     sliceId: stored.sliceId,
     state: stored.state,
     startedAtMs: stored.startedAtMs,
@@ -1570,13 +1658,10 @@ function materializeAgentTurnSessionRecord(stored, piProjection, turnStartMessag
     piMessages: restoredProjection.messages,
     piMessageProvenance: restoredProjection.provenance,
     actors: instructionActors(piProjection.provenance),
-    cumulativeDurationMs: runtimeMetadata?.cumulativeDurationMs ?? 0,
+    cumulativeDurationMs: runtimeMetrics?.cumulativeDurationMs ?? 0,
     ...definedProps({
-      channelName: runtimeMetadata?.channelName,
-      cumulativeUsage: runtimeMetadata?.cumulativeUsage,
-      loadedSkillNames: runtimeMetadata?.loadedSkillNames,
-      modelId: runtimeMetadata?.modelId,
-      reasoningLevel: runtimeMetadata?.reasoningLevel,
+      channelName: runtimeMetrics?.channelName,
+      cumulativeUsage: runtimeMetrics?.cumulativeUsage,
       dispatchId: stored.dispatchId,
       dispatchOutcome: stored.dispatchOutcome,
       errorMessage: stored.errorMessage,
@@ -1625,19 +1710,14 @@ function restoreRuntimeContext(projection, runtimeContext) {
     ]
   };
 }
-async function getStoredAgentTurnSessionRecord(conversationId, sessionId) {
+async function getStoredTurnRecord(conversationId, turnId) {
   const stateAdapter = getStateAdapter();
   await stateAdapter.connect();
-  const value = await stateAdapter.get(
-    agentTurnSessionKey(conversationId, sessionId)
-  );
-  return value == null ? void 0 : parseAgentTurnSessionRecord(value);
+  const value = await stateAdapter.get(turnCursorKey(conversationId, turnId));
+  return value == null ? void 0 : parseTurnRecord(value);
 }
-async function materializeStoredAgentTurnSessionRecord(conversationId, sessionId, followCurrentReplacement) {
-  const parsed = await getStoredAgentTurnSessionRecord(
-    conversationId,
-    sessionId
-  );
+async function materializeStoredTurnRecord(conversationId, turnId, followCurrentReplacement) {
+  const parsed = await getStoredTurnRecord(conversationId, turnId);
   if (!parsed) {
     return void 0;
   }
@@ -1646,19 +1726,19 @@ async function materializeStoredAgentTurnSessionRecord(conversationId, sessionId
     committedSeq: parsed.committedSeq,
     // Unfinished records include the current-epoch tail so parked input
     // appended after the last safe boundary stays model-visible on resume.
-    includeTail: parsed.state === "running" || parsed.state === "awaiting_resume"
+    includeTail: parsed.state === "running" || parsed.state === "paused"
   });
   if (!pinnedProjection) {
     return void 0;
   }
   const currentHistory = await getConversationEventStore().loadCurrentHistory(conversationId);
   const currentHistoryVersion = currentHistory.at(-1)?.historyVersion ?? parsed.historyVersion ?? 0;
-  const followsReplacement = followCurrentReplacement && (parsed.state === "running" || parsed.state === "awaiting_resume") && parsed.historyVersion !== void 0 && parsed.historyVersion !== currentHistoryVersion;
+  const followsReplacement = followCurrentReplacement && (parsed.state === "running" || parsed.state === "paused") && parsed.historyVersion !== void 0 && parsed.historyVersion !== currentHistoryVersion;
   const piProjection = followsReplacement ? projectConversationEvents(currentHistory) : pinnedProjection;
   const turnStartMessageIndex = followsReplacement ? 0 : parsed.turnStartSeq === void 0 ? void 0 : piProjection.seqs.filter((seq) => seq <= parsed.turnStartSeq).length;
   const conversation = await getConversationStore().get({ conversationId });
-  const executionMetrics = executionMetricsForSession(conversation, sessionId);
-  return materializeAgentTurnSessionRecord(
+  const executionMetrics = executionMetricsForTurn(conversation, turnId);
+  return materializeTurnRecord(
     parsed,
     piProjection,
     turnStartMessageIndex,
@@ -1670,26 +1750,19 @@ async function materializeStoredAgentTurnSessionRecord(conversationId, sessionId
     }
   );
 }
-async function getAgentTurnSessionRecord(conversationId, sessionId) {
-  return await materializeStoredAgentTurnSessionRecord(
-    conversationId,
-    sessionId,
-    false
-  );
+async function getTurnRecord(conversationId, turnId) {
+  return await materializeStoredTurnRecord(conversationId, turnId, false);
 }
-async function getAgentTurnSessionRecordForResume(conversationId, sessionId) {
-  return await materializeStoredAgentTurnSessionRecord(
-    conversationId,
-    sessionId,
-    true
-  );
+async function getTurnRecordForResume(conversationId, turnId) {
+  return await materializeStoredTurnRecord(conversationId, turnId, true);
 }
 function buildStoredRecord(args) {
   const nowMs = Date.now();
   return {
+    schemaVersion: TURN_CURSOR_SCHEMA_VERSION,
     version: (args.previousVersion ?? 0) + 1,
     conversationId: args.conversationId,
-    sessionId: args.sessionId,
+    turnId: args.turnId,
     sliceId: args.sliceId,
     state: args.state,
     startedAtMs: args.startedAtMs ?? nowMs,
@@ -1714,7 +1787,8 @@ function buildStoredRecord(args) {
 async function setStoredRecord(args) {
   const stateAdapter = getStateAdapter();
   await stateAdapter.connect();
-  const storedRecord = storedAgentTurnSessionRecordSchema.parse(args.record);
+  const storedRecord = storedTurnRecordSchema.parse(args.record);
+  await args.fence();
   await recordConversationActivityMetadata({
     actor: args.actor,
     conversationStore: args.conversationStore,
@@ -1722,18 +1796,24 @@ async function setStoredRecord(args) {
     destinationVisibility: args.destinationVisibility,
     nowMs: Date.now(),
     source: args.source,
-    summary: { ...storedRecord, ...args.runtimeMetadata }
+    summary: {
+      ...projectTurnSummary(storedRecord),
+      startedAtMs: storedRecord.startedAtMs,
+      ...args.runtimeMetrics
+    }
   });
+  await args.fence();
   await stateAdapter.set(
-    agentTurnSessionKey(storedRecord.conversationId, storedRecord.sessionId),
+    turnCursorKey(storedRecord.conversationId, storedRecord.turnId),
     storedRecord,
     args.ttlMs
   );
-  await appendAgentTurnSessionSummary(
-    projectAgentTurnSessionSummary(storedRecord),
-    agentTurnSessionIndexTtlMs(args.indexTtlMs)
+  await args.fence();
+  await appendTurnSummary(
+    projectTurnSummary(storedRecord),
+    turnCursorIndexTtlMs(args.indexTtlMs)
   );
-  return materializeAgentTurnSessionRecord(
+  return materializeTurnRecord(
     storedRecord,
     {
       messages: [...args.piMessages],
@@ -1741,29 +1821,27 @@ async function setStoredRecord(args) {
     },
     args.turnStartMessageIndex,
     true,
-    args.runtimeMetadata
+    args.runtimeMetrics
   );
 }
-async function updateAgentTurnSessionState(args) {
-  const parsed = await getStoredAgentTurnSessionRecord(
+async function updateTurnState(args) {
+  const parsed = await getStoredTurnRecord(
     args.existing.conversationId,
-    args.existing.sessionId
+    args.existing.turnId
   );
   if (!parsed || parsed.version !== args.existing.version) {
     return void 0;
   }
   return await setStoredRecord({
+    fence: args.fence,
     piMessages: args.existing.piMessages,
     piMessageProvenance: args.existing.piMessageProvenance,
-    ttlMs: agentTurnSessionRecordTtlMs(args.state),
-    runtimeMetadata: {
+    ttlMs: turnCursorTtlMs(args.state),
+    runtimeMetrics: {
       cumulativeDurationMs: args.existing.cumulativeDurationMs,
       ...definedProps({
         channelName: args.existing.channelName,
-        cumulativeUsage: args.existing.cumulativeUsage,
-        loadedSkillNames: args.existing.loadedSkillNames,
-        modelId: args.existing.modelId,
-        reasoningLevel: args.existing.reasoningLevel
+        cumulativeUsage: args.existing.cumulativeUsage
       })
     },
     ...definedProps({
@@ -1771,7 +1849,7 @@ async function updateAgentTurnSessionState(args) {
     }),
     record: buildStoredRecord({
       conversationId: args.existing.conversationId,
-      sessionId: args.existing.sessionId,
+      turnId: args.existing.turnId,
       sliceId: args.existing.sliceId,
       state: args.state,
       committedSeq: parsed.committedSeq,
@@ -1784,7 +1862,7 @@ async function updateAgentTurnSessionState(args) {
         errorMessage: args.errorMessage ?? args.existing.errorMessage,
         historyVersion: parsed.historyVersion,
         resumeReason: args.existing.resumeReason,
-        resultMessageId: args.existing.resultMessageId,
+        resultMessageId: args.resultMessageId ?? args.existing.resultMessageId,
         resumedFromSliceId: args.existing.resumedFromSliceId,
         surface: args.existing.surface,
         traceId: args.existing.traceId,
@@ -1793,25 +1871,29 @@ async function updateAgentTurnSessionState(args) {
     })
   });
 }
-async function upsertAgentTurnSessionRecord(args) {
-  const existingRecord = await getStoredAgentTurnSessionRecord(
+async function upsertTurnRecord(args) {
+  return await withTurnCursorMutation(
+    args.conversationId,
+    args.turnId,
+    async (fence) => await upsertTurnRecordLocked(args, fence)
+  );
+}
+async function upsertTurnRecordLocked(args, fence) {
+  const existingRecord = await getStoredTurnRecord(
     args.conversationId,
-    args.sessionId
+    args.turnId
   );
   const conversation = await (args.conversationStore ?? getConversationStore()).get({
     conversationId: args.conversationId
   });
-  const executionMetrics = executionMetricsForSession(
-    conversation,
-    args.sessionId
-  );
-  const existingDispatchId = existingRecord?.dispatchId ?? (await listAgentTurnSessionSummariesForConversation(args.conversationId)).find((summary) => summary.sessionId === args.sessionId)?.dispatchId;
+  const executionMetrics = executionMetricsForTurn(conversation, args.turnId);
+  const existingDispatchId = existingRecord?.dispatchId ?? (await listTurnSummaries(args.conversationId)).find(
+    (summary) => summary.turnId === args.turnId
+  )?.dispatchId;
   if (existingDispatchId && args.dispatchId && existingDispatchId !== args.dispatchId) {
-    throw new Error(
-      `Turn session ${args.sessionId} dispatchId cannot be changed`
-    );
+    throw new Error(`Turn ${args.turnId} dispatchId cannot be changed`);
   }
-  const ttlMs = agentTurnSessionRecordTtlMs(args.state, args.ttlMs);
+  const ttlMs = turnCursorTtlMs(args.state, args.ttlMs);
   const instructionActor = args.actor;
   const commit = await commitMessages({
     conversationId: args.conversationId,
@@ -1821,7 +1903,7 @@ async function upsertAgentTurnSessionRecord(args) {
     ...args.turnContexts && args.turnContexts.length > 0 ? {
       turnContext: {
         contexts: args.turnContexts,
-        turnId: args.sessionId
+        turnId: args.turnId
       }
     } : {}
   });
@@ -1834,6 +1916,7 @@ async function upsertAgentTurnSessionRecord(args) {
   const turnStartMessageIndex = durableTurnStartMessageIndex ?? (turnStartSeq === void 0 ? void 0 : commit.messageSeqs.filter((seq) => seq <= turnStartSeq).length);
   return await setStoredRecord({
     actor: args.actor,
+    fence,
     conversationStore: args.conversationStore,
     destination: args.destination,
     destinationVisibility: args.destinationVisibility,
@@ -1841,15 +1924,12 @@ async function upsertAgentTurnSessionRecord(args) {
     piMessages: commit.messages,
     piMessageProvenance: commit.provenance,
     ttlMs,
-    // TODO(#1267): remove the temporary caller-to-SQL metadata write once the
-    // SQL-only turn-session readers have completed rollout.
-    runtimeMetadata: {
+    // Checkpoint commit also updates conversation execution metrics in SQL.
+    // Channel/duration/usage are not Redis resume-cursor fields.
+    runtimeMetrics: {
       channelName: args.channelName ?? conversation?.channelName,
       cumulativeDurationMs: args.cumulativeDurationMs ?? executionMetrics?.durationMs ?? 0,
-      cumulativeUsage: args.cumulativeUsage ?? executionMetrics?.usage,
-      loadedSkillNames: args.loadedSkillNames,
-      modelId: args.modelId,
-      reasoningLevel: args.reasoningLevel
+      cumulativeUsage: args.cumulativeUsage ?? executionMetrics?.usage
     },
     // Pass through only an explicit override so indexes stay on the resume window
     // by default even when the record takes a short terminal TTL.
@@ -1857,7 +1937,7 @@ async function upsertAgentTurnSessionRecord(args) {
     turnStartMessageIndex,
     record: buildStoredRecord({
       conversationId: args.conversationId,
-      sessionId: args.sessionId,
+      turnId: args.turnId,
       sliceId: args.sliceId,
       state: args.state,
       committedSeq: commit.committedSeq,
@@ -1871,7 +1951,7 @@ async function upsertAgentTurnSessionRecord(args) {
         resumeReason: args.resumeReason,
         resultMessageId: args.resultMessageId ?? existingRecord?.resultMessageId,
         resumedFromSliceId: args.resumedFromSliceId,
-        runtimeContext: args.state === "running" || args.state === "awaiting_resume" ? retainedRuntimeContext : void 0,
+        runtimeContext: args.state === "running" || args.state === "paused" ? retainedRuntimeContext : void 0,
         startedAtMs: existingRecord?.startedAtMs,
         surface: args.surface ?? existingRecord?.surface,
         traceId: args.traceId ?? existingRecord?.traceId,
@@ -1880,35 +1960,42 @@ async function upsertAgentTurnSessionRecord(args) {
     })
   });
 }
-async function recordAgentTurnSessionSummary(args) {
-  const stored = await getStoredAgentTurnSessionRecord(
+async function recordTurnSummary(args) {
+  await withTurnCursorMutation(
     args.conversationId,
-    args.sessionId
+    args.turnId,
+    async (fence) => await recordTurnSummaryOwned(args, fence)
   );
+}
+async function recordTurnSummaryOwned(args, fence) {
+  const stored = await getStoredTurnRecord(args.conversationId, args.turnId);
   const conversationStore = args.conversationStore ?? getConversationStore();
   const conversation = await conversationStore.get({
     conversationId: args.conversationId
   });
-  const executionMetrics = executionMetricsForSession(
-    conversation,
-    args.sessionId
+  const executionMetrics = executionMetricsForTurn(conversation, args.turnId);
+  const priorSummary = (await listTurnSummaries(args.conversationId)).find(
+    (summary2) => summary2.turnId === args.turnId
   );
-  const priorSummary = (await listAgentTurnSessionSummariesForConversation(args.conversationId)).find((summary2) => summary2.sessionId === args.sessionId);
-  const existing = stored ?? priorSummary;
+  const terminalSummary = priorSummary && (priorSummary.state === "completed" || priorSummary.state === "failed" || priorSummary.state === "abandoned") ? priorSummary : void 0;
+  const terminalRecord = stored && (stored.state === "completed" || stored.state === "failed" || stored.state === "abandoned") ? stored : void 0;
+  const existing = terminalSummary ?? terminalRecord ?? stored ?? priorSummary;
+  if ((terminalSummary || terminalRecord) && (args.state === "running" || args.state === "paused")) {
+    return;
+  }
   const existingDispatchId = existing?.dispatchId;
   const existingDispatchOutcome = priorSummary?.dispatchOutcome ?? stored?.dispatchOutcome;
   const existingResultMessageId = priorSummary?.resultMessageId ?? stored?.resultMessageId;
   if (existingDispatchId && args.dispatchId && existingDispatchId !== args.dispatchId) {
-    throw new Error(
-      `Turn session ${args.sessionId} dispatchId cannot be changed`
-    );
+    throw new Error(`Turn ${args.turnId} dispatchId cannot be changed`);
   }
   const nowMs = Date.now();
-  const ttlMs = agentTurnSessionIndexTtlMs(args.ttlMs);
+  const ttlMs = turnCursorIndexTtlMs(args.ttlMs);
   const summary = {
+    schemaVersion: TURN_CURSOR_SCHEMA_VERSION,
     version: existing?.version ?? 0,
     conversationId: args.conversationId,
-    sessionId: args.sessionId,
+    turnId: args.turnId,
     sliceId: args.sliceId,
     state: args.state,
     updatedAtMs: nowMs,
@@ -1920,6 +2007,7 @@ async function recordAgentTurnSessionSummary(args) {
       surface: args.surface ?? existing?.surface
     })
   };
+  await fence();
   await recordConversationActivityMetadata({
     actor: args.actor,
     conversationStore,
@@ -1935,9 +2023,10 @@ async function recordAgentTurnSessionSummary(args) {
       startedAtMs: stored?.startedAtMs ?? args.startedAtMs ?? nowMs
     }
   });
-  await appendAgentTurnSessionSummary(summary, ttlMs);
+  await fence();
+  await appendTurnSummary(summary, ttlMs);
 }
-async function readAgentTurnSessionSummariesFromIndex(key) {
+async function readTurnSummaries(key) {
   const stateAdapter = getStateAdapter();
   await stateAdapter.connect();
   const values = await stateAdapter.getList(key);
@@ -1945,11 +2034,11 @@ async function readAgentTurnSessionSummariesFromIndex(key) {
   for (const value of [...values].reverse()) {
     let summary;
     try {
-      summary = parseAgentTurnSessionSummary(value);
+      summary = parseTurnSummary(value);
     } catch {
       continue;
     }
-    const summaryKey = `${summary.conversationId}:${summary.sessionId}`;
+    const summaryKey = `${summary.conversationId}:${summary.turnId}`;
     if (!summaries.has(summaryKey)) {
       summaries.set(summaryKey, summary);
     }
@@ -1958,56 +2047,62 @@ async function readAgentTurnSessionSummariesFromIndex(key) {
     (left, right) => right.updatedAtMs - left.updatedAtMs
   );
 }
-async function listAgentTurnSessionSummariesForConversation(conversationId) {
-  return readAgentTurnSessionSummariesFromIndex(
-    agentTurnSessionConversationIndexKey(conversationId)
-  );
+async function listTurnSummaries(conversationId) {
+  return readTurnSummaries(turnCursorIndexKey(conversationId));
 }
-async function abandonAgentTurnSessionRecord(args) {
-  const existing = await getAgentTurnSessionRecord(
+async function abandonTurnRecord(args) {
+  return await withTurnCursorMutation(
     args.conversationId,
-    args.sessionId
+    args.turnId,
+    async (fence) => {
+      const existing = await getTurnRecord(args.conversationId, args.turnId);
+      if (!existing || existing.state === "completed" || existing.state === "failed" || existing.state === "abandoned") {
+        return void 0;
+      }
+      return await updateTurnState({
+        existing,
+        fence,
+        state: "abandoned",
+        errorMessage: args.errorMessage ?? existing.errorMessage
+      });
+    }
   );
-  if (!existing || existing.state === "completed" || existing.state === "failed" || existing.state === "abandoned") {
-    return void 0;
-  }
-  return await updateAgentTurnSessionState({
-    existing,
-    state: "abandoned",
-    errorMessage: args.errorMessage ?? existing.errorMessage
-  });
 }
-async function failAgentTurnSessionRecord(args) {
-  const existing = await getAgentTurnSessionRecord(
+async function completeTurnRecord(args) {
+  return await withTurnCursorMutation(
     args.conversationId,
-    args.sessionId
+    args.turnId,
+    async (fence) => {
+      const existing = await getTurnRecord(args.conversationId, args.turnId);
+      if (!existing || existing.state === "completed" || existing.state === "failed" || existing.state === "abandoned" || existing.version !== args.expectedVersion) {
+        return void 0;
+      }
+      return await updateTurnState({
+        existing,
+        fence,
+        resultMessageId: args.resultMessageId,
+        state: "completed"
+      });
+    }
   );
-  if (!existing || existing.state === "completed" || existing.state === "failed" || existing.state === "abandoned" || existing.version !== args.expectedVersion) {
-    return void 0;
-  }
-  return await updateAgentTurnSessionState({
-    existing,
-    state: "failed",
-    errorMessage: args.errorMessage ?? existing.errorMessage
-  });
 }
-
-// src/chat/services/persist-retry.ts
-var PERSIST_ATTEMPTS = 3;
-async function persistWithRetry(persist) {
-  let lastError;
-  for (let attempt = 1; attempt <= PERSIST_ATTEMPTS; attempt += 1) {
-    try {
-      await persist();
-      return;
-    } catch (error) {
-      lastError = error;
-      if (attempt < PERSIST_ATTEMPTS) {
-        await sleep(attempt * 100);
+async function failTurnRecord(args) {
+  return await withTurnCursorMutation(
+    args.conversationId,
+    args.turnId,
+    async (fence) => {
+      const existing = await getTurnRecord(args.conversationId, args.turnId);
+      if (!existing || existing.state === "completed" || existing.state === "failed" || existing.state === "abandoned" || existing.version !== args.expectedVersion) {
+        return void 0;
       }
+      return await updateTurnState({
+        existing,
+        fence,
+        state: "failed",
+        errorMessage: args.errorMessage ?? existing.errorMessage
+      });
     }
-  }
-  throw lastError;
+  );
 }
 
 // src/chat/services/turn-limit.ts
@@ -2021,41 +2116,12 @@ function buildTurnLimitResponse(eventId) {
   return `I couldn't finish this request because this turn reached its execution limit. Please try again with a smaller or more specific request. Reference: \`event_id=${eventId}\`.`;
 }
 
-// src/chat/services/turn-session-record.ts
+// src/chat/task-execution/checkpoint.ts
 function definedProps2(values) {
   return Object.fromEntries(
     Object.entries(values).filter(([, value]) => value !== void 0)
   );
 }
-function sessionWriteContext(args, latest) {
-  return {
-    conversationId: args.conversationId,
-    modelId: args.modelId,
-    sessionId: args.sessionId,
-    ...definedProps2({
-      // Live only: Redis no longer stores execution actor across resumes.
-      actor: args.actor,
-      channelName: args.channelName ?? latest?.channelName,
-      destination: args.destination,
-      destinationVisibility: args.destinationVisibility,
-      dispatchId: args.dispatchId ?? latest?.dispatchId,
-      // Caller-resolved: some paths inherit these, others stay caller-only.
-      loadedSkillNames: args.loadedSkillNames,
-      reasoningLevel: args.reasoningLevel,
-      source: args.source,
-      surface: args.surface ?? latest?.surface,
-      traceId: getActiveTraceId() ?? latest?.traceId,
-      turnStartMessageIndex: args.turnStartMessageIndex ?? latest?.turnStartMessageIndex
-    })
-  };
-}
-function logSessionRecordError(error, eventName, args, attributes) {
-  logException(error, eventName, {
-    "app.ai.resume_conversation_id": args.conversationId,
-    "app.ai.resume_session_id": args.sessionId,
-    ...attributes
-  });
-}
 function addDurationMs(prior, current) {
   const total = [prior, current].reduce((sum, value) => {
     if (typeof value !== "number" || !Number.isFinite(value)) {
@@ -2065,356 +2131,165 @@ function addDurationMs(prior, current) {
   }, void 0);
   return total;
 }
-function resumableBoundary(messages, fallbackMessages) {
+function continuableMessages(messages, fallback) {
   const current = trimTrailingAssistantMessages(messages);
   if (current.length > 0 && isContinuablePiBoundary(current)) {
     return current;
   }
-  return trimTrailingAssistantMessages(fallbackMessages ?? []);
+  return trimTrailingAssistantMessages(fallback ?? []);
 }
-async function loadTurnSessionRecord(ctx) {
-  const existingSessionRecord = await getAgentTurnSessionRecordForResume(
-    ctx.conversationId,
-    ctx.sessionId
-  );
-  const hasAwaitingResumeRecord = Boolean(
-    existingSessionRecord && existingSessionRecord.state === "awaiting_resume"
-  );
+async function loadTurnCheckpoint(args) {
+  const record = await getTurnRecordForResume(args.conversationId, args.turnId);
+  if (record?.state === "paused") {
+    return { resumed: true, sliceId: record.sliceId, record };
+  }
+  return { resumed: false, sliceId: 1, record };
+}
+async function saveTurnCheckpoint(args) {
+  if (args.mode === "running") {
+    return await saveRunning(args);
+  }
+  if (args.mode === "paused") {
+    return await savePaused(args);
+  }
+  await saveDone(args);
+  return void 0;
+}
+function sharedWrite(args, latest) {
   return {
-    resumedFromSessionRecord: hasAwaitingResumeRecord,
-    currentSliceId: hasAwaitingResumeRecord ? existingSessionRecord.sliceId : 1,
-    existingSessionRecord
+    conversationId: args.conversationId,
+    turnId: args.turnId,
+    ...definedProps2({
+      actor: args.actor,
+      channelName: args.channelName ?? latest?.channelName,
+      destination: args.destination,
+      destinationVisibility: args.destinationVisibility,
+      dispatchId: args.dispatchId ?? latest?.dispatchId,
+      source: args.source,
+      surface: args.surface ?? latest?.surface,
+      traceId: getActiveTraceId() ?? latest?.traceId,
+      turnStartMessageIndex: args.turnStartMessageIndex ?? latest?.turnStartMessageIndex
+    })
   };
 }
-async function persistRunningSessionRecord(args) {
+async function saveRunning(args) {
   if (args.messages.length === 0 || !isContinuablePiBoundary(args.messages)) {
-    return false;
+    return void 0;
   }
   try {
-    const latestSessionRecord = await getAgentTurnSessionRecord(
-      args.conversationId,
-      args.sessionId
-    );
-    await upsertAgentTurnSessionRecord({
-      ...sessionWriteContext(
-        {
-          actor: args.actor,
-          channelName: args.channelName,
-          conversationId: args.conversationId,
-          destination: args.destination,
-          destinationVisibility: args.destinationVisibility,
-          dispatchId: args.dispatchId,
-          loadedSkillNames: args.loadedSkillNames,
-          modelId: args.modelId,
-          reasoningLevel: args.reasoningLevel,
-          sessionId: args.sessionId,
-          source: args.source,
-          surface: args.surface,
-          turnStartMessageIndex: args.turnStartMessageIndex
-        },
-        latestSessionRecord
-      ),
+    const latest = await getTurnRecord(args.conversationId, args.turnId);
+    return await upsertTurnRecord({
+      ...sharedWrite(args, latest),
       ...definedProps2({
         trailingMessageProvenance: args.trailingMessageProvenance,
         turnContexts: args.turnContexts
       }),
-      cumulativeDurationMs: latestSessionRecord?.cumulativeDurationMs,
-      cumulativeUsage: latestSessionRecord?.cumulativeUsage,
+      cumulativeDurationMs: latest?.cumulativeDurationMs,
+      cumulativeUsage: latest?.cumulativeUsage,
       piMessages: args.messages,
       sliceId: args.sliceId,
       state: "running"
     });
-    return true;
-  } catch (recordError) {
-    logSessionRecordError(
-      recordError,
-      "agent.turn.running_session_record.failed",
-      args,
-      {
+  } catch (error) {
+    if (!(error instanceof AgentHistoryBranchError)) {
+      logException(error, "agent.turn.checkpoint.running.failed", {
+        "app.ai.resume_conversation_id": args.conversationId,
+        "app.ai.resume_session_id": args.turnId,
         "app.ai.resume_slice_id": args.sliceId
-      }
-    );
-    return false;
-  }
-}
-async function persistCompletedSessionRecord(args) {
-  let latestSessionRecord;
-  await persistWithRetry(async () => {
-    latestSessionRecord = await getAgentTurnSessionRecord(
-      args.conversationId,
-      args.sessionId
-    );
-  });
-  const sliceId = args.sliceId ?? latestSessionRecord?.sliceId;
-  if (sliceId === void 0) {
-    throw new Error(
-      "Completed session record requires a slice id from the caller or the latest stored record"
-    );
+      });
+    }
+    return void 0;
   }
-  const target = {
-    ...sessionWriteContext(
-      {
-        actor: args.actor,
-        channelName: args.channelName,
-        conversationId: args.conversationId,
-        destination: args.destination,
-        destinationVisibility: args.destinationVisibility,
-        dispatchId: args.dispatchId,
-        loadedSkillNames: args.loadedSkillNames,
-        modelId: args.modelId,
-        reasoningLevel: args.reasoningLevel,
-        sessionId: args.sessionId,
-        source: args.source,
-        surface: args.surface,
-        turnStartMessageIndex: args.turnStartMessageIndex
-      },
-      latestSessionRecord
-    ),
-    ...definedProps2({
-      cumulativeDurationMs: addDurationMs(
-        latestSessionRecord?.cumulativeDurationMs,
-        args.currentDurationMs
-      ),
-      cumulativeUsage: addAgentTurnUsage(
-        latestSessionRecord?.cumulativeUsage,
-        args.currentUsage
-      ),
-      dispatchOutcome: args.dispatchOutcome ?? latestSessionRecord?.dispatchOutcome,
-      errorMessage: args.errorMessage,
-      resultMessageId: args.resultMessageId ?? latestSessionRecord?.resultMessageId
-    }),
-    piMessages: args.allMessages,
-    sliceId,
-    state: "completed"
-  };
-  await persistWithRetry(async () => {
-    await upsertAgentTurnSessionRecord(target);
-  });
-}
-async function completeDeliveredTurn(args) {
-  await persistCompletedSessionRecord({
-    channelName: args.channelName,
-    conversationId: args.conversationId,
-    currentDurationMs: args.durationMs,
-    currentUsage: args.usage,
-    destination: args.destination,
-    destinationVisibility: args.destinationVisibility,
-    dispatchId: args.dispatchId,
-    dispatchOutcome: args.dispatchOutcome,
-    errorMessage: args.errorMessage,
-    resultMessageId: args.resultMessageId,
-    source: args.source,
-    sessionId: args.sessionId,
-    sliceId: args.sliceId,
-    allMessages: args.messages,
-    loadedSkillNames: args.loadedSkillNames,
-    modelId: args.modelId,
-    actor: args.actor,
-    reasoningLevel: args.reasoningLevel,
-    surface: args.surface,
-    turnStartMessageIndex: args.turnStartMessageIndex
-  });
 }
-async function persistAuthPauseSessionRecord(args) {
-  const nextSliceId = args.currentSliceId + 1;
+async function savePaused(args) {
+  const keepSlice = args.reason === "yield";
+  const nextSliceId = keepSlice ? args.sliceId : args.sliceId + 1;
   try {
-    const latestSessionRecord = await getAgentTurnSessionRecord(
-      args.conversationId,
-      args.sessionId
-    );
-    const piMessages = resumableBoundary(
-      args.messages,
-      latestSessionRecord?.piMessages
-    );
-    if (piMessages.length > 0 && !isContinuablePiBoundary(piMessages)) {
+    const latest = await getTurnRecord(args.conversationId, args.turnId);
+    const messages = args.reason === "yield" ? [...args.messages] : continuableMessages(args.messages, latest?.piMessages);
+    if (args.reason === "auth") {
+      if (messages.length > 0 && !isContinuablePiBoundary(messages)) {
+        return void 0;
+      }
+    } else if (messages.length === 0 || !isContinuablePiBoundary(messages)) {
       return void 0;
     }
-    return await upsertAgentTurnSessionRecord({
-      ...sessionWriteContext(
-        {
-          actor: args.actor,
-          channelName: args.channelName,
-          conversationId: args.conversationId,
-          destination: args.destination,
-          destinationVisibility: args.destinationVisibility,
-          dispatchId: args.dispatchId,
-          // Auth-pause keeps caller-owned skill names only.
-          loadedSkillNames: args.loadedSkillNames,
-          modelId: args.modelId,
-          reasoningLevel: args.reasoningLevel,
-          sessionId: args.sessionId,
-          source: args.source,
-          surface: args.surface
-        },
-        latestSessionRecord
-      ),
+    const base = {
+      ...sharedWrite(args, latest),
       ...definedProps2({
         cumulativeDurationMs: addDurationMs(
-          latestSessionRecord?.cumulativeDurationMs,
-          args.currentDurationMs
+          latest?.cumulativeDurationMs,
+          args.durationMs
         ),
-        cumulativeUsage: addAgentTurnUsage(
-          latestSessionRecord?.cumulativeUsage,
-          args.currentUsage
-        )
-      }),
-      errorMessage: args.errorMessage,
-      piMessages,
-      resumeReason: "auth",
-      resumedFromSliceId: args.currentSliceId,
-      sliceId: nextSliceId,
-      state: "awaiting_resume"
-    });
-  } catch (recordError) {
-    logSessionRecordError(
-      recordError,
-      "agent.turn.auth_resume_session_record.failed",
-      args,
-      {
-        "app.ai.resume_from_slice_id": args.currentSliceId,
-        "app.ai.resume_next_slice_id": nextSliceId
-      }
-    );
-  }
-  return void 0;
-}
-async function persistContinuationSessionRecord(args) {
-  const nextSliceId = args.currentSliceId + 1;
-  try {
-    const latestSessionRecord = await getAgentTurnSessionRecord(
-      args.conversationId,
-      args.sessionId
-    );
-    const piMessages = resumableBoundary(
-      args.messages,
-      latestSessionRecord?.piMessages
-    );
-    if (piMessages.length === 0 || !isContinuablePiBoundary(piMessages)) {
-      return void 0;
-    }
-    const cumulativeDurationMs = addDurationMs(
-      latestSessionRecord?.cumulativeDurationMs,
-      args.currentDurationMs
-    );
-    const cumulativeUsage = addAgentTurnUsage(
-      latestSessionRecord?.cumulativeUsage,
-      args.currentUsage
-    );
-    const shared = {
-      ...sessionWriteContext(
-        {
-          actor: args.actor,
-          channelName: args.channelName,
-          conversationId: args.conversationId,
-          destination: args.destination,
-          destinationVisibility: args.destinationVisibility,
-          dispatchId: args.dispatchId,
-          // Continuation keeps caller-owned skill names only.
-          loadedSkillNames: args.loadedSkillNames,
-          modelId: args.modelId,
-          reasoningLevel: args.reasoningLevel,
-          sessionId: args.sessionId,
-          source: args.source,
-          surface: args.surface
-        },
-        latestSessionRecord
-      ),
-      ...definedProps2({
-        cumulativeDurationMs,
-        cumulativeUsage
+        cumulativeUsage: addAgentTurnUsage(latest?.cumulativeUsage, args.usage),
+        errorMessage: args.errorMessage
       }),
-      piMessages,
-      resumeReason: args.resumeReason
+      piMessages: messages,
+      resumeReason: args.reason
     };
-    if (nextSliceId > botConfig.maxSlicesPerTurn) {
-      return await upsertAgentTurnSessionRecord({
-        ...shared,
-        ...definedProps2({
-          resumedFromSliceId: latestSessionRecord?.resumedFromSliceId
-        }),
-        errorMessage: new TurnSliceLimitExceededError(
-          botConfig.maxSlicesPerTurn
-        ).message,
-        sliceId: args.currentSliceId,
+    if (!keepSlice && nextSliceId > botConfig.maxSlicesPerTurn) {
+      const error = new TurnSliceLimitExceededError(botConfig.maxSlicesPerTurn);
+      await upsertTurnRecord({
+        ...base,
+        ...definedProps2({ resumedFromSliceId: latest?.resumedFromSliceId }),
+        errorMessage: error.message,
+        sliceId: args.sliceId,
         state: "failed"
       });
+      throw error;
     }
-    return await upsertAgentTurnSessionRecord({
-      ...shared,
-      errorMessage: args.errorMessage,
-      resumedFromSliceId: args.currentSliceId,
+    return await upsertTurnRecord({
+      ...base,
+      ...definedProps2({
+        resumedFromSliceId: keepSlice ? latest?.resumedFromSliceId : args.sliceId
+      }),
       sliceId: nextSliceId,
-      state: "awaiting_resume"
+      // Stored name is historical; means "paused, may continue".
+      state: "paused"
+    });
+  } catch (error) {
+    if (error instanceof TurnSliceLimitExceededError) {
+      throw error;
+    }
+    logException(error, "agent.turn.checkpoint.paused.failed", {
+      "app.ai.resume_conversation_id": args.conversationId,
+      "app.ai.resume_session_id": args.turnId,
+      "app.ai.resume_from_slice_id": args.sliceId,
+      "app.ai.resume_next_slice_id": nextSliceId,
+      "app.ai.resume_reason": args.reason
     });
-  } catch (recordError) {
-    logSessionRecordError(
-      recordError,
-      "agent.continue.session_record.failed",
-      args,
-      {
-        "app.ai.resume_from_slice_id": args.currentSliceId,
-        "app.ai.resume_next_slice_id": nextSliceId
-      }
-    );
     return void 0;
   }
 }
-async function persistYieldSessionRecord(args) {
-  try {
-    const piMessages = [...args.messages];
-    if (piMessages.length === 0 || !isContinuablePiBoundary(piMessages)) {
-      return void 0;
-    }
-    const latestSessionRecord = await getAgentTurnSessionRecord(
-      args.conversationId,
-      args.sessionId
+async function saveDone(args) {
+  let latest;
+  await persistWithRetry(async () => {
+    latest = await getTurnRecord(args.conversationId, args.turnId);
+  });
+  const sliceId = args.sliceId ?? latest?.sliceId;
+  if (sliceId === void 0) {
+    throw new Error(
+      "Completed turn checkpoint requires a slice id from the caller or the latest stored record"
     );
-    return await upsertAgentTurnSessionRecord({
-      ...sessionWriteContext(
-        {
-          actor: args.actor,
-          channelName: args.channelName,
-          conversationId: args.conversationId,
-          destination: args.destination,
-          dispatchId: args.dispatchId,
-          // Yield keeps caller-owned skill names only.
-          loadedSkillNames: args.loadedSkillNames,
-          modelId: args.modelId,
-          reasoningLevel: args.reasoningLevel,
-          sessionId: args.sessionId,
-          source: args.source,
-          surface: args.surface
-        },
-        latestSessionRecord
-      ),
+  }
+  await persistWithRetry(async () => {
+    await upsertTurnRecord({
+      ...sharedWrite(args, latest),
       ...definedProps2({
         cumulativeDurationMs: addDurationMs(
-          latestSessionRecord?.cumulativeDurationMs,
-          args.currentDurationMs
-        ),
-        cumulativeUsage: addAgentTurnUsage(
-          latestSessionRecord?.cumulativeUsage,
-          args.currentUsage
+          latest?.cumulativeDurationMs,
+          args.durationMs
         ),
-        resumedFromSliceId: latestSessionRecord?.resumedFromSliceId
+        cumulativeUsage: addAgentTurnUsage(latest?.cumulativeUsage, args.usage),
+        dispatchOutcome: args.dispatchOutcome ?? latest?.dispatchOutcome,
+        errorMessage: args.errorMessage,
+        resultMessageId: args.resultMessageId ?? latest?.resultMessageId
       }),
-      errorMessage: args.errorMessage,
-      piMessages,
-      resumeReason: "yield",
-      sliceId: args.currentSliceId,
-      state: "awaiting_resume"
+      piMessages: args.messages,
+      sliceId,
+      state: args.mode
     });
-  } catch (recordError) {
-    logSessionRecordError(
-      recordError,
-      "agent.turn.yield_session_record.failed",
-      args,
-      {
-        "app.ai.resume_slice_id": args.currentSliceId
-      }
-    );
-    return void 0;
-  }
+  });
 }
 
 // src/chat/state/conversation.ts
@@ -2923,9 +2798,9 @@ function clearPendingAuth(conversation, sessionId) {
 }
 async function abandonReplacedPendingAuth(args) {
   if (args.previousPendingAuth && args.previousPendingAuth.sessionId !== args.nextPendingAuth.sessionId && args.conversationId) {
-    await abandonAgentTurnSessionRecord({
+    await abandonTurnRecord({
       conversationId: args.conversationId,
-      sessionId: args.previousPendingAuth.sessionId,
+      turnId: args.previousPendingAuth.sessionId,
       errorMessage: "Abandoned by a newer auth-blocked request in the same conversation."
     });
   }
@@ -3021,22 +2896,19 @@ export {
   sanitizeAssistantText,
   decideReply,
   getAssistantReplyText,
-  getAgentTurnSessionRecord,
-  getAgentTurnSessionRecordForResume,
-  recordAgentTurnSessionSummary,
-  listAgentTurnSessionSummariesForConversation,
-  abandonAgentTurnSessionRecord,
-  failAgentTurnSessionRecord,
-  persistWithRetry,
   TurnSliceLimitExceededError,
   buildTurnLimitResponse,
-  loadTurnSessionRecord,
-  persistRunningSessionRecord,
-  persistCompletedSessionRecord,
-  completeDeliveredTurn,
-  persistAuthPauseSessionRecord,
-  persistContinuationSessionRecord,
-  persistYieldSessionRecord,
+  persistWithRetry,
+  getTurnRecord,
+  getTurnRecordForResume,
+  recordTurnSummary,
+  listTurnSummaries,
+  abandonTurnRecord,
+  completeTurnRecord,
+  failTurnRecord,
+  continuableMessages,
+  loadTurnCheckpoint,
+  saveTurnCheckpoint,
   canReusePendingAuthLink,
   getConversationPendingAuth,
   clearPendingAuth,