@@ -1,12 +1,14 @@
 #!/usr/bin/env node
-// @effect-diagnostics nodeBuiltinImport:off
+// @effect-diagnostics nodeBuiltinImport:off globalTimers:off -- A plain Node child; `afterMs` delays an inbound frame.
 import * as NodeFS from "node:fs";
 import * as NodeReadline from "node:readline";
 
 interface ReplayEntry {
   readonly type: "emit_inbound" | "expect_outbound" | "runtime_exit";
   readonly label?: string;
   readonly frame?: unknown;
+  /** Delay before an `emit_inbound` frame; an outbound frame arriving meanwhile is a mismatch. */
+  readonly afterMs?: number;
   readonly status?: "success" | "error" | "cancelled";
   readonly error?: unknown;
 }
@@ -72,6 +74,7 @@ function resumedCursor(): number {
 }
 let cursor = resumedCursor();
 let stopped = false;
+let delayedCursor: number | undefined;
 let nextAgentRequestId = 1;
 const pendingClientRequestIds = new Map<string, string | number>();
 const pendingAgentRequestMethods = new Map<string, string>();
@@ -258,6 +261,11 @@ function flushInbound(): void {
       if (cursor < transcript.entries.length) return;
       continue;
     }
+    if (entry.afterMs !== undefined && entry.afterMs > 0 && delayedCursor !== cursor) {
+      delayedCursor = cursor;
+      setTimeout(flushInbound, entry.afterMs);
+      return;
+    }
     const frame = entry.frame as LogicalFrame;
     if (
       typeof frame !== "object" ||
 
@@ -403,6 +403,13 @@ export interface AcpAdapterV2Flavor {
   readonly assertComplete?: Effect.Effect<void, EffectAcpErrors.AcpError>;
   /** Interrupt the local prompt fiber before `session/cancel` (Grok wedged prompts). */
   readonly interruptPromptOnCancel?: boolean;
+  /**
+   * Hold `session/cancel` until the agent sends its first prompt-scoped
+   * `session/update`, or skip it when the prompt settles first. Kiro 2.27
+   * drops a cancel that arrives before it has started the prompt and runs the
+   * turn to completion.
+   */
+  readonly cancelAfterPromptStarts?: boolean;
   /**
    * Kill and respawn the ACP child process before the next `session/prompt` after a
    * user interrupt. Grok can keep `task_already_running` state until the process exits.
@@ -1228,6 +1235,10 @@ interface ActiveAcpTurn {
    * complete this; settled-soft classification ORs it with `promptSettled`.
    */
   readonly promptWireSettled: Deferred.Deferred<void, never>;
+  /** Completed once `session/prompt` is the runtime's active prompt. */
+  readonly promptDispatched: Deferred.Deferred<void, never>;
+  /** Completed by the first prompt-scoped `session/update` after dispatch. */
+  readonly promptStarted: Deferred.Deferred<void, never>;
   backgroundFinalizeGeneration: number;
 }
 
@@ -5431,10 +5442,27 @@ export function makeAcpAdapterV2(
           }
         });
 
