From 6132b650b40eb3ab08ecb10a808831d677fc8762 Mon Sep 17 00:00:00 2001
From: 7Sageer <7sageer@djwcb.cn>
Date: Thu, 30 Jul 2026 14:47:34 +0800
Subject: [PATCH 1/6] feat(agent-core-v2): interruption reminder for
 user-cancelled turns

When the user interrupts a turn with Esc, append a durable
<system-reminder> (origin: injection/interruption) to the agent context
via a new loop aspect watching turn.ended, so the model learns the
previous turn was deliberately cut off. The marker persists to the
wire, replays on resume, stays hidden from transcripts, skips non-user
aborts and steer, and does not stack on repeated cancels.

Two supporting fixes:

- An aborted LLM stream now persists its accumulated partial
  text/thinking as content.part loop events instead of dropping every
  produced token; gated on the turn signal so retried or
  step-cancelled attempts keep their partial output out of the record.
- The turn.cancel wire op carries an optional reason
  ('user_cancelled' | 'aborted') so cold readers can tell deliberate
  interrupts from programmatic aborts. Goal-lifecycle cancels now pass
  an explicit programmatic reason to keep that field honest.
---
 .changeset/interrupt-reminder.md              |   5 +
 .../agent-core-v2/docs/state-manifest.d.ts    |   2 +-
 .../agent-core-v2/docs/wire-manifest.d.ts     |   1 +
 .../src/agent/goal/goalService.ts             |  25 +-
 .../src/agent/loop/interruptionReminder.ts    |   8 +
 .../agent/loop/interruptionReminderService.ts | 105 ++++++
 .../src/agent/loop/loopService.ts             | 186 +++++++----
 .../src/agent/loop/turnEvents.ts              |  16 +
 .../agent-core-v2/src/agent/loop/turnOps.ts   |   7 +
 .../agent-core-v2/src/app/telemetry/events.ts |   1 +
 packages/agent-core-v2/src/index.ts           |   2 +
 .../fullCompaction/fullCompaction.test.ts     |   1 +
 .../test/agent/goal/goal.test.ts              |  14 +-
 .../test/agent/loop/loop.test.ts              | 298 +++++++++++++++++-
 .../kap-server/src/protocol/events-zod.ts     |   3 +
 packages/klient/src/contract/agent/events.ts  |   4 +
 .../test/e2e/invalid-input-matrix.test.ts     |  13 +-
 17 files changed, 614 insertions(+), 77 deletions(-)
 create mode 100644 .changeset/interrupt-reminder.md
 create mode 100644 packages/agent-core-v2/src/agent/loop/interruptionReminder.ts
 create mode 100644 packages/agent-core-v2/src/agent/loop/interruptionReminderService.ts

