fix local codex review comment

  - [P0] Track session diff deterministically — packages/agents-core/src/runImplementation.ts:1870-1884
    In the session merge logic we decrement historyCounts before newInputCounts. If a sessionInputCallback reorders the combined list so that a newly supplied item (e.g. a
  repeated user message) appears before the matching historical entry, the new turn is treated as history and filtered out of appended. The run will therefore skip persisting that
  user input (sessionItems becomes empty), causing the session store to silently drop real customer messages whenever they match the shape of an older entry. This is a blocking
  data-loss bug for any callback that returns new items first or otherwise reorders items. We need to differentiate originals by identity (or at least consult newInputCounts

Author: seratch

packages/agents-core/src/runImplementation.ts

@@ -1865,13 +1865,15 @@ export async function prepareInputItemsWithSession(
 
   const historyCounts = buildItemFrequencyMap(history);
   const newInputCounts = buildItemFrequencyMap(newInputItems);
+  const historyRefs = buildItemReferenceMap(history);
+  const newInputRefs = buildItemReferenceMap(newInputItems);
 
   const appended: AgentInputItem[] = [];
   for (const item of combined) {
     const key = sessionItemKey(item);
-    const historyRemaining = historyCounts.get(key) ?? 0;
-    if (historyRemaining > 0) {
-      historyCounts.set(key, historyRemaining - 1);
+    if (consumeReference(newInputRefs, key, item)) {
+      decrementCount(newInputCounts, key);
+      appended.push(item);
       continue;
     }
 
@@ -1882,6 +1884,17 @@ export async function prepareInputItemsWithSession(
       continue;
     }
 
+    if (consumeReference(historyRefs, key, item)) {
+      decrementCount(historyCounts, key);
+      continue;
+    }
+
+    const historyRemaining = historyCounts.get(key) ?? 0;
+    if (historyRemaining > 0) {
+      historyCounts.set(key, historyRemaining - 1);
+      continue;
+    }
+
     appended.push(item);
   }
 
@@ -1900,6 +1913,51 @@ function buildItemFrequencyMap(items: AgentInputItem[]): Map<string, number> {
   return counts;
 }
 
+function buildItemReferenceMap(
+  items: AgentInputItem[],
+): Map<string, AgentInputItem[]> {
+  const refs = new Map<string, AgentInputItem[]>();
+  for (const item of items) {
+    const key = sessionItemKey(item);
+    const list = refs.get(key);
+    if (list) {
+      list.push(item);
+    } else {
+      refs.set(key, [item]);
+    }
+  }
+  return refs;
+}
+
+function consumeReference(
+  refs: Map<string, AgentInputItem[]>,
+  key: string,
+  target: AgentInputItem,
+): boolean {
+  const candidates = refs.get(key);
+  if (!candidates || candidates.length === 0) {
+    return false;
+  }
+  const index = candidates.findIndex((candidate) => candidate === target);
+  if (index === -1) {
+    return false;
+  }
+  candidates.splice(index, 1);
+  if (candidates.length === 0) {
+    refs.delete(key);
+  }
+  return true;
+}
+
+function decrementCount(map: Map<string, number>, key: string) {
+  const remaining = (map.get(key) ?? 0) - 1;
+  if (remaining <= 0) {
+    map.delete(key);
+  } else {
+    map.set(key, remaining);
+  }
+}
+
 function sessionItemKey(item: AgentInputItem): string {
   return JSON.stringify(item, sessionSerializationReplacer);
 }

packages/agents-core/test/run.test.ts

@@ -848,6 +848,35 @@ describe('Runner.run', () => {
         expect(getFirstTextContent(persistedUsers[0])).toBe('Fresh input');
       });
 
+      it('persists reordered new items ahead of matching history', async () => {
+        const model = new RecordingModel([
+          {
+            ...TEST_MODEL_RESPONSE_BASIC,
+            output: [fakeModelMessage('reordered response')],
+          },
+        ]);
+        const historyMessage = user('Repeatable message');
+        const newMessage = user('Repeatable message');
+        const session = new MemorySession([historyMessage]);
+        const agent = new Agent({ name: 'ReorderedSession', model });
+        const runner = new Runner({
+          sessionInputCallback: (history, newItems) => newItems.concat(history),
+        });
+
+        await runner.run(agent, [newMessage], { session });
+
+        expect(session.added).toHaveLength(1);
+        const [persisted] = session.added;
+        const persistedUsers = persisted.filter(
+          (item): item is protocol.UserMessageItem =>
+            item.type === 'message' && 'role' in item && item.role === 'user',
+        );
+        expect(persistedUsers).toHaveLength(1);
+        expect(getFirstTextContent(persistedUsers[0])).toBe(
+          'Repeatable message',
+        );
+      });
+
       it('persists binary payloads that share prefixes with history', async () => {
         const model = new RecordingModel([
           {