@@ -98,9 +98,12 @@ Skills are discovered from these locations, in priority order:
 While a turn is running, `Enter` no longer blocks and does not have to wait: the prompt becomes
 supplemental guidance, appended to the conversation right before the model's next step of that
 turn. The model therefore reads it together with the work it already did and can revise or
-supersede the earlier instructions. Up to 10 messages can wait; press `Backspace` on an empty
-prompt to drop the last one. `Esc` still interrupts the turn immediately, and slash commands
-still wait for the turn to finish.
+supersede the earlier instructions. When the model is in the middle of writing an answer, that
+answer is cut short and whatever it already wrote stays in the conversation; set
+`steerMode: "queue"` to wait for the next request boundary instead. Up to 10 messages can wait;
+press `Backspace` on an empty prompt to drop the last one. Running commands are never
+interrupted, `Esc` still interrupts the turn immediately, and slash commands still wait for the
+turn to finish.
 
 ## Supported Models
 
 
@@ -96,8 +96,9 @@ Skills 会按以下优先级扫描：
 
 AI 正在回复时，`Enter` 不再被拒绝，也不必等到本轮结束：消息会作为补充指引，在本轮下一次
 LLM 调用前作为 user 消息追加到对话中。模型因此能读到它，并结合已完成的工作修改甚至推翻之前的
-指令。最多可排队 10 条；输入框为空时按 `Backspace` 可移除最后一条。按 `Esc` 仍会立即中断本轮，
-斜杠命令仍需等待本轮结束。
+指令。如果模型正在输出回答，该回答会被截断，已生成的内容仍保留在对话里；可用 `steerMode: "queue"`
+改为等到下次请求边界再注入。最多可排队 10 条；输入框为空时按 `Backspace` 可移除最后一条。
+正在执行的命令不会被中断，按 `Esc` 仍会立即中断本轮，斜杠命令仍需等待本轮结束。
 
 ## 支持的模型
 
 
@@ -33,6 +33,7 @@ Deep Code 使用 `settings.json` 设置文件进行持久化配置，支持两
 | `thinkingEnabled`    | boolean   | 是否启用思考模式（DeepSeek V4 系列默认启用）                         |
 | `reasoningEffort`    | string    | 推理强度，可选 `"low"`、`"high"` 或 `"max"`（默认 `"max"`）        |
 | `multimodal`         | string    | 多模态（图片）能力开关，可选 `"default"`、`"on"` 或 `"off"`（默认 `"default"`） |
+| `steerMode`          | string    | 模型正在输出时发送新指令的处理方式：`"interrupt"`（截断当前回复、立即读取新指令，默认）或 `"queue"`（等到下次请求边界再注入） |
 | `filesApiEnabled`    | boolean   | 是否通过 DeepSeek Files API 发送图片（默认 `false`）                       |
 | `filesApiTimeoutMs`  | number    | 单张图片 Files API 处理超时，默认 `60000`，最大 `600000` 毫秒              |
 | `fileExpiresAfterSeconds` | number | 远端文件有效期，默认 `604800` 秒                                      |
@@ -106,6 +107,19 @@ Deep Code 使用 `settings.json` 设置文件进行持久化配置，支持两
 
 当使用的模型未内置在已知模型列表中、或其实际能力与默认判定不符时，可通过该配置覆盖。
 
+#### `steerMode` — 模型输出中追加指令
+
+控制模型还在输出回答时你发送新指令的处理方式：
+
+| 值          | 说明                                                         |
+| ----------- | ------------------------------------------------------------ |
+| `interrupt` | 截断正在流式输出的回答，已生成的内容保留在对话中，新指令立即被读取（默认值） |
+| `queue`     | 新指令进入队列，在本轮下一次 LLM 调用前注入                     |
+
+两种方式都会把新指令作为本轮对话中的 user 消息，模型因此可以修改甚至推翻它原本正在执行的指令。
+正在执行的命令不会被中断：steering 只影响模型输出流，因此工具会先执行完，新指令在下一个请求边界注入。
+按 `Esc` 仍会中断整个轮次。
+
 #### DeepSeek Files API
 
 当 `BASE_URL` 为 `https://api.deepseek.com` 时，设置 `filesApiEnabled: true` 后，Deep Code 会将图片上传到固定的 `https://api.deepseek.com/files`，并在聊天请求中使用 `file_id`。其他 API 地址不会启用该功能。上传或缓存刷新失败时，本次请求直接失败；关闭开关时图片处理逻辑保持不变。
 