diff --git a/.changeset/interrupt-reminder.md b/.changeset/interrupt-reminder.md
new file mode 100644
index 0000000000..2a28b1cf87
--- /dev/null
+++ b/.changeset/interrupt-reminder.md
@@ -0,0 +1,5 @@
+---
+"@moonshot-ai/kimi-code": patch
+---
+
+Preserve the assistant's partial output when a turn is interrupted with Esc, and remind the model that the previous turn was deliberately interrupted.
diff --git a/packages/agent-core-v2/docs/state-manifest.d.ts b/packages/agent-core-v2/docs/state-manifest.d.ts
index 52cf313268..a64f61b718 100644
--- a/packages/agent-core-v2/docs/state-manifest.d.ts
+++ b/packages/agent-core-v2/docs/state-manifest.d.ts
@@ -1013,7 +1013,7 @@ export interface AgentStateSnapshot {
   'llmRequester.lastConfigLogSignature': string | undefined;
   'llmRequester.mediaDegradedTurns': Set<number>;
   'llmRequester.mediaStrippedTurns': Map<number, /* MediaStripSnapshot — packages/agent-core-v2/src/agent/contextProjector/contextProjector.ts */ {
-    readonly "__@mediaStripSnapshotBrand@2678": undefined;
+    readonly "__@mediaStripSnapshotBrand@2683": undefined;
   }>;
   'llmRequester.turnConfigs': Map<number, /* TurnRequestConfig — packages/agent-core-v2/src/agent/llmRequester/llmRequesterService.ts */ {
     readonly resolved: /* ProfileModelContext — packages/agent-core-v2/src/agent/profile/profile.ts */ {
diff --git a/packages/agent-core-v2/docs/wire-manifest.d.ts b/packages/agent-core-v2/docs/wire-manifest.d.ts
index 01917f495d..c2dd16f696 100644
--- a/packages/agent-core-v2/docs/wire-manifest.d.ts
+++ b/packages/agent-core-v2/docs/wire-manifest.d.ts
@@ -571,6 +571,7 @@ interface TurnCancelPayload {
   _name: 'turn.cancel';
   turnId?: number;
   target?: 'active' | 'queued';
+  reason?: 'user_cancelled' | 'aborted';
 }
 
 /**
diff --git a/packages/agent-core-v2/src/agent/goal/goalService.ts b/packages/agent-core-v2/src/agent/goal/goalService.ts
index 5c38e1b97f..6dd74939c3 100644
--- a/packages/agent-core-v2/src/agent/goal/goalService.ts
+++ b/packages/agent-core-v2/src/agent/goal/goalService.ts
@@ -625,7 +625,11 @@ export class AgentGoalService extends Disposable implements IAgentGoalService {
     const state = this.requireState();
     const snapshot = this.toSnapshot(state);
     if (state.status === 'active' && this.liveTurnId !== undefined) {
-      this.loopService.cancel(this.liveTurnId);
+      // A goal-lifecycle cancel is programmatic even when the goal change is
+      // user-driven: the turn was not directly interrupted, so it must not be
+      // recorded (or reminded) as a user cancellation — the goal-cancelled
+      // reminder below carries the user-facing fact.
+      this.loopService.cancel(this.liveTurnId, abortError('Goal cancelled'));
     }
     this.clearInternal(actor);
     if (actor === 'user') {
@@ -988,18 +992,13 @@ export class AgentGoalService extends Disposable implements IAgentGoalService {
     const pending = this.pendingContinuation;
     if (preserveLiveContinuation && pending?.turnId === this.liveTurnId) return;
     this.pendingContinuation = undefined;
-    const aborted =
-      reason === undefined ? pending?.receipt.abort() : pending?.receipt.abort(reason);
-    if (
-      pending !== undefined &&
-      !aborted &&
-      pending.turnId !== undefined
-    ) {
-      if (reason === undefined) {
-        this.loopService.cancel(pending.turnId);
-      } else {
-        this.loopService.cancel(pending.turnId, reason);
-      }
+    // Same provenance rule as `cancelGoal`: goal-lifecycle cancels are
+    // programmatic, never user cancellations (see `handleWallClockDeadline`
+    // for the explicit-reason precedent).
+    const cancellation = reason ?? abortError('Goal continuation cancelled');
+    const aborted = pending?.receipt.abort(cancellation);
+    if (pending !== undefined && !aborted && pending.turnId !== undefined) {
+      this.loopService.cancel(pending.turnId, cancellation);
     }
   }
 
diff --git a/packages/agent-core-v2/src/agent/loop/interruptionReminder.ts b/packages/agent-core-v2/src/agent/loop/interruptionReminder.ts
new file mode 100644
index 0000000000..1ce27d2020
--- /dev/null
+++ b/packages/agent-core-v2/src/agent/loop/interruptionReminder.ts
@@ -0,0 +1,8 @@
+import { createDecorator } from '#/_base/di/instantiation';
+
+export interface IAgentLoopInterruptionReminderService {
+  readonly _serviceBrand: undefined;
+}
+
+export const IAgentLoopInterruptionReminderService =
+  createDecorator<IAgentLoopInterruptionReminderService>('agentLoopInterruptionReminderService');
diff --git a/packages/agent-core-v2/src/agent/loop/interruptionReminderService.ts b/packages/agent-core-v2/src/agent/loop/interruptionReminderService.ts
new file mode 100644
index 0000000000..edbd4f5327
--- /dev/null
+++ b/packages/agent-core-v2/src/agent/loop/interruptionReminderService.ts
@@ -0,0 +1,105 @@
+/**
+ * `loop` domain (L4) — user-interruption reminder aspect.
+ *
+ * A turn the user deliberately cancelled (Esc) would otherwise leave no mark
+ * the model can see: the next user prompt lands as an ordinary message right
+ * after the interrupted turn's residue, with nothing saying the previous turn
+ * was cut off on purpose. This service watches `turn.ended` and appends a
+ * durable `<system-reminder>` (`origin: { kind: 'injection', variant:
+ * 'interruption' }`) at the context tail — after the interrupted turn's
+ * residue, before the next user message — so the marker persists to the wire,
+ * replays on resume, and stays hidden from transcripts, all through the
+ * existing injection machinery. Only `user_cancelled` qualifies: timeouts,
+ * programmatic aborts, and steer (which never cancels the turn) produce no
+ * marker, and a cancelled queued turn publishes no `turn.ended` at all. If
+ * the last durable message already is the interruption reminder (repeated
+ * cancellations with no message in between, a trailing vacuous open
+ * assistant left by the cancelled turn notwithstanding), appending is
+ * skipped so markers do not stack in practice — a reminder still deferred
+ * behind an unsettled tool exchange is invisible to that check, accepted
+ * since a second cancellation cannot normally arrive before the exchange
+ * settles. Bound at Agent scope and constructed with the scope so the
+ * subscription exists before the first turn runs (same rationale as
+ * `loopContinuation`).
+ */
+
+import { Disposable } from '#/_base/di/lifecycle';
+import { LifecycleScope, ScopeActivation, registerScopedService } from '#/_base/di/scope';
+import { IAgentContextMemoryService } from '#/agent/contextMemory/contextMemory';
+import type { ContextMessage } from '#/agent/contextMemory/types';
+import { isVacuousContentPart } from '#/agent/contextMemory/vacuousContent';
+import { IAgentSystemReminderService } from '#/agent/systemReminder/systemReminder';
+import { IEventBus } from '#/app/event/eventBus';
+
+import { IAgentLoopInterruptionReminderService } from './interruptionReminder';
+
+export const INTERRUPTION_REMINDER_VARIANT = 'interruption';
+
+const INTERRUPTION_REMINDER = [
+  'The previous turn was interrupted by the user before completion;',
+  'any partial output shown above is incomplete.',
+  "The user's next message continues the conversation.",
+].join(' ');
+
+export class AgentLoopInterruptionReminderService
+  extends Disposable
+  implements IAgentLoopInterruptionReminderService
+{
+  declare readonly _serviceBrand: undefined;
+
+  constructor(
+    @IEventBus eventBus: IEventBus,
+    @IAgentContextMemoryService private readonly context: IAgentContextMemoryService,
+    @IAgentSystemReminderService private readonly reminders: IAgentSystemReminderService,
+  ) {
+    super();
+    this._register(
+      eventBus.subscribe('turn.ended', (event) => {
+        if (event.reason !== 'cancelled' || event.interruptReason !== 'user_cancelled') return;
+        this.appendInterruptionReminder();
+      }),
+    );
+  }
+
+  private appendInterruptionReminder(): void {
+    const origin = lastDurableMessageOrigin(this.context.get());
+    if (origin?.kind === 'injection' && origin.variant === INTERRUPTION_REMINDER_VARIANT) return;
+    this.reminders.appendSystemReminder(INTERRUPTION_REMINDER, {
+      kind: 'injection',
+      variant: INTERRUPTION_REMINDER_VARIANT,
+    });
+  }
+}
+
+/**
+ * Origin of the last message that survives the fold, skipping a trailing open
+ * assistant the cancelled turn left with nothing sendable recorded (the fold
+ * drops it as vacuous at the next `step.begin`). Judging dedup against it
+ * would let markers stack around the dropped shell (e.g. an empty retry turn
+ * interrupted before its first token).
+ */
+function lastDurableMessageOrigin(
+  messages: readonly ContextMessage[],
+): ContextMessage['origin'] | undefined {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const message = messages[i]!;
+    if (
+      message.role === 'assistant' &&
+      message.partial === true &&
+      message.toolCalls.length === 0 &&
+      message.content.every(isVacuousContentPart)
+    ) {
+      continue;
+    }
+    return message.origin;
+  }
+  return undefined;
+}
+
+registerScopedService(
+  LifecycleScope.Agent,
+  IAgentLoopInterruptionReminderService,
+  AgentLoopInterruptionReminderService,
+  ScopeActivation.OnScopeCreated,
+  'loop',
+);
diff --git a/packages/agent-core-v2/src/agent/loop/loopService.ts b/packages/agent-core-v2/src/agent/loop/loopService.ts
index 69a67fd771..c3b84cf8be 100644
--- a/packages/agent-core-v2/src/agent/loop/loopService.ts
+++ b/packages/agent-core-v2/src/agent/loop/loopService.ts
@@ -53,12 +53,13 @@ import { IAgentToolExecutorService } from '#/agent/toolExecutor/toolExecutor';
 import { IConfigService } from '#/app/config/config';
 import { IEventBus } from '#/app/event/eventBus';
 import { type FinishReason } from '#/kosong/contract/provider';
-import { type StreamedMessagePart } from '#/kosong/contract/message';
+import { mergeInPlace, type ContentPart, type StreamedMessagePart } from '#/kosong/contract/message';
 import { type TokenUsage } from '#/kosong/contract/usage';
 import { BugIndicatingError, ErrorCodes, Error2, isError2, toKimiErrorPayload } from '#/errors';
 import { OrderedHookSlot } from '#/hooks';
 
 import { IAgentContextMemoryService } from '#/agent/contextMemory/contextMemory';
+import { isVacuousContentPart } from '#/agent/contextMemory/vacuousContent';
 import { IAgentStateService } from '#/agent/state/agentState';
 import { IAgentTelemetryContextService } from '#/app/telemetry/agentTelemetryContext';
 import type {
@@ -92,7 +93,7 @@ import {
   type TurnSeed,
 } from './stepRequest';
 import { StepRequestQueue, type StepRequestBatch } from './stepRequestQueue';
-import { isDisplayablePromptOrigin, turnPromptText } from './turnEvents';
+import { isDisplayablePromptOrigin, turnPromptText, type TurnInterruptReason } from './turnEvents';
 import { cancelTurn, promptTurn, TurnModel } from './turnOps';
 
 export type LoopInterruptReason = 'aborted' | 'max_steps' | 'error';
@@ -283,7 +284,9 @@ export class AgentLoopService extends Disposable implements IAgentLoopService {
   private cancelActiveTurn(turnId: number | undefined, cancellation: unknown): boolean {
     const job = this.activeTurnJob;
     if (job === undefined || (turnId !== undefined && job.turn.id !== turnId)) return false;
-    this.wire.dispatch(cancelTurn({ turnId: job.turn.id, target: 'active' }));
+    this.wire.dispatch(
+      cancelTurn({ turnId: job.turn.id, target: 'active', reason: cancelReasonFor(cancellation) }),
+    );
     job.controller.abort(cancellation);
     return true;
   }
@@ -293,7 +296,7 @@ export class AgentLoopService extends Disposable implements IAgentLoopService {
     if (index < 0) return false;
     const [job] = this.pendingTurns.splice(index, 1);
     if (job === undefined || job.turn.state !== 'queued') return false;
-    this.wire.dispatch(cancelTurn({ turnId, target: 'queued' }));
+    this.wire.dispatch(cancelTurn({ turnId, target: 'queued', reason: cancelReasonFor(cancellation) }));
     for (const step of job.steps.values()) step.cancel(cancellation);
     job.controller.abort(cancellation);
     job.turn.state = 'cancelled';
@@ -506,20 +509,23 @@ export class AgentLoopService extends Disposable implements IAgentLoopService {
           : this.activeRequestTrace?.traceId;
       if (result !== undefined) {
         const error = result.type === 'failed' ? toKimiErrorPayload(result.error) : undefined;
+        const interruptReason =
+          result.type === 'completed' ? undefined : interruptReasonFor(result);
         this.eventBus.publish({
           type: 'turn.ended',
           turnId: turn.id,
           reason: result.type,
           error,
           durationMs: Date.now() - startedAt,
+          interruptReason,
         });
         if (error !== undefined) this.eventBus.publish({ type: 'error', ...error });
-        if (result.type !== 'completed') {
+        if (interruptReason !== undefined) {
           const interrupted: TurnInterruptedEvent = {
             turn_id: turn.id,
             at_step: result.steps,
             mode,
-            interrupt_reason: interruptReasonFor(result),
+            interrupt_reason: interruptReason,
             provider_type,
             protocol,
             thinking_effort: thinkingEffort,
@@ -618,6 +624,7 @@ export class AgentLoopService extends Disposable implements IAgentLoopService {
           const result = await this.executeLoopStep(
             runtime.turnId,
             begun.step.signal,
+            runtime.turnSignal,
             begun.step.number,
             begun.step.uuid,
             options.onStarted,
@@ -801,6 +808,7 @@ export class AgentLoopService extends Disposable implements IAgentLoopService {
   private async executeLoopStep(
     turnId: number,
     signal: AbortSignal,
+    turnSignal: AbortSignal,
     currentStep: number,
     stepUuid: string,
     onStarted: ((step: number) => void) | undefined,
@@ -808,13 +816,20 @@ export class AgentLoopService extends Disposable implements IAgentLoopService {
     this.activeRequestTrace = undefined;
     await this.hooks.onWillBeginStep.run({ turnId, step: currentStep, signal });
     const markStepStarted = this.beginStep(turnId, signal, currentStep, stepUuid, onStarted);
+    const streamParts = this.createStreamPartHandler(turnId, markStepStarted);
     const request = this.llmRequester.start(
       { source: { type: 'turn', turnId, step: currentStep } },
-      this.createStreamPartHandler(turnId, markStepStarted),
+      streamParts.handle,
       signal,
     );
     this.activeRequestTrace = request.trace;
-    const response = await request.result;
+    let response: AgentLLMRequestFinish;
+    try {
+      response = await request.result;
+    } catch (error) {
+      this.appendInterruptedStreamContent(turnId, currentStep, stepUuid, streamParts, turnSignal);
+      throw error;
+    }
     this.lastRequestTraceId = request.trace.traceId;
     this.appendResponseContent(turnId, currentStep, stepUuid, response);
     const finishReason = await this.executeStepTools(
@@ -877,6 +892,37 @@ export class AgentLoopService extends Disposable implements IAgentLoopService {
     }
   }
 
+  /**
+   * `appendResponseContent` runs only after a full LLM response, so an abort
+   * mid-stream would otherwise lose every token the model already produced
+   * (the fold then drops the step's empty partial assistant as vacuous). When
+   * the turn itself was aborted, persist the accumulated partial text/thinking
+   * parts so the interrupted step replays to the same partial assistant
+   * message the user saw. Gated on the turn signal, not the step signal: a
+   * step-level cancel lets the turn continue with a regenerated step, and a
+   * failed (non-abort) attempt is retried — both keep their partial output
+   * out of the record because what follows re-generates it.
+   */
+  private appendInterruptedStreamContent(
+    turnId: number,
+    currentStep: number,
+    stepUuid: string,
+    streamParts: StreamPartCollector,
+    turnSignal: AbortSignal,
+  ): void {
+    if (!turnSignal.aborted) return;
+    for (const part of streamParts.drainInterruptedContent()) {
+      this.context.appendLoopEvent({
+        type: 'content.part',
+        uuid: randomUUID(),
+        turnId: String(turnId),
+        step: currentStep,
+        stepUuid,
+        part,
+      });
+    }
+  }
+
   private async executeStepTools(
     turnId: number,
     signal: AbortSignal,
@@ -1031,54 +1077,72 @@ export class AgentLoopService extends Disposable implements IAgentLoopService {
   private createStreamPartHandler(
     turnId: number,
     onResponseEvent: () => void,
-  ): (part: StreamedMessagePart) => void {
+  ): StreamPartCollector {
     const callsByIndex = new Map<number | string | undefined, { id: string; name: string }>();
+    const partialContent: ContentPart[] = [];
+    let mergeBroken = false;
+    // Mirror kosong's stream merge (`mergeInPlace` + flush-on-boundary,
+    // including the tool-call boundary) so the drained partials match the
+    // parts a completed response would have carried.
+    const accumulate = (part: ContentPart): void => {
+      const last = partialContent.at(-1);
+      if (!mergeBroken && last !== undefined && mergeInPlace(last, part)) return;
+      mergeBroken = false;
+      partialContent.push({ ...part });
+    };
 
-    return (part) => {
-      switch (part.type) {
-        case 'text':
-          onResponseEvent();
-          this.eventBus.publish({ type: 'assistant.delta', turnId, delta: part.text });
-          return;
-        case 'think':
-          onResponseEvent();
-          this.eventBus.publish({ type: 'thinking.delta', turnId, delta: part.think });
-          return;
-        case 'image_url':
-        case 'audio_url':
-        case 'video_url':
-          return;
-        case 'function': {
-          onResponseEvent();
-          callsByIndex.set(part._streamIndex, { id: part.id, name: part.name });
-          this.eventBus.publish({
-            type: 'tool.call.delta',
-            turnId,
-            toolCallId: part.id,
-            name: part.name,
-            argumentsPart: part.arguments ?? undefined,
-          });
-          return;
-        }
-        case 'tool_call_part': {
-          if (part.argumentsPart === null) return;
-          const toolCall = callsByIndex.get(part.index);
-          if (toolCall === undefined) return;
-          onResponseEvent();
-          this.eventBus.publish({
-            type: 'tool.call.delta',
-            turnId,
-            toolCallId: toolCall.id,
-            name: toolCall.name,
-            argumentsPart: part.argumentsPart,
-          });
-          return;
-        }
-        default: {
-          const _exhaustive: never = part;
-          return _exhaustive;
+    return {
+      handle: (part) => {
+        switch (part.type) {
+          case 'text':
+            onResponseEvent();
+            accumulate(part);
+            this.eventBus.publish({ type: 'assistant.delta', turnId, delta: part.text });
+            return;
+          case 'think':
+            onResponseEvent();
+            accumulate(part);
+            this.eventBus.publish({ type: 'thinking.delta', turnId, delta: part.think });
+            return;
+          case 'image_url':
+          case 'audio_url':
+          case 'video_url':
+            return;
+          case 'function': {
+            onResponseEvent();
+            mergeBroken = true;
+            callsByIndex.set(part._streamIndex, { id: part.id, name: part.name });
+            this.eventBus.publish({
+              type: 'tool.call.delta',
+              turnId,
+              toolCallId: part.id,
+              name: part.name,
+              argumentsPart: part.arguments ?? undefined,
+            });
+            return;
+          }
+          case 'tool_call_part': {
+            if (part.argumentsPart === null) return;
+            const toolCall = callsByIndex.get(part.index);
+            if (toolCall === undefined) return;
+            onResponseEvent();
+            this.eventBus.publish({
+              type: 'tool.call.delta',
+              turnId,
+              toolCallId: toolCall.id,
+              name: toolCall.name,
+              argumentsPart: part.argumentsPart,
+            });
+            return;
+          }
+          default: {
+            const _exhaustive: never = part;
+            return _exhaustive;
+          }
         }
-      }
+      },
+      drainInterruptedContent: () =>
+        partialContent.splice(0).filter((part) => !isVacuousContentPart(part)),
     };
   }
 }
@@ -1137,9 +1201,23 @@ interface StepRuntime {
 
 type BeginStepResult = { readonly step: StepRuntime } | { readonly result: LoopRunResult };
 
+interface StreamPartCollector {
+  readonly handle: (part: StreamedMessagePart) => void;
+  /**
+   * Drains the merged partial text/thinking parts accumulated from the stream
+   * so far (vacuous parts dropped). Never called on a completed request — the
+   * full response's content is authoritative and lands separately.
+   */
+  drainInterruptedContent(): ContentPart[];
+}
+
+function cancelReasonFor(cancellation: unknown): 'user_cancelled' | 'aborted' {
+  return isUserCancellation(cancellation) ? 'user_cancelled' : 'aborted';
+}
+
 function interruptReasonFor(
   result: Extract<TurnResult, { readonly type: 'cancelled' | 'failed' }>,
-): TurnInterruptedEvent['interrupt_reason'] {
+): TurnInterruptReason {
   if (result.type === 'cancelled') {
     return isUserCancellation(result.reason) ? 'user_cancelled' : 'aborted';
   }
diff --git a/packages/agent-core-v2/src/agent/loop/turnEvents.ts b/packages/agent-core-v2/src/agent/loop/turnEvents.ts
index 0d3f60ab49..6811f9b76c 100644
--- a/packages/agent-core-v2/src/agent/loop/turnEvents.ts
+++ b/packages/agent-core-v2/src/agent/loop/turnEvents.ts
@@ -21,6 +21,20 @@ import type { TokenUsage } from '#/kosong/contract/usage';
 /** Why a turn ended. `blocked` folds into `failed` at the wire edge. */
 export type TurnEndReason = 'completed' | 'cancelled' | 'failed' | 'blocked';
 
+/**
+ * Why a non-completed turn stopped early — the same enum the `turn_interrupted`
+ * telemetry event reports. `user_cancelled` marks a deliberate user interrupt
+ * (Esc); every other value is a programmatic or provider-side stop. Absent on
+ * `turn.ended` when the turn completed.
+ */
+export type TurnInterruptReason =
+  | 'user_cancelled'
+  | 'aborted'
+  | 'max_steps'
+  | 'error'
+  | 'filtered'
+  | 'blocked';
+
 export interface TurnStartedEvent {
   readonly type: 'turn.started';
   readonly turnId: number;
@@ -50,6 +64,8 @@ export interface TurnEndedEvent {
   readonly reason: TurnEndReason;
   readonly error?: KimiErrorPayload;
   readonly durationMs?: number;
+  /** Present iff `reason` is not `'completed'`. */
+  readonly interruptReason?: TurnInterruptReason;
 }
 
 export interface TurnStepStartedEvent {
diff --git a/packages/agent-core-v2/src/agent/loop/turnOps.ts b/packages/agent-core-v2/src/agent/loop/turnOps.ts
index 0a6714e92c..b578e3a7ae 100644
--- a/packages/agent-core-v2/src/agent/loop/turnOps.ts
+++ b/packages/agent-core-v2/src/agent/loop/turnOps.ts
@@ -63,6 +63,13 @@ export const cancelTurn = TurnModel.defineOp('turn.cancel', {
   schema: z.object({
     turnId: z.number().optional(),
     target: z.enum(['active', 'queued']).optional(),
+    /**
+     * Why the turn was cancelled, persisted so a cold reader (transcript
+     * rebuild, future resume-time interruption detection) can tell a
+     * deliberate user interrupt apart from a programmatic abort. Absent on
+     * records written before this field existed.
+     */
+    reason: z.enum(['user_cancelled', 'aborted']).optional(),
   }),
   apply: (s, { turnId, target }) => {
     if (target === undefined || turnId === undefined || turnId < s.nextTurnId) return s;
diff --git a/packages/agent-core-v2/src/app/telemetry/events.ts b/packages/agent-core-v2/src/app/telemetry/events.ts
index 8c41cf5147..d8d23b5019 100644
--- a/packages/agent-core-v2/src/app/telemetry/events.ts
+++ b/packages/agent-core-v2/src/app/telemetry/events.ts
@@ -75,6 +75,7 @@ export interface TurnInterruptedEvent {
   turn_id: number;
   at_step: number;
   mode: 'agent' | 'plan';
+  /** Mirrored as `TurnInterruptReason` in `agent/loop/turnEvents.ts` — telemetry (L1) cannot import the loop (L4) type, so the union is duplicated; keep the two in sync. */
   interrupt_reason: 'user_cancelled' | 'aborted' | 'max_steps' | 'error' | 'filtered' | 'blocked';
   provider_type?: string;
   protocol?: string;
diff --git a/packages/agent-core-v2/src/index.ts b/packages/agent-core-v2/src/index.ts
index 3f667afe1e..3cb812560f 100644
--- a/packages/agent-core-v2/src/index.ts
+++ b/packages/agent-core-v2/src/index.ts
@@ -493,6 +493,8 @@ export * from '#/agent/loop/loop';
 export * from '#/agent/loop/loopService';
 export * from '#/agent/loop/loopContinuation';
 export * from '#/agent/loop/loopContinuationService';
+export * from '#/agent/loop/interruptionReminder';
+export * from '#/agent/loop/interruptionReminderService';
 export * from '#/agent/mcp/mcp';
 export * from '#/agent/mcp/mcpService';
 export * from '#/agent/mcp/mcpDiscoveryOps';
diff --git a/packages/agent-core-v2/test/agent/fullCompaction/fullCompaction.test.ts b/packages/agent-core-v2/test/agent/fullCompaction/fullCompaction.test.ts
index 6160bf672e..d2f0490542 100644
--- a/packages/agent-core-v2/test/agent/fullCompaction/fullCompaction.test.ts
+++ b/packages/agent-core-v2/test/agent/fullCompaction/fullCompaction.test.ts
@@ -1122,6 +1122,7 @@ describe('FullCompaction', () => {
             code: 'compaction.failed',
             message: 'APIStatusError: Bad request',
           }),
+          interruptReason: 'error',
         },
       }),
     );
diff --git a/packages/agent-core-v2/test/agent/goal/goal.test.ts b/packages/agent-core-v2/test/agent/goal/goal.test.ts
index 8c59fd7931..4c3dc01b3b 100644
--- a/packages/agent-core-v2/test/agent/goal/goal.test.ts
+++ b/packages/agent-core-v2/test/agent/goal/goal.test.ts
@@ -6,6 +6,7 @@
  */
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 
+import { isUserCancellation } from '#/_base/utils/abort';
 import type { TurnEndedEvent } from '#/agent/loop/turnEvents';
 
 import type { IDisposable } from '#/_base/di/lifecycle';
@@ -1160,7 +1161,10 @@ describe('AgentGoalService core workflow hooks', () => {
     await goals.cancelGoal();
 
     expect(abort).toHaveBeenCalledOnce();
-    expect(cancel).toHaveBeenCalledWith(41);
+    // Goal-lifecycle cancels are programmatic: the reason must not read as a
+    // user cancellation (which would also fire the interruption reminder).
+    expect(cancel).toHaveBeenCalledWith(41, expect.any(Error));
+    expect(isUserCancellation(cancel.mock.calls[0]?.[1])).toBe(false);
   });
 
   it.each(['turn', 'token', 'wall-clock'] as const)(
@@ -1928,7 +1932,7 @@ describe('AgentGoalService hard wall-clock deadline', () => {
     }
   });
 
-  it('keeps user cancellation authoritative when it precedes the wall-clock deadline', async () => {
+  it('keeps the goal-cancellation abort authoritative when it precedes the wall-clock deadline', async () => {
     const clock = new ManualGoalDeadlineScheduler();
     const llm = blockingGenerate();
     const ctx = createTestAgent(appService(IGoalDeadlineScheduler, clock), {
@@ -1944,10 +1948,14 @@ describe('AgentGoalService hard wall-clock deadline', () => {
       await llm.started;
 
       await ctx.rpc.cancelGoal({});
+      // A goal-lifecycle cancel is programmatic, not a user turn interrupt —
+      // and as the first abort it stays the recorded reason once the
+      // wall-clock deadline fires later.
       expect(llm.signal()).toMatchObject({
         aborted: true,
-        reason: expect.objectContaining({ userCancelled: true }),
+        reason: expect.objectContaining({ message: 'Goal cancelled' }),
       });
+      expect(isUserCancellation(llm.signal().reason)).toBe(false);
       clock.advanceBy(1_000);
 
       await ctx.untilTurnEnd();
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 02a7a24767..8bf8f5a871 100644
--- a/packages/agent-core-v2/test/agent/loop/loop.test.ts
+++ b/packages/agent-core-v2/test/agent/loop/loop.test.ts
@@ -2,12 +2,15 @@ import { type ToolCall } from '#/kosong/contract/message';
 import { emptyUsage } from '#/kosong/contract/usage';
 import { afterEach, beforeEach, describe, expect, it } from 'vitest';
 
+import type { IDisposable } from '#/_base/di/lifecycle';
 import { IAgentProfileService } from '#/index';
 import { IAgentLLMRequesterService } from '#/agent/llmRequester/llmRequester';
 import type { ModelRequestTiming } from '#/kosong/model/modelRequester';
+import type { ContextMessage } from '#/agent/contextMemory/types';
 import { IAgentGoalService } from '#/agent/goal/goal';
 import { IAgentLoopService, type Turn } from '#/agent/loop/loop';
 import { ContinuationStepRequest, MessageStepRequest } from '#/agent/loop/stepRequest';
+import { RetryStepRequest } from '#/agent/prompt/promptStepRequests';
 import type { ExecutableTool } from '#/tool/toolContract';
 import { IAgentToolRegistryService } from '#/agent/toolRegistry/toolRegistry';
 import { IAgentUsageService } from '#/agent/usage/usage';
@@ -115,7 +118,7 @@ describe('Agent loop', () => {
       [emit] agent.activity.updated      { "lifecycle": "ready", "turn": { "turnId": 0, "origin": { "kind": "user" }, "phase": "running", "step": 1, "ending": false, "pendingApprovals": [], "activeToolCalls": [], "since": "<time>" }, "background": [] }
       [wire] context.append_loop_event   { "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   { "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>" }
-      [emit] turn.ended                  { "turnId": 0, "reason": "failed", "error": { "code": "provider.filtered", "message": "Provider safety policy blocked the response.", "name": "ProviderFilteredError", "details": { "finishReason": "filtered" }, "retryable": false } }
+      [emit] turn.ended                  { "turnId": 0, "reason": "failed", "error": { "code": "provider.filtered", "message": "Provider safety policy blocked the response.", "name": "ProviderFilteredError", "details": { "finishReason": "filtered" }, "retryable": false }, "interruptReason": "filtered" }
     `);
 
     const stepCompleted = ctx.allEvents.find(
@@ -937,6 +940,299 @@ describe('turn telemetry', () => {
   );
 });
 
+describe('interruption reminder', () => {
+  let ctx: TestAgentContext;
+  let loop: IAgentLoopService;
+
+  beforeEach(() => {
+    ctx = createTestAgent();
+    loop = ctx.get(IAgentLoopService);
+  });
+
+  afterEach(async () => {
+    try {
+      await ctx.expectResumeMatches();
+    } finally {
+      await ctx.dispose();
+    }
+  });
+
+  function cancelOnFirstDelta(): IDisposable {
+    return ctx.get(IEventBus).subscribe('assistant.delta', () => {
+      loop.cancel();
+    });
+  }
+
+  function remindersIn(target: TestAgentContext): ContextMessage[] {
+    return target.contextData().history.filter(
+      (message) =>
+        message.origin?.kind === 'injection' && message.origin.variant === 'interruption',
+    );
+  }
+
+  function interruptionReminders(): ContextMessage[] {
+    return remindersIn(ctx);
+  }
+
+  function contentPartRecordsIn(target: TestAgentContext): number {
+    return target.allEvents.filter(
+      (entry) =>
+        entry.type === '[wire]' &&
+        entry.event === 'context.append_loop_event' &&
+        (entry.args as { event?: { type?: string } }).event?.type === 'content.part',
+    ).length;
+  }
+
+  it('preserves the partial stream and appends one reminder on user cancel', async () => {
+    ctx.mockNextResponse({ type: 'text', text: 'partial answer' }, { type: 'text', text: ' more' });
+    const subscription = cancelOnFirstDelta();
+    const turn = (await loop.enqueue(nextTurnMessage('Hello')).assigned).turn;
+    await expect(turn.result).resolves.toMatchObject({ type: 'cancelled' });
+    subscription.dispose();
+
+    expect(ctx.contextData().history).toEqual([
+      expect.objectContaining({ role: 'user', content: [{ type: 'text', text: 'Hello' }] }),
+      {
+        role: 'assistant',
+        content: [{ type: 'text', text: 'partial answer' }],
+        toolCalls: [],
+        partial: true,
+      },
+      expect.objectContaining({
+        role: 'user',
+        origin: { kind: 'injection', variant: 'interruption' },
+      }),
+    ]);
+    expect(interruptionReminders()).toHaveLength(1);
+    expect(interruptionReminders()[0]!.content).toEqual([
+      {
+        type: 'text',
+        text: '<system-reminder>\nThe previous turn was interrupted by the user before completion; any partial output shown above is incomplete. The user\'s next message continues the conversation.\n</system-reminder>',
+      },
+    ]);
+
+    const cancelRecord = ctx.allEvents.find(
+      (entry) => entry.type === '[wire]' && entry.event === 'turn.cancel',
+    );
+    expect(cancelRecord?.args).toMatchObject({
+      turnId: 0,
+      target: 'active',
+      reason: 'user_cancelled',
+    });
+    const turnEnded = ctx.allEvents.find(
+      (entry) => entry.type === '[rpc]' && entry.event === 'turn.ended',
+    );
+    expect(turnEnded?.args).toMatchObject({
+      reason: 'cancelled',
+      interruptReason: 'user_cancelled',
+    });
+    expect(contentPartRecordsIn(ctx)).toBe(1);
+  });
+
+  it('preserves the partial stream but appends no reminder on programmatic abort', async () => {
+    ctx.mockNextResponse({ type: 'text', text: 'partial answer' }, { type: 'text', text: ' more' });
+    const subscription = ctx.get(IEventBus).subscribe('assistant.delta', () => {
+      loop.cancel(undefined, new Error('stop'));
+    });
+    const turn = (await loop.enqueue(nextTurnMessage('Hello')).assigned).turn;
+    await expect(turn.result).resolves.toMatchObject({ type: 'cancelled' });
+    subscription.dispose();
+
+    expect(ctx.contextData().history).toContainEqual({
+      role: 'assistant',
+      content: [{ type: 'text', text: 'partial answer' }],
+      toolCalls: [],
+      partial: true,
+    });
+    expect(interruptionReminders()).toHaveLength(0);
+
+    const cancelRecord = ctx.allEvents.find(
+      (entry) => entry.type === '[wire]' && entry.event === 'turn.cancel',
+    );
+    expect(cancelRecord?.args).toMatchObject({ target: 'active', reason: 'aborted' });
+    const turnEnded = ctx.allEvents.find(
+      (entry) => entry.type === '[rpc]' && entry.event === 'turn.ended',
+    );
+    expect(turnEnded?.args).toMatchObject({ reason: 'cancelled', interruptReason: 'aborted' });
+  });
+
+  it('does not stack a second reminder without an intervening message', async () => {
+    ctx.mockNextResponse({ type: 'text', text: 'partial answer' });
+    const subscription = cancelOnFirstDelta();
+    const turn = (await loop.enqueue(nextTurnMessage('Hello')).assigned).turn;
+    await expect(turn.result).resolves.toMatchObject({ type: 'cancelled' });
+    subscription.dispose();
+    expect(interruptionReminders()).toHaveLength(1);
+
+    ctx.get(IEventBus).publish({
+      type: 'turn.ended',
+      turnId: 99,
+      reason: 'cancelled',
+      interruptReason: 'user_cancelled',
+    });
+
+    expect(interruptionReminders()).toHaveLength(1);
+  });
+
+  it('appends no reminder when a queued turn is user-cancelled before starting', async () => {
+    let release!: () => void;
+    loop.hooks.onWillBeginStep.register('test-hang-queued-cancel', async (hookCtx, next) => {
+      await new Promise<void>((resolve) => {
+        release = resolve;
+      });
+      await next();
+    });
+    ctx.mockNextResponse({ type: 'text', text: 'unreached' });
+
+    const active = (await loop.enqueue(nextTurnMessage('active')).assigned).turn;
+    const queued = (await loop.enqueue(nextTurnMessage('queued')).assigned).turn;
+    expect(loop.cancel(queued.id)).toBe(true);
+    await expect(queued.result).resolves.toMatchObject({ type: 'cancelled', steps: 0 });
+    release();
+    loop.cancel(active.id);
+    await expect(active.result).resolves.toMatchObject({ type: 'cancelled' });
+
+    expect(interruptionReminders()).toHaveLength(1);
+    const queuedCancel = ctx.allEvents.find(
+      (entry) =>
+        entry.type === '[wire]' &&
+        entry.event === 'turn.cancel' &&
+        (entry.args as { target?: string }).target === 'queued',
+    );
+    expect(queuedCancel?.args).toMatchObject({ target: 'queued', reason: 'user_cancelled' });
+  });
+
+  it('sends the partial output and reminder ahead of the next user message', async () => {
+    ctx.mockNextResponse({ type: 'text', text: 'partial answer' }, { type: 'text', text: ' more' });
+    const subscription = cancelOnFirstDelta();
+    await ctx.rpc.prompt({ input: [{ type: 'text', text: 'Hello' }] });
+    await ctx.untilTurnEnd();
+    subscription.dispose();
+    ctx.llmInputs(); // drain the interrupted turn's request
+
+    ctx.mockNextResponse({ type: 'text', text: 'second answer' });
+    await ctx.rpc.prompt({ input: [{ type: 'text', text: 'Next' }] });
+    await ctx.untilTurnEnd();
+
+    expect(ctx.lastLlmInput()).toMatchInlineSnapshot(`
+      messages:
+        <last>
+        assistant: text "partial answer"
+        user: text "<system-reminder>\\nThe previous turn was interrupted by the user before completion; any partial output shown above is incomplete. The user's next message continues the conversation.\\n</system-reminder>"
+        user: text "Next"
+    `);
+  });
+
+  it('removes the reminder together with the undone turn', async () => {
+    ctx.mockNextResponse({ type: 'text', text: 'partial answer' });
+    const subscription = cancelOnFirstDelta();
+    await ctx.rpc.prompt({ input: [{ type: 'text', text: 'Hello' }] });
+    await ctx.untilTurnEnd();
+    subscription.dispose();
+    expect(interruptionReminders()).toHaveLength(1);
+
+    await ctx.undoHistory(1);
+
+    expect(ctx.contextData().history).toEqual([]);
+  });
+
+  it('preserves partial thinking on user cancel', async () => {
+    ctx.mockNextResponse({ type: 'think', think: 'pondering' }, { type: 'text', text: 'answer' });
+    const subscription = ctx.get(IEventBus).subscribe('thinking.delta', () => {
+      loop.cancel();
+    });
+    const turn = (await loop.enqueue(nextTurnMessage('Hello')).assigned).turn;
+    await expect(turn.result).resolves.toMatchObject({ type: 'cancelled' });
+    subscription.dispose();
+
+    expect(ctx.contextData().history).toContainEqual({
+      role: 'assistant',
+      content: [{ type: 'think', think: 'pondering' }],
+      toolCalls: [],
+      partial: true,
+    });
+    expect(interruptionReminders()).toHaveLength(1);
+  });
+
+  it('records no partial content when the stream only produced whitespace', async () => {
+    ctx.mockNextResponse({ type: 'text', text: '  ' }, { type: 'text', text: 'answer' });
+    const subscription = cancelOnFirstDelta();
+    const turn = (await loop.enqueue(nextTurnMessage('Hello')).assigned).turn;
+    await expect(turn.result).resolves.toMatchObject({ type: 'cancelled' });
+    subscription.dispose();
+
+    // The whitespace-only partial is vacuous: nothing is persisted, the open
+    // assistant stays empty, and the reminder still lands.
+    expect(contentPartRecordsIn(ctx)).toBe(0);
+    expect(ctx.contextData().history).toEqual([
+      expect.objectContaining({ role: 'user' }),
+      { role: 'assistant', content: [], toolCalls: [], partial: true },
+      expect.objectContaining({ origin: { kind: 'injection', variant: 'interruption' } }),
+    ]);
+  });
+
+  it('does not stack a second reminder around a vacuous retry turn', async () => {
+    ctx.mockNextResponse({ type: 'text', text: 'partial answer' });
+    const first = cancelOnFirstDelta();
+    const firstTurn = (await loop.enqueue(nextTurnMessage('Hello')).assigned).turn;
+    await expect(firstTurn.result).resolves.toMatchObject({ type: 'cancelled' });
+    first.dispose();
+    expect(interruptionReminders()).toHaveLength(1);
+
+    // A retry turn materializes no message; cancelled before its first token
+    // it leaves only a vacuous open assistant at the tail — the dedup check
+    // must see through it to the reminder below.
+    ctx.mockNextResponse({ type: 'text', text: 'retried answer' });
+    const onStepStarted = ctx.get(IEventBus).subscribe('turn.step.started', () => {
+      loop.cancel();
+    });
+    const retryTurn = (await loop.enqueue(new RetryStepRequest()).assigned).turn;
+    await expect(retryTurn.result).resolves.toMatchObject({ type: 'cancelled' });
+    onStepStarted.dispose();
+    expect(interruptionReminders()).toHaveLength(1);
+
+    // The next turn settles the vacuous shell away; still no second marker.
+    ctx.mockNextResponse({ type: 'text', text: 'third answer' });
+    await ctx.rpc.prompt({ input: [{ type: 'text', text: 'Next' }] });
+    await ctx.untilTurnEnd();
+    expect(interruptionReminders()).toHaveLength(1);
+  });
+
+  it('does not duplicate recorded content when cancelled during tool execution', async () => {
+    const local = createTestAgent(permissionModeServices('yolo'));
+    try {
+      const slowToolStarted = registerAbortableWorkTool(local);
+      const localLoop = local.get(IAgentLoopService);
+      local.mockNextResponse(
+        { type: 'text', text: 'working' },
+        { type: 'function', id: 'call-work-1', name: 'Work', arguments: '{}' },
+      );
+      local.mockNextResponse(
+        { type: 'text', text: 'still working' },
+        { type: 'function', id: 'call-work-2', name: 'Work', arguments: '{}' },
+      );
+      const turn = (await localLoop.enqueue(nextTurnMessage('do work')).assigned).turn;
+      await slowToolStarted.promise;
+      localLoop.cancel(turn.id);
+      await expect(turn.result).resolves.toMatchObject({ type: 'cancelled' });
+
+      // Both steps' streamed text landed exactly once through the completed
+      // response path; the mid-tool cancel flushed nothing extra.
+      expect(contentPartRecordsIn(local)).toBe(2);
+
+      // The reminder lands after the interrupted tool exchange.
+      const history = local.contextData().history;
+      expect(remindersIn(local)).toHaveLength(1);
+      expect(history.at(-1)?.origin).toEqual({ kind: 'injection', variant: 'interruption' });
+      expect(history.at(-2)?.role).toBe('tool');
+
+      await local.expectResumeMatches();
+    } finally {
+      await local.dispose();
+    }
+  });
+});
+
 describe('step timing split propagation', () => {
   it('carries the split from the llmRequester timing event to the turn.step.completed protocol event', async () => {
     const ctx = createTestAgent(agentService(IAgentLLMRequesterService, createTimingRequester()));
diff --git a/packages/kap-server/src/protocol/events-zod.ts b/packages/kap-server/src/protocol/events-zod.ts
index 79de1337ca..7ce003fe61 100644
--- a/packages/kap-server/src/protocol/events-zod.ts
+++ b/packages/kap-server/src/protocol/events-zod.ts
@@ -646,6 +646,9 @@ export const turnEndedEventSchema = z.object({
   reason: turnEndReasonSchema,
   error: kimiErrorPayloadSchema.optional(),
   durationMs: z.number().optional(),
+  interruptReason: z
+    .enum(['user_cancelled', 'aborted', 'max_steps', 'error', 'filtered', 'blocked'])
+    .optional(),
 });
 
 export const turnStepStartedEventSchema = z.object({
diff --git a/packages/klient/src/contract/agent/events.ts b/packages/klient/src/contract/agent/events.ts
index ea5466a2ad..9212bec926 100644
--- a/packages/klient/src/contract/agent/events.ts
+++ b/packages/klient/src/contract/agent/events.ts
@@ -43,6 +43,10 @@ export const turnEndedEventSchema = z.object({
   /** Protocol `KimiErrorPayload` — mirrored as `unknown`. */
   error: z.unknown().optional(),
   durationMs: z.number().optional(),
+  /** Why a non-completed turn stopped early; absent on completion. */
+  interruptReason: z
+    .enum(['user_cancelled', 'aborted', 'max_steps', 'error', 'filtered', 'blocked'])
+    .optional(),
 });
 
 export const assistantDeltaEventSchema = z.object({
diff --git a/packages/klient/test/e2e/invalid-input-matrix.test.ts b/packages/klient/test/e2e/invalid-input-matrix.test.ts
index 6f4d66a9af..91071aa593 100644
--- a/packages/klient/test/e2e/invalid-input-matrix.test.ts
+++ b/packages/klient/test/e2e/invalid-input-matrix.test.ts
@@ -990,7 +990,7 @@ describe('tool exchange structure', () => {
     }
   }, 60_000);
 
-  it('after an abort, consecutive user messages are merged into one on the wire (projector fallback)', async () => {
+  it('after a user abort, an interruption reminder separates the next user message on the wire', async () => {
     const ctx = await newCase(M_OPENAI, 'abort-merge');
     resetMock((_req, callIndex) => (callIndex === 0 ? { kind: 'hang' } : OK_OPENAI));
 
@@ -1004,11 +1004,14 @@ describe('tool exchange structure', () => {
 
     expect(requests).toHaveLength(2);
     const userMessages = openAiMessages(1).filter((message) => message['role'] === 'user');
-    // The projector folds consecutive origin=user messages into one
-    // (\n\n-joined) instead of sending two same-role messages in a row.
-    expect(userMessages).toHaveLength(1);
+    // A deliberate user cancel injects an interruption reminder between the
+    // aborted turn's prompt and the next user message, so the two prompts no
+    // longer merge into one wire message.
+    expect(userMessages).toHaveLength(3);
     expect(String(userMessages[0]?.['content'])).toContain('first message');
-    expect(String(userMessages[0]?.['content'])).toContain('second message');
+    expect(String(userMessages[1]?.['content'])).toContain('<system-reminder>');
+    expect(String(userMessages[1]?.['content'])).toContain('interrupted by the user');
+    expect(String(userMessages[2]?.['content'])).toContain('second message');
     expect(ctx.payloads('prompt.completed')[0]?.['reason']).toBe('completed');
   }, 60_000);
 });

From 683db918e0ed4ca11ae36142d6b7509b6b533bd1 Mon Sep 17 00:00:00 2001
From: 7Sageer <7sageer@djwcb.cn>
Date: Thu, 30 Jul 2026 15:42:48 +0800
Subject: [PATCH 2/6] feat(transcript): mark user-cancelled turns with an
 interruption marker

Project the deliberate user interrupt onto the transcript timeline: the
live projector emits an 'interruption' marker when a turn ends with
interruptReason 'user_cancelled', and the cold fold consumes the
persisted turn.cancel reason into the same marker. Programmatic aborts
keep surfacing through their own outlets (errors, goal/task state), and
queued cancels that left no visible residue are skipped.
---
 .../src/services/transcript/coreEventMap.ts   | 10 +++++++
 .../test/services/transcript.test.ts          | 24 +++++++++++++++++
 packages/transcript/src/history/foldFacts.ts  | 18 +++++++++++++
 packages/transcript/test/layers.test.ts       | 27 +++++++++++++++++++
 4 files changed, 79 insertions(+)

diff --git a/packages/kap-server/src/services/transcript/coreEventMap.ts b/packages/kap-server/src/services/transcript/coreEventMap.ts
index 157904ad4d..a54b21b158 100644
--- a/packages/kap-server/src/services/transcript/coreEventMap.ts
+++ b/packages/kap-server/src/services/transcript/coreEventMap.ts
@@ -323,6 +323,7 @@ export class AgentTranscriptProjector {
     reason: 'completed' | 'cancelled' | 'failed' | 'blocked';
     error?: { message: string };
     durationMs?: number;
+    interruptReason?: string;
   }): TranscriptOperation[] {
     const ops: TranscriptOperation[] = [];
     this.flushOpenFrames(ops);
@@ -351,6 +352,15 @@ export class AgentTranscriptProjector {
     };
     ops.push({ op: 'turn.upsert', turn: this.currentTurn });
     this.currentStep = undefined;
+    // The user-facing counterpart of the (hidden) context reminder: a
+    // deliberate user interrupt gets a timeline marker, mirroring the cold
+    // fold's `turn.cancel` handling. Programmatic aborts already surface
+    // through the turn's error field or goal/task state.
+    if (event.reason === 'cancelled' && event.interruptReason === 'user_cancelled') {
+      ops.push(
+        this.markerOp('interruption', { turnId: event.turnId, reason: event.interruptReason }),
+      );
+    }
     return ops;
   }
 
diff --git a/packages/kap-server/test/services/transcript.test.ts b/packages/kap-server/test/services/transcript.test.ts
index 28c25fc766..9a1414fafc 100644
--- a/packages/kap-server/test/services/transcript.test.ts
+++ b/packages/kap-server/test/services/transcript.test.ts
@@ -417,6 +417,30 @@ describe('AgentTranscriptProjector', () => {
     );
   });
 
+  it('marks a user-cancelled turn with an interruption marker, but not programmatic aborts', () => {
+    const projector = new AgentTranscriptProjector('main');
+    const tx = new AgentTranscript('main');
+    const feed = (event: DomainEvent): void => void tx.apply(projector.map(event));
+
+    feed(ev({ type: 'turn.started', turnId: 0, origin: { kind: 'user' }, prompt: 'hi' }));
+    feed(
+      ev({ type: 'turn.ended', turnId: 0, reason: 'cancelled', interruptReason: 'user_cancelled' }),
+    );
+    feed(ev({ type: 'turn.started', turnId: 1, origin: { kind: 'user' }, prompt: 'again' }));
+    feed(ev({ type: 'turn.ended', turnId: 1, reason: 'cancelled', interruptReason: 'aborted' }));
+    feed(ev({ type: 'turn.started', turnId: 2, origin: { kind: 'user' }, prompt: 'legacy' }));
+    feed(ev({ type: 'turn.ended', turnId: 2, reason: 'cancelled' }));
+
+    const markers = tx
+      .getItems()
+      .filter((item): item is Extract<typeof item, { kind: 'marker' }> => item.kind === 'marker');
+    expect(markers).toHaveLength(1);
+    expect(markers[0]).toMatchObject({
+      marker: 'interruption',
+      payload: { turnId: 0, reason: 'user_cancelled' },
+    });
+  });
+
   it('carries usage / finishReason / the full timing breakdown on turn.step.completed', () => {
     const projector = new AgentTranscriptProjector('main');
     const tx = new AgentTranscript('main');
diff --git a/packages/transcript/src/history/foldFacts.ts b/packages/transcript/src/history/foldFacts.ts
index c038988439..2059f0aef2 100644
--- a/packages/transcript/src/history/foldFacts.ts
+++ b/packages/transcript/src/history/foldFacts.ts
@@ -97,6 +97,13 @@ interface PlanRevisionPayload {
   readonly bytes?: unknown;
 }
 
+/** `turn.cancel` payload. */
+interface TurnCancelPayload {
+  readonly turnId?: unknown;
+  readonly target?: unknown;
+  readonly reason?: unknown;
+}
+
 /** Engine task kinds (`AgentTaskInfoByKind`: process / agent / question) → transcript kinds. */
 function mapTaskKind(kind: unknown): TranscriptTask['kind'] {
   switch (kind) {
@@ -344,6 +351,17 @@ export function foldWireRecordFacts(
         upsertTask(record);
         break;
       }
+      case 'turn.cancel': {
+        const payload = record as TurnCancelPayload;
+        // Only a deliberate user interrupt of a turn that actually ran becomes
+        // a marker: programmatic aborts surface through their own outlets
+        // (errors, goal/task state), and a queued cancel left no visible
+        // residue. Records written before the reason field existed are
+        // skipped — they cannot be attributed.
+        if (payload.reason !== 'user_cancelled' || payload.target === 'queued') break;
+        pushMarker('interruption', record);
+        break;
+      }
       case 'interaction.request': {
         const payload = record as InteractionRequestPayload;
         // The live path projects only approvals/questions (`user_tool`
diff --git a/packages/transcript/test/layers.test.ts b/packages/transcript/test/layers.test.ts
index 3ce1b213cd..57cace92cf 100644
--- a/packages/transcript/test/layers.test.ts
+++ b/packages/transcript/test/layers.test.ts
@@ -750,6 +750,33 @@ describe('foldWireRecordFacts (cold facts)', () => {
     expect(cleared.meta.goal).toBeUndefined();
   });
 
+  it('marks user-cancelled turns with interruption markers, skipping unattributable cancels', () => {
+    const base = baseWithMarker();
+    const folded = foldWireRecordFacts(
+      [
+        { type: 'turn.cancel', turnId: 0, target: 'active', reason: 'user_cancelled', time: 1000 },
+        // A queued cancel left no visible residue — no marker.
+        { type: 'turn.cancel', turnId: 1, target: 'queued', reason: 'user_cancelled', time: 2000 },
+        // Programmatic aborts surface through their own outlets — no marker.
+        { type: 'turn.cancel', turnId: 2, target: 'active', reason: 'aborted', time: 3000 },
+        // Records written before the reason field existed cannot be attributed.
+        { type: 'turn.cancel', turnId: 3, target: 'active', time: 4000 },
+      ],
+      base,
+    );
+    expect(
+      folded.items.filter((item) => item.kind === 'marker' && item.marker === 'interruption'),
+    ).toEqual([
+      {
+        kind: 'marker',
+        markerId: 'm2',
+        marker: 'interruption',
+        payload: { turnId: 0, target: 'active', reason: 'user_cancelled' },
+        at: new Date(1000).toISOString(),
+      },
+    ]);
+  });
+
   it('folds plan/swarm mode records into meta.modes with enter/exit markers', () => {
     const base = baseWithMarker();
     const folded = foldWireRecordFacts(

From a9e9e8f0b2709117b39620410dc7ee3373a8136f Mon Sep 17 00:00:00 2001
From: 7Sageer <7sageer@djwcb.cn>
Date: Thu, 30 Jul 2026 17:45:47 +0800
Subject: [PATCH 3/6] fix(agent-core-v2): make user-turn cancellation
 idempotent and reconcile interruption reminders on restore

---
 .../agent-core-v2/docs/wire-manifest.d.ts     | 13 +++-
 .../src/agent/goal/goalService.ts             |  7 --
 .../src/agent/loop/interruptionReminder.ts    |  7 ++
 .../agent/loop/interruptionReminderService.ts | 67 ++++++++++---------
 .../src/agent/loop/loopService.ts             | 28 ++------
 .../src/agent/loop/turnEvents.ts              |  7 --
 .../agent-core-v2/src/agent/loop/turnOps.ts   | 55 +++++++++++----
 .../agent-core-v2/src/app/telemetry/events.ts |  1 -
 .../test/agent/goal/goal.test.ts              |  5 --
 .../test/agent/loop/loop.test.ts              | 37 +++++++---
 packages/agent-core-v2/test/index.test.ts     |  1 +
 .../agent-core-v2/test/wire/resume.test.ts    | 63 +++++++++++++++++
 12 files changed, 194 insertions(+), 97 deletions(-)

diff --git a/packages/agent-core-v2/docs/wire-manifest.d.ts b/packages/agent-core-v2/docs/wire-manifest.d.ts
index c2dd16f696..541881254f 100644
--- a/packages/agent-core-v2/docs/wire-manifest.d.ts
+++ b/packages/agent-core-v2/docs/wire-manifest.d.ts
@@ -21,7 +21,7 @@
 // owning model offloads inline media to blob storage), cross-reducers
 // (foreign models that also reduce this record on dispatch and replay).
 
-// Index (44 record types)
+// Index (45 record types)
 //   config.update                      profile              persisted  src/agent/profile/profileOps.ts
 //   context_size.measured              contextSize          transient  src/agent/contextSize/contextSizeOps.ts
 //   context.append_loop_event          contextMemory        persisted  src/agent/contextMemory/contextOps.ts
@@ -63,6 +63,7 @@
 //   tools.unregister_user_tool         userTool             persisted  src/agent/userTool/userToolOps.ts
 //   tools.update_store                 todo                 persisted  src/session/todo/todoOps.ts
 //   turn.cancel                        turn                 persisted  src/agent/loop/turnOps.ts
+//   turn.interruption_reminded         turn                 persisted  src/agent/loop/turnOps.ts
 //   turn.prompt                        turn                 persisted  src/agent/loop/turnOps.ts
 //   turn.steer                         turn                 persisted  src/agent/loop/turnOps.ts
 //   usage.record                       usage                persisted  src/agent/usage/usageOps.ts
@@ -574,6 +575,15 @@ interface TurnCancelPayload {
   reason?: 'user_cancelled' | 'aborted';
 }
 
+/**
+ * model: turn · persisted
+ * owner: src/agent/loop/turnOps.ts
+ */
+interface TurnInterruptionRemindedPayload {
+  _name: 'turn.interruption_reminded';
+  turnId: number;
+}
+
 /**
  * model: turn · persisted
  * owner: src/agent/loop/turnOps.ts
@@ -657,6 +667,7 @@ interface WirePayloadMap {
   "tools.unregister_user_tool": ToolsUnregisterUserToolPayload;
   "tools.update_store": ToolsUpdateStorePayload;
   "turn.cancel": TurnCancelPayload;
+  "turn.interruption_reminded": TurnInterruptionRemindedPayload;
   "turn.prompt": TurnPromptPayload;
   "turn.steer": TurnSteerPayload;
   "usage.record": UsageRecordPayload;
diff --git a/packages/agent-core-v2/src/agent/goal/goalService.ts b/packages/agent-core-v2/src/agent/goal/goalService.ts
index 6dd74939c3..99428ef600 100644
--- a/packages/agent-core-v2/src/agent/goal/goalService.ts
+++ b/packages/agent-core-v2/src/agent/goal/goalService.ts
@@ -625,10 +625,6 @@ export class AgentGoalService extends Disposable implements IAgentGoalService {
     const state = this.requireState();
     const snapshot = this.toSnapshot(state);
     if (state.status === 'active' && this.liveTurnId !== undefined) {
-      // A goal-lifecycle cancel is programmatic even when the goal change is
-      // user-driven: the turn was not directly interrupted, so it must not be
-      // recorded (or reminded) as a user cancellation — the goal-cancelled
-      // reminder below carries the user-facing fact.
       this.loopService.cancel(this.liveTurnId, abortError('Goal cancelled'));
     }
     this.clearInternal(actor);
@@ -992,9 +988,6 @@ export class AgentGoalService extends Disposable implements IAgentGoalService {
     const pending = this.pendingContinuation;
     if (preserveLiveContinuation && pending?.turnId === this.liveTurnId) return;
     this.pendingContinuation = undefined;
-    // Same provenance rule as `cancelGoal`: goal-lifecycle cancels are
-    // programmatic, never user cancellations (see `handleWallClockDeadline`
-    // for the explicit-reason precedent).
     const cancellation = reason ?? abortError('Goal continuation cancelled');
     const aborted = pending?.receipt.abort(cancellation);
     if (pending !== undefined && !aborted && pending.turnId !== undefined) {
diff --git a/packages/agent-core-v2/src/agent/loop/interruptionReminder.ts b/packages/agent-core-v2/src/agent/loop/interruptionReminder.ts
index 1ce27d2020..f6bca5c348 100644
--- a/packages/agent-core-v2/src/agent/loop/interruptionReminder.ts
+++ b/packages/agent-core-v2/src/agent/loop/interruptionReminder.ts
@@ -1,3 +1,10 @@
+/**
+ * `loop` domain (L4) — user-interruption reminder contract.
+ *
+ * Defines the Agent-scoped aspect that records a model-visible reminder after
+ * a user-cancelled turn. Bound at Agent scope.
+ */
+
 import { createDecorator } from '#/_base/di/instantiation';
 
 export interface IAgentLoopInterruptionReminderService {
diff --git a/packages/agent-core-v2/src/agent/loop/interruptionReminderService.ts b/packages/agent-core-v2/src/agent/loop/interruptionReminderService.ts
index edbd4f5327..f50320cf41 100644
--- a/packages/agent-core-v2/src/agent/loop/interruptionReminderService.ts
+++ b/packages/agent-core-v2/src/agent/loop/interruptionReminderService.ts
@@ -1,26 +1,10 @@
 /**
- * `loop` domain (L4) — user-interruption reminder aspect.
+ * `loop` domain (L4) — `IAgentLoopInterruptionReminderService` implementation.
  *
- * A turn the user deliberately cancelled (Esc) would otherwise leave no mark
- * the model can see: the next user prompt lands as an ordinary message right
- * after the interrupted turn's residue, with nothing saying the previous turn
- * was cut off on purpose. This service watches `turn.ended` and appends a
- * durable `<system-reminder>` (`origin: { kind: 'injection', variant:
- * 'interruption' }`) at the context tail — after the interrupted turn's
- * residue, before the next user message — so the marker persists to the wire,
- * replays on resume, and stays hidden from transcripts, all through the
- * existing injection machinery. Only `user_cancelled` qualifies: timeouts,
- * programmatic aborts, and steer (which never cancels the turn) produce no
- * marker, and a cancelled queued turn publishes no `turn.ended` at all. If
- * the last durable message already is the interruption reminder (repeated
- * cancellations with no message in between, a trailing vacuous open
- * assistant left by the cancelled turn notwithstanding), appending is
- * skipped so markers do not stack in practice — a reminder still deferred
- * behind an unsettled tool exchange is invisible to that check, accepted
- * since a second cancellation cannot normally arrive before the exchange
- * settles. Bound at Agent scope and constructed with the scope so the
- * subscription exists before the first turn runs (same rationale as
- * `loopContinuation`).
+ * Observes turn completion through `event`, persists reminder completion through
+ * `turn`, reads conversation history through `contextMemory`, and appends
+ * model-visible notices through `systemReminder`. Reconciles reminders left
+ * pending by an interrupted restore. Bound at Agent scope.
  */
 
 import { Disposable } from '#/_base/di/lifecycle';
@@ -30,8 +14,10 @@ import type { ContextMessage } from '#/agent/contextMemory/types';
 import { isVacuousContentPart } from '#/agent/contextMemory/vacuousContent';
 import { IAgentSystemReminderService } from '#/agent/systemReminder/systemReminder';
 import { IEventBus } from '#/app/event/eventBus';
+import { IWireService } from '#/wire/wire';
 
 import { IAgentLoopInterruptionReminderService } from './interruptionReminder';
+import { interruptionReminderRecorded, TurnModel } from './turnOps';
 
 export const INTERRUPTION_REMINDER_VARIANT = 'interruption';
 
@@ -51,33 +37,50 @@ export class AgentLoopInterruptionReminderService
     @IEventBus eventBus: IEventBus,
     @IAgentContextMemoryService private readonly context: IAgentContextMemoryService,
     @IAgentSystemReminderService private readonly reminders: IAgentSystemReminderService,
+    @IWireService private readonly wire: IWireService,
   ) {
     super();
+    this._register(
+      this.wire.hooks.onDidRestore.register('interruption-reminder', async (_ctx, next) => {
+        this.reconcilePendingReminders();
+        await next();
+      }),
+    );
     this._register(
       eventBus.subscribe('turn.ended', (event) => {
         if (event.reason !== 'cancelled' || event.interruptReason !== 'user_cancelled') return;
-        this.appendInterruptionReminder();
+        this.recordReminder(event.turnId, true);
       }),
     );
   }
 
-  private appendInterruptionReminder(): void {
-    const origin = lastDurableMessageOrigin(this.context.get());
-    if (origin?.kind === 'injection' && origin.variant === INTERRUPTION_REMINDER_VARIANT) return;
+  private reconcilePendingReminders(): void {
+    const pending = this.wire.getModel(TurnModel).pendingUserInterruptionTurnIds;
+    for (const turnId of pending) this.recordReminder(turnId);
+  }
+
+  private recordReminder(turnId: number, allowUntracked = false): void {
+    const pending = this.wire.getModel(TurnModel).pendingUserInterruptionTurnIds.includes(turnId);
+    if (!pending && !allowUntracked) return;
+    if (!this.appendInterruptionReminder()) return;
+    if (pending) this.wire.dispatch(interruptionReminderRecorded({ turnId }));
+  }
+
+  private appendInterruptionReminder(): boolean {
+    const before = this.context.get();
+    const origin = lastDurableMessageOrigin(before);
+    if (origin?.kind === 'injection' && origin.variant === INTERRUPTION_REMINDER_VARIANT) return true;
     this.reminders.appendSystemReminder(INTERRUPTION_REMINDER, {
       kind: 'injection',
       variant: INTERRUPTION_REMINDER_VARIANT,
     });
+    const after = this.context.get();
+    if (after === before) return false;
+    const appended = lastDurableMessageOrigin(after);
+    return appended?.kind === 'injection' && appended.variant === INTERRUPTION_REMINDER_VARIANT;
   }
 }
 
-/**
- * Origin of the last message that survives the fold, skipping a trailing open
- * assistant the cancelled turn left with nothing sendable recorded (the fold
- * drops it as vacuous at the next `step.begin`). Judging dedup against it
- * would let markers stack around the dropped shell (e.g. an empty retry turn
- * interrupted before its first token).
- */
 function lastDurableMessageOrigin(
   messages: readonly ContextMessage[],
 ): ContextMessage['origin'] | undefined {
diff --git a/packages/agent-core-v2/src/agent/loop/loopService.ts b/packages/agent-core-v2/src/agent/loop/loopService.ts
index c3b84cf8be..8045e74270 100644
--- a/packages/agent-core-v2/src/agent/loop/loopService.ts
+++ b/packages/agent-core-v2/src/agent/loop/loopService.ts
@@ -284,6 +284,7 @@ export class AgentLoopService extends Disposable implements IAgentLoopService {
   private cancelActiveTurn(turnId: number | undefined, cancellation: unknown): boolean {
     const job = this.activeTurnJob;
     if (job === undefined || (turnId !== undefined && job.turn.id !== turnId)) return false;
+    if (job.controller.signal.aborted) return true;
     this.wire.dispatch(
       cancelTurn({ turnId: job.turn.id, target: 'active', reason: cancelReasonFor(cancellation) }),
     );
@@ -892,17 +893,6 @@ export class AgentLoopService extends Disposable implements IAgentLoopService {
     }
   }
 
-  /**
-   * `appendResponseContent` runs only after a full LLM response, so an abort
-   * mid-stream would otherwise lose every token the model already produced
-   * (the fold then drops the step's empty partial assistant as vacuous). When
-   * the turn itself was aborted, persist the accumulated partial text/thinking
-   * parts so the interrupted step replays to the same partial assistant
-   * message the user saw. Gated on the turn signal, not the step signal: a
-   * step-level cancel lets the turn continue with a regenerated step, and a
-   * failed (non-abort) attempt is retried — both keep their partial output
-   * out of the record because what follows re-generates it.
-   */
   private appendInterruptedStreamContent(
     turnId: number,
     currentStep: number,
@@ -1080,14 +1070,11 @@ export class AgentLoopService extends Disposable implements IAgentLoopService {
   ): StreamPartCollector {
     const callsByIndex = new Map<number | string | undefined, { id: string; name: string }>();
     const partialContent: ContentPart[] = [];
-    let mergeBroken = false;
-    // Mirror kosong's stream merge (`mergeInPlace` + flush-on-boundary,
-    // including the tool-call boundary) so the drained partials match the
-    // parts a completed response would have carried.
+    let forceContentPartBoundary = false;
     const accumulate = (part: ContentPart): void => {
       const last = partialContent.at(-1);
-      if (!mergeBroken && last !== undefined && mergeInPlace(last, part)) return;
-      mergeBroken = false;
+      if (!forceContentPartBoundary && last !== undefined && mergeInPlace(last, part)) return;
+      forceContentPartBoundary = false;
       partialContent.push({ ...part });
     };
 
@@ -1110,7 +1097,7 @@ export class AgentLoopService extends Disposable implements IAgentLoopService {
             return;
           case 'function': {
             onResponseEvent();
-            mergeBroken = true;
+            forceContentPartBoundary = true;
             callsByIndex.set(part._streamIndex, { id: part.id, name: part.name });
             this.eventBus.publish({
               type: 'tool.call.delta',
@@ -1203,11 +1190,6 @@ type BeginStepResult = { readonly step: StepRuntime } | { readonly result: LoopR
 
 interface StreamPartCollector {
   readonly handle: (part: StreamedMessagePart) => void;
-  /**
-   * Drains the merged partial text/thinking parts accumulated from the stream
-   * so far (vacuous parts dropped). Never called on a completed request — the
-   * full response's content is authoritative and lands separately.
-   */
   drainInterruptedContent(): ContentPart[];
 }
 
diff --git a/packages/agent-core-v2/src/agent/loop/turnEvents.ts b/packages/agent-core-v2/src/agent/loop/turnEvents.ts
index 6811f9b76c..aff0ecd701 100644
--- a/packages/agent-core-v2/src/agent/loop/turnEvents.ts
+++ b/packages/agent-core-v2/src/agent/loop/turnEvents.ts
@@ -21,12 +21,6 @@ import type { TokenUsage } from '#/kosong/contract/usage';
 /** Why a turn ended. `blocked` folds into `failed` at the wire edge. */
 export type TurnEndReason = 'completed' | 'cancelled' | 'failed' | 'blocked';
 
-/**
- * Why a non-completed turn stopped early — the same enum the `turn_interrupted`
- * telemetry event reports. `user_cancelled` marks a deliberate user interrupt
- * (Esc); every other value is a programmatic or provider-side stop. Absent on
- * `turn.ended` when the turn completed.
- */
 export type TurnInterruptReason =
   | 'user_cancelled'
   | 'aborted'
@@ -64,7 +58,6 @@ export interface TurnEndedEvent {
   readonly reason: TurnEndReason;
   readonly error?: KimiErrorPayload;
   readonly durationMs?: number;
-  /** Present iff `reason` is not `'completed'`. */
   readonly interruptReason?: TurnInterruptReason;
 }
 
diff --git a/packages/agent-core-v2/src/agent/loop/turnOps.ts b/packages/agent-core-v2/src/agent/loop/turnOps.ts
index b578e3a7ae..a4fb1670a5 100644
--- a/packages/agent-core-v2/src/agent/loop/turnOps.ts
+++ b/packages/agent-core-v2/src/agent/loop/turnOps.ts
@@ -2,8 +2,8 @@
  * `loop` domain (L4) — persists and restores monotonically increasing turn
  * identity.
  *
- * Owns the next available turn id, including cancelled queued reservations and
- * legacy loop-event observations. Consumed by the Agent-scope `loopService`.
+ * Owns the next available turn id, cancelled queued reservations, and pending
+ * user-interruption reminders. Consumed by the Agent-scope `loopService`.
  */
 
 import { z } from 'zod';
@@ -15,11 +15,12 @@ import type { PromptOrigin } from '#/agent/contextMemory/types';
 export interface TurnModelState {
   readonly nextTurnId: number;
   readonly cancelledTurnIds: readonly number[];
+  readonly pendingUserInterruptionTurnIds: readonly number[];
 }
 
 export const TurnModel = defineModel<TurnModelState>(
   'turn',
-  () => ({ nextTurnId: 0, cancelledTurnIds: [] }),
+  () => ({ nextTurnId: 0, cancelledTurnIds: [], pendingUserInterruptionTurnIds: [] }),
   {
     reducers: {
       'context.append_loop_event': (state, { event }) => {
@@ -46,6 +47,7 @@ declare module '#/wire/types' {
     'turn.prompt': typeof promptTurn;
     'turn.steer': typeof steerTurn;
     'turn.cancel': typeof cancelTurn;
+    'turn.interruption_reminded': typeof interruptionReminderRecorded;
   }
 }
 
@@ -63,20 +65,48 @@ export const cancelTurn = TurnModel.defineOp('turn.cancel', {
   schema: z.object({
     turnId: z.number().optional(),
     target: z.enum(['active', 'queued']).optional(),
-    /**
-     * Why the turn was cancelled, persisted so a cold reader (transcript
-     * rebuild, future resume-time interruption detection) can tell a
-     * deliberate user interrupt apart from a programmatic abort. Absent on
-     * records written before this field existed.
-     */
     reason: z.enum(['user_cancelled', 'aborted']).optional(),
   }),
-  apply: (s, { turnId, target }) => {
-    if (target === undefined || turnId === undefined || turnId < s.nextTurnId) return s;
-    return advanceTurnClock(s, s.nextTurnId, [...s.cancelledTurnIds, turnId]);
+  apply: (s, { turnId, target, reason }) => {
+    if (target === undefined || turnId === undefined) return s;
+    const withPendingInterruption =
+      target === 'active' && reason === 'user_cancelled'
+        ? addPendingUserInterruption(s, turnId)
+        : s;
+    if (turnId < s.nextTurnId) return withPendingInterruption;
+    return advanceTurnClock(withPendingInterruption, s.nextTurnId, [
+      ...s.cancelledTurnIds,
+      turnId,
+    ]);
   },
 });
 
+export const interruptionReminderRecorded = TurnModel.defineOp(
+  'turn.interruption_reminded',
+  {
+    schema: z.object({ turnId: z.number().int().nonnegative() }),
+    apply: (s, { turnId }) => {
+      if (!s.pendingUserInterruptionTurnIds.includes(turnId)) return s;
+      return {
+        ...s,
+        pendingUserInterruptionTurnIds: s.pendingUserInterruptionTurnIds.filter(
+          (pendingTurnId) => pendingTurnId !== turnId,
+        ),
+      };
+    },
+  },
+);
+
+function addPendingUserInterruption(state: TurnModelState, turnId: number): TurnModelState {
+  if (state.pendingUserInterruptionTurnIds.includes(turnId)) return state;
+  return {
+    ...state,
+    pendingUserInterruptionTurnIds: [...state.pendingUserInterruptionTurnIds, turnId].toSorted(
+      (a, b) => a - b,
+    ),
+  };
+}
+
 function advanceTurnClock(
   state: TurnModelState,
   nextTurnId: number,
@@ -89,5 +119,6 @@ function advanceTurnClock(
   return {
     nextTurnId,
     cancelledTurnIds: [...pendingCancellations].toSorted((a, b) => a - b),
+    pendingUserInterruptionTurnIds: state.pendingUserInterruptionTurnIds,
   };
 }
diff --git a/packages/agent-core-v2/src/app/telemetry/events.ts b/packages/agent-core-v2/src/app/telemetry/events.ts
index d8d23b5019..8c41cf5147 100644
--- a/packages/agent-core-v2/src/app/telemetry/events.ts
+++ b/packages/agent-core-v2/src/app/telemetry/events.ts
@@ -75,7 +75,6 @@ export interface TurnInterruptedEvent {
   turn_id: number;
   at_step: number;
   mode: 'agent' | 'plan';
-  /** Mirrored as `TurnInterruptReason` in `agent/loop/turnEvents.ts` — telemetry (L1) cannot import the loop (L4) type, so the union is duplicated; keep the two in sync. */
   interrupt_reason: 'user_cancelled' | 'aborted' | 'max_steps' | 'error' | 'filtered' | 'blocked';
   provider_type?: string;
   protocol?: string;
diff --git a/packages/agent-core-v2/test/agent/goal/goal.test.ts b/packages/agent-core-v2/test/agent/goal/goal.test.ts
index 4c3dc01b3b..1f24896d5f 100644
--- a/packages/agent-core-v2/test/agent/goal/goal.test.ts
+++ b/packages/agent-core-v2/test/agent/goal/goal.test.ts
@@ -1161,8 +1161,6 @@ describe('AgentGoalService core workflow hooks', () => {
     await goals.cancelGoal();
 
     expect(abort).toHaveBeenCalledOnce();
-    // Goal-lifecycle cancels are programmatic: the reason must not read as a
-    // user cancellation (which would also fire the interruption reminder).
     expect(cancel).toHaveBeenCalledWith(41, expect.any(Error));
     expect(isUserCancellation(cancel.mock.calls[0]?.[1])).toBe(false);
   });
@@ -1948,9 +1946,6 @@ describe('AgentGoalService hard wall-clock deadline', () => {
       await llm.started;
 
       await ctx.rpc.cancelGoal({});
-      // A goal-lifecycle cancel is programmatic, not a user turn interrupt —
-      // and as the first abort it stays the recorded reason once the
-      // wall-clock deadline fires later.
       expect(llm.signal()).toMatchObject({
         aborted: true,
         reason: expect.objectContaining({ message: 'Goal cancelled' }),
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 78fc571982..09a4c64afd 100644
--- a/packages/agent-core-v2/test/agent/loop/loop.test.ts
+++ b/packages/agent-core-v2/test/agent/loop/loop.test.ts
@@ -1029,6 +1029,34 @@ describe('interruption reminder', () => {
     expect(contentPartRecordsIn(ctx)).toBe(1);
   });
 
+  it('writes one active cancellation when cancel repeats before the turn settles', async () => {
+    ctx.mockNextResponse({ type: 'text', text: 'partial answer' }, { type: 'text', text: ' more' });
+    const results: boolean[] = [];
+    let cancelled = false;
+    const subscription = ctx.get(IEventBus).subscribe('assistant.delta', () => {
+      if (cancelled) return;
+      cancelled = true;
+      results.push(loop.cancel(), loop.cancel());
+    });
+    const turn = (await loop.enqueue(nextTurnMessage('Hello')).assigned).turn;
+    await expect(turn.result).resolves.toMatchObject({ type: 'cancelled' });
+    subscription.dispose();
+    await ctx.wire.flush();
+
+    expect(results).toEqual([true, true]);
+    expect(
+      ctx.allEvents.filter(
+        (entry) => entry.type === '[wire]' && entry.event === 'turn.cancel',
+      ),
+    ).toHaveLength(1);
+    expect(interruptionReminders()).toHaveLength(1);
+    expect(
+      ctx.allEvents.filter(
+        (entry) => entry.type === '[wire]' && entry.event === 'turn.interruption_reminded',
+      ),
+    ).toHaveLength(1);
+  });
+
   it('preserves the partial stream but appends no reminder on programmatic abort', async () => {
     ctx.mockNextResponse({ type: 'text', text: 'partial answer' }, { type: 'text', text: ' more' });
     const subscription = ctx.get(IEventBus).subscribe('assistant.delta', () => {
@@ -1161,8 +1189,6 @@ describe('interruption reminder', () => {
     await expect(turn.result).resolves.toMatchObject({ type: 'cancelled' });
     subscription.dispose();
 
-    // The whitespace-only partial is vacuous: nothing is persisted, the open
-    // assistant stays empty, and the reminder still lands.
     expect(contentPartRecordsIn(ctx)).toBe(0);
     expect(ctx.contextData().history).toEqual([
       expect.objectContaining({ role: 'user' }),
@@ -1179,9 +1205,6 @@ describe('interruption reminder', () => {
     first.dispose();
     expect(interruptionReminders()).toHaveLength(1);
 
-    // A retry turn materializes no message; cancelled before its first token
-    // it leaves only a vacuous open assistant at the tail — the dedup check
-    // must see through it to the reminder below.
     ctx.mockNextResponse({ type: 'text', text: 'retried answer' });
     const onStepStarted = ctx.get(IEventBus).subscribe('turn.step.started', () => {
       loop.cancel();
@@ -1191,7 +1214,6 @@ describe('interruption reminder', () => {
     onStepStarted.dispose();
     expect(interruptionReminders()).toHaveLength(1);
 
-    // The next turn settles the vacuous shell away; still no second marker.
     ctx.mockNextResponse({ type: 'text', text: 'third answer' });
     await ctx.rpc.prompt({ input: [{ type: 'text', text: 'Next' }] });
     await ctx.untilTurnEnd();
@@ -1216,11 +1238,8 @@ describe('interruption reminder', () => {
       localLoop.cancel(turn.id);
       await expect(turn.result).resolves.toMatchObject({ type: 'cancelled' });
 
-      // Both steps' streamed text landed exactly once through the completed
-      // response path; the mid-tool cancel flushed nothing extra.
       expect(contentPartRecordsIn(local)).toBe(2);
 
-      // The reminder lands after the interrupted tool exchange.
       const history = local.contextData().history;
       expect(remindersIn(local)).toHaveLength(1);
       expect(history.at(-1)?.origin).toEqual({ kind: 'injection', variant: 'interruption' });
diff --git a/packages/agent-core-v2/test/index.test.ts b/packages/agent-core-v2/test/index.test.ts
index db7cd48bad..ed1e6951ed 100644
--- a/packages/agent-core-v2/test/index.test.ts
+++ b/packages/agent-core-v2/test/index.test.ts
@@ -87,6 +87,7 @@ const V2_RECORD_TYPES: ReadonlySet<string> = new Set([
   'interaction.request',
   'interaction.resolved',
   'plan.revision',
+  'turn.interruption_reminded',
 ]);
 
 describe('v1 wire vocabulary', () => {
diff --git a/packages/agent-core-v2/test/wire/resume.test.ts b/packages/agent-core-v2/test/wire/resume.test.ts
index 337a69c17c..2affb492a6 100644
--- a/packages/agent-core-v2/test/wire/resume.test.ts
+++ b/packages/agent-core-v2/test/wire/resume.test.ts
@@ -65,6 +65,69 @@ describe('Agent resume', () => {
     expect(persistence.records.filter((record) => record.type === 'metadata')).toHaveLength(1);
   });
 
+  it('reconciles a pending user interruption after restore when the reminder is missing', async () => {
+    const persistence = new RecordingAgentPersistence([
+      resumeConfigRecord(),
+      {
+        type: 'context.append_message',
+        message: {
+          role: 'user',
+          content: [{ type: 'text', text: 'Hello' }],
+          toolCalls: [],
+          origin: { kind: 'user' },
+        },
+      },
+      {
+        type: 'turn.prompt',
+        input: [{ type: 'text', text: 'Hello' }],
+        origin: { kind: 'user' },
+      },
+      {
+        type: 'context.append_loop_event',
+        event: { type: 'step.begin', uuid: 'step-0', turnId: '0', step: 1 },
+      },
+      {
+        type: 'context.append_loop_event',
+        event: {
+          type: 'content.part',
+          uuid: 'part-0',
+          turnId: '0',
+          step: 1,
+          stepUuid: 'step-0',
+          part: { type: 'text', text: 'partial answer' },
+        },
+      },
+      { type: 'turn.cancel', turnId: 0, target: 'active', reason: 'user_cancelled' },
+    ] as unknown as WireRecord[]);
+    const ctx = testAgent({ persistence, autoConfigure: false });
+
+    try {
+      await ctx.restorePersisted();
+
+      expect(ctx.context.get()).toContainEqual(
+        expect.objectContaining({
+          role: 'user',
+          origin: { kind: 'injection', variant: 'interruption' },
+        }),
+      );
+      expect(persistence.appended).toContainEqual(
+        expect.objectContaining({
+          type: 'context.append_message',
+          message: expect.objectContaining({
+            origin: { kind: 'injection', variant: 'interruption' },
+          }),
+        }),
+      );
+      expect(persistence.appended).toContainEqual(
+        expect.objectContaining({ type: 'turn.interruption_reminded', turnId: 0 }),
+      );
+
+      await ctx.expectResumeMatches();
+    } finally {
+      await ctx.dispose();
+    }
+  });
+
   it('replays persisted records without restarting turns, compactions, plan turns, or tools', async () => {
     const persistence = new RecordingAgentPersistence(resumeHistory() as unknown as WireRecord[]);
     const execWithEnv = vi.fn().mockRejectedValue(new Error('Bash should not execute on resume'));

From 201e3201901eb57fd4941fd431f734dc7c61258e Mon Sep 17 00:00:00 2001
From: 7Sageer <7sageer@djwcb.cn>
Date: Thu, 30 Jul 2026 17:45:52 +0800
Subject: [PATCH 4/6] fix(transcript): dedupe user-cancelled interruption
 markers by turn in the cold fold

---
 packages/transcript/src/history/foldFacts.ts | 18 ++++++++++++------
 packages/transcript/test/layers.test.ts      |  3 +++
 2 files changed, 15 insertions(+), 6 deletions(-)

diff --git a/packages/transcript/src/history/foldFacts.ts b/packages/transcript/src/history/foldFacts.ts
index 2059f0aef2..3a68ba2f9f 100644
--- a/packages/transcript/src/history/foldFacts.ts
+++ b/packages/transcript/src/history/foldFacts.ts
@@ -190,6 +190,7 @@ export function foldWireRecordFacts(
 
   /** Markers/taskrefs generated by the fold, appended after the base items. */
   const appended: TranscriptItem[] = [];
+  const activeCancelTurnIds = new Set<number>();
   // Marker ids continue the base's `m<N>` numbering (groupTurns uses the same
   // namespace); taskref ids dedupe against refs the base already carries.
   let markerSeq = 0;
@@ -353,12 +354,17 @@ export function foldWireRecordFacts(
       }
       case 'turn.cancel': {
         const payload = record as TurnCancelPayload;
-        // Only a deliberate user interrupt of a turn that actually ran becomes
-        // a marker: programmatic aborts surface through their own outlets
-        // (errors, goal/task state), and a queued cancel left no visible
-        // residue. Records written before the reason field existed are
-        // skipped — they cannot be attributed.
-        if (payload.reason !== 'user_cancelled' || payload.target === 'queued') break;
+        if (
+          payload.target !== 'active' ||
+          typeof payload.turnId !== 'number' ||
+          !Number.isInteger(payload.turnId) ||
+          payload.turnId < 0 ||
+          activeCancelTurnIds.has(payload.turnId)
+        ) {
+          break;
+        }
+        activeCancelTurnIds.add(payload.turnId);
+        if (payload.reason !== 'user_cancelled') break;
         pushMarker('interruption', record);
         break;
       }
diff --git a/packages/transcript/test/layers.test.ts b/packages/transcript/test/layers.test.ts
index 57cace92cf..4e0cc45124 100644
--- a/packages/transcript/test/layers.test.ts
+++ b/packages/transcript/test/layers.test.ts
@@ -755,10 +755,13 @@ describe('foldWireRecordFacts (cold facts)', () => {
     const folded = foldWireRecordFacts(
       [
         { type: 'turn.cancel', turnId: 0, target: 'active', reason: 'user_cancelled', time: 1000 },
+        { type: 'turn.cancel', turnId: 0, target: 'active', reason: 'user_cancelled', time: 1500 },
         // A queued cancel left no visible residue — no marker.
         { type: 'turn.cancel', turnId: 1, target: 'queued', reason: 'user_cancelled', time: 2000 },
         // Programmatic aborts surface through their own outlets — no marker.
         { type: 'turn.cancel', turnId: 2, target: 'active', reason: 'aborted', time: 3000 },
+        { type: 'turn.cancel', turnId: 4, target: 'active', reason: 'aborted', time: 3500 },
+        { type: 'turn.cancel', turnId: 4, target: 'active', reason: 'user_cancelled', time: 3600 },
         // Records written before the reason field existed cannot be attributed.
         { type: 'turn.cancel', turnId: 3, target: 'active', time: 4000 },
       ],

From 27553bf532dd1a6e10831cf52182baafb9c4c79e Mon Sep 17 00:00:00 2001
From: 7Sageer <7sageer@djwcb.cn>
Date: Fri, 31 Jul 2026 12:45:25 +0800
Subject: [PATCH 5/6] chore(agent-core-v2): regenerate state manifest after
 merging main

---
 packages/agent-core-v2/docs/state-manifest.d.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/packages/agent-core-v2/docs/state-manifest.d.ts b/packages/agent-core-v2/docs/state-manifest.d.ts
index dfe4bd4f11..cd49f48e42 100644
--- a/packages/agent-core-v2/docs/state-manifest.d.ts
+++ b/packages/agent-core-v2/docs/state-manifest.d.ts
@@ -740,7 +740,7 @@ export interface AgentStateSnapshot {
   'llmRequester.lastConfigLogSignature': string | undefined;
   'llmRequester.mediaDegradedTurns': Set<number>;
   'llmRequester.mediaStrippedTurns': Map<number, /* MediaStripSnapshot — packages/agent-core-v2/src/agent/contextProjector/contextProjector.ts */ {
-    readonly "__@mediaStripSnapshotBrand@2242": undefined;
+    readonly "__@mediaStripSnapshotBrand@2247": undefined;
   }>;
   'llmRequester.turnConfigs': Map<number, /* TurnRequestConfig — packages/agent-core-v2/src/agent/llmRequester/llmRequesterService.ts */ {
     readonly resolved: /* ProfileModelContext — packages/agent-core-v2/src/agent/profile/profile.ts */ {

From 8a5bab708ea76a2641247a2d910dd13a55526ad6 Mon Sep 17 00:00:00 2001
From: 7Sageer <7sageer@djwcb.cn>
Date: Fri, 31 Jul 2026 14:05:54 +0800
Subject: [PATCH 6/6] refactor(agent-core-v2): split interruptionReminder out
 of the loop domain

The loop domain owns turn execution mechanics; whether an interrupted turn
should produce a model-visible reminder is a model-context policy. Move it
into its own L4 domain with its own wire model that cross-reduces the
loop's turn.cancel fact, and rename the op to interruptionReminder.recorded.
---
 .../agent-core-v2/docs/wire-manifest.d.ts     | 112 +++++++++---------
 .../scripts/check-domain-layers.mjs           |   5 +
 .../interruptionReminder.ts                   |  15 +++
 .../interruptionReminderOps.ts                |  43 +++++++
 .../interruptionReminderService.ts            |  26 ++--
 .../src/agent/loop/interruptionReminder.ts    |  15 ---
 .../agent-core-v2/src/agent/loop/turnOps.ts   |  49 ++------
 packages/agent-core-v2/src/index.ts           |   5 +-
 .../test/agent/loop/loop.test.ts              |   2 +-
 packages/agent-core-v2/test/index.test.ts     |   2 +-
 .../agent-core-v2/test/wire/resume.test.ts    |   2 +-
 11 files changed, 145 insertions(+), 131 deletions(-)
 create mode 100644 packages/agent-core-v2/src/agent/interruptionReminder/interruptionReminder.ts
 create mode 100644 packages/agent-core-v2/src/agent/interruptionReminder/interruptionReminderOps.ts
 rename packages/agent-core-v2/src/agent/{loop => interruptionReminder}/interruptionReminderService.ts (79%)
 delete mode 100644 packages/agent-core-v2/src/agent/loop/interruptionReminder.ts

diff --git a/packages/agent-core-v2/docs/wire-manifest.d.ts b/packages/agent-core-v2/docs/wire-manifest.d.ts
index 8dc194653e..2281dab18a 100644
--- a/packages/agent-core-v2/docs/wire-manifest.d.ts
+++ b/packages/agent-core-v2/docs/wire-manifest.d.ts
@@ -22,51 +22,51 @@
 // (foreign models that also reduce this record on dispatch and replay).
 
 // Index (45 record types)
-//   config.update                      profile              persisted  src/agent/profile/profileOps.ts
-//   context_size.measured              contextSize          transient  src/agent/contextSize/contextSizeOps.ts
-//   context.append_loop_event          contextMemory        persisted  src/agent/contextMemory/contextOps.ts
-//   context.append_message             contextMemory        persisted  src/agent/contextMemory/contextOps.ts
-//   context.apply_compaction           contextMemory        persisted  src/agent/contextMemory/contextOps.ts
-//   context.clear                      contextMemory        persisted  src/agent/contextMemory/contextOps.ts
-//   context.undo                       contextMemory        persisted  src/agent/contextMemory/contextOps.ts
-//   cron.add                           cron                 transient  src/session/cron/cronOps.ts
-//   cron.cursor                        cron                 transient  src/session/cron/cronOps.ts
-//   cron.delete                        cron                 transient  src/session/cron/cronOps.ts
-//   forked                             goal                 persisted  src/agent/goal/goalOps.ts
-//   full_compaction.begin              fullCompaction       persisted  src/agent/fullCompaction/compactionOps.ts
-//   full_compaction.cancel             fullCompaction       persisted  src/agent/fullCompaction/compactionOps.ts
-//   full_compaction.complete           fullCompaction       persisted  src/agent/fullCompaction/compactionOps.ts
-//   goal.clear                         goal                 persisted  src/agent/goal/goalOps.ts
-//   goal.create                        goal                 persisted  src/agent/goal/goalOps.ts
-//   goal.update                        goal                 persisted  src/agent/goal/goalOps.ts
-//   interaction.request                interaction          persisted  src/session/interaction/interactionOps.ts
-//   interaction.resolved               interaction          persisted  src/session/interaction/interactionOps.ts
-//   llm.request                        llm.requestTrace     persisted  src/agent/llmRequester/llmRequestOps.ts
-//   llm.tools_snapshot                 llm.requestTrace     persisted  src/agent/llmRequester/llmRequestOps.ts
-//   mcp.tools_discovered               mcp.discovery        persisted  src/agent/mcp/mcpDiscoveryOps.ts
-//   permission.record_approval_result  permissionRules      persisted  src/agent/permissionRules/permissionRulesOps.ts
-//   permission.rules.add               permissionRules      transient  src/agent/permissionRules/permissionRulesOps.ts
-//   permission.set_mode                permissionMode       persisted  src/agent/permissionMode/permissionModeOps.ts
-//   plan_mode.cancel                   plan                 persisted  src/agent/plan/planOps.ts
-//   plan_mode.enter                    plan                 persisted  src/agent/plan/planOps.ts
-//   plan_mode.exit                     plan                 persisted  src/agent/plan/planOps.ts
-//   plan.revision                      plan                 persisted  src/agent/plan/planOps.ts
-//   profile.bind                       profile              persisted  src/agent/profile/profileOps.ts
-//   skill.activate                     skill                transient  src/agent/skill/skillOps.ts
-//   swarm_mode.enter                   swarm                persisted  src/agent/swarm/swarmOps.ts
-//   swarm_mode.exit                    swarm                persisted  src/agent/swarm/swarmOps.ts
-//   task.started                       task                 persisted  src/agent/task/taskOps.ts
-//   task.terminated                    task                 persisted  src/agent/task/taskOps.ts
-//   tools.register_user_tool           userTool             persisted  src/agent/userTool/userToolOps.ts
-//   tools.reset_active_tools           profile.activeTools  persisted  src/agent/profile/profileOps.ts
-//   tools.set_active_tools             profile.activeTools  persisted  src/agent/profile/profileOps.ts
-//   tools.unregister_user_tool         userTool             persisted  src/agent/userTool/userToolOps.ts
-//   tools.update_store                 todo                 persisted  src/session/todo/todoOps.ts
-//   turn.cancel                        turn                 persisted  src/agent/loop/turnOps.ts
-//   turn.interruption_reminded         turn                 persisted  src/agent/loop/turnOps.ts
-//   turn.prompt                        turn                 persisted  src/agent/loop/turnOps.ts
-//   turn.steer                         turn                 persisted  src/agent/loop/turnOps.ts
-//   usage.record                       usage                persisted  src/agent/usage/usageOps.ts
+//   config.update                      profile               persisted  src/agent/profile/profileOps.ts
+//   context_size.measured              contextSize           transient  src/agent/contextSize/contextSizeOps.ts
+//   context.append_loop_event          contextMemory         persisted  src/agent/contextMemory/contextOps.ts
+//   context.append_message             contextMemory         persisted  src/agent/contextMemory/contextOps.ts
+//   context.apply_compaction           contextMemory         persisted  src/agent/contextMemory/contextOps.ts
+//   context.clear                      contextMemory         persisted  src/agent/contextMemory/contextOps.ts
+//   context.undo                       contextMemory         persisted  src/agent/contextMemory/contextOps.ts
+//   cron.add                           cron                  transient  src/session/cron/cronOps.ts
+//   cron.cursor                        cron                  transient  src/session/cron/cronOps.ts
+//   cron.delete                        cron                  transient  src/session/cron/cronOps.ts
+//   forked                             goal                  persisted  src/agent/goal/goalOps.ts
+//   full_compaction.begin              fullCompaction        persisted  src/agent/fullCompaction/compactionOps.ts
+//   full_compaction.cancel             fullCompaction        persisted  src/agent/fullCompaction/compactionOps.ts
+//   full_compaction.complete           fullCompaction        persisted  src/agent/fullCompaction/compactionOps.ts
+//   goal.clear                         goal                  persisted  src/agent/goal/goalOps.ts
+//   goal.create                        goal                  persisted  src/agent/goal/goalOps.ts
+//   goal.update                        goal                  persisted  src/agent/goal/goalOps.ts
+//   interaction.request                interaction           persisted  src/session/interaction/interactionOps.ts
+//   interaction.resolved               interaction           persisted  src/session/interaction/interactionOps.ts
+//   interruptionReminder.recorded      interruptionReminder  persisted  src/agent/interruptionReminder/interruptionReminderOps.ts
+//   llm.request                        llm.requestTrace      persisted  src/agent/llmRequester/llmRequestOps.ts
+//   llm.tools_snapshot                 llm.requestTrace      persisted  src/agent/llmRequester/llmRequestOps.ts
+//   mcp.tools_discovered               mcp.discovery         persisted  src/agent/mcp/mcpDiscoveryOps.ts
+//   permission.record_approval_result  permissionRules       persisted  src/agent/permissionRules/permissionRulesOps.ts
+//   permission.rules.add               permissionRules       transient  src/agent/permissionRules/permissionRulesOps.ts
+//   permission.set_mode                permissionMode        persisted  src/agent/permissionMode/permissionModeOps.ts
+//   plan_mode.cancel                   plan                  persisted  src/agent/plan/planOps.ts
+//   plan_mode.enter                    plan                  persisted  src/agent/plan/planOps.ts
+//   plan_mode.exit                     plan                  persisted  src/agent/plan/planOps.ts
+//   plan.revision                      plan                  persisted  src/agent/plan/planOps.ts
+//   profile.bind                       profile               persisted  src/agent/profile/profileOps.ts
+//   skill.activate                     skill                 transient  src/agent/skill/skillOps.ts
+//   swarm_mode.enter                   swarm                 persisted  src/agent/swarm/swarmOps.ts
+//   swarm_mode.exit                    swarm                 persisted  src/agent/swarm/swarmOps.ts
+//   task.started                       task                  persisted  src/agent/task/taskOps.ts
+//   task.terminated                    task                  persisted  src/agent/task/taskOps.ts
+//   tools.register_user_tool           userTool              persisted  src/agent/userTool/userToolOps.ts
+//   tools.reset_active_tools           profile.activeTools   persisted  src/agent/profile/profileOps.ts
+//   tools.set_active_tools             profile.activeTools   persisted  src/agent/profile/profileOps.ts
+//   tools.unregister_user_tool         userTool              persisted  src/agent/userTool/userToolOps.ts
+//   tools.update_store                 todo                  persisted  src/session/todo/todoOps.ts
+//   turn.cancel                        turn                  persisted  src/agent/loop/turnOps.ts
+//   turn.prompt                        turn                  persisted  src/agent/loop/turnOps.ts
+//   turn.steer                         turn                  persisted  src/agent/loop/turnOps.ts
+//   usage.record                       usage                 persisted  src/agent/usage/usageOps.ts
 
 /**
  * model: profile · persisted
@@ -306,6 +306,15 @@ interface InteractionResolvedPayload {
   response: any;
 }
 
+/**
+ * model: interruptionReminder · persisted
+ * owner: src/agent/interruptionReminder/interruptionReminderOps.ts
+ */
+interface InterruptionReminderRecordedPayload {
+  _name: 'interruptionReminder.recorded';
+  turnId: number;
+}
+
 /**
  * model: llm.requestTrace · persisted
  * owner: src/agent/llmRequester/llmRequestOps.ts
@@ -563,7 +572,7 @@ interface ToolsUpdateStorePayload {
 }
 
 /**
- * model: turn · persisted
+ * model: turn · persisted · cross-reducers: interruptionReminder
  * owner: src/agent/loop/turnOps.ts
  */
 interface TurnCancelPayload {
@@ -573,15 +582,6 @@ interface TurnCancelPayload {
   reason?: 'user_cancelled' | 'aborted';
 }
 
-/**
- * model: turn · persisted
- * owner: src/agent/loop/turnOps.ts
- */
-interface TurnInterruptionRemindedPayload {
-  _name: 'turn.interruption_reminded';
-  turnId: number;
-}
-
 /**
  * model: turn · persisted
  * owner: src/agent/loop/turnOps.ts
@@ -643,6 +643,7 @@ interface WirePayloadMap {
   "goal.update": GoalUpdatePayload;
   "interaction.request": InteractionRequestPayload;
   "interaction.resolved": InteractionResolvedPayload;
+  "interruptionReminder.recorded": InterruptionReminderRecordedPayload;
   "llm.request": LlmRequestPayload;
   "llm.tools_snapshot": LlmToolsSnapshotPayload;
   "mcp.tools_discovered": McpToolsDiscoveredPayload;
@@ -665,7 +666,6 @@ interface WirePayloadMap {
   "tools.unregister_user_tool": ToolsUnregisterUserToolPayload;
   "tools.update_store": ToolsUpdateStorePayload;
   "turn.cancel": TurnCancelPayload;
-  "turn.interruption_reminded": TurnInterruptionRemindedPayload;
   "turn.prompt": TurnPromptPayload;
   "turn.steer": TurnSteerPayload;
   "usage.record": UsageRecordPayload;
diff --git a/packages/agent-core-v2/scripts/check-domain-layers.mjs b/packages/agent-core-v2/scripts/check-domain-layers.mjs
index 6e73d366cf..9b39d6144e 100644
--- a/packages/agent-core-v2/scripts/check-domain-layers.mjs
+++ b/packages/agent-core-v2/scripts/check-domain-layers.mjs
@@ -271,6 +271,11 @@ const DOMAIN_LAYER = new Map([
   ['contextSize', 4],
   ['fullCompaction', 4],
   ['loop', 4],
+  // `interruptionReminder` is the model-context aspect reacting to the loop's
+  // `turn.cancel` fact: it projects pending reminders into its own wire model
+  // and appends them through `systemReminder`, so it sits in L4 beside the
+  // other agent-behaviour aspects.
+  ['interruptionReminder', 4],
   ['stepRetry', 4],
   ['media', 4],
   // `edit` spans two scopes: the App-scope `IFileEditService` capability (pure
diff --git a/packages/agent-core-v2/src/agent/interruptionReminder/interruptionReminder.ts b/packages/agent-core-v2/src/agent/interruptionReminder/interruptionReminder.ts
new file mode 100644
index 0000000000..619accfcfe
--- /dev/null
+++ b/packages/agent-core-v2/src/agent/interruptionReminder/interruptionReminder.ts
@@ -0,0 +1,15 @@
+/**
+ * `interruptionReminder` domain (L4) — user-interruption reminder contract.
+ *
+ * Defines the Agent-scoped aspect that records a model-visible reminder after
+ * a user-cancelled turn. Bound at Agent scope.
+ */
+
+import { createDecorator } from '#/_base/di/instantiation';
+
+export interface IAgentInterruptionReminderService {
+  readonly _serviceBrand: undefined;
+}
+
+export const IAgentInterruptionReminderService =
+  createDecorator<IAgentInterruptionReminderService>('agentInterruptionReminderService');
diff --git a/packages/agent-core-v2/src/agent/interruptionReminder/interruptionReminderOps.ts b/packages/agent-core-v2/src/agent/interruptionReminder/interruptionReminderOps.ts
new file mode 100644
index 0000000000..0c7a39e13b
--- /dev/null
+++ b/packages/agent-core-v2/src/agent/interruptionReminder/interruptionReminderOps.ts
@@ -0,0 +1,43 @@
+/**
+ * `interruptionReminder` domain (L4) — persists and restores pending
+ * user-interruption reminders.
+ *
+ * Projects the `loop` domain's `turn.cancel` fact into the set of turns whose
+ * interruption reminder still has to reach the conversation, and owns the op
+ * that records a reminder's delivery. Consumed by the Agent-scope
+ * `interruptionReminderService`.
+ */
+
+import { z } from 'zod';
+
+import { defineModel } from '#/wire/model';
+
+export const InterruptionReminderModel = defineModel<readonly number[]>(
+  'interruptionReminder',
+  () => [],
+  {
+    reducers: {
+      'turn.cancel': (state, { turnId, target, reason }) => {
+        if (target !== 'active' || reason !== 'user_cancelled' || turnId === undefined) {
+          return state;
+        }
+        if (state.includes(turnId)) return state;
+        return [...state, turnId].toSorted((a, b) => a - b);
+      },
+    },
+  },
+);
+
+declare module '#/wire/types' {
+  interface PersistedOpMap {
+    'interruptionReminder.recorded': typeof interruptionReminderRecorded;
+  }
+}
+
+export const interruptionReminderRecorded = InterruptionReminderModel.defineOp(
+  'interruptionReminder.recorded',
+  {
+    schema: z.object({ turnId: z.number().int().nonnegative() }),
+    apply: (state, { turnId }) => state.filter((pendingTurnId) => pendingTurnId !== turnId),
+  },
+);
diff --git a/packages/agent-core-v2/src/agent/loop/interruptionReminderService.ts b/packages/agent-core-v2/src/agent/interruptionReminder/interruptionReminderService.ts
similarity index 79%
rename from packages/agent-core-v2/src/agent/loop/interruptionReminderService.ts
rename to packages/agent-core-v2/src/agent/interruptionReminder/interruptionReminderService.ts
index f50320cf41..1974cd741b 100644
--- a/packages/agent-core-v2/src/agent/loop/interruptionReminderService.ts
+++ b/packages/agent-core-v2/src/agent/interruptionReminder/interruptionReminderService.ts
@@ -1,10 +1,10 @@
 /**
- * `loop` domain (L4) — `IAgentLoopInterruptionReminderService` implementation.
+ * `interruptionReminder` domain (L4) — `IAgentInterruptionReminderService` implementation.
  *
  * Observes turn completion through `event`, persists reminder completion through
- * `turn`, reads conversation history through `contextMemory`, and appends
- * model-visible notices through `systemReminder`. Reconciles reminders left
- * pending by an interrupted restore. Bound at Agent scope.
+ * its own wire model, reads conversation history through `contextMemory`, and
+ * appends model-visible notices through `systemReminder`. Reconciles reminders
+ * left pending by an interrupted restore. Bound at Agent scope.
  */
 
 import { Disposable } from '#/_base/di/lifecycle';
@@ -16,8 +16,8 @@ import { IAgentSystemReminderService } from '#/agent/systemReminder/systemRemind
 import { IEventBus } from '#/app/event/eventBus';
 import { IWireService } from '#/wire/wire';
 
-import { IAgentLoopInterruptionReminderService } from './interruptionReminder';
-import { interruptionReminderRecorded, TurnModel } from './turnOps';
+import { IAgentInterruptionReminderService } from './interruptionReminder';
+import { interruptionReminderRecorded, InterruptionReminderModel } from './interruptionReminderOps';
 
 export const INTERRUPTION_REMINDER_VARIANT = 'interruption';
 
@@ -27,9 +27,9 @@ const INTERRUPTION_REMINDER = [
   "The user's next message continues the conversation.",
 ].join(' ');
 
-export class AgentLoopInterruptionReminderService
+export class AgentInterruptionReminderService
   extends Disposable
-  implements IAgentLoopInterruptionReminderService
+  implements IAgentInterruptionReminderService
 {
   declare readonly _serviceBrand: undefined;
 
@@ -55,12 +55,12 @@ export class AgentLoopInterruptionReminderService
   }
 
   private reconcilePendingReminders(): void {
-    const pending = this.wire.getModel(TurnModel).pendingUserInterruptionTurnIds;
+    const pending = this.wire.getModel(InterruptionReminderModel);
     for (const turnId of pending) this.recordReminder(turnId);
   }
 
   private recordReminder(turnId: number, allowUntracked = false): void {
-    const pending = this.wire.getModel(TurnModel).pendingUserInterruptionTurnIds.includes(turnId);
+    const pending = this.wire.getModel(InterruptionReminderModel).includes(turnId);
     if (!pending && !allowUntracked) return;
     if (!this.appendInterruptionReminder()) return;
     if (pending) this.wire.dispatch(interruptionReminderRecorded({ turnId }));
@@ -101,8 +101,8 @@ function lastDurableMessageOrigin(
 
 registerScopedService(
   LifecycleScope.Agent,
-  IAgentLoopInterruptionReminderService,
-  AgentLoopInterruptionReminderService,
+  IAgentInterruptionReminderService,
+  AgentInterruptionReminderService,
   ScopeActivation.OnScopeCreated,
-  'loop',
+  'interruptionReminder',
 );
diff --git a/packages/agent-core-v2/src/agent/loop/interruptionReminder.ts b/packages/agent-core-v2/src/agent/loop/interruptionReminder.ts
deleted file mode 100644
index f6bca5c348..0000000000
--- a/packages/agent-core-v2/src/agent/loop/interruptionReminder.ts
+++ /dev/null
@@ -1,15 +0,0 @@
-/**
- * `loop` domain (L4) — user-interruption reminder contract.
- *
- * Defines the Agent-scoped aspect that records a model-visible reminder after
- * a user-cancelled turn. Bound at Agent scope.
- */
-
-import { createDecorator } from '#/_base/di/instantiation';
-
-export interface IAgentLoopInterruptionReminderService {
-  readonly _serviceBrand: undefined;
-}
-
-export const IAgentLoopInterruptionReminderService =
-  createDecorator<IAgentLoopInterruptionReminderService>('agentLoopInterruptionReminderService');
diff --git a/packages/agent-core-v2/src/agent/loop/turnOps.ts b/packages/agent-core-v2/src/agent/loop/turnOps.ts
index a4fb1670a5..2d1dcdf651 100644
--- a/packages/agent-core-v2/src/agent/loop/turnOps.ts
+++ b/packages/agent-core-v2/src/agent/loop/turnOps.ts
@@ -2,8 +2,9 @@
  * `loop` domain (L4) — persists and restores monotonically increasing turn
  * identity.
  *
- * Owns the next available turn id, cancelled queued reservations, and pending
- * user-interruption reminders. Consumed by the Agent-scope `loopService`.
+ * Owns the next available turn id and cancelled queued reservations. Consumed
+ * by the Agent-scope `loopService`; the `interruptionReminder` domain projects
+ * `turn.cancel` into its own model.
  */
 
 import { z } from 'zod';
@@ -15,12 +16,11 @@ import type { PromptOrigin } from '#/agent/contextMemory/types';
 export interface TurnModelState {
   readonly nextTurnId: number;
   readonly cancelledTurnIds: readonly number[];
-  readonly pendingUserInterruptionTurnIds: readonly number[];
 }
 
 export const TurnModel = defineModel<TurnModelState>(
   'turn',
-  () => ({ nextTurnId: 0, cancelledTurnIds: [], pendingUserInterruptionTurnIds: [] }),
+  () => ({ nextTurnId: 0, cancelledTurnIds: [] }),
   {
     reducers: {
       'context.append_loop_event': (state, { event }) => {
@@ -47,7 +47,6 @@ declare module '#/wire/types' {
     'turn.prompt': typeof promptTurn;
     'turn.steer': typeof steerTurn;
     'turn.cancel': typeof cancelTurn;
-    'turn.interruption_reminded': typeof interruptionReminderRecorded;
   }
 }
 
@@ -67,46 +66,13 @@ export const cancelTurn = TurnModel.defineOp('turn.cancel', {
     target: z.enum(['active', 'queued']).optional(),
     reason: z.enum(['user_cancelled', 'aborted']).optional(),
   }),
-  apply: (s, { turnId, target, reason }) => {
+  apply: (s, { turnId, target }) => {
     if (target === undefined || turnId === undefined) return s;
-    const withPendingInterruption =
-      target === 'active' && reason === 'user_cancelled'
-        ? addPendingUserInterruption(s, turnId)
-        : s;
-    if (turnId < s.nextTurnId) return withPendingInterruption;
-    return advanceTurnClock(withPendingInterruption, s.nextTurnId, [
-      ...s.cancelledTurnIds,
-      turnId,
-    ]);
+    if (turnId < s.nextTurnId) return s;
+    return advanceTurnClock(s, s.nextTurnId, [...s.cancelledTurnIds, turnId]);
   },
 });
 
-export const interruptionReminderRecorded = TurnModel.defineOp(
-  'turn.interruption_reminded',
-  {
-    schema: z.object({ turnId: z.number().int().nonnegative() }),
-    apply: (s, { turnId }) => {
-      if (!s.pendingUserInterruptionTurnIds.includes(turnId)) return s;
-      return {
-        ...s,
-        pendingUserInterruptionTurnIds: s.pendingUserInterruptionTurnIds.filter(
-          (pendingTurnId) => pendingTurnId !== turnId,
-        ),
-      };
-    },
-  },
-);
-
-function addPendingUserInterruption(state: TurnModelState, turnId: number): TurnModelState {
-  if (state.pendingUserInterruptionTurnIds.includes(turnId)) return state;
-  return {
-    ...state,
-    pendingUserInterruptionTurnIds: [...state.pendingUserInterruptionTurnIds, turnId].toSorted(
-      (a, b) => a - b,
-    ),
-  };
-}
-
 function advanceTurnClock(
   state: TurnModelState,
   nextTurnId: number,
@@ -119,6 +85,5 @@ function advanceTurnClock(
   return {
     nextTurnId,
     cancelledTurnIds: [...pendingCancellations].toSorted((a, b) => a - b),
-    pendingUserInterruptionTurnIds: state.pendingUserInterruptionTurnIds,
   };
 }
diff --git a/packages/agent-core-v2/src/index.ts b/packages/agent-core-v2/src/index.ts
index cffb8f8202..e4d8559697 100644
--- a/packages/agent-core-v2/src/index.ts
+++ b/packages/agent-core-v2/src/index.ts
@@ -533,8 +533,9 @@ export * from '#/agent/loop/loop';
 export * from '#/agent/loop/loopService';
 export * from '#/agent/loop/loopContinuation';
 export * from '#/agent/loop/loopContinuationService';
-export * from '#/agent/loop/interruptionReminder';
-export * from '#/agent/loop/interruptionReminderService';
+export * from '#/agent/interruptionReminder/interruptionReminder';
+export * from '#/agent/interruptionReminder/interruptionReminderService';
+export * from '#/agent/interruptionReminder/interruptionReminderOps';
 export * from '#/agent/mcp/mcp';
 export * from '#/agent/mcp/mcpService';
 export * from '#/agent/mcp/mcpDiscoveryOps';
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 ea4c290256..6e1255a435 100644
--- a/packages/agent-core-v2/test/agent/loop/loop.test.ts
+++ b/packages/agent-core-v2/test/agent/loop/loop.test.ts
@@ -1052,7 +1052,7 @@ describe('interruption reminder', () => {
     expect(interruptionReminders()).toHaveLength(1);
     expect(
       ctx.allEvents.filter(
-        (entry) => entry.type === '[wire]' && entry.event === 'turn.interruption_reminded',
+        (entry) => entry.type === '[wire]' && entry.event === 'interruptionReminder.recorded',
       ),
     ).toHaveLength(1);
   });
diff --git a/packages/agent-core-v2/test/index.test.ts b/packages/agent-core-v2/test/index.test.ts
index ed1e6951ed..e8bd92e6ed 100644
--- a/packages/agent-core-v2/test/index.test.ts
+++ b/packages/agent-core-v2/test/index.test.ts
@@ -87,7 +87,7 @@ const V2_RECORD_TYPES: ReadonlySet<string> = new Set([
   'interaction.request',
   'interaction.resolved',
   'plan.revision',
-  'turn.interruption_reminded',
+  'interruptionReminder.recorded',
 ]);
 
 describe('v1 wire vocabulary', () => {
diff --git a/packages/agent-core-v2/test/wire/resume.test.ts b/packages/agent-core-v2/test/wire/resume.test.ts
index 2affb492a6..098c327946 100644
--- a/packages/agent-core-v2/test/wire/resume.test.ts
+++ b/packages/agent-core-v2/test/wire/resume.test.ts
@@ -119,7 +119,7 @@ describe('Agent resume', () => {
         }),
       );
       expect(persistence.appended).toContainEqual(
-        expect.objectContaining({ type: 'turn.interruption_reminded', turnId: 0 }),
+        expect.objectContaining({ type: 'interruptionReminder.recorded', turnId: 0 }),
       );
 
       await ctx.expectResumeMatches();