diff --git a/packages/acp-adapter/src/events-map.ts b/packages/acp-adapter/src/events-map.ts
index 0448f2eb9cb..9ce23573ad6 100644
--- a/packages/acp-adapter/src/events-map.ts
+++ b/packages/acp-adapter/src/events-map.ts
@@ -63,6 +63,8 @@ export function assistantDeltaToSessionUpdate(
  * `blocked`   → `refusal`: a prompt hook blocked the turn before the model
  *   ran. ACP has no separate hook-blocked terminal state, so reuse the
  *   refusal channel instead of reporting a clean `end_turn`.
+ * `interrupted` → `end_turn`: the turn was closed at restore after the
+ *   process died mid-turn; ACP has no interrupted terminal state either.
  */
 export function turnEndReasonToStopReason(
   reason: TurnEndReason,
@@ -78,6 +80,8 @@ export function turnEndReasonToStopReason(
       return 'end_turn';
     case 'blocked':
       return 'refusal';
+    case 'interrupted':
+      return 'end_turn';
   }
 }
 
diff --git a/packages/acp-server/src/events-map.ts b/packages/acp-server/src/events-map.ts
index cb549b73619..5194d59dd8a 100644
--- a/packages/acp-server/src/events-map.ts
+++ b/packages/acp-server/src/events-map.ts
@@ -55,9 +55,11 @@ export function assistantDeltaToSessionUpdate(
  * `blocked`   → `refusal`: a prompt hook blocked the turn before the model
  *   ran. ACP has no separate hook-blocked terminal state, so reuse the
  *   refusal channel.
+ * `interrupted` → `end_turn`: the turn was closed at restore after the
+ *   process died mid-turn; ACP has no interrupted terminal state either.
  */
 export function turnEndReasonToStopReason(
-  reason: TurnEndReason,
+  reason: TurnEndReason | 'interrupted',
   error?: { readonly code: string },
 ): AcpStopReason {
   switch (reason) {
@@ -70,6 +72,8 @@ export function turnEndReasonToStopReason(
       return 'end_turn';
     case 'blocked':
       return 'refusal';
+    case 'interrupted':
+      return 'end_turn';
   }
 }
 
diff --git a/packages/agent-core-v2/docs/state-manifest.d.ts b/packages/agent-core-v2/docs/state-manifest.d.ts
index bc51251a9a6..9dc9cf802a6 100644
--- a/packages/agent-core-v2/docs/state-manifest.d.ts
+++ b/packages/agent-core-v2/docs/state-manifest.d.ts
@@ -802,7 +802,7 @@ export interface AgentStateSnapshot {
     };
     readonly lastTurn?: /* ActivityLastTurnState — packages/agent-core-v2/src/agent/activityView/activityView.ts */ {
       readonly turnId: number;
-      readonly reason: /* TurnEndReason — packages/agent-core-v2/src/agent/loop/turnEvents.ts */ 'completed' | 'cancelled' | 'failed' | 'blocked';
+      readonly reason: /* TurnEndReason — packages/agent-core-v2/src/agent/loop/turnEvents.ts */ 'completed' | 'cancelled' | 'failed' | 'blocked' | 'interrupted';
       readonly durationMs?: number;
       readonly at: number;
     };
@@ -814,7 +814,7 @@ export interface AgentStateSnapshot {
   };
   'activityView.lastTurn': /* ActivityLastTurnState — packages/agent-core-v2/src/agent/activityView/activityView.ts */ {
     readonly turnId: number;
-    readonly reason: /* TurnEndReason — packages/agent-core-v2/src/agent/loop/turnEvents.ts */ 'completed' | 'cancelled' | 'failed' | 'blocked';
+    readonly reason: /* TurnEndReason — packages/agent-core-v2/src/agent/loop/turnEvents.ts */ 'completed' | 'cancelled' | 'failed' | 'blocked' | 'interrupted';
     readonly durationMs?: number;
     readonly at: number;
   } | undefined;
@@ -1192,7 +1192,7 @@ export interface AgentStateSnapshot {
     readonly cancelledTurnIds: readonly number[];
     readonly lastEnded?: {
       readonly turnId: number;
-      readonly reason: 'completed' | 'cancelled' | 'failed' | 'blocked';
+      readonly reason: 'completed' | 'cancelled' | 'failed' | 'blocked' | 'interrupted';
       readonly durationMs?: number;
     };
   };
diff --git a/packages/agent-core-v2/docs/wire-manifest.d.ts b/packages/agent-core-v2/docs/wire-manifest.d.ts
index 0ef3e5124d2..5d6030ba707 100644
--- a/packages/agent-core-v2/docs/wire-manifest.d.ts
+++ b/packages/agent-core-v2/docs/wire-manifest.d.ts
@@ -735,7 +735,7 @@ interface TurnEndedPayload {
   _name: 'turn.ended';
   agentId: string;
   turnId: number;
-  reason: 'completed' | 'cancelled' | 'failed' | 'blocked';
+  reason: 'completed' | 'cancelled' | 'failed' | 'blocked' | 'interrupted';
   /** KimiErrorPayload */
   error?: {
     code: (typeof ErrorCodes)[keyof typeof ErrorCodes];
@@ -781,6 +781,7 @@ interface TurnEndedPayload {
     };
   };
   durationMs?: number;
+  interruptReason?: 'user_cancelled' | 'aborted' | 'max_steps' | 'error' | 'filtered' | 'blocked';
 }
 
 /**
diff --git a/packages/agent-core-v2/src/agent/interruptionReminder/interruptionReminderService.ts b/packages/agent-core-v2/src/agent/interruptionReminder/interruptionReminderService.ts
index d5348bb6995..8882c8676ab 100644
--- a/packages/agent-core-v2/src/agent/interruptionReminder/interruptionReminderService.ts
+++ b/packages/agent-core-v2/src/agent/interruptionReminder/interruptionReminderService.ts
@@ -10,6 +10,7 @@ import { IAgentScopeContext } from '#/agent/scopeContext/scopeContext';
 import { IAgentLifecycleService } from '#/session/agentLifecycle/agentLifecycle';
 import { IAgentStateService } from '#/agent/state/agentState';
 import { IEventBus } from '#/app/event/eventBus';
+import { IEventDispatcher } from '#/state/eventDispatcher';
 
 import { IAgentInterruptionReminderService } from './interruptionReminder';
 import { INTERRUPTION_REMINDER_VARIANT, interruptionReminderKey } from './interruptionReminderOps';
@@ -29,6 +30,7 @@ export class AgentInterruptionReminderService
   constructor(
     @IEventBus eventBus: IEventBus,
     @IAgentContextMemoryService private readonly context: IAgentContextMemoryService,
+    @IEventDispatcher dispatcher: IEventDispatcher,
     @IAgentLifecycleService agentLifecycle: IAgentLifecycleService,
     @IAgentScopeContext scopeContext: IAgentScopeContext,
     @IAgentStateService agentState: IAgentStateService,
@@ -37,6 +39,7 @@ export class AgentInterruptionReminderService
     agentState.contributeState(interruptionReminderKey);
     this._register(
       eventBus.subscribe(TurnEnded, (event) => {
+        if (dispatcher.restorePhase === 'restoring') return;
         if (event.reason !== 'cancelled' || event.interruptReason !== 'user_cancelled') return;
         const origin = lastComparableMessage(this.context.get())?.origin;
         if (origin?.kind === 'injection' && origin.variant === INTERRUPTION_REMINDER_VARIANT) return;
diff --git a/packages/agent-core-v2/src/agent/loop/turnEvents.ts b/packages/agent-core-v2/src/agent/loop/turnEvents.ts
index 4994ea4a095..0ad81f1bc67 100644
--- a/packages/agent-core-v2/src/agent/loop/turnEvents.ts
+++ b/packages/agent-core-v2/src/agent/loop/turnEvents.ts
@@ -6,7 +6,7 @@ import type { FinishReason } from '#/kosong/contract/provider';
 import type { ContentPart, TextPart } from '#/kosong/contract/message';
 import type { TokenUsage } from '#/kosong/contract/usage';
 
-export type TurnEndReason = 'completed' | 'cancelled' | 'failed' | 'blocked';
+export type TurnEndReason = 'completed' | 'cancelled' | 'failed' | 'blocked' | 'interrupted';
 
 export type TurnInterruptReason =
   | 'user_cancelled'
diff --git a/packages/agent-core-v2/src/agent/loop/turnOps.ts b/packages/agent-core-v2/src/agent/loop/turnOps.ts
index c209e9356bd..b5bb9317bdb 100644
--- a/packages/agent-core-v2/src/agent/loop/turnOps.ts
+++ b/packages/agent-core-v2/src/agent/loop/turnOps.ts
@@ -15,7 +15,7 @@ export interface TurnModelState {
   readonly cancelledTurnIds: readonly number[];
   readonly lastEnded?: {
     readonly turnId: number;
-    readonly reason: 'completed' | 'cancelled' | 'failed' | 'blocked';
+    readonly reason: 'completed' | 'cancelled' | 'failed' | 'blocked' | 'interrupted';
     readonly durationMs?: number;
   };
 }
@@ -74,15 +74,16 @@ export interface TurnCancel {
 const turnEndedSchema = z.object({
   agentId: z.string(),
   turnId: z.number(),
-  reason: z.enum(['completed', 'cancelled', 'failed', 'blocked']),
+  reason: z.enum(['completed', 'cancelled', 'failed', 'blocked', 'interrupted']),
   error: z.custom<KimiErrorPayload>().optional(),
   durationMs: z.number().optional(),
+  interruptReason: z.enum(['user_cancelled', 'aborted', 'max_steps', 'error', 'filtered', 'blocked']).optional(),
 });
 
 export interface TurnEndedPayload {
   readonly agentId: string;
   readonly turnId: number;
-  readonly reason: 'completed' | 'cancelled' | 'failed' | 'blocked';
+  readonly reason: 'completed' | 'cancelled' | 'failed' | 'blocked' | 'interrupted';
   readonly error?: KimiErrorPayload;
   readonly durationMs?: number;
   readonly interruptReason?: TurnInterruptReason;
@@ -103,6 +104,7 @@ export class TurnEnded extends AgentEvent2<TurnEndedPayload> {
     };
     if (this.error !== undefined) record['error'] = this.error;
     if (this.durationMs !== undefined) record['durationMs'] = this.durationMs;
+    if (this.interruptReason !== undefined) record['interruptReason'] = this.interruptReason;
     record['time'] = this.time;
     return record as SerializedEvent2;
   }
@@ -137,7 +139,7 @@ export const turnKey = defineState(
     lastEnded: { turnId: e.turnId, reason: e.reason, durationMs: e.durationMs },
   }));
 
-function advanceTurnClock(
+export function advanceTurnClock(
   state: TurnModelState,
   nextTurnId: number,
   cancelledTurnIds: readonly number[] = state.cancelledTurnIds,
diff --git a/packages/agent-core-v2/src/app/event/eventBusService.ts b/packages/agent-core-v2/src/app/event/eventBusService.ts
index 340bdb16f30..0f1a3adfc05 100644
--- a/packages/agent-core-v2/src/app/event/eventBusService.ts
+++ b/packages/agent-core-v2/src/app/event/eventBusService.ts
@@ -15,24 +15,45 @@ export class EventBusService extends Service implements ISessionEventBus {
   private readonly allEmitter = this._register(new Emitter<Event2<any>>('*'));
   private readonly perType = new Map<string, Emitter<Event2<any>>>();
   private readonly agents = new Map<string, AgentContext>();
+  private readonly latestGeneration = new Map<string, number>();
+  private readonly retiredGeneration = new Map<string, number>();
   private readonly sources = new WeakMap<Event2<any>, AgentContext>();
 
   activateAgent(agent: AgentContext): void {
+    this.latestGeneration.set(
+      agent.agentId,
+      Math.max(this.latestGeneration.get(agent.agentId) ?? 0, agent.generation),
+    );
     this.agents.set(agent.agentId, agent);
   }
 
   deactivateAgent(agent: AgentContext): void {
+    this.retiredGeneration.set(
+      agent.agentId,
+      Math.max(this.retiredGeneration.get(agent.agentId) ?? 0, agent.generation),
+    );
+    this.latestGeneration.set(
+      agent.agentId,
+      Math.max(this.latestGeneration.get(agent.agentId) ?? 0, agent.generation),
+    );
     if (this.agents.get(agent.agentId) === agent) this.agents.delete(agent.agentId);
   }
 
   publish(event: Event2<any>, agent?: AgentContext): void {
     const cls = event.constructor as Event2Class;
     if (cls.agentDomain) {
-      if (
-        agent === undefined ||
-        this.agents.get(agent.agentId) !== agent ||
-        (event as Event2<any> & AgentDomainTrait).agentId !== agent.agentId
-      ) {
+      const eventAgentId = (event as Event2<any> & AgentDomainTrait).agentId;
+      if (agent === undefined || eventAgentId !== agent.agentId) {
+        throw new Error(`Agent event '${event.type}' has no active lifecycle context`);
+      }
+      const active = this.agents.get(agent.agentId);
+      if (active !== agent) {
+        const latest = this.latestGeneration.get(agent.agentId);
+        const retired = this.retiredGeneration.get(agent.agentId);
+        const known = latest !== undefined || retired !== undefined;
+        if (known && (agent.generation < (latest ?? 0) || agent.generation <= (retired ?? 0))) {
+          return;
+        }
         throw new Error(`Agent event '${event.type}' has no active lifecycle context`);
       }
     }
diff --git a/packages/agent-core-v2/src/session/sessionActivity/sessionOutcomeMirrorService.ts b/packages/agent-core-v2/src/session/sessionActivity/sessionOutcomeMirrorService.ts
index 1ebd6a49c38..ff5e7e94609 100644
--- a/packages/agent-core-v2/src/session/sessionActivity/sessionOutcomeMirrorService.ts
+++ b/packages/agent-core-v2/src/session/sessionActivity/sessionOutcomeMirrorService.ts
@@ -64,7 +64,11 @@ export class SessionOutcomeMirror extends Disposable implements ISessionOutcomeM
           this.write('completed');
           return;
         }
-        if (event.reason === 'failed' || event.reason === 'blocked') {
+        if (
+          event.reason === 'failed' ||
+          event.reason === 'blocked' ||
+          event.reason === 'interrupted'
+        ) {
           this.write('failed');
           return;
         }
@@ -86,7 +90,7 @@ export class SessionOutcomeMirror extends Disposable implements ISessionOutcomeM
         const reason = event.lastTurn?.reason;
         if (reason === 'completed' || reason === 'cancelled') {
           this.write(reason, { touchUpdatedAt: false });
-        } else if (reason === 'failed' || reason === 'blocked') {
+        } else if (reason === 'failed' || reason === 'blocked' || reason === 'interrupted') {
           this.write('failed', { touchUpdatedAt: false });
         }
       }),
diff --git a/packages/agent-core-v2/src/state/eventDispatcher.ts b/packages/agent-core-v2/src/state/eventDispatcher.ts
index caecbe00c41..2848238c359 100644
--- a/packages/agent-core-v2/src/state/eventDispatcher.ts
+++ b/packages/agent-core-v2/src/state/eventDispatcher.ts
@@ -10,6 +10,8 @@ export type EventDispatcherHooks = {
   readonly onDidRestore: Record<string, never>;
 };
 
+export type RestorePhase = 'new' | 'restoring' | 'ready' | 'failed';
+
 export interface ModelCheckpointDepth {
   readonly id: string;
   readonly depth: number;
@@ -24,6 +26,8 @@ export interface IEventDispatcher extends DurableRuntimeParticipantHost {
 
   readonly hooks: Hooks<EventDispatcherHooks>;
 
+  readonly restorePhase: RestorePhase;
+
   dispatch(event: Event2<any>): Promise<void>;
   history<S>(key: ReplayableStateKey<S>): readonly PatchEntry[];
   checkpointDepth(key: ReplayableStateKey<any>): number;
diff --git a/packages/agent-core-v2/src/state/eventDispatcherService.ts b/packages/agent-core-v2/src/state/eventDispatcherService.ts
index 345e028372d..0f8fe9fe4d4 100644
--- a/packages/agent-core-v2/src/state/eventDispatcherService.ts
+++ b/packages/agent-core-v2/src/state/eventDispatcherService.ts
@@ -19,6 +19,8 @@ import {
   type Event2Class,
 } from '#/app/event/event2';
 import { IEventBus } from '#/app/event/eventBus';
+import { ContextAppendLoopEvent } from '#/agent/contextMemory/contextEvents';
+import { advanceTurnClock, TurnCancel, TurnEnded, TurnPrompt, type TurnModelState } from '#/agent/loop/turnOps';
 import type { ContentPart } from '#/kosong/contract/message';
 import { OrderedHookSlot } from '#/hooks';
 import { IWireService } from '#/wire/wire';
@@ -31,7 +33,7 @@ import {
   type AgentModel,
   type AgentModelDefinition,
 } from './agentModel';
-import { IEventDispatcher, type ModelCheckpointDepth } from './eventDispatcher';
+import { IEventDispatcher, type ModelCheckpointDepth, type RestorePhase } from './eventDispatcher';
 import { StateError, StateErrors } from './errors';
 import {
   expandedModelAppliers,
@@ -109,8 +111,6 @@ interface PreparedParticipant {
   readonly inversePatches: PatchEntry['inversePatches'];
 }
 
-type RestorePhase = 'new' | 'restoring' | 'ready' | 'failed';
-
 class FoldContextImpl implements FoldContext {
   pendingCheckpoint = false;
   pendingClear = false;
@@ -178,7 +178,7 @@ export class EventDispatcherService extends Service implements IEventDispatcher
     readLegacyState: (key) => this.agentState.get(key),
   };
 
-  private restorePhase: RestorePhase = 'new';
+  restorePhase: RestorePhase = 'new';
   private dispatching = false;
   private disposed = false;
   private queue: QueuedEvent[] = [];
@@ -718,6 +718,9 @@ export class EventDispatcherService extends Service implements IEventDispatcher
     }
     this.restorePhase = 'restoring';
     try {
+      let openTurn: number | undefined;
+      let openTurnCancel: 'user_cancelled' | 'aborted' | undefined;
+      let turnClock: TurnModelState = { nextTurnId: 0, cancelledTurnIds: [] };
       let recordIndex = 0;
       for await (const record of this.wire.readJournal()) {
         if (record.type === 'metadata') continue;
@@ -750,9 +753,51 @@ export class EventDispatcherService extends Service implements IEventDispatcher
           continue;
         }
         this.executeEvent(event, true);
+        if (event instanceof TurnPrompt) {
+          openTurn = turnClock.nextTurnId;
+          openTurnCancel = undefined;
+          turnClock = advanceTurnClock(turnClock, turnClock.nextTurnId + 1);
+        } else if (event instanceof TurnCancel) {
+          if (
+            event.target !== undefined &&
+            event.turnId !== undefined &&
+            event.turnId >= turnClock.nextTurnId
+          ) {
+            turnClock = advanceTurnClock(turnClock, turnClock.nextTurnId, [
+              ...turnClock.cancelledTurnIds,
+              event.turnId,
+            ]);
+          }
+          if (event.turnId !== undefined && event.turnId === openTurn) {
+            openTurnCancel = event.reason ?? 'aborted';
+          }
+        } else if (event instanceof TurnEnded) {
+          if (event.turnId === openTurn) {
+            openTurn = undefined;
+            openTurnCancel = undefined;
+          }
+        } else if (event instanceof ContextAppendLoopEvent) {
+          const loopEvent = event.event;
+          if (loopEvent.type !== 'tool.result' && loopEvent.turnId !== undefined) {
+            const turnId = Number.parseInt(loopEvent.turnId, 10);
+            if (Number.isInteger(turnId) && turnId >= turnClock.nextTurnId) {
+              turnClock = advanceTurnClock(turnClock, turnId + 1);
+            }
+          }
+        }
         recordIndex++;
       }
       await this.rehydrateStates();
+      if (openTurn !== undefined) {
+        const event = new TurnEnded({
+          agentId: this.agentScope!.agentId,
+          turnId: openTurn,
+          reason: openTurnCancel === undefined ? 'interrupted' : 'cancelled',
+          interruptReason: openTurnCancel ?? 'aborted',
+        });
+        this.executeEvent(event, false);
+        await this.wire.flush();
+      }
       this.restorePhase = 'ready';
       await this.hooks.onDidRestore.run({});
     } catch (error) {
diff --git a/packages/agent-core-v2/test/agent/loop/loop.test.ts b/packages/agent-core-v2/test/agent/loop/loop.test.ts
index 5fd1356b53c..f3da8d3ec97 100644
--- a/packages/agent-core-v2/test/agent/loop/loop.test.ts
+++ b/packages/agent-core-v2/test/agent/loop/loop.test.ts
@@ -148,7 +148,7 @@ describe('Agent loop', () => {
       [emit] agent.activity.updated      { "time": "<time>", "lifecycle": "ready", "turn": { "turnId": 0, "origin": { "kind": "user" }, "phase": "running", "step": 1, "ending": false, "pendingApprovals": [], "activeToolCalls": [], "since": "<time>" }, "background": [], "agentId": "main" }
       [wire] context.append_loop_event   { "agentId": "main", "event": { "type": "content.part", "uuid": "<uuid-2>", "turnId": "0", "step": 1, "stepUuid": "<uuid-1>", "part": { "type": "text", "text": "blocked" } }, "time": "<time>" }
       [wire] context.append_loop_event   { "agentId": "main", "event": { "type": "step.end", "uuid": "<uuid-1>", "turnId": "0", "step": 1, "finishReason": "filtered", "usage": { "inputOther": 3, "output": 5, "inputCacheRead": 0, "inputCacheCreation": 0 }, "messageId": "mock-1", "providerFinishReason": "filtered", "rawFinishReason": "filtered" }, "time": "<time>" }
-      [wire] turn.ended                  { "agentId": "main", "turnId": 0, "reason": "failed", "error": { "code": "provider.filtered", "message": "Provider safety policy blocked the response.", "name": "ProviderFilteredError", "details": { "finishReason": "filtered" }, "retryable": false }, "time": "<time>" }
+      [wire] turn.ended                  { "agentId": "main", "turnId": 0, "reason": "failed", "error": { "code": "provider.filtered", "message": "Provider safety policy blocked the response.", "name": "ProviderFilteredError", "details": { "finishReason": "filtered" }, "retryable": false }, "interruptReason": "filtered", "time": "<time>" }
       [emit] turn.ended                  { "time": "<time>", "agentId": "main", "turnId": 0, "reason": "failed", "error": { "code": "provider.filtered", "message": "Provider safety policy blocked the response.", "name": "ProviderFilteredError", "details": { "finishReason": "filtered" }, "retryable": false }, "interruptReason": "filtered" }
     `);
 
diff --git a/packages/agent-core-v2/test/agent/loop/turnOps.test.ts b/packages/agent-core-v2/test/agent/loop/turnOps.test.ts
index 77dd4f5f1d2..281188d06ff 100644
--- a/packages/agent-core-v2/test/agent/loop/turnOps.test.ts
+++ b/packages/agent-core-v2/test/agent/loop/turnOps.test.ts
@@ -68,7 +68,7 @@ describe('turnKey lastEnded', () => {
 });
 
 describe('TurnEnded serialization', () => {
-  it('emits the op record shape without the bus-only interruptReason', () => {
+  it('persists the interruptReason in the op record shape', () => {
     const event = new TurnEnded(
       {
         agentId: 'main',
@@ -85,6 +85,7 @@ describe('TurnEnded serialization', () => {
       turnId: 3,
       reason: 'cancelled',
       durationMs: 12,
+      interruptReason: 'user_cancelled',
       time: 42,
     });
   });
diff --git a/packages/agent-core-v2/test/app/event/eventBus.test.ts b/packages/agent-core-v2/test/app/event/eventBus.test.ts
index 9ed829c1bf8..0e2e833c977 100644
--- a/packages/agent-core-v2/test/app/event/eventBus.test.ts
+++ b/packages/agent-core-v2/test/app/event/eventBus.test.ts
@@ -222,9 +222,31 @@ describe('session agent event routing', () => {
 
     expect(seenA).toEqual([1]);
     expect(() => bus.onAgent(stale, TestAgentEvent, () => {})).toThrow('not the active');
-    bus.deactivateAgent(a);
-    expect(() => bus.publish(new TestAgentEvent({ agentId: 'a', value: 3 }), a)).toThrow(
+    const newer = stubAgentContext('a', 3);
+    bus.activateAgent(newer);
+    expect(() => bus.publish(new TestAgentEvent({ agentId: 'a', value: 3 }), stale)).not.toThrow();
+    expect(() => bus.publish(new TestAgentEvent({ agentId: 'b', value: 3 }), stale)).toThrow(
       'no active lifecycle context',
     );
+    bus.deactivateAgent(newer);
+    expect(() => bus.publish(new TestAgentEvent({ agentId: 'a', value: 4 }), newer)).not.toThrow();
+    expect(() => bus.publish(new TestAgentEvent({ agentId: 'a', value: 5 }), stubAgentContext('a', 4))).toThrow(
+      'no active lifecycle context',
+    );
+    expect(() => bus.publish(new TestAgentEvent({ agentId: 'unknown', value: 6 }), stubAgentContext('unknown', 1))).toThrow(
+      'no active lifecycle context',
+    );
+  });
+
+  it('rejects never-activated generation-zero contexts instead of dropping their events', () => {
+    const bus = new EventBusService();
+    const ghost = stubAgentContext('ghost', 0);
+    const seen: number[] = [];
+    bus.subscribe(TestAgentEvent, (event) => seen.push(event.value));
+
+    expect(() => bus.publish(new TestAgentEvent({ agentId: 'ghost', value: 1 }), ghost)).toThrow(
+      'no active lifecycle context',
+    );
+    expect(seen).toEqual([]);
   });
 });
diff --git a/packages/agent-core-v2/test/session/agentLifecycle/agentLifecycle.test.ts b/packages/agent-core-v2/test/session/agentLifecycle/agentLifecycle.test.ts
index 2d5fba01a33..b06f95fa9ac 100644
--- a/packages/agent-core-v2/test/session/agentLifecycle/agentLifecycle.test.ts
+++ b/packages/agent-core-v2/test/session/agentLifecycle/agentLifecycle.test.ts
@@ -70,7 +70,6 @@ import { IBootstrapService } from '#/app/bootstrap/bootstrap';
 import { IConfigService } from '#/app/config/config';
 import { ISessionEventBus } from '#/app/event/eventBus';
 import { EventBusService } from '#/app/event/eventBusService';
-import '#/app/event/eventBusService';
 import { AgentActivityUpdated } from '#/agent/activityView/activityView';
 import { IAgentBlobService } from '#/agent/blob/agentBlobService';
 import { IAgentPluginService } from '#/agent/plugin/agentPlugin';
@@ -547,7 +546,7 @@ describe('AgentLifecycleService', () => {
           new AgentActivityUpdated({ lifecycle: 'disposed', background: [], agentId: 'main' }),
           main,
         ),
-      ).toThrow("Agent event 'agent.activity.updated' has no active lifecycle context");
+      ).not.toThrow();
       expect(unhandled).toEqual([]);
     } finally {
       process.off('unhandledRejection', onUnhandled);
diff --git a/packages/agent-core-v2/test/wire/resume.test.ts b/packages/agent-core-v2/test/wire/resume.test.ts
index 5f1d72a50cf..e0192fbc65b 100644
--- a/packages/agent-core-v2/test/wire/resume.test.ts
+++ b/packages/agent-core-v2/test/wire/resume.test.ts
@@ -60,7 +60,7 @@ describe('Agent resume', () => {
 
     await ctx.restorePersisted();
 
-    expect(persistence.appended).toEqual([]);
+    expect(persistence.appended.filter((record) => record.type === 'turn.ended')).toHaveLength(1);
     expect(persistence.records.filter((record) => record.type === 'metadata')).toHaveLength(1);
   });
 
@@ -153,7 +153,7 @@ describe('Agent resume', () => {
       await ctx.untilTurnEnd();
 
       expect(findRpcEvent(ctx.allEvents, 'turn.started')?.args).toMatchObject({ turnId: 1 });
-      expect(findRpcEvent(ctx.allEvents, 'turn.ended')?.args).toMatchObject({
+      expect(findRpcEvent(ctx.allEvents, 'turn.ended', (a) => a.turnId === 1)?.args).toMatchObject({
         turnId: 1,
         reason: 'completed',
       });
@@ -214,10 +214,16 @@ describe('Agent resume', () => {
     await ctx.restorePersisted();
     const plan = await ctx.get(IAgentPlanService).status();
     expect(plan?.path).toContain('resume-plan');
-    expect(ctx.newEvents()).toMatchInlineSnapshot(`[]`);
+    expect(ctx.newEvents()).toMatchInlineSnapshot(`
+      [wire] turn.ended                     { "agentId": "main", "turnId": 0, "reason": "interrupted", "interruptReason": "aborted", "time": "<time>" }
+      [emit] turn.ended                     { "time": "<time>", "agentId": "main", "turnId": 0, "reason": "interrupted", "interruptReason": "aborted" }
+      [wire] token_counting.turn_recorded   { "agentId": "main", "turnId": 0, "length": 1, "tokens": 9, "time": "<time>" }
+      [emit] agent.status.updated           { "time": "<time>", "agentId": "main", "contextTokens": 9 }
+      [emit] agent.activity.updated         { "time": "<time>", "lifecycle": "ready", "lastTurn": { "turnId": 0, "reason": "interrupted", "at": "<time>" }, "background": [], "agentId": "main" }
+    `);
     expect(ctx.llmCalls).toHaveLength(0);
     expect(execWithEnv).not.toHaveBeenCalled();
-    expect(persistence.appended).toEqual([]);
+    expect(persistence.appended.filter((record) => record.type === 'turn.ended')).toHaveLength(1);
     await ctx.expectResumeMatches();
 
     ctx.mockNextResponse({ type: 'text', text: 'Fresh response after resume.' });
@@ -227,7 +233,7 @@ describe('Agent resume', () => {
     expect(findRpcEvent(ctx.allEvents, 'turn.started')?.args).toMatchObject({
       turnId: 1,
     });
-    expect(findRpcEvent(ctx.allEvents, 'turn.ended')?.args).toMatchObject({
+    expect(findRpcEvent(ctx.allEvents, 'turn.ended', (a) => a.turnId === 1)?.args).toMatchObject({
       turnId: 1,
       reason: 'completed',
     });
@@ -258,7 +264,7 @@ describe('Agent resume', () => {
     await ctx.untilTurnEnd();
 
     expect(findRpcEvent(ctx.allEvents, 'turn.started')?.args).toMatchObject({ turnId: 2 });
-    expect(findRpcEvent(ctx.allEvents, 'turn.ended')?.args).toMatchObject({
+    expect(findRpcEvent(ctx.allEvents, 'turn.ended', (a) => a.turnId === 2)?.args).toMatchObject({
       turnId: 2,
       reason: 'completed',
     });
@@ -277,12 +283,127 @@ describe('Agent resume', () => {
     await ctx.untilTurnEnd();
 
     expect(findRpcEvent(ctx.allEvents, 'turn.started')?.args).toMatchObject({ turnId: 3 });
-    expect(findRpcEvent(ctx.allEvents, 'turn.ended')?.args).toMatchObject({
+    expect(findRpcEvent(ctx.allEvents, 'turn.ended', (a) => a.turnId === 3)?.args).toMatchObject({
       turnId: 3,
       reason: 'completed',
     });
   });
 
+  it('closes an open turn during restore without replaying it', async () => {
+    const persistence = new RecordingAgentPersistence([
+      resumeConfigRecord(),
+      { type: 'turn.prompt', input: [{ type: 'text', text: 'Interrupted' }], origin: { kind: 'user' } },
+      { type: 'context.append_loop_event', event: { type: 'step.begin', uuid: 'open', turnId: '0' } },
+    ] as unknown as WireRecord[]);
+    const ctx = testAgent({ persistence, autoConfigure: false });
+
+    await ctx.restorePersisted();
+
+    expect(turnCurrentId(ctx)).toBe(0);
+    expect(persistence.records).toContainEqual(expect.objectContaining({
+      type: 'turn.ended', turnId: 0, reason: 'interrupted', interruptReason: 'aborted',
+    }));
+    expect(persistence.appended.filter((record) => record.type === 'turn.ended')).toHaveLength(1);
+
+    const resumedPersistence = new RecordingAgentPersistence(
+      persistence.records as unknown as WireRecord[],
+    );
+    const resumed = testAgent({ persistence: resumedPersistence, autoConfigure: false });
+    await resumed.restorePersisted();
+    expect(resumedPersistence.appended.filter((record) => record.type === 'turn.ended')).toHaveLength(0);
+  });
+
+  it('closes prompt-only turns and preserves complete and multiple turns', async () => {
+    const persistence = new RecordingAgentPersistence([
+      resumeConfigRecord(),
+      { type: 'turn.prompt', input: [{ type: 'text', text: 'open' }], origin: { kind: 'user' } },
+      { type: 'turn.prompt', input: [{ type: 'text', text: 'complete' }], origin: { kind: 'user' } },
+      { type: 'turn.ended', turnId: 1, reason: 'completed' },
+      { type: 'turn.prompt', input: [{ type: 'text', text: 'open second' }], origin: { kind: 'user' } },
+    ] as unknown as WireRecord[]);
+    const ctx = testAgent({ persistence, autoConfigure: false });
+
+    await ctx.restorePersisted();
+
+    expect(persistence.appended.filter((record) => record.type === 'turn.ended')).toHaveLength(1);
+    expect(persistence.records).toContainEqual(expect.objectContaining({
+      type: 'turn.ended', turnId: 2, reason: 'interrupted', interruptReason: 'aborted',
+    }));
+    expect(persistence.appended).not.toContainEqual(expect.objectContaining({
+      type: 'turn.ended', turnId: 0,
+    }));
+  });
+
+  it('retires superseded turns without synthetic endings for legacy journals', async () => {
+    const persistence = new RecordingAgentPersistence([
+      resumeConfigRecord(),
+      { type: 'turn.prompt', input: [{ type: 'text', text: 'first' }], origin: { kind: 'user' } },
+      { type: 'turn.prompt', input: [{ type: 'text', text: 'second' }], origin: { kind: 'user' } },
+    ] as unknown as WireRecord[]);
+    const ctx = testAgent({ persistence, autoConfigure: false });
+
+    await ctx.restorePersisted();
+
+    expect(persistence.appended.filter((record) => record.type === 'turn.ended')).toHaveLength(1);
+    expect(persistence.records).toContainEqual(expect.objectContaining({
+      type: 'turn.ended', turnId: 1, reason: 'interrupted', interruptReason: 'aborted',
+    }));
+    expect(persistence.appended).not.toContainEqual(expect.objectContaining({
+      type: 'turn.ended', turnId: 0,
+    }));
+
+    ctx.mockNextResponse({ type: 'text', text: 'Fresh response.' });
+    await ctx.rpc.prompt({ input: [{ type: 'text', text: 'Fresh prompt' }] });
+    await ctx.untilTurnEnd();
+    expect(findRpcEvent(ctx.allEvents, 'turn.started')?.args).toMatchObject({ turnId: 2 });
+  });
+
+  it('honours cancelled turn-id gaps when closing restored turns', async () => {
+    const persistence = new RecordingAgentPersistence([
+      resumeConfigRecord(),
+      { type: 'turn.prompt', input: [{ type: 'text', text: 'done' }], origin: { kind: 'user' } },
+      { type: 'turn.ended', turnId: 0, reason: 'completed' },
+      { type: 'turn.cancel', turnId: 1, target: 'queued', reason: 'user_cancelled' },
+      { type: 'turn.prompt', input: [{ type: 'text', text: 'open' }], origin: { kind: 'user' } },
+      { type: 'context.append_loop_event', event: { type: 'step.begin', uuid: 'open', turnId: '2' } },
+    ] as unknown as WireRecord[]);
+    const ctx = testAgent({ persistence, autoConfigure: false });
+
+    await ctx.restorePersisted();
+
+    expect(persistence.appended.filter((record) => record.type === 'turn.ended')).toHaveLength(1);
+    expect(persistence.records).toContainEqual(expect.objectContaining({
+      type: 'turn.ended', turnId: 2, reason: 'interrupted', interruptReason: 'aborted',
+    }));
+    expect(persistence.records).not.toContainEqual(expect.objectContaining({
+      type: 'turn.ended', turnId: 1,
+    }));
+
+    ctx.mockNextResponse({ type: 'text', text: 'Fresh response.' });
+    await ctx.rpc.prompt({ input: [{ type: 'text', text: 'Fresh prompt' }] });
+    await ctx.untilTurnEnd();
+    expect(findRpcEvent(ctx.allEvents, 'turn.started')?.args).toMatchObject({ turnId: 3 });
+  });
+
+  it('preserves a persisted user cancellation when closing restored turns', async () => {
+    const persistence = new RecordingAgentPersistence([
+      resumeConfigRecord(),
+      { type: 'turn.prompt', input: [{ type: 'text', text: 'cancel me' }], origin: { kind: 'user' } },
+      { type: 'turn.cancel', turnId: 0, target: 'active', reason: 'user_cancelled' },
+    ] as unknown as WireRecord[]);
+    const ctx = testAgent({ persistence, autoConfigure: false });
+
+    await ctx.restorePersisted();
+
+    expect(persistence.appended.filter((record) => record.type === 'turn.ended')).toHaveLength(1);
+    expect(persistence.records).toContainEqual(expect.objectContaining({
+      type: 'turn.ended', turnId: 0, reason: 'cancelled', interruptReason: 'user_cancelled',
+    }));
+    expect(persistence.records).not.toContainEqual(expect.objectContaining({
+      type: 'turn.ended', reason: 'interrupted',
+    }));
+  });
+
   it('keeps turnIds monotonic across repeated resume cycles', async () => {
     const persistence = new RecordingAgentPersistence(multiTurnResumeHistory() as unknown as WireRecord[]);
     const ctx = testAgent({ persistence, autoConfigure: false });
@@ -304,7 +425,7 @@ describe('Agent resume', () => {
     await ctx2.untilTurnEnd();
 
     expect(findRpcEvent(ctx2.allEvents, 'turn.started')?.args).toMatchObject({ turnId: 3 });
-    expect(findRpcEvent(ctx2.allEvents, 'turn.ended')?.args).toMatchObject({
+    expect(findRpcEvent(ctx2.allEvents, 'turn.ended', (a) => a.turnId === 3)?.args).toMatchObject({
       turnId: 3,
       reason: 'completed',
     });
@@ -416,7 +537,7 @@ describe('Agent resume', () => {
     ]);
     expect(textContent(ctx.project()[2])).toBe('lookup result');
     expect(textContent(ctx.project()[3])).toBe('Follow-up recorded before result');
-    expect(persistence.appended).toEqual([]);
+    expect(persistence.appended.filter((record) => record.type === 'turn.ended')).toHaveLength(1);
     await ctx.expectResumeMatches();
   });
 
@@ -1362,6 +1483,12 @@ function goalContinuationResumeHistory(): WireRecord[] {
 function findRpcEvent(
   ctxEvents: readonly { type: string; event: string; args: unknown }[],
   event: string,
+  match?: (args: { turnId?: unknown }) => boolean,
 ) {
-  return ctxEvents.find((entry) => entry.type === '[rpc]' && entry.event === event);
+  return ctxEvents.find(
+    (entry) =>
+      entry.type === '[rpc]' &&
+      entry.event === event &&
+      (match === undefined || match(entry.args as { turnId?: unknown })),
+  );
 }
diff --git a/packages/agent-core/src/agent/turn/index.ts b/packages/agent-core/src/agent/turn/index.ts
index ccdeed93994..fae57cb5a21 100644
--- a/packages/agent-core/src/agent/turn/index.ts
+++ b/packages/agent-core/src/agent/turn/index.ts
@@ -1531,6 +1531,7 @@ function telemetryInterruptReason(
     return 'user_cancelled';
   }
   if (reason === 'aborted' || reason === 'cancelled') return 'aborted';
+  if (reason === 'interrupted') return 'aborted';
   if (reason === 'failed') return 'error';
   if (reason === 'blocked') return 'blocked';
   // Remaining values are `max_steps` | `error` | `filtered`, which match the
diff --git a/packages/kap-server/src/protocol/events-zod.ts b/packages/kap-server/src/protocol/events-zod.ts
index 98b1206579f..6b33cf91123 100644
--- a/packages/kap-server/src/protocol/events-zod.ts
+++ b/packages/kap-server/src/protocol/events-zod.ts
@@ -478,7 +478,7 @@ export const mcpOAuthAuthorizationUrlUpdateDataSchema = z.object({
   expiresAt: z.number().optional(),
 }) satisfies z.ZodType<McpOAuthAuthorizationUrlUpdateData>;
 
-export const turnEndReasonSchema = z.enum(['completed', 'cancelled', 'failed', 'blocked']) satisfies z.ZodType<TurnEndReason>;
+export const turnEndReasonSchema = z.enum(['completed', 'cancelled', 'failed', 'blocked', 'interrupted']) satisfies z.ZodType<TurnEndReason>;
 
 export const agentPhaseSchema = z.discriminatedUnion('kind', [
   z.object({ kind: z.literal('idle') }),
diff --git a/packages/kap-server/src/services/transcript/coreBinding.ts b/packages/kap-server/src/services/transcript/coreBinding.ts
index 69b327af4d3..f5120c2c2cb 100644
--- a/packages/kap-server/src/services/transcript/coreBinding.ts
+++ b/packages/kap-server/src/services/transcript/coreBinding.ts
@@ -3,6 +3,7 @@ import {
   IAgentActivityView,
   IAgentTaskService,
   IEventBus,
+  IEventDispatcher,
   ISessionMetadata,
   MAIN_AGENT_ID,
   listSessionPendingInteractions,
@@ -91,6 +92,14 @@ export function bindSessionTranscript(
           return turn === undefined || `t${turn.turnId}` !== turnId ? undefined : turn.step;
         },
         turn: (turnId) => store.getAgent(agentId)?.getTurn(turnId),
+        prompts: () => store.getAgent(agentId)?.getPrompts() ?? new Map(),
+        restoring: () => {
+          const agentHandle = agents.handleOf(agentId);
+          if (agentHandle === undefined) return false;
+          const dispatcher: IEventDispatcher | undefined =
+            agentHandle.accessor.get(IEventDispatcher);
+          return dispatcher?.restorePhase === 'restoring';
+        },
       });
       const agentHandle = agents.handleOf(agentId);
       if (agentHandle !== undefined) {
diff --git a/packages/kap-server/src/services/transcript/coreEventMap.ts b/packages/kap-server/src/services/transcript/coreEventMap.ts
index 6798a39ceb8..25cdbfc7d8d 100644
--- a/packages/kap-server/src/services/transcript/coreEventMap.ts
+++ b/packages/kap-server/src/services/transcript/coreEventMap.ts
@@ -160,11 +160,15 @@ export type ProjectorStepOrdinalLookup = (turnId: string) => number | undefined;
 
 export type ProjectorTurnLookup = (turnId: string) => TurnHeader | undefined;
 
+export type ProjectorPromptsLookup = () => ReadonlyMap<string, TranscriptPrompt>;
+
 export interface ProjectorLookups {
   readonly stepFrames?: ProjectorFrameLookup;
   readonly toolFrame?: ProjectorToolFrameLookup;
   readonly stepOrdinal?: ProjectorStepOrdinalLookup;
   readonly turn?: ProjectorTurnLookup;
+  readonly prompts?: ProjectorPromptsLookup;
+  readonly restoring?: () => boolean;
 }
 
 interface OpenTextFrame {
@@ -360,7 +364,7 @@ export class AgentTranscriptProjector {
   private onTurnEnded(event: {
     time?: number;
     turnId: number;
-    reason: 'completed' | 'cancelled' | 'failed' | 'blocked';
+    reason: 'completed' | 'cancelled' | 'failed' | 'blocked' | 'interrupted';
     error?: { message: string };
     durationMs?: number;
     interruptReason?: string;
@@ -399,6 +403,28 @@ export class AgentTranscriptProjector {
         this.markerOp('interruption', { turnId: event.turnId, reason: event.interruptReason }),
       );
     }
+    if (
+      (event.reason === 'interrupted' || event.reason === 'cancelled') &&
+      this.lookups?.restoring?.() === true &&
+      this.lookups.prompts !== undefined
+    ) {
+      const finishedAt = event.time === undefined ? nowIso() : epochMsToIso(event.time);
+      const status = event.reason === 'interrupted' ? 'failed' : 'aborted';
+      for (const [promptId, prev] of this.lookups.prompts()) {
+        if (prev.status !== 'running' && prev.status !== 'queued') continue;
+        const prompt: TranscriptPrompt = {
+          promptId,
+          status,
+          userMessageId: prev.userMessageId,
+          content: prev.content,
+          createdAt: prev.createdAt,
+          finishedAt,
+          steeredAt: prev.steeredAt,
+        };
+        this.prompts.set(promptId, prompt);
+        ops.push({ op: 'prompt.upsert', prompt });
+      }
+    }
     return ops;
   }
 
@@ -1387,7 +1413,9 @@ function mapTurnOrigin(origin: unknown): TurnOrigin {
   }
 }
 
-function mapTurnEndState(reason: 'completed' | 'cancelled' | 'failed' | 'blocked'): TurnState {
+function mapTurnEndState(
+  reason: 'completed' | 'cancelled' | 'failed' | 'blocked' | 'interrupted',
+): TurnState {
   switch (reason) {
     case 'completed':
       return 'completed';
@@ -1395,6 +1423,7 @@ function mapTurnEndState(reason: 'completed' | 'cancelled' | 'failed' | 'blocked
       return 'cancelled';
     case 'failed':
     case 'blocked':
+    case 'interrupted':
       return 'failed';
   }
 }
diff --git a/packages/kap-server/test/services/transcript.test.ts b/packages/kap-server/test/services/transcript.test.ts
index f38ab8eb262..7f21f02ba36 100644
--- a/packages/kap-server/test/services/transcript.test.ts
+++ b/packages/kap-server/test/services/transcript.test.ts
@@ -2172,6 +2172,70 @@ describe('AgentTranscriptProjector', () => {
     expect(turnOps('t0', tx.getItems()).state).toBe('failed');
   });
 
+  it('folds interrupted turn endings into failed (engine wire contract)', () => {
+    const projector = new AgentTranscriptProjector('main');
+    const tx = new AgentTranscript('main');
+    tx.apply(projector.map(ev({ type: 'turn.started', turnId: 0, origin: { kind: 'user' } })));
+    tx.apply(projector.map(ev({ type: 'turn.ended', turnId: 0, reason: 'interrupted' })));
+    expect(turnOps('t0', tx.getItems()).state).toBe('failed');
+  });
+
+  it('settles open prompts when a turn ends interrupted', () => {
+    const tx = new AgentTranscript('main');
+    const projector = new AgentTranscriptProjector('main', {
+      prompts: () => tx.getPrompts(),
+      restoring: () => true,
+    });
+    tx.apply(projector.map(ev({ type: 'prompt.accepted', promptId: 'p1' })));
+    tx.apply(
+      projector.map(
+        ev({ type: 'prompt.queued', promptId: 'p2', content: [{ type: 'text', text: 'later' }], queueLength: 1 }),
+      ),
+    );
+    tx.apply(projector.map(ev({ type: 'turn.started', turnId: 0, origin: { kind: 'user' } })));
+    tx.apply(projector.map(ev({ type: 'turn.ended', turnId: 0, reason: 'interrupted' })));
+    expect(tx.getPrompt('p1')).toMatchObject({ status: 'failed' });
+    expect(tx.getPrompt('p2')).toMatchObject({ status: 'failed' });
+  });
+
+  it('settles open prompts as aborted when a restored turn ends cancelled', () => {
+    const tx = new AgentTranscript('main');
+    const projector = new AgentTranscriptProjector('main', {
+      prompts: () => tx.getPrompts(),
+      restoring: () => true,
+    });
+    tx.apply(projector.map(ev({ type: 'prompt.accepted', promptId: 'p1' })));
+    tx.apply(projector.map(ev({ type: 'turn.started', turnId: 0, origin: { kind: 'user' } })));
+    tx.apply(
+      projector.map(
+        ev({ type: 'turn.ended', turnId: 0, reason: 'cancelled', interruptReason: 'user_cancelled' }),
+      ),
+    );
+    expect(tx.getPrompt('p1')).toMatchObject({ status: 'aborted' });
+  });
+
+  it('leaves running and queued prompts pending for live cancelled endings', () => {
+    const tx = new AgentTranscript('main');
+    const projector = new AgentTranscriptProjector('main', {
+      prompts: () => tx.getPrompts(),
+      restoring: () => false,
+    });
+    tx.apply(projector.map(ev({ type: 'prompt.accepted', promptId: 'p1' })));
+    tx.apply(
+      projector.map(
+        ev({ type: 'prompt.queued', promptId: 'p2', content: [{ type: 'text', text: 'later' }], queueLength: 1 }),
+      ),
+    );
+    tx.apply(projector.map(ev({ type: 'turn.started', turnId: 0, origin: { kind: 'user' } })));
+    tx.apply(
+      projector.map(
+        ev({ type: 'turn.ended', turnId: 0, reason: 'cancelled', interruptReason: 'user_cancelled' }),
+      ),
+    );
+    expect(tx.getPrompt('p1')).toMatchObject({ status: 'running' });
+    expect(tx.getPrompt('p2')).toMatchObject({ status: 'queued' });
+  });
+
   it('tracks the prompt queue from accepted/queued through terminal', () => {
     const projector = new AgentTranscriptProjector('main');
     const tx = new AgentTranscript('main');
diff --git a/packages/kap-server/test/sessionEventBroadcaster.test.ts b/packages/kap-server/test/sessionEventBroadcaster.test.ts
index 4283f1675ac..e3890d55538 100644
--- a/packages/kap-server/test/sessionEventBroadcaster.test.ts
+++ b/packages/kap-server/test/sessionEventBroadcaster.test.ts
@@ -863,6 +863,27 @@ describe('SessionEventBroadcaster', () => {
     ]);
   });
 
+  it('passes an interrupted last turn through to the legacy ended phase', async () => {
+    const lc = new FakeLifecycle();
+    const main = lc.addAgent('main');
+    sessions.set('s1', lc);
+    const { target, envelopes } = collectingTarget();
+    await bc.subscribe('s1', target);
+
+    main.bus.emit(
+      agentEvent('agent.activity.updated', {
+        lifecycle: 'ready',
+        lastTurn: { turnId: 1, reason: 'interrupted', at: 200 },
+      }),
+    );
+    await bc.getCursor('s1');
+
+    const statuses = envelopes.filter((envelope) => envelope.type === 'agent.status.updated');
+    expect(statuses.map((envelope) => envelope.payload)).toMatchObject([
+      { phase: { kind: 'ended', turnId: 1, reason: 'interrupted' } },
+    ]);
+  });
+
   it('replays durable events since a cursor from the journal', async () => {
     const lc = new FakeLifecycle();
     const main = lc.addAgent('main');
diff --git a/packages/klient/src/contract/agent/activity.ts b/packages/klient/src/contract/agent/activity.ts
index 5f9f0c5a082..a784be67351 100644
--- a/packages/klient/src/contract/agent/activity.ts
+++ b/packages/klient/src/contract/agent/activity.ts
@@ -46,7 +46,13 @@ export const activityTurnStateSchema = z.object({
   since: z.number(),
 });
 
-export const turnEndReasonSchema = z.enum(['completed', 'cancelled', 'failed', 'blocked']);
+export const turnEndReasonSchema = z.enum([
+  'completed',
+  'cancelled',
+  'failed',
+  'blocked',
+  'interrupted',
+]);
 
 export const activityLastTurnStateSchema = z.object({
   turnId: z.number(),
diff --git a/packages/klient/src/contract/agent/events.ts b/packages/klient/src/contract/agent/events.ts
index e657d6550a7..cf6ee0540cd 100644
--- a/packages/klient/src/contract/agent/events.ts
+++ b/packages/klient/src/contract/agent/events.ts
@@ -43,7 +43,7 @@ export const turnEndedEventSchema = z.object({
   type: z.literal('turn.ended'),
   time: z.number().optional(),
   turnId: z.number(),
-  reason: z.enum(['completed', 'cancelled', 'failed', 'blocked']),
+  reason: z.enum(['completed', 'cancelled', 'failed', 'blocked', 'interrupted']),
   /** Protocol `KimiErrorPayload` — mirrored as `unknown`. */
   error: z.unknown().optional(),
   durationMs: z.number().optional(),
diff --git a/packages/protocol/src/events.ts b/packages/protocol/src/events.ts
index 8e22d7c85f6..b6747652ef9 100644
--- a/packages/protocol/src/events.ts
+++ b/packages/protocol/src/events.ts
@@ -466,7 +466,7 @@ export interface McpOAuthAuthorizationUrlUpdateData {
   readonly expiresAt?: number;
 }
 
-export type TurnEndReason = 'completed' | 'cancelled' | 'failed' | 'blocked';
+export type TurnEndReason = 'completed' | 'cancelled' | 'failed' | 'blocked' | 'interrupted';
 
 export type TurnInterruptReason =
   | 'user_cancelled'
@@ -1469,7 +1469,7 @@ export const mcpOAuthAuthorizationUrlUpdateDataSchema = z.object({
   expiresAt: z.number().optional(),
 }) satisfies z.ZodType<McpOAuthAuthorizationUrlUpdateData>;
 
-export const turnEndReasonSchema = z.enum(['completed', 'cancelled', 'failed', 'blocked']) satisfies z.ZodType<TurnEndReason>;
+export const turnEndReasonSchema = z.enum(['completed', 'cancelled', 'failed', 'blocked', 'interrupted']) satisfies z.ZodType<TurnEndReason>;
 
 export const turnInterruptReasonSchema = z.enum(['user_cancelled', 'aborted', 'max_steps', 'error', 'filtered', 'blocked']) satisfies z.ZodType<TurnInterruptReason>;
 
diff --git a/packages/transcript/src/contract/schema.ts b/packages/transcript/src/contract/schema.ts
index 46bdcea4d23..af63e7ffdb2 100644
--- a/packages/transcript/src/contract/schema.ts
+++ b/packages/transcript/src/contract/schema.ts
@@ -287,7 +287,7 @@ export const agentPhaseMetaSchema = z.discriminatedUnion('kind', [
   z.object({
     kind: z.literal('ended'),
     turnId: z.number(),
-    reason: z.enum(['completed', 'cancelled', 'failed', 'blocked']),
+    reason: z.enum(['completed', 'cancelled', 'failed', 'blocked', 'interrupted']),
     durationMs: z.number().optional(),
     at: z.number(),
   }),
diff --git a/packages/transcript/src/history/foldFacts.ts b/packages/transcript/src/history/foldFacts.ts
index 4585ca69d8a..ea82398f338 100644
--- a/packages/transcript/src/history/foldFacts.ts
+++ b/packages/transcript/src/history/foldFacts.ts
@@ -127,6 +127,7 @@ function mapTurnEndReason(reason: unknown): TranscriptTurn['state'] | undefined
       return 'cancelled';
     case 'failed':
     case 'blocked':
+    case 'interrupted':
       return 'failed';
     default:
       return undefined;
diff --git a/packages/transcript/src/model/meta.ts b/packages/transcript/src/model/meta.ts
index f9ac1c00ee0..554252e6752 100644
--- a/packages/transcript/src/model/meta.ts
+++ b/packages/transcript/src/model/meta.ts
@@ -24,7 +24,7 @@ export interface ModesMetaMerge {
 
 export type ActivityMeta = 'idle' | 'turn' | 'disposing' | 'unknown';
 
-export type TurnEndReasonMeta = 'completed' | 'cancelled' | 'failed' | 'blocked';
+export type TurnEndReasonMeta = 'completed' | 'cancelled' | 'failed' | 'blocked' | 'interrupted';
 
 export type AgentPhaseMeta =
   | { readonly kind: 'idle' }
diff --git a/packages/transcript/test/layers.test.ts b/packages/transcript/test/layers.test.ts
index 1d6af5a3690..a5a22a7fa64 100644
--- a/packages/transcript/test/layers.test.ts
+++ b/packages/transcript/test/layers.test.ts
@@ -1514,6 +1514,14 @@ describe('foldWireRecordFacts (cold facts)', () => {
     const blockedTurn = blocked.items[0];
     if (blockedTurn?.kind !== 'turn') throw new Error('expected turn');
     expect(blockedTurn.state).toBe('failed');
+
+    const interrupted = foldWireRecordFacts(
+      [{ type: 'turn.ended', turnId: 0, reason: 'interrupted', time: 4000 }],
+      base,
+    );
+    const interruptedTurn = interrupted.items[0];
+    if (interruptedTurn?.kind !== 'turn') throw new Error('expected turn');
+    expect(interruptedTurn.state).toBe('failed');
   });
 
   it('ignores turn.ended records with unknown turn ids or malformed payloads', () => {