@@ -33,6 +33,7 @@ The following are all the top-level fields supported in `settings.json`, along w
 | `thinkingEnabled`  | boolean | Whether to enable thinking mode (enabled by default for DeepSeek V4 series)|
 | `reasoningEffort`  | string  | Reasoning intensity: `"low"`, `"high"`, or `"max"` (default `"max"`)    |
 | `multimodal`       | string  | Multimodal (image) capability override: `"default"`, `"on"`, or `"off"` (default `"default"`) |
+| `steerMode`        | string  | How a prompt sent while the model is writing is handled: `"interrupt"` (cut the answer short so the prompt is read immediately, default) or `"queue"` (wait for the next request boundary) |
 | `filesApiEnabled`  | boolean | Send images through the DeepSeek Files API (default `false`)               |
 | `filesApiTimeoutMs` | number | Per-image Files API timeout; defaults to `60000`, maximum `600000` ms       |
 | `fileExpiresAfterSeconds` | number | Remote file lifetime, default `604800` seconds                       |
@@ -106,6 +107,20 @@ Controls whether the current model is treated as a multimodal model that accepts
 
 Use this to override the default detection when your model is not in the known-model list, or when its actual capability differs from the default.
 
+#### `steerMode` — Steering While the Model Is Writing
+
+Controls what happens when you send a prompt while the model is still producing an answer:
+
+| Value       | Description                                                                 |
+| ----------- | --------------------------------------------------------------------------- |
+| `interrupt` | The answer that is streaming is cut short; its text is kept in the conversation and the prompt is read immediately (default) |
+| `queue`     | The prompt waits and is injected before the next LLM call of the running turn |
+
+Either way the prompt becomes a user message of the running turn, so the model can revise or
+supersede the instructions it was already following. Running commands are never interrupted:
+steering only affects the model stream, so a tool that is executing finishes first and the
+prompt is injected at the next request boundary. Pressing `Esc` still interrupts the whole turn.
+
 #### DeepSeek Files API
 
 When `BASE_URL` is `https://api.deepseek.com`, enabling `filesApiEnabled` uploads images to the fixed `https://api.deepseek.com/files` endpoint and sends `file_id` references in chat requests. Other API endpoints do not enable this feature. An upload or cache-refresh failure fails the request; disabling the setting preserves the existing image path.
 
@@ -33,6 +33,7 @@ function createSettings(
     debugLogEnabled: false,
     telemetryEnabled: false,
     multimodal: "default",
+    steerMode: "interrupt",
     filesApiEnabled: false,
     filesApiTimeoutMs: 60_000,
     fileExpiresAfterSeconds: 604_800,
 
@@ -88,6 +88,7 @@ export function MessageView({ message, collapsed, width = 80 }: MessageViewProps
                 return <Text key={i}>{seg.body}</Text>;
               })
             : null}
+          {message.meta?.interrupted ? <Text dimColor>— superseded by your guidance</Text> : null}
         </Box>
       </Box>
     );
 
@@ -566,11 +566,17 @@ function App({ projectRoot, initialPrompt, resumeSessionId, forkSessionId, onRes
           imageUrls: submission.imageUrls,
           skills: submission.selectedSkills,
         });
+        // With `steerMode: "interrupt"` (the default) the answer that is streaming is
+        // cut short so the guidance is read straight away; `"queue"` only waits for the
+        // next request boundary. Running tools are never interrupted.
+        if (resolveCurrentSettings(projectRoot).steerMode !== "queue") {
+          sessionManager.steerActiveSession();
+        }
         return;
       }
       void handlePrompt(submission);
     },
-    [handlePrompt, sessionManager]
+    [handlePrompt, projectRoot, sessionManager]
   );
 
   const handlePlanImplementationChoice = useCallback(
 
@@ -31,6 +31,26 @@ export class LlmStreamDisconnectedError extends Error {
   }
 }
 