+        // Session-scoped updates (late setup echoes) do not show that the
+        // agent has started the prompt.
+        const markPromptStarted = Effect.fnUntraced(function* (
+          notification: EffectAcpSchema.SessionNotification,
+        ) {
+          const context = yield* Ref.get(activeTurn);
+          if (context === null || context.nativeThreadId !== notification.sessionId) return;
+          if (!(yield* Deferred.isDone(context.promptDispatched))) return;
+          switch (notification.update.sessionUpdate) {
+            case "available_commands_update":
+            case "config_option_update":
+            case "current_mode_update":
+              return;
+          }
+          yield* Deferred.succeed(context.promptStarted, undefined);
+        });
         const projectAcpRuntimeSessionUpdateEffect = (
           rawNotification: EffectAcpSchema.SessionNotification,
         ) =>
           Effect.gen(function* () {
+            yield* markPromptStarted(rawNotification);
             if (clientTerminals !== undefined) {
               const embedded = embeddedTerminalIdsFromSessionUpdate(rawNotification);
               if (embedded !== undefined) {
@@ -6536,6 +6564,19 @@ export function makeAcpAdapterV2(
           }
         });
 
+        /**
+         * `cancelAfterPromptStarts`: waits until the agent has started the
+         * prompt. False when the prompt settled first, so there is nothing to
+         * cancel. A hold that outlives the interrupt timeout cancels anyway.
+         */
+        const promptStillRunsAfterHold = Effect.fnUntraced(function* (context: ActiveAcpTurn) {
+          if (flavor.cancelAfterPromptStarts !== true) return true;
+          const started = yield* Effect.raceFirst(
+            Deferred.await(context.promptStarted).pipe(Effect.as(true)),
+            Deferred.await(context.completed).pipe(Effect.as(false)),
+          ).pipe(Effect.timeoutOption("10 seconds"));
+          return Option.getOrElse(started, () => true);
+        });
         const quarantineStoppedRun = Effect.fnUntraced(function* () {
           yield* continuationPermit.withPermit(
             Effect.gen(function* () {
@@ -6962,6 +7003,8 @@ export function makeAcpAdapterV2(
             const providerTurnId = deriveProviderTurnId(nativeTurnId);
             const completed = yield* Deferred.make<void, never>();
             const promptWireSettled = yield* Deferred.make<void, never>();
+            const promptDispatched = yield* Deferred.make<void, never>();
+            const promptStarted = yield* Deferred.make<void, never>();
             const rememberedContextUsage = (yield* Ref.get(contextUsageBySessionId)).get(
               requestedSessionId,
             );
@@ -7010,6 +7053,8 @@ export function makeAcpAdapterV2(
               promptSettled: false,
               promptSettledStatus: null,
               promptWireSettled,
+              promptDispatched,
+              promptStarted,
               backgroundFinalizeGeneration: 0,
             };
             const carryover = yield* Ref.getAndSet(carryoverSubagents, null);
@@ -7140,7 +7185,8 @@ export function makeAcpAdapterV2(
               return;
             }
             const promptGeneration = yield* Ref.get(runtimeCallbackGeneration);
-            yield* runtime.prompt({ prompt: promptParts!.prompt }).pipe(
+            const promptOptions = { dispatched: context.promptDispatched };
+            yield* runtime.prompt({ prompt: promptParts!.prompt }, promptOptions).pipe(
               Effect.tap(() =>
                 Ref.update(promptInstructionStates, (current) => {
                   if (promptParts?.instructionState === undefined) return current;
@@ -7692,7 +7738,7 @@ export function makeAcpAdapterV2(
                         // acknowledge and would only threaten still-running
                         // background subagents. Skip it and leave the runtime
                         // untouched for the replacement turn.
-                        if (!settledSoftInterrupt) {
+                        if (!settledSoftInterrupt && (yield* promptStillRunsAfterHold(context))) {
                           yield* runtime.cancel;
                         }
                         if (restartRuntime && flavor.restartRuntimeAfterInterrupt === true) {
 
@@ -17,8 +17,10 @@ import {
 import { resolveSelfInvocation } from "@t3tools/shared/nodeRuntime";
 import * as Crypto from "effect/Crypto";
 import * as DateTime from "effect/DateTime";
+import * as Deferred from "effect/Deferred";
 import * as Effect from "effect/Effect";
 import * as Exit from "effect/Exit";
+import * as Fiber from "effect/Fiber";
 import * as FileSystem from "effect/FileSystem";
 import * as Layer from "effect/Layer";
 import * as Path from "effect/Path";
@@ -391,6 +393,79 @@ describe("KiroAdapterV2", () => {
   );
 });
 
+describe("KiroAdapterV2 early Stop", () => {
+  // Kiro CLI 2.27.1 drops a `session/cancel` that arrives 0-0.5 s after
+  // `session/prompt` and runs the turn to completion (reported by TinBane).
+  // These scripts hold Kiro's first frame for the prompt until after Stop was
+  // pressed, so a cancel sent before it reaches the script as a frame it does
+  // not expect.
+  const promptStarted = {
+    ...update({
+      sessionUpdate: "session_info_update",
+      _meta: { kiro: { userMessageId: "message-1", kind: "user_message_id_assigned" } },
+    }),
+    afterMs: 300,
+  };
+  const runningProviderTurnId = (event: ProviderAdapterV2Event) =>
+    event.type === "provider_turn.updated" && event.providerTurn.status === "running"
+      ? event.providerTurn.id
+      : undefined;
+  const stopBeforeKiroStarts = (frames: ReadonlyArray<Frame>) =>
+    runKiroScript({
+      scenario: "early-stop",
+      frames: [
+        ...openSessionFrames({
+          initialize: KIRO_V3_INITIALIZE,
+          configOptions: [modeOption, autopilotOption("on")],
+        }),
+        turnPrompt,
+        ...frames,
+        ...closeSession,
+      ],
+      drive: ({ events, startTurn, interrupt }) =>
+        Effect.gen(function* () {
+          const running = yield* Deferred.make<ProviderTurnId>();
+          const turn = yield* collectTurn(
+            events.pipe(
+              Stream.tap((event) => {
+                const providerTurnId = runningProviderTurnId(event);
+                return providerTurnId === undefined
+                  ? Effect.void
+                  : Deferred.succeed(running, providerTurnId);
+              }),
+            ),
+          ).pipe(Effect.forkChild);
+          yield* startTurn;
+          yield* interrupt(yield* Deferred.await(running));
+          // Stop decides the run's outcome; the script fails on any cancel it
+          // does not expect.
+          assert.equal(terminalStatus(yield* Fiber.join(turn)), "interrupted");
+        }),
+    }).pipe(Effect.provide(testLayer), Effect.scoped);
+
+  it.live("holds Stop until Kiro starts the prompt, then cancels it", () =>
+    stopBeforeKiroStarts([
+      promptStarted,
+      {
+        type: "expect_outbound",
+        label: "session/cancel",
+        frame: {
+          kind: "notification",
+          method: "session/cancel",
+          params: { sessionId: SESSION_ID },
+        },
+      },
+      answer("session/prompt", { stopReason: "cancelled" }),
+    ]),
+  );
+
+  it.live("sends no cancel when Kiro finishes the prompt before starting it", () =>
+    stopBeforeKiroStarts([
+      { ...answer("session/prompt", { stopReason: "end_turn" }), afterMs: 300 },
+    ]),
+  );
+});
+
 describe("KiroAdapterV2 unknown model", () => {
   // Recorded live from Kiro 2.27.0 with the thread on a model id the account
   // lacks. Kiro has not advertised `model` yet, so T3 sends the id; Kiro
 
@@ -162,6 +162,9 @@ function makeKiroAcpAdapterFlavor(options: KiroAdapterV2Options): AcpAdapterV2Fl
     sessionConfigForPolicy: (policy) => [
       { id: KIRO_AUTOPILOT_CONFIG_ID, value: kiroAutopilotValue(policy) },
     ],
+    // Kiro 2.27 drops a `session/cancel` sent before it starts the prompt
+    // (live: 0-0.5 s after `session/prompt`) and runs the turn to completion.
+    cancelAfterPromptStarts: true,
     permissionDisposition: kiroPermissionDisposition,
     approvalOptions: kiroApprovalOptions,
     // Kiro V3 advertises `promptCapabilities.image`; the shared adapter reads it.