fix(agent-core-v2): adopt the replayed turn outcome on restore

A session whose persisted outcome went stale (a write that never landed
before shutdown) kept that outcome after restore whenever the replayed
wire still had an ended turn, because the restore reconcile only cleared
the outcome when no ended turn existed. Adopt the replayed outcome when
it is unambiguous: completed stays completed, failed and blocked map to
failed. A replayed cancellation is left alone, since the wire cannot tell
a user stop from a programmatic abort and only user stops are persisted.

Author: elkaix

.changeset/restore-reconciles-turn-outcome.md

@@ -0,0 +1,5 @@
+---
+"@pymodel/pythinker-code": patch
+---
+
+Fix a resumed session showing a stale "manually stopped" or failed state when its last turn had actually completed.

packages/agent-core-v2/src/session/sessionActivity/sessionOutcomeMirrorService.ts

@@ -129,6 +129,11 @@ export class SessionOutcomeMirror extends Disposable implements ISessionOutcomeM
       this.write(undefined, { touchUpdatedAt: false });
       return;
     }
+    const replayed = replayedOutcome(lastEnded.reason);
+    if (replayed !== undefined && replayed !== this.lastPersisted) {
+      this.write(replayed, { touchUpdatedAt: false, turnId: lastEnded.turnId });
+      return;
+    }
     if (this.lastPersistedTurnId === undefined) this.lastPersistedTurnId = lastEnded.turnId;
   }
 
@@ -164,3 +169,9 @@ registerScopedService(
   ScopeActivation.OnScopeCreated,
   'sessionActivity',
 );
+
+function replayedOutcome(reason: TurnEnded['reason']): SessionTurnOutcome | undefined {
+  if (reason === 'completed') return 'completed';
+  if (reason === 'failed' || reason === 'blocked') return 'failed';
+  return undefined;
+}

packages/agent-core-v2/test/session/sessionActivity/sessionOutcomeMirror.test.ts

@@ -371,6 +371,79 @@ describe('SessionOutcomeMirror (Session scope)', () => {
     expect(writes).toEqual([]);
   });
 
+  const restoredSession = (
+    id: string,
+    persisted: SessionMeta['lastTurnReason'],
+    lastEnded: FakeAgentLifecycle['lastEnded'],
+  ) => {
+    const scope = host.child(LifecycleScope.Session, id, [
+      stubPair(ISessionMetadata, {
+        read: async () => ({ lastTurnReason: persisted }) as SessionMeta,
+        update: async (
+          patch: { lastTurnReason?: SessionMeta['lastTurnReason'] },
+          uopts?: { touchUpdatedAt?: boolean },
+        ) => {
+          writes.push(patch.lastTurnReason);
+          touches.push(uopts?.touchUpdatedAt !== false);
+        },
+      } as unknown as ISessionMetadata),
+    ]);
+    const scopeLifecycle = scope.accessor.get(IAgentLifecycleService) as unknown as FakeAgentLifecycle;
+    scope.accessor.get(ISessionOutcomeMirror);
+    scopeLifecycle.addMain();
+    scopeLifecycle.lastEnded = lastEnded;
+    return scopeLifecycle;
+  };
+
+  it('replaces a stale persisted outcome with the replayed completed turn', async () => {
+    const restored = restoredSession('session-restored-completed', 'cancelled', {
+      turnId: 3,
+      reason: 'completed',
+      durationMs: 5,
+    });
+    await tick();
+    for (const hook of restored.restoreHooks) await hook(undefined, async () => {});
+    expect(writes).toEqual(['completed']);
+    expect(touches).toEqual([false]);
+  });
+
+  it('maps a replayed blocked turn onto the persisted failed outcome', async () => {
+    const restored = restoredSession('session-restored-blocked', 'completed', {
+      turnId: 3,
+      reason: 'blocked',
+      durationMs: 5,
+    });
+    await tick();
+    for (const hook of restored.restoreHooks) await hook(undefined, async () => {});
+    expect(writes).toEqual(['failed']);
+    expect(touches).toEqual([false]);
+  });
+
+  it('keeps the persisted outcome when the replayed turn was cancelled', async () => {
+    const restored = restoredSession('session-restored-cancelled', 'completed', {
+      turnId: 3,
+      reason: 'cancelled',
+      durationMs: 5,
+    });
+    await tick();
+    for (const hook of restored.restoreHooks) await hook(undefined, async () => {});
+    expect(writes).toEqual([]);
+  });
+
+  it('tracks the replayed turn for the undo range after a restore reconcile', async () => {
+    const restored = restoredSession('session-restored-undo', 'cancelled', {
+      turnId: 3,
+      reason: 'completed',
+      durationMs: 5,
+    });
+    await tick();
+    for (const hook of restored.restoreHooks) await hook(undefined, async () => {});
+    restored.bus.publish(new ContextUndone({ agentId: 'main', turns: 1, fromTurnId: 4 }));
+    expect(writes).toEqual(['completed']);
+    restored.bus.publish(new ContextUndone({ agentId: 'main', turns: 1, fromTurnId: 3 }));
+    expect(writes).toEqual(['completed', undefined]);
+  });
+
   it('reattaches when the main agent is disposed and recreated', async () => {
     lifecycle.addMain();
     await tick();