+/**
+ * Raised when a streaming answer is cut short because the user sent new guidance
+ * while the model was still writing. The partial answer is carried along so the
+ * caller can keep it in the conversation before continuing with the guidance.
+ */
+export class LlmSteeredError extends Error {
+  constructor(
+    readonly partialContent: string,
+    readonly partialThinking: string | null
+  ) {
+    super("Model answer was superseded by new user guidance.");
+    this.name = "LlmSteeredError";
+  }
+
+  /** True when the model had already produced something worth keeping. */
+  hasPartialAnswer(): boolean {
+    return this.partialContent.trim().length > 0 || (this.partialThinking ?? "").trim().length > 0;
+  }
+}
+
 export function getLlmRetryDelayMs(attempt: number, random: () => number = Math.random): number {
   const exponentialDelay = BASE_RETRY_DELAY_MS * 2 ** Math.max(0, attempt - 1);
   const jitter = 0.9 + Math.min(1, Math.max(0, random())) * 0.2;
 
@@ -35,6 +35,7 @@ export type {
   PermissionDefaultMode,
   McpServerConfig,
   ReasoningEffort,
+  SteerMode,
   StatusLineSettings,
   ResolvedStatusLineSettings,
   StatusLineProviderConfig,
 
@@ -81,6 +81,7 @@ import {
   LLM_STREAM_IDLE_TIMEOUT_MS,
   LlmStreamDisconnectedError,
   LlmStreamIdleTimeoutError,
+  LlmSteeredError,
   MAX_LLM_RETRIES,
   waitForLlmRetry,
 } from "./common/llm-retry";
@@ -316,6 +317,8 @@ export type MessageMeta = {
   userPrompt?: UserPromptContent;
   /** User guidance that arrived while the turn was already running. */
   isSupplementary?: boolean;
+  /** Assistant output that was cut short because new guidance superseded it. */
+  interrupted?: boolean;
 };
 
 export type SessionMessage = {
@@ -461,6 +464,10 @@ export class SessionManager {
   /** Supplemental guidance that arrived while a turn was already running. */
   private readonly supplementaryPrompts = new Map<string, SupplementaryPrompt[]>();
   private supplementaryPromptNextId = 1;
+  /** Abort handle of the LLM request each session is currently streaming. */
+  private readonly steerControllers = new Map<string, AbortController>();
+  /** Sessions whose in-flight answer was superseded by new user guidance. */
+  private readonly steeredSessions = new Set<string>();
   private readonly processTimeoutControls = new Map<string, ProcessTimeoutControl>();
   private readonly liveProcessKeys = new Set<string>();
   private readonly toolExecutor: ToolExecutor;
@@ -723,7 +730,12 @@ export class SessionManager {
       try {
         return await this.createChatCompletionStreamAttempt(client, request, options, sessionId, debug, requestId);
       } catch (error) {
-        if (signal?.aborted || retryCount >= MAX_LLM_RETRIES || !isRetryableLlmError(error)) {
+        if (
+          error instanceof LlmSteeredError ||
+          signal?.aborted ||
+          retryCount >= MAX_LLM_RETRIES ||
+          !isRetryableLlmError(error)
+        ) {
           throw error;
         }
         const attempt = retryCount + 1;
@@ -970,6 +982,11 @@ export class SessionManager {
         throw new LlmStreamDisconnectedError();
       }
     } catch (error) {
+      if (sessionId && this.steeredSessions.has(sessionId)) {
+        // The user sent new guidance while this answer was streaming. Hand the
+        // partial answer to the caller instead of reporting a failure.
+        throw new LlmSteeredError(content, reasoningContent.length > 0 ? reasoningContent : null);
+      }
       const streamError = idleTimedOut ? new LlmStreamIdleTimeoutError() : error;
       this.logChatCompletionDebug(debug, {
         timestamp: new Date().toISOString(),
@@ -1579,6 +1596,79 @@ ${agentInstructions}
     return pending.length;
   }
 
+  /**
+   * Cut short the answer the model is currently writing so the guidance the user
+   * just sent is read now instead of after that answer finishes.
+   *
+   * Nothing is interrupted when no answer is streaming (for example while a tool
+   * is executing): the guidance then waits for the next request boundary, so a
+   * running command is never killed by normal typing. Returns whether an answer
+   * was cut short.
+   */
+  steerActiveSession(): boolean {
+    const sessionId = this.activeSessionId;
+    if (!sessionId) {
+      return false;
+    }
+
+    const controller = this.steerControllers.get(sessionId);
+    if (!controller) {
+      return false;
+    }
+
+    this.steeredSessions.add(sessionId);
+    if (!controller.signal.aborted) {
+      controller.abort(new Error("Superseded by new user guidance."));
+    }
+    return true;
+  }
+
+  /**
+   * Keep the part of the answer the model produced before it was steered, so the
+   * conversation still shows what it had said when the user changed direction.
+   */
+  private appendSteeredAnswer(sessionId: string, error: LlmSteeredError): void {
+    if (!error.hasPartialAnswer()) {
+      return;
+    }
+
+    const message = this.buildAssistantMessage(sessionId, error.partialContent, null, error.partialThinking ?? "");
+    message.meta = { ...(message.meta ?? {}), interrupted: true };
+    this.appendSessionMessage(sessionId, message);
+    this.onAssistantMessage(message, false);
+  }
+
+  /**
+   * Signal for one LLM request: it aborts when the turn is interrupted or when the
+   * answer is superseded by new guidance, and it is released once the request is
+   * settled so `steerActiveSession` only ever targets a live stream.
+   */
+  private beginRequestSteer(sessionId: string, turnSignal: AbortSignal): { signal: AbortSignal; release: () => void } {
+    const steerController = new AbortController();
+    const forwardTurnAbort = () => {
+      if (!steerController.signal.aborted) {
+        steerController.abort(turnSignal.reason);
+      }
+    };
+    if (turnSignal.aborted) {
+      forwardTurnAbort();
+    } else {
+      turnSignal.addEventListener("abort", forwardTurnAbort, { once: true });
+    }
+    this.steerControllers.set(sessionId, steerController);
+
+    return {
+      signal: steerController.signal,
+      release: () => {
+        turnSignal.removeEventListener("abort", forwardTurnAbort);
+        if (this.steerControllers.get(sessionId) === steerController) {
+          this.steerControllers.delete(sessionId);
+        }
+        this.steeredSessions.delete(sessionId);
+      },
+    };
+  }
+
   async handleUserPrompt(userPrompt: UserPromptContent): Promise<void> {
     const controller = new AbortController();
     this.activePromptController = controller;
@@ -1933,6 +2023,7 @@ ${agentInstructions}
               references: [] as DeepSeekFileReference[],
             };
         const thinkingOptions = buildThinkingRequestOptions(thinkingEnabled, baseURL, reasoningEffort);
+        const steer = this.beginRequestSteer(sessionId, sessionController.signal);
         const request = () =>
           this.createChatCompletionStream(
             client,
@@ -1943,7 +2034,7 @@ ${agentInstructions}
               tools: getTools(this.getPromptToolOptions(), this.mcpToolDefinitions),
               ...thinkingOptions,
             },
-            { signal: sessionController.signal },
+            { signal: steer.signal },
             sessionId,
             {
               enabled: debugLogEnabled,
@@ -1956,6 +2047,12 @@ ${agentInstructions}
         try {
           response = await request();
         } catch (error) {
+          if (error instanceof LlmSteeredError && !sessionController.signal.aborted) {
+            // The user changed direction while this answer was streaming: keep what
+            // the model already wrote, then let the loop continue with the guidance.
+            this.appendSteeredAnswer(sessionId, error);
+            continue;
+          }
           if (!filesSettings.enabled || prepared.references.length === 0 || !this.isRejectedDeepSeekFile(error)) {
             throw error;
           }
@@ -1970,6 +2067,8 @@ ${agentInstructions}
             sessionController.signal
           );
           response = await request();
+        } finally {
+          steer.release();
         }
 
         const message = response.choices?.[0]?.message;
@@ -2801,6 +2900,8 @@ ${agentInstructions}
     }
     this.sessionControllers.delete(sessionId);
     this.setSupplementaryPrompts(sessionId, []);
+    this.steerControllers.delete(sessionId);
+    this.steeredSessions.delete(sessionId);
     if (options.removeMessages) {
       this.removeSessionMessages([sessionId]);
       try {