Fix replay-invalid session reset semantics

dredozubov · dredozubov · commit 78c13ac5f85d · 2026-05-22T15:54:09.000+04:00
diff --git a/src/auto-reply/reply/agent-runner-execution.test.ts b/src/auto-reply/reply/agent-runner-execution.test.ts
@@ -4776,7 +4776,6 @@ describe("runAgentTurnWithFallback", () => {
       shouldEmitToolResult: () => true,
       shouldEmitToolOutput: () => false,
       pendingToolTasks: new Set(),
-      resetSessionAfterCompactionFailure: async () => false,
       resetSessionAfterRoleOrderingConflict: async () => false,
       isHeartbeat: false,
       sessionKey: "main",
diff --git a/src/auto-reply/reply/agent-runner.runreplyagent.e2e.test.ts b/src/auto-reply/reply/agent-runner.runreplyagent.e2e.test.ts
@@ -196,6 +196,7 @@ function createMinimalRun(params?: {
   return {
     typing,
     opts,
+    followupRun,
     run: async () => {
       const runReplyAgent = await getRunReplyAgent();
       return runReplyAgent({
@@ -373,7 +374,7 @@ describe("runReplyAgent pending final delivery capture", () => {
       ),
     );
 
-    const { run } = createMinimalRun({
+    const { followupRun, run } = createMinimalRun({
       sessionEntry,
       sessionStore,
       sessionKey: "main",
@@ -391,10 +392,18 @@ describe("runReplyAgent pending final delivery capture", () => {
       text: "⚠️ Session history got out of sync. Please try again, or use /new to start a fresh session.",
     });
     expect(stored.sessionId).not.toBe("poisoned-session");
+    expect(stored.sessionFile).toEqual(expect.any(String));
+    expect(stored.sessionFile).not.toBe("/tmp/poisoned-session.jsonl");
+    expect(followupRun.run.sessionId).toBe(stored.sessionId);
+    expect(followupRun.run.sessionFile).toBe(stored.sessionFile);
+    expect(vi.mocked(refreshQueuedFollowupSession)).toHaveBeenCalledWith({
+      key: "main",
+      previousSessionId: "poisoned-session",
+      nextSessionId: stored.sessionId,
+      nextSessionFile: stored.sessionFile,
+    });
     expect(stored.systemSent).toBe(false);
-    expect(stored.status).toBeUndefined();
     expect(stored.contextTokens).toBeUndefined();
-    expect(stored.cliSessionBindings).toBeUndefined();
   });
 
   it("does not persist message-tool-only final replies for heartbeat replay", async () => {
diff --git a/src/auto-reply/reply/agent-runner.ts b/src/auto-reply/reply/agent-runner.ts
@@ -1,4 +1,3 @@
-import crypto from "node:crypto";
 import fs from "node:fs/promises";
 import {
   hasSessionAutoModelFallbackProvenance,
@@ -103,7 +102,6 @@ import {
   type ReplyOperation,
 } from "./reply-run-registry.js";
 import { createReplyToModeFilterForChannel, resolveReplyToMode } from "./reply-threading.js";
-import { clearSessionResetRuntimeState } from "./session-reset-cleanup.js";
 import { incrementRunCompactionCount, persistRunSessionUsage } from "./session-run-accounting.js";
 import { resolveSourceReplyVisibilityPolicy } from "./source-reply-delivery-mode.js";
 import { createTypingSignaler } from "./typing-mode.js";
@@ -115,54 +113,6 @@ function isReplayInvalidAgentRunError(error: unknown): boolean {
   return classifyProviderRuntimeFailureKind(formatErrorMessage(error)) === "replay_invalid";
 }
 
-function buildReplayInvalidSessionResetPatch(now: number): Partial<SessionEntry> {
-  return {
-    sessionId: crypto.randomUUID(),
-    sessionFile: undefined,
-    updatedAt: now,
-    sessionStartedAt: now,
-    lastInteractionAt: now,
-    systemSent: false,
-    abortedLastRun: false,
-    status: undefined,
-    startedAt: undefined,
-    endedAt: undefined,
-    runtimeMs: undefined,
-    totalTokens: undefined,
-    inputTokens: undefined,
-    outputTokens: undefined,
-    totalTokensFresh: undefined,
-    estimatedCostUsd: undefined,
-    cacheRead: undefined,
-    cacheWrite: undefined,
-    contextTokens: undefined,
-    responseUsage: undefined,
-    modelProvider: undefined,
-    model: undefined,
-    agentHarnessId: undefined,
-    fallbackNoticeSelectedModel: undefined,
-    fallbackNoticeActiveModel: undefined,
-    fallbackNoticeReason: undefined,
-    compactionCount: 0,
-    memoryFlushAt: undefined,
-    memoryFlushCompactionCount: undefined,
-    memoryFlushContextHash: undefined,
-    pendingFinalDelivery: undefined,
-    pendingFinalDeliveryCreatedAt: undefined,
-    pendingFinalDeliveryLastAttemptAt: undefined,
-    pendingFinalDeliveryAttemptCount: undefined,
-    pendingFinalDeliveryLastError: undefined,
-    pendingFinalDeliveryText: undefined,
-    pendingFinalDeliveryContext: undefined,
-    pendingFinalDeliveryIntentId: undefined,
-    cliSessionIds: undefined,
-    cliSessionBindings: undefined,
-    claudeCliSessionId: undefined,
-    skillsSnapshot: undefined,
-    systemPromptReport: undefined,
-  };
-}
-
 function markBeforeAgentRunBlockedPayloads(payloads: ReplyPayload[]): ReplyPayload[] {
   return payloads.map((payload) =>
     setReplyPayloadMetadata(payload, { beforeAgentRunBlocked: true }),
@@ -1209,52 +1159,44 @@ export async function runReplyAgent(params: {
       });
     }
   };
-  const resetSessionAfterReplayInvalid = async (reason: string): Promise<boolean> => {
-    if (!sessionKey) {
-      return false;
-    }
-    const oldSessionId = activeSessionEntry?.sessionId;
-    const patch = buildReplayInvalidSessionResetPatch(Date.now());
-    let didReset = false;
-    if (activeSessionStore && activeSessionEntry) {
-      const nextEntry = { ...activeSessionEntry, ...patch } as SessionEntry;
-      activeSessionStore[sessionKey] = nextEntry;
-      activeSessionEntry = nextEntry;
-      didReset = true;
-    }
-    if (storePath) {
-      try {
-        const updated = await updateSessionStoreEntry({
-          storePath,
-          sessionKey,
-          update: async () => patch,
-        });
-        if (updated) {
-          activeSessionEntry = updated;
-          if (activeSessionStore) {
-            activeSessionStore[sessionKey] = updated;
-          }
-          didReset = true;
-        }
-      } catch (resetError) {
-        logVerbose(
-          `failed to reset replay-invalid session ${sessionKey}: ${formatErrorMessage(resetError)}`,
-        );
-      }
-    }
-    if (!didReset) {
-      return false;
-    }
-    followupRun.run.sessionId = String(patch.sessionId);
-    activeIsNewSession = true;
-    clearSessionResetRuntimeState([sessionKey, oldSessionId]);
-    logVerbose(
-      `reset replay-invalid session ${sessionKey}` +
-        (oldSessionId ? ` (${oldSessionId} -> ${String(patch.sessionId)})` : "") +
-        ` after ${reason}`,
-    );
-    return true;
+  type SessionResetOptions = {
+    failureLabel: string;
+    buildLogMessage: (nextSessionId: string) => string;
+    cleanupTranscripts?: boolean;
   };
+  const resetSession = async ({
+    failureLabel,
+    buildLogMessage,
+    cleanupTranscripts,
+  }: SessionResetOptions): Promise<boolean> =>
+    await resetReplyRunSession({
+      options: {
+        failureLabel,
+        buildLogMessage,
+        cleanupTranscripts,
+      },
+      sessionKey,
+      queueKey,
+      activeSessionEntry,
+      activeSessionStore,
+      storePath,
+      messageThreadId:
+        typeof sessionCtx.MessageThreadId === "string" ? sessionCtx.MessageThreadId : undefined,
+      followupRun,
+      onActiveSessionEntry: (nextEntry) => {
+        activeSessionEntry = nextEntry;
+      },
+      onNewSession: () => {
+        activeIsNewSession = true;
+      },
+    });
+  const resetSessionAfterReplayInvalid = async (reason: string): Promise<boolean> =>
+    resetSession({
+      failureLabel: "replay-invalid session state",
+      buildLogMessage: (nextSessionId) =>
+        `Replay-invalid session state (${reason}). Restarting session ${sessionKey} -> ${nextSessionId}.`,
+      cleanupTranscripts: true,
+    });
 
   if (effectiveShouldSteer && isStreaming) {
     const steerSessionId =
@@ -1508,37 +1450,6 @@ export async function runReplyAgent(params: {
     });
 
     let responseUsageLine: string | undefined;
-    type SessionResetOptions = {
-      failureLabel: string;
-      buildLogMessage: (nextSessionId: string) => string;
-      cleanupTranscripts?: boolean;
-    };
-    const resetSession = async ({
-      failureLabel,
-      buildLogMessage,
-      cleanupTranscripts,
-    }: SessionResetOptions): Promise<boolean> =>
-      await resetReplyRunSession({
-        options: {
-          failureLabel,
-          buildLogMessage,
-          cleanupTranscripts,
-        },
-        sessionKey,
-        queueKey,
-        activeSessionEntry,
-        activeSessionStore,
-        storePath,
-        messageThreadId:
-          typeof sessionCtx.MessageThreadId === "string" ? sessionCtx.MessageThreadId : undefined,
-        followupRun,
-        onActiveSessionEntry: (nextEntry) => {
-          activeSessionEntry = nextEntry;
-        },
-        onNewSession: () => {
-          activeIsNewSession = true;
-        },
-      });
     const resetSessionAfterRoleOrderingConflict = async (reason: string): Promise<boolean> =>
       resetSession({
         failureLabel: "role ordering conflict",
