From 9a568889fd82dcb46c09b4cd2eca2dedb75ca4b0 Mon Sep 17 00:00:00 2001
From: liruifengv <liruifeng1024@gmail.com>
Date: Mon, 13 Jul 2026 13:40:34 +0800
Subject: [PATCH 1/7] fix(tui): deliver pasted media in /skill and plugin
 command args via file tags

Skill and plugin command args are a plain-text RPC channel, so pasted image/video placeholders never reached the model. Rewrite matched placeholders into <image|video path="..."> tags pointing at cache-dir copies (the same convention pasted videos already use), and gate them on model media capabilities like the normal prompt path.
---
 .changeset/fix-skill-command-media.md         |  5 ++
 apps/kimi-code/src/tui/kimi-tui.ts            | 30 +++++--
 .../src/tui/utils/image-placeholder.ts        | 80 ++++++++++++++++-
 .../test/tui/input/image-placeholder.test.ts  | 86 ++++++++++++++++++-
 4 files changed, 190 insertions(+), 11 deletions(-)
 create mode 100644 .changeset/fix-skill-command-media.md

diff --git a/.changeset/fix-skill-command-media.md b/.changeset/fix-skill-command-media.md
new file mode 100644
index 0000000000..60e088b137
--- /dev/null
+++ b/.changeset/fix-skill-command-media.md
@@ -0,0 +1,5 @@
+---
+"@moonshot-ai/kimi-code": patch
+---
+
+Fix pasted media being dropped from /skill and plugin command arguments.
diff --git a/apps/kimi-code/src/tui/kimi-tui.ts b/apps/kimi-code/src/tui/kimi-tui.ts
index 62d1b2370b..44b2ed34ec 100644
--- a/apps/kimi-code/src/tui/kimi-tui.ts
+++ b/apps/kimi-code/src/tui/kimi-tui.ts
@@ -132,7 +132,7 @@ import { isDeadTerminalError } from './utils/dead-terminal';
 import { formatErrorMessage } from './utils/event-payload';
 import { pickForegroundTasks } from './utils/foreground-task';
 import { ImageAttachmentStore, type ImageAttachment } from './utils/image-attachment-store';
-import { extractMediaAttachments } from './utils/image-placeholder';
+import { extractMediaAttachments, rewriteMediaPlaceholdersAsTags } from './utils/image-placeholder';
 import { hasPatchChanges } from './utils/object-patch';
 import { sessionRowsForPicker } from './utils/session-picker-rows';
 import { formatBashOutputForDisplay } from './utils/shell-output';
@@ -1095,9 +1095,11 @@ export class KimiTUI {
     this.state.ui.requestRender();
   }
 
-  private validateMediaCapabilities(
-    extraction: ReturnType<typeof extractMediaAttachments>,
-  ): boolean {
+  private validateMediaCapabilities(extraction: {
+    hasMedia: boolean;
+    imageAttachmentIds: readonly number[];
+    videoAttachmentIds: readonly number[];
+  }): boolean {
     if (!extraction.hasMedia) return true;
     if (
       extraction.imageAttachmentIds.length > 0 &&
@@ -1243,8 +1245,13 @@ export class KimiTUI {
   }
 
   sendSkillActivation(session: Session, skillName: string, skillArgs: string): void {
+    // Args are a plain-text channel, so pasted media can't ride along as
+    // inline parts. Rewrite placeholders into cache-file tags the model
+    // can open with ReadMediaFile instead of leaving dead placeholder text.
+    const rewrite = rewriteMediaPlaceholdersAsTags(skillArgs, this.imageStore);
+    if (!this.validateMediaCapabilities(rewrite)) return;
     this.beginSessionRequest();
-    void session.activateSkill(skillName, skillArgs).catch((error: unknown) => {
+    void session.activateSkill(skillName, rewrite.text).catch((error: unknown) => {
       const message = formatErrorMessage(error);
       this.failSessionRequest(`Skill "${skillName}" failed: ${message}`);
     });
@@ -1256,11 +1263,16 @@ export class KimiTUI {
     commandName: string,
     args: string,
   ): void {
+    // Same plain-text constraint as skill args — see sendSkillActivation.
+    const rewrite = rewriteMediaPlaceholdersAsTags(args, this.imageStore);
+    if (!this.validateMediaCapabilities(rewrite)) return;
     this.beginSessionRequest();
-    void session.activatePluginCommand(pluginId, commandName, args).catch((error: unknown) => {
-      const message = formatErrorMessage(error);
-      this.failSessionRequest(`Command "${pluginId}:${commandName}" failed: ${message}`);
-    });
+    void session
+      .activatePluginCommand(pluginId, commandName, rewrite.text)
+      .catch((error: unknown) => {
+        const message = formatErrorMessage(error);
+        this.failSessionRequest(`Command "${pluginId}:${commandName}" failed: ${message}`);
+      });
   }
 
   private sendMessage(session: Session, input: string, options?: SendMessageOptions): void {
diff --git a/apps/kimi-code/src/tui/utils/image-placeholder.ts b/apps/kimi-code/src/tui/utils/image-placeholder.ts
index 4017c4b2d1..180d217fcf 100644
--- a/apps/kimi-code/src/tui/utils/image-placeholder.ts
+++ b/apps/kimi-code/src/tui/utils/image-placeholder.ts
@@ -18,7 +18,7 @@
  */
 
 import { randomUUID } from 'node:crypto';
-import { copyFileSync, mkdirSync } from 'node:fs';
+import { copyFileSync, mkdirSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 
 import type { PromptPart } from '@moonshot-ai/kimi-code-sdk';
@@ -101,6 +101,64 @@ export function extractMediaAttachments(
   };
 }
 
+export interface MediaTagRewriteResult {
+  /** Input text with resolved placeholders replaced by media path tags. */
+  text: string;
+  hasMedia: boolean;
+  imageAttachmentIds: number[];
+  videoAttachmentIds: number[];
+}
+
+/**
+ * Rewrite media placeholders in slash-command args (`/skill:foo …`,
+ * plugin commands) into `<image|video path="…"></…>` tags pointing at
+ * cache-dir copies. Command args are a plain-text channel — unlike
+ * `extractMediaAttachments`, which inlines image parts for the prompt
+ * endpoint — so the model reaches the media through `ReadMediaFile`
+ * instead, the same way it already handles pasted videos.
+ *
+ * Surrounding text is preserved verbatim (args are user content, not
+ * LLM parts), and unresolved placeholders stay literal.
+ */
+export function rewriteMediaPlaceholdersAsTags(
+  text: string,
+  store: ImageAttachmentStore,
+): MediaTagRewriteResult {
+  const imageAttachmentIds: number[] = [];
+  const videoAttachmentIds: number[] = [];
+  let cursor = 0;
+  let out = '';
+
+  PLACEHOLDER_REGEX.lastIndex = 0;
+  let match: RegExpExecArray | null;
+  while ((match = PLACEHOLDER_REGEX.exec(text)) !== null) {
+    const [literal, kind, idStr] = match;
+    if (kind !== 'image' && kind !== 'video') continue;
+    if (idStr === undefined) continue;
+    const id = Number.parseInt(idStr, 10);
+    const attachment = store.get(id);
+    if (attachment === undefined) continue; // stale / user-typed — leave as text
+    if (attachment.kind !== kind) continue;
+    out += text.slice(cursor, match.index);
+    if (attachment.kind === 'video') {
+      out += formatMediaTag('video', materializeVideoToCache(attachment));
+      videoAttachmentIds.push(id);
+    } else {
+      out += formatMediaTag('image', materializeImageToCache(attachment));
+      imageAttachmentIds.push(id);
+    }
+    cursor = match.index + literal.length;
+  }
+
+  const hasMedia = imageAttachmentIds.length + videoAttachmentIds.length > 0;
+  return {
+    text: hasMedia ? out + text.slice(cursor) : text,
+    hasMedia,
+    imageAttachmentIds,
+    videoAttachmentIds,
+  };
+}
+
 function pushText(parts: PromptPart[], segment: string): void {
   if (segment.length === 0) return;
   // Keep whitespace-only segments only when they sit between non-empty
@@ -131,6 +189,26 @@ function materializeVideoToCache(att: VideoAttachment): string {
   return target;
 }
 
+const IMAGE_MIME_EXTENSION: Readonly<Record<string, string>> = {
+  'image/png': 'png',
+  'image/jpeg': 'jpg',
+  'image/gif': 'gif',
+  'image/webp': 'webp',
+  'image/bmp': 'bmp',
+  'image/tiff': 'tif',
+};
+
+function materializeImageToCache(att: ImageAttachment): string {
+  const cacheDir = getCacheDir();
+  mkdirSync(cacheDir, { recursive: true });
+  // ReadMediaFile sniffs the real format from the bytes, so the extension
+  // only needs to be a reasonable hint.
+  const ext = IMAGE_MIME_EXTENSION[att.mime.trim().toLowerCase()] ?? 'img';
+  const target = join(cacheDir, `${randomUUID()}.${ext}`);
+  writeFileSync(target, att.bytes);
+  return target;
+}
+
 function captionForCompressedImage(att: ImageAttachment): string {
   const original = att.original;
   if (original === undefined) return '';
diff --git a/apps/kimi-code/test/tui/input/image-placeholder.test.ts b/apps/kimi-code/test/tui/input/image-placeholder.test.ts
index e157cbf8c8..c73ebe18b2 100644
--- a/apps/kimi-code/test/tui/input/image-placeholder.test.ts
+++ b/apps/kimi-code/test/tui/input/image-placeholder.test.ts
@@ -6,7 +6,10 @@ import { describe, it, expect } from 'vitest';
 
 import { KIMI_CODE_HOME_ENV } from '#/constant/app';
 import { ImageAttachmentStore } from '#/tui/utils/image-attachment-store';
-import { extractMediaAttachments } from '#/tui/utils/image-placeholder';
+import {
+  extractMediaAttachments,
+  rewriteMediaPlaceholdersAsTags,
+} from '#/tui/utils/image-placeholder';
 import { getCacheDir } from '#/utils/paths';
 
 function storeWith(
@@ -221,3 +224,84 @@ describe('extractMediaAttachments', () => {
     expect(r.parts[0]?.type).toBe('image_url');
   });
 });
+
+describe('rewriteMediaPlaceholdersAsTags', () => {
+  it('returns plain text untouched with hasMedia=false', () => {
+    const store = new ImageAttachmentStore();
+    const r = rewriteMediaPlaceholdersAsTags('just some args', store);
+    expect(r.text).toBe('just some args');
+    expect(r.hasMedia).toBe(false);
+    expect(r.imageAttachmentIds).toEqual([]);
+    expect(r.videoAttachmentIds).toEqual([]);
+  });
+
+  it('rewrites an image placeholder into a cache-path image tag', () => {
+    const { cleanup } = setupTempCache();
+    try {
+      const bytes = new Uint8Array([0x89, 0x50, 0x4e, 0x47]);
+      const { store, placeholder } = storeWith(bytes);
+      const r = rewriteMediaPlaceholdersAsTags(`look at ${placeholder} please`, store);
+      expect(r.hasMedia).toBe(true);
+      expect(r.imageAttachmentIds).toEqual([1]);
+      const m = /^look at <image path="([^"]+)"><\/image> please$/.exec(r.text);
+      if (!m) throw new Error(`no image tag found in: ${r.text}`);
+      expect(m[1]!.startsWith(getCacheDir())).toBe(true);
+      expect(m[1]!.endsWith('.png')).toBe(true);
+      expect(new Uint8Array(readFileSync(m[1]!))).toEqual(bytes);
+    } finally {
+      cleanup();
+    }
+  });
+
+  it('rewrites a video placeholder into a cache-path video tag', () => {
+    const { cleanup } = setupTempCache();
+    const srcDir = makeTempDir();
+    try {
+      const srcVideo = join(srcDir, 'clip.mov');
+      writeFileSync(srcVideo, 'video-bytes');
+      const store = new ImageAttachmentStore();
+      const att = store.addVideo('video/quicktime', srcVideo);
+      const r = rewriteMediaPlaceholdersAsTags(att.placeholder, store);
+      expect(r.hasMedia).toBe(true);
+      expect(r.videoAttachmentIds).toEqual([1]);
+      const m = /<video path="([^"]+)"><\/video>/.exec(r.text);
+      if (!m) throw new Error(`no video tag found in: ${r.text}`);
+      expect(m[1]!.startsWith(getCacheDir())).toBe(true);
+      expect(readFileSync(m[1]!, 'utf8')).toBe('video-bytes');
+    } finally {
+      cleanup();
+      rmSync(srcDir, { recursive: true, force: true });
+    }
+  });
+
+  it('leaves unresolved (typed by hand) placeholders as literal text', () => {
+    const store = new ImageAttachmentStore();
+    const text = 'try [image #999 (1×1)] and [video #42 clip.mov] now';
+    const r = rewriteMediaPlaceholdersAsTags(text, store);
+    expect(r.text).toBe(text);
+    expect(r.hasMedia).toBe(false);
+  });
+
+  it('preserves surrounding text verbatim across multiple attachments', () => {
+    const { cleanup } = setupTempCache();
+    try {
+      const store = new ImageAttachmentStore();
+      const a = store.addImage(new Uint8Array([1]), 'image/png', 10, 10);
+      const b = store.addImage(new Uint8Array([2]), 'image/jpeg', 20, 20);
+      const r = rewriteMediaPlaceholdersAsTags(
+        `first ${a.placeholder}   then ${b.placeholder} end`,
+        store,
+      );
+      expect(r.imageAttachmentIds).toEqual([1, 2]);
+      const tags = [...r.text.matchAll(/<image path="([^"]+)"><\/image>/g)];
+      expect(tags).toHaveLength(2);
+      expect(r.text.startsWith('first <image path=')).toBe(true);
+      expect(r.text).toContain('>   then <image path=');
+      expect(r.text.endsWith('> end')).toBe(true);
+      expect(new Uint8Array(readFileSync(tags[0]![1]!))).toEqual(new Uint8Array([1]));
+      expect(new Uint8Array(readFileSync(tags[1]![1]!))).toEqual(new Uint8Array([2]));
+    } finally {
+      cleanup();
+    }
+  });
+});

From 3581fc689eabbca6c6a222998a35bfde97b32e50 Mon Sep 17 00:00:00 2001
From: liruifengv <liruifeng1024@gmail.com>
Date: Mon, 13 Jul 2026 13:56:14 +0800
Subject: [PATCH 2/7] fix(tui): deliver pasted media when steering with Ctrl-S

Ctrl-S steer dropped media: queued messages were reduced to their text and the editor draft never went through placeholder extraction, so session.steer only ever received placeholder strings. Carry the queued items' extracted parts, extract the editor draft on the spot (with the same capability gate as a normal submit), and merge everything into a part list when any item has media.
---
 .changeset/fix-steer-media.md                 |  5 ++
 .../src/tui/controllers/editor-keyboard.ts    | 46 +++++++++---
 apps/kimi-code/src/tui/kimi-tui.ts            | 56 ++++++++++++---
 apps/kimi-code/src/tui/types.ts               | 12 ++++
 .../test/tui/kimi-tui-message-flow.test.ts    | 71 +++++++++++++++++++
 5 files changed, 173 insertions(+), 17 deletions(-)
 create mode 100644 .changeset/fix-steer-media.md

diff --git a/.changeset/fix-steer-media.md b/.changeset/fix-steer-media.md
new file mode 100644
index 0000000000..5d0f8ac61e
--- /dev/null
+++ b/.changeset/fix-steer-media.md
@@ -0,0 +1,5 @@
+---
+"@moonshot-ai/kimi-code": patch
+---
+
+Fix pasted images being dropped when steering with Ctrl-S.
diff --git a/apps/kimi-code/src/tui/controllers/editor-keyboard.ts b/apps/kimi-code/src/tui/controllers/editor-keyboard.ts
index 383694c073..5575738ec8 100644
--- a/apps/kimi-code/src/tui/controllers/editor-keyboard.ts
+++ b/apps/kimi-code/src/tui/controllers/editor-keyboard.ts
@@ -15,7 +15,8 @@ import {
 } from '../constant/kimi-tui';
 import { formatErrorMessage } from '../utils/event-payload';
 import type { ImageAttachmentStore } from '../utils/image-attachment-store';
-import type { PendingExit, QueuedMessage } from '../types';
+import { extractMediaAttachments } from '../utils/image-placeholder';
+import type { PendingExit, QueuedMessage, SteerInputItem } from '../types';
 import type { TUIState } from '../tui-state';
 import type { BtwPanelController } from './btw-panel';
 
@@ -32,7 +33,12 @@ export interface EditorKeyboardHost {
 
   handleUserInput(text: string): void;
   readonly btwPanelController: BtwPanelController;
-  steerMessage(session: Session, input: string[]): void;
+  steerMessage(session: Session, input: readonly SteerInputItem[]): void;
+  validateMediaCapabilities(extraction: {
+    hasMedia: boolean;
+    imageAttachmentIds: readonly number[];
+    videoAttachmentIds: readonly number[];
+  }): boolean;
   recallLastQueued(): QueuedMessage | undefined;
   showError(msg: string): void;
   track(event: string, props?: Record<string, unknown>): void;
@@ -250,22 +256,46 @@ export class EditorKeyboardController {
       // after the current task instead of being injected into the turn as text.
       const queued = host.state.queuedMessages;
       const steerable = queued.filter((m) => m.mode !== 'bash');
-      host.state.queuedMessages = queued.filter((m) => m.mode === 'bash');
 
-      const parts: string[] = [];
+      const items: SteerInputItem[] = [];
       for (const m of steerable) {
         const trimmed = m.text.trim();
-        if (trimmed.length > 0) parts.push(trimmed);
+        if (trimmed.length > 0) {
+          // Queued items carry the parts extracted when they were submitted
+          // (and were already capability-validated then).
+          items.push({ text: trimmed, parts: m.parts, imageAttachmentIds: m.imageAttachmentIds });
+        }
+      }
+      let editorExtraction: ReturnType<typeof extractMediaAttachments> | undefined;
+      if (!editorIsBash && text.length > 0) {
+        editorExtraction = extractMediaAttachments(text, this.imageStore);
+        items.push({
+          text,
+          parts: editorExtraction.hasMedia ? editorExtraction.parts : undefined,
+          imageAttachmentIds:
+            editorExtraction.imageAttachmentIds.length > 0
+              ? editorExtraction.imageAttachmentIds
+              : undefined,
+        });
       }
-      if (!editorIsBash && text.length > 0) parts.push(text);
 
-      if (parts.length > 0) {
+      if (items.length > 0) {
+        // The editor draft is fresh input: gate it on the model's media
+        // capabilities before splicing the queue, so a rejection leaves the
+        // queue and the draft untouched.
+        if (
+          editorExtraction !== undefined &&
+          !host.validateMediaCapabilities(editorExtraction)
+        ) {
+          return;
+        }
+        host.state.queuedMessages = queued.filter((m) => m.mode === 'bash');
         if (!editorIsBash) editor.setText('');
         const session = host.session;
         if (host.state.appState.model.trim().length === 0 || session === undefined) {
           host.showError(LLM_NOT_SET_MESSAGE);
         } else {
-          host.steerMessage(session, parts);
+          host.steerMessage(session, items);
         }
       }
       host.updateQueueDisplay();
diff --git a/apps/kimi-code/src/tui/kimi-tui.ts b/apps/kimi-code/src/tui/kimi-tui.ts
index 44b2ed34ec..f52c232d5c 100644
--- a/apps/kimi-code/src/tui/kimi-tui.ts
+++ b/apps/kimi-code/src/tui/kimi-tui.ts
@@ -123,6 +123,7 @@ import {
   type LivePaneState,
   type LoginProgressSpinnerHandle,
   type QueuedMessage,
+  type SteerInputItem,
   type TranscriptEntry,
   type TUIStartupOptions,
   type TUIStartupState,
@@ -238,6 +239,39 @@ interface SendMessageOptions {
   readonly hasMedia?: boolean;
 }
 
+/**
+ * Flatten steer items into the payload `session.steer` expects: the
+ * historical `'\n\n'`-joined string when nothing carries media, or a
+ * merged part list when any item has extracted media parts (queued image
+ * messages, or the editor draft after placeholder extraction).
+ */
+function combineSteerInput(items: readonly SteerInputItem[]): string | PromptPart[] {
+  const hasMedia = items.some((item) => item.parts !== undefined && item.parts.length > 0);
+  if (!hasMedia) return items.map((item) => item.text).join('\n\n');
+  const parts: PromptPart[] = [];
+  for (const item of items) {
+    if (parts.length > 0) appendSteerText(parts, '\n\n');
+    if (item.parts !== undefined && item.parts.length > 0) {
+      for (const part of item.parts) {
+        if (part.type === 'text') appendSteerText(parts, part.text);
+        else parts.push(part);
+      }
+    } else {
+      appendSteerText(parts, item.text);
+    }
+  }
+  return parts;
+}
+
+function appendSteerText(parts: PromptPart[], text: string): void {
+  const last = parts.at(-1);
+  if (last?.type === 'text') {
+    parts[parts.length - 1] = { type: 'text', text: last.text + text };
+    return;
+  }
+  parts.push({ type: 'text', text });
+}
+
 /** How long the one-shot "moved to background" footer hint stays visible. */
 const DETACH_HINT_DISPLAY_MS = 4_000;
 
@@ -1095,7 +1129,7 @@ export class KimiTUI {
     this.state.ui.requestRender();
   }
 
-  private validateMediaCapabilities(extraction: {
+  validateMediaCapabilities(extraction: {
     hasMedia: boolean;
     imageAttachmentIds: readonly number[];
     videoAttachmentIds: readonly number[];
@@ -1287,31 +1321,35 @@ export class KimiTUI {
     this.sendMessageInternal(session, input, options);
   }
 
-  steerMessage(session: Session, input: string[]): void {
+  steerMessage(session: Session, input: readonly SteerInputItem[]): void {
     if (this.deferUserMessages || this.state.appState.isCompacting) {
-      for (const part of input) {
-        this.enqueueMessage(part);
+      for (const item of input) {
+        this.enqueueMessage(item.text, item);
       }
       return;
     }
     if (this.state.appState.streamingPhase === 'idle') {
-      for (const part of input) {
-        this.sendMessageInternal(session, part);
+      for (const item of input) {
+        this.sendMessageInternal(session, item.text, item);
       }
       return;
     }
 
-    for (const part of input) {
+    for (const item of input) {
       this.appendTranscriptEntry({
         id: nextTranscriptId(),
         kind: 'user',
         turnId: this.streamingUI.getTurnContext().turnId,
         renderMode: 'plain',
-        content: part,
+        content: item.text,
+        imageAttachmentIds:
+          item.imageAttachmentIds !== undefined && item.imageAttachmentIds.length > 0
+            ? item.imageAttachmentIds
+            : undefined,
       });
     }
 
-    void session.steer(input.join('\n\n')).catch((error: unknown) => {
+    void session.steer(combineSteerInput(input)).catch((error: unknown) => {
       const message = formatErrorMessage(error);
       this.showError(`Failed to steer: ${message}`);
     });
diff --git a/apps/kimi-code/src/tui/types.ts b/apps/kimi-code/src/tui/types.ts
index 6dcdccdd1a..e79d2c8b40 100644
--- a/apps/kimi-code/src/tui/types.ts
+++ b/apps/kimi-code/src/tui/types.ts
@@ -206,6 +206,18 @@ export interface QueuedMessage {
   readonly mode?: 'prompt' | 'bash';
 }
 
+/**
+ * One unit of Ctrl-S steer input: a queued message or the editor draft,
+ * with the media parts extracted at submit/paste time so images and video
+ * tags survive the steer path (which accepts full prompt parts, not just
+ * text).
+ */
+export interface SteerInputItem {
+  readonly text: string;
+  readonly parts?: readonly PromptPart[];
+  readonly imageAttachmentIds?: readonly number[];
+}
+
 export const INITIAL_LIVE_PANE: LivePaneState = {
   mode: 'idle',
   pendingApproval: null,
diff --git a/apps/kimi-code/test/tui/kimi-tui-message-flow.test.ts b/apps/kimi-code/test/tui/kimi-tui-message-flow.test.ts
index ef18d45de9..59cab9d5db 100644
--- a/apps/kimi-code/test/tui/kimi-tui-message-flow.test.ts
+++ b/apps/kimi-code/test/tui/kimi-tui-message-flow.test.ts
@@ -1729,6 +1729,77 @@ command = "vim"
     expect(driver.state.editor.getText()).toBe('ls');
   });
 
+  it('drains a queued image message with its media parts', async () => {
+    const session = makeSession();
+    const { driver } = await makeDriver(session);
+    const imageStore = (driver as unknown as { imageStore: ImageAttachmentStore }).imageStore;
+    const attachment = imageStore.addImage(new Uint8Array([0xaa, 0xbb]), 'image/png', 1, 1);
+    driver.state.appState.streamingPhase = 'waiting';
+
+    driver.handleUserInput(`describe ${attachment.placeholder}`);
+
+    expect(session.prompt).not.toHaveBeenCalled();
+    const queued = driver.state.queuedMessages[0];
+    expect(queued?.parts).toEqual([
+      { type: 'text', text: 'describe ' },
+      { type: 'image_url', imageUrl: { url: 'data:image/png;base64,qrs=' } },
+    ]);
+
+    driver.sendQueuedMessage(session, queued!);
+
+    expect(session.prompt).toHaveBeenCalledWith([
+      { type: 'text', text: 'describe ' },
+      { type: 'image_url', imageUrl: { url: 'data:image/png;base64,qrs=' } },
+    ]);
+  });
+
+  it('steers editor image input as media parts', async () => {
+    const session = makeSession();
+    const { driver } = await makeDriver(session);
+    driver.state.appState.model = 'k2';
+    driver.state.appState.streamingPhase = 'waiting';
+    driver.streamingUI.setTurnId('1');
+    const imageStore = (driver as unknown as { imageStore: ImageAttachmentStore }).imageStore;
+    const attachment = imageStore.addImage(new Uint8Array([0xaa, 0xbb]), 'image/png', 1, 1);
+    driver.state.editor.setText(`check ${attachment.placeholder}`);
+
+    driver.state.editor.onCtrlS?.();
+
+    expect(session.steer).toHaveBeenCalledWith([
+      { type: 'text', text: 'check ' },
+      { type: 'image_url', imageUrl: { url: 'data:image/png;base64,qrs=' } },
+    ]);
+  });
+
+  it('steers queued image messages with their media parts', async () => {
+    const session = makeSession();
+    const { driver } = await makeDriver(session);
+    driver.state.appState.model = 'k2';
+    driver.state.appState.streamingPhase = 'waiting';
+    driver.streamingUI.setTurnId('1');
+    const imageStore = (driver as unknown as { imageStore: ImageAttachmentStore }).imageStore;
+    const attachment = imageStore.addImage(new Uint8Array([0xaa, 0xbb]), 'image/png', 1, 1);
+    driver.state.queuedMessages = [
+      {
+        text: `look ${attachment.placeholder}`,
+        agentId: 'main',
+        parts: [
+          { type: 'text', text: 'look ' },
+          { type: 'image_url', imageUrl: { url: 'data:image/png;base64,qrs=' } },
+        ],
+        imageAttachmentIds: [attachment.id],
+      },
+    ];
+
+    driver.state.editor.onCtrlS?.();
+
+    expect(session.steer).toHaveBeenCalledWith([
+      { type: 'text', text: 'look ' },
+      { type: 'image_url', imageUrl: { url: 'data:image/png;base64,qrs=' } },
+    ]);
+    expect(driver.state.queuedMessages).toEqual([]);
+  });
+
   it('recalls a queued bash command back into bash mode on Up', async () => {
     const { driver } = await makeDriver();
     driver.state.appState.streamingPhase = 'waiting';

From 035c181cf8d84781e3d08a6e627c442c5dd17693 Mon Sep 17 00:00:00 2001
From: liruifengv <liruifeng1024@gmail.com>
Date: Mon, 13 Jul 2026 14:12:43 +0800
Subject: [PATCH 3/7] fix(tui): avoid empty text separator when steering
 consecutive media
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The '\n\n' item separator could land as a standalone whitespace-only text part between two media parts, which normalizePromptInput rejects — failing the steer after the queue and editor draft were already cleared. Only append the separator onto a trailing text part so it always merges.
---
 apps/kimi-code/src/tui/kimi-tui.ts            |  6 +++-
 .../test/tui/kimi-tui-message-flow.test.ts    | 36 +++++++++++++++++++
 2 files changed, 41 insertions(+), 1 deletion(-)

diff --git a/apps/kimi-code/src/tui/kimi-tui.ts b/apps/kimi-code/src/tui/kimi-tui.ts
index f52c232d5c..6a07e9812f 100644
--- a/apps/kimi-code/src/tui/kimi-tui.ts
+++ b/apps/kimi-code/src/tui/kimi-tui.ts
@@ -244,13 +244,17 @@ interface SendMessageOptions {
  * historical `'\n\n'`-joined string when nothing carries media, or a
  * merged part list when any item has extracted media parts (queued image
  * messages, or the editor draft after placeholder extraction).
+ *
+ * The item separator is only appended onto a trailing text part — never
+ * as a standalone `{type:'text',text:'\n\n'}` between media parts, which
+ * `normalizePromptInput` rejects as an empty text part.
  */
 function combineSteerInput(items: readonly SteerInputItem[]): string | PromptPart[] {
   const hasMedia = items.some((item) => item.parts !== undefined && item.parts.length > 0);
   if (!hasMedia) return items.map((item) => item.text).join('\n\n');
   const parts: PromptPart[] = [];
   for (const item of items) {
-    if (parts.length > 0) appendSteerText(parts, '\n\n');
+    if (parts.at(-1)?.type === 'text') appendSteerText(parts, '\n\n');
     if (item.parts !== undefined && item.parts.length > 0) {
       for (const part of item.parts) {
         if (part.type === 'text') appendSteerText(parts, part.text);
diff --git a/apps/kimi-code/test/tui/kimi-tui-message-flow.test.ts b/apps/kimi-code/test/tui/kimi-tui-message-flow.test.ts
index 59cab9d5db..17ce760983 100644
--- a/apps/kimi-code/test/tui/kimi-tui-message-flow.test.ts
+++ b/apps/kimi-code/test/tui/kimi-tui-message-flow.test.ts
@@ -1800,6 +1800,42 @@ command = "vim"
     expect(driver.state.queuedMessages).toEqual([]);
   });
 
+  it('steers consecutive image-only messages without a whitespace-only separator part', async () => {
+    const session = makeSession();
+    const { driver } = await makeDriver(session);
+    driver.state.appState.model = 'k2';
+    driver.state.appState.streamingPhase = 'waiting';
+    driver.streamingUI.setTurnId('1');
+    const imageStore = (driver as unknown as { imageStore: ImageAttachmentStore }).imageStore;
+    const first = imageStore.addImage(new Uint8Array([0xaa]), 'image/png', 1, 1);
+    const second = imageStore.addImage(new Uint8Array([0xbb]), 'image/png', 1, 1);
+    const imagePart = (bytes: Uint8Array) => ({
+      type: 'image_url' as const,
+      imageUrl: { url: `data:image/png;base64,${Buffer.from(bytes).toString('base64')}` },
+    });
+    driver.state.queuedMessages = [
+      {
+        text: first.placeholder,
+        agentId: 'main',
+        parts: [imagePart(first.bytes)],
+        imageAttachmentIds: [first.id],
+      },
+      {
+        text: second.placeholder,
+        agentId: 'main',
+        parts: [imagePart(second.bytes)],
+        imageAttachmentIds: [second.id],
+      },
+    ];
+
+    driver.state.editor.onCtrlS?.();
+
+    // normalizePromptInput rejects whitespace-only text parts, so the
+    // item separator must not become a standalone `{type:'text',text:'\n\n'}`
+    // between two image parts.
+    expect(session.steer).toHaveBeenCalledWith([imagePart(first.bytes), imagePart(second.bytes)]);
+  });
+
   it('recalls a queued bash command back into bash mode on Up', async () => {
     const { driver } = await makeDriver();
     driver.state.appState.streamingPhase = 'waiting';

From 456b7b2aa815a4f870405f64befeb87df38a3b7f Mon Sep 17 00:00:00 2001
From: liruifengv <liruifeng1024@gmail.com>
Date: Mon, 13 Jul 2026 14:30:19 +0800
Subject: [PATCH 4/7] fix(tui): keep blank-line separator between media and
 text steer items
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The separator was only appended onto trailing text parts, so a media item followed by a plain-text steer item lost the historical '\n\n' separation. Always append it — it merges into the adjacent text part — except between two touching media parts, where a standalone whitespace-only text part would be rejected by normalizePromptInput.
---
 apps/kimi-code/src/tui/kimi-tui.ts            | 15 +++--
 .../test/tui/kimi-tui-message-flow.test.ts    | 59 +++++++++++++++++++
 2 files changed, 70 insertions(+), 4 deletions(-)

diff --git a/apps/kimi-code/src/tui/kimi-tui.ts b/apps/kimi-code/src/tui/kimi-tui.ts
index 6a07e9812f..5aea4e58e7 100644
--- a/apps/kimi-code/src/tui/kimi-tui.ts
+++ b/apps/kimi-code/src/tui/kimi-tui.ts
@@ -245,16 +245,23 @@ interface SendMessageOptions {
  * merged part list when any item has extracted media parts (queued image
  * messages, or the editor draft after placeholder extraction).
  *
- * The item separator is only appended onto a trailing text part — never
- * as a standalone `{type:'text',text:'\n\n'}` between media parts, which
- * `normalizePromptInput` rejects as an empty text part.
+ * Items are separated by the historical `'\n\n'`, which merges into the
+ * adjacent text part. The one exception is two touching media parts: a
+ * standalone `{type:'text',text:'\n\n'}` between them would be rejected
+ * by `normalizePromptInput` as an empty text part, so the separator is
+ * dropped there (media parts are self-delimiting anyway).
  */
 function combineSteerInput(items: readonly SteerInputItem[]): string | PromptPart[] {
   const hasMedia = items.some((item) => item.parts !== undefined && item.parts.length > 0);
   if (!hasMedia) return items.map((item) => item.text).join('\n\n');
   const parts: PromptPart[] = [];
   for (const item of items) {
-    if (parts.at(-1)?.type === 'text') appendSteerText(parts, '\n\n');
+    const startsWithMedia =
+      item.parts !== undefined && item.parts.length > 0 && item.parts[0]?.type !== 'text';
+    const lastIsMedia = parts.length > 0 && parts.at(-1)?.type !== 'text';
+    if (parts.length > 0 && !(lastIsMedia && startsWithMedia)) {
+      appendSteerText(parts, '\n\n');
+    }
     if (item.parts !== undefined && item.parts.length > 0) {
       for (const part of item.parts) {
         if (part.type === 'text') appendSteerText(parts, part.text);
diff --git a/apps/kimi-code/test/tui/kimi-tui-message-flow.test.ts b/apps/kimi-code/test/tui/kimi-tui-message-flow.test.ts
index 17ce760983..016fb9ab4e 100644
--- a/apps/kimi-code/test/tui/kimi-tui-message-flow.test.ts
+++ b/apps/kimi-code/test/tui/kimi-tui-message-flow.test.ts
@@ -1836,6 +1836,65 @@ command = "vim"
     expect(session.steer).toHaveBeenCalledWith([imagePart(first.bytes), imagePart(second.bytes)]);
   });
 
+  it('steers a media item followed by plain text with a blank-line separator', async () => {
+    const session = makeSession();
+    const { driver } = await makeDriver(session);
+    driver.state.appState.model = 'k2';
+    driver.state.appState.streamingPhase = 'waiting';
+    driver.streamingUI.setTurnId('1');
+    const imageStore = (driver as unknown as { imageStore: ImageAttachmentStore }).imageStore;
+    const attachment = imageStore.addImage(new Uint8Array([0xaa, 0xbb]), 'image/png', 1, 1);
+    driver.state.queuedMessages = [
+      {
+        text: `look ${attachment.placeholder}`,
+        agentId: 'main',
+        parts: [
+          { type: 'text', text: 'look ' },
+          { type: 'image_url', imageUrl: { url: 'data:image/png;base64,qrs=' } },
+        ],
+        imageAttachmentIds: [attachment.id],
+      },
+      { text: 'focus on tests', agentId: 'main' },
+    ];
+
+    driver.state.editor.onCtrlS?.();
+
+    // The historical '\n\n' item separator merges into the following text
+    // part (legal for normalizePromptInput) instead of vanishing after a
+    // media part.
+    expect(session.steer).toHaveBeenCalledWith([
+      { type: 'text', text: 'look ' },
+      { type: 'image_url', imageUrl: { url: 'data:image/png;base64,qrs=' } },
+      { type: 'text', text: '\n\nfocus on tests' },
+    ]);
+  });
+
+  it('steers plain text followed by a media item with a blank-line separator', async () => {
+    const session = makeSession();
+    const { driver } = await makeDriver(session);
+    driver.state.appState.model = 'k2';
+    driver.state.appState.streamingPhase = 'waiting';
+    driver.streamingUI.setTurnId('1');
+    const imageStore = (driver as unknown as { imageStore: ImageAttachmentStore }).imageStore;
+    const attachment = imageStore.addImage(new Uint8Array([0xaa, 0xbb]), 'image/png', 1, 1);
+    driver.state.queuedMessages = [
+      { text: 'hello', agentId: 'main' },
+      {
+        text: attachment.placeholder,
+        agentId: 'main',
+        parts: [{ type: 'image_url', imageUrl: { url: 'data:image/png;base64,qrs=' } }],
+        imageAttachmentIds: [attachment.id],
+      },
+    ];
+
+    driver.state.editor.onCtrlS?.();
+
+    expect(session.steer).toHaveBeenCalledWith([
+      { type: 'text', text: 'hello\n\n' },
+      { type: 'image_url', imageUrl: { url: 'data:image/png;base64,qrs=' } },
+    ]);
+  });
+
   it('recalls a queued bash command back into bash mode on Up', async () => {
     const { driver } = await makeDriver();
     driver.state.appState.streamingPhase = 'waiting';

From 10ac69059de34e1ecc7937dfc46b79a4ec20d495 Mon Sep 17 00:00:00 2001
From: liruifengv <liruifeng1024@gmail.com>
Date: Mon, 13 Jul 2026 15:05:12 +0800
Subject: [PATCH 5/7] fix(tui): use escape-proof media references in /skill
 args

Skill args are XML-escaped on render (renderSkillAttributes + expandSkillParameters), which mangled the <image|video path> tags into escaped text. Add a 'plain' reference style (Attached image file: <path> (open it with ReadMediaFile)) with no tag/attribute boundary characters and use it for the skill channel; plugin command args expand verbatim and keep the tag form.
---
 apps/kimi-code/src/tui/kimi-tui.ts            | 15 +++--
 .../src/tui/utils/image-placeholder.ts        | 41 +++++++++++---
 .../test/tui/input/image-placeholder.test.ts  | 56 ++++++++++++++++---
 3 files changed, 90 insertions(+), 22 deletions(-)

diff --git a/apps/kimi-code/src/tui/kimi-tui.ts b/apps/kimi-code/src/tui/kimi-tui.ts
index 5aea4e58e7..93d246dfed 100644
--- a/apps/kimi-code/src/tui/kimi-tui.ts
+++ b/apps/kimi-code/src/tui/kimi-tui.ts
@@ -133,7 +133,7 @@ import { isDeadTerminalError } from './utils/dead-terminal';
 import { formatErrorMessage } from './utils/event-payload';
 import { pickForegroundTasks } from './utils/foreground-task';
 import { ImageAttachmentStore, type ImageAttachment } from './utils/image-attachment-store';
-import { extractMediaAttachments, rewriteMediaPlaceholdersAsTags } from './utils/image-placeholder';
+import { extractMediaAttachments, rewriteMediaPlaceholders } from './utils/image-placeholder';
 import { hasPatchChanges } from './utils/object-patch';
 import { sessionRowsForPicker } from './utils/session-picker-rows';
 import { formatBashOutputForDisplay } from './utils/shell-output';
@@ -1291,9 +1291,10 @@ export class KimiTUI {
 
   sendSkillActivation(session: Session, skillName: string, skillArgs: string): void {
     // Args are a plain-text channel, so pasted media can't ride along as
-    // inline parts. Rewrite placeholders into cache-file tags the model
-    // can open with ReadMediaFile instead of leaving dead placeholder text.
-    const rewrite = rewriteMediaPlaceholdersAsTags(skillArgs, this.imageStore);
+    // inline parts. Skill args are XML-escaped on render (renderSkillAttributes
+    // + expandSkillParameters), so rewrite placeholders into escape-proof
+    // plain-text file references the model can open with ReadMediaFile.
+    const rewrite = rewriteMediaPlaceholders(skillArgs, this.imageStore, 'plain');
     if (!this.validateMediaCapabilities(rewrite)) return;
     this.beginSessionRequest();
     void session.activateSkill(skillName, rewrite.text).catch((error: unknown) => {
@@ -1308,8 +1309,10 @@ export class KimiTUI {
     commandName: string,
     args: string,
   ): void {
-    // Same plain-text constraint as skill args — see sendSkillActivation.
-    const rewrite = rewriteMediaPlaceholdersAsTags(args, this.imageStore);
+    // Plugin command args are expanded verbatim (no XML escaping), so the
+    // standard <image|video path> tag convention works — see
+    // sendSkillActivation for the escaped-channel variant.
+    const rewrite = rewriteMediaPlaceholders(args, this.imageStore, 'tag');
     if (!this.validateMediaCapabilities(rewrite)) return;
     this.beginSessionRequest();
     void session
diff --git a/apps/kimi-code/src/tui/utils/image-placeholder.ts b/apps/kimi-code/src/tui/utils/image-placeholder.ts
index 180d217fcf..b04d826931 100644
--- a/apps/kimi-code/src/tui/utils/image-placeholder.ts
+++ b/apps/kimi-code/src/tui/utils/image-placeholder.ts
@@ -102,27 +102,39 @@ export function extractMediaAttachments(
 }
 
 export interface MediaTagRewriteResult {
-  /** Input text with resolved placeholders replaced by media path tags. */
+  /** Input text with resolved placeholders replaced by media references. */
   text: string;
   hasMedia: boolean;
   imageAttachmentIds: number[];
   videoAttachmentIds: number[];
 }
 
+/**
+ * How a resolved placeholder is rendered into command args:
+ *  - `'tag'`: the `<image|video path="…"></…>` convention, for channels
+ *    that pass args through verbatim (plugin commands).
+ *  - `'plain'`: a plain-text file reference with no XML tag/attribute
+ *    boundary characters, for channels that XML-escape args (`/skill`
+ *    args are escaped by both `renderSkillAttributes` and
+ *    `expandSkillParameters`, which would mangle the tag form).
+ */
+export type MediaReferenceStyle = 'tag' | 'plain';
+
 /**
  * Rewrite media placeholders in slash-command args (`/skill:foo …`,
- * plugin commands) into `<image|video path="…"></…>` tags pointing at
- * cache-dir copies. Command args are a plain-text channel — unlike
- * `extractMediaAttachments`, which inlines image parts for the prompt
- * endpoint — so the model reaches the media through `ReadMediaFile`
- * instead, the same way it already handles pasted videos.
+ * plugin commands) into references pointing at cache-dir copies. Command
+ * args are a plain-text channel — unlike `extractMediaAttachments`, which
+ * inlines image parts for the prompt endpoint — so the model reaches the
+ * media through `ReadMediaFile` instead, the same way it already handles
+ * pasted videos.
  *
  * Surrounding text is preserved verbatim (args are user content, not
  * LLM parts), and unresolved placeholders stay literal.
  */
-export function rewriteMediaPlaceholdersAsTags(
+export function rewriteMediaPlaceholders(
   text: string,
   store: ImageAttachmentStore,
+  style: MediaReferenceStyle = 'tag',
 ): MediaTagRewriteResult {
   const imageAttachmentIds: number[] = [];
   const videoAttachmentIds: number[] = [];
@@ -141,10 +153,12 @@ export function rewriteMediaPlaceholdersAsTags(
     if (attachment.kind !== kind) continue;
     out += text.slice(cursor, match.index);
     if (attachment.kind === 'video') {
-      out += formatMediaTag('video', materializeVideoToCache(attachment));
+      const path = materializeVideoToCache(attachment);
+      out += style === 'plain' ? formatMediaReference('video', path) : formatMediaTag('video', path);
       videoAttachmentIds.push(id);
     } else {
-      out += formatMediaTag('image', materializeImageToCache(attachment));
+      const path = materializeImageToCache(attachment);
+      out += style === 'plain' ? formatMediaReference('image', path) : formatMediaTag('image', path);
       imageAttachmentIds.push(id);
     }
     cursor = match.index + literal.length;
@@ -233,6 +247,15 @@ function formatMediaTag(tag: 'image' | 'video', path: string): string {
   return `<${tag} path="${escapeAttribute(path)}"></${tag}>`;
 }
 
+/**
+ * Plain-text media reference for channels that XML-escape args (`/skill`).
+ * Stays free of `& < > "` in practice (UUID image names; sanitized video
+ * labels) so it survives `escapeXml`/`escapeXmlTags` untouched.
+ */
+function formatMediaReference(kind: 'image' | 'video', path: string): string {
+  return `Attached ${kind} file: ${path} (open it with ReadMediaFile)`;
+}
+
 function escapeAttribute(value: string): string {
   return value
     .replaceAll('&', '&amp;')
diff --git a/apps/kimi-code/test/tui/input/image-placeholder.test.ts b/apps/kimi-code/test/tui/input/image-placeholder.test.ts
index c73ebe18b2..e5c81bda40 100644
--- a/apps/kimi-code/test/tui/input/image-placeholder.test.ts
+++ b/apps/kimi-code/test/tui/input/image-placeholder.test.ts
@@ -8,7 +8,7 @@ import { KIMI_CODE_HOME_ENV } from '#/constant/app';
 import { ImageAttachmentStore } from '#/tui/utils/image-attachment-store';
 import {
   extractMediaAttachments,
-  rewriteMediaPlaceholdersAsTags,
+  rewriteMediaPlaceholders,
 } from '#/tui/utils/image-placeholder';
 import { getCacheDir } from '#/utils/paths';
 
@@ -225,10 +225,10 @@ describe('extractMediaAttachments', () => {
   });
 });
 
-describe('rewriteMediaPlaceholdersAsTags', () => {
+describe('rewriteMediaPlaceholders', () => {
   it('returns plain text untouched with hasMedia=false', () => {
     const store = new ImageAttachmentStore();
-    const r = rewriteMediaPlaceholdersAsTags('just some args', store);
+    const r = rewriteMediaPlaceholders('just some args', store);
     expect(r.text).toBe('just some args');
     expect(r.hasMedia).toBe(false);
     expect(r.imageAttachmentIds).toEqual([]);
@@ -240,7 +240,7 @@ describe('rewriteMediaPlaceholdersAsTags', () => {
     try {
       const bytes = new Uint8Array([0x89, 0x50, 0x4e, 0x47]);
       const { store, placeholder } = storeWith(bytes);
-      const r = rewriteMediaPlaceholdersAsTags(`look at ${placeholder} please`, store);
+      const r = rewriteMediaPlaceholders(`look at ${placeholder} please`, store);
       expect(r.hasMedia).toBe(true);
       expect(r.imageAttachmentIds).toEqual([1]);
       const m = /^look at <image path="([^"]+)"><\/image> please$/.exec(r.text);
@@ -261,7 +261,7 @@ describe('rewriteMediaPlaceholdersAsTags', () => {
       writeFileSync(srcVideo, 'video-bytes');
       const store = new ImageAttachmentStore();
       const att = store.addVideo('video/quicktime', srcVideo);
-      const r = rewriteMediaPlaceholdersAsTags(att.placeholder, store);
+      const r = rewriteMediaPlaceholders(att.placeholder, store);
       expect(r.hasMedia).toBe(true);
       expect(r.videoAttachmentIds).toEqual([1]);
       const m = /<video path="([^"]+)"><\/video>/.exec(r.text);
@@ -277,7 +277,7 @@ describe('rewriteMediaPlaceholdersAsTags', () => {
   it('leaves unresolved (typed by hand) placeholders as literal text', () => {
     const store = new ImageAttachmentStore();
     const text = 'try [image #999 (1×1)] and [video #42 clip.mov] now';
-    const r = rewriteMediaPlaceholdersAsTags(text, store);
+    const r = rewriteMediaPlaceholders(text, store);
     expect(r.text).toBe(text);
     expect(r.hasMedia).toBe(false);
   });
@@ -288,7 +288,7 @@ describe('rewriteMediaPlaceholdersAsTags', () => {
       const store = new ImageAttachmentStore();
       const a = store.addImage(new Uint8Array([1]), 'image/png', 10, 10);
       const b = store.addImage(new Uint8Array([2]), 'image/jpeg', 20, 20);
-      const r = rewriteMediaPlaceholdersAsTags(
+      const r = rewriteMediaPlaceholders(
         `first ${a.placeholder}   then ${b.placeholder} end`,
         store,
       );
@@ -304,4 +304,46 @@ describe('rewriteMediaPlaceholdersAsTags', () => {
       cleanup();
     }
   });
+
+  it("rewrites an image placeholder into an escape-proof plain reference in 'plain' style", () => {
+    const { cleanup } = setupTempCache();
+    try {
+      const bytes = new Uint8Array([0x89, 0x50, 0x4e, 0x47]);
+      const { store, placeholder } = storeWith(bytes);
+      const r = rewriteMediaPlaceholders(`look at ${placeholder}`, store, 'plain');
+      expect(r.hasMedia).toBe(true);
+      expect(r.imageAttachmentIds).toEqual([1]);
+      // Skill args pass through XML escaping, so the reference must not
+      // contain any tag/attribute boundary characters.
+      expect(r.text).not.toMatch(/[<>&"]/);
+      const m =
+        /^look at Attached image file: (\S+) \(open it with ReadMediaFile\)$/.exec(r.text);
+      if (!m) throw new Error(`no plain reference found in: ${r.text}`);
+      expect(m[1]!.startsWith(getCacheDir())).toBe(true);
+      expect(new Uint8Array(readFileSync(m[1]!))).toEqual(bytes);
+    } finally {
+      cleanup();
+    }
+  });
+
+  it("rewrites a video placeholder into an escape-proof plain reference in 'plain' style", () => {
+    const { cleanup } = setupTempCache();
+    const srcDir = makeTempDir();
+    try {
+      const srcVideo = join(srcDir, 'clip.mov');
+      writeFileSync(srcVideo, 'video-bytes');
+      const store = new ImageAttachmentStore();
+      const att = store.addVideo('video/quicktime', srcVideo);
+      const r = rewriteMediaPlaceholders(att.placeholder, store, 'plain');
+      expect(r.hasMedia).toBe(true);
+      expect(r.videoAttachmentIds).toEqual([1]);
+      expect(r.text).not.toMatch(/[<>&"]/);
+      const m = /^Attached video file: (\S+) \(open it with ReadMediaFile\)$/.exec(r.text);
+      if (!m) throw new Error(`no plain reference found in: ${r.text}`);
+      expect(readFileSync(m[1]!, 'utf8')).toBe('video-bytes');
+    } finally {
+      cleanup();
+      rmSync(srcDir, { recursive: true, force: true });
+    }
+  });
 });

From 973ac9b60e5e8b57c9b43abd68dc317e684ed99c Mon Sep 17 00:00:00 2001
From: liruifengv <liruifeng1024@gmail.com>
Date: Mon, 13 Jul 2026 15:17:38 +0800
Subject: [PATCH 6/7] fix(tui): strip XML boundary chars from plain-style video
 cache names

Video cache names carry the original label, which permits <>&"; in the plain (/skill) reference style those chars get XML-escaped in args and the reference no longer matches the file on disk. Strip them from the cache name in plain mode; the tag channel is unchanged (its attribute escaping already handles them).
---
 .../src/tui/utils/image-placeholder.ts        | 15 ++++++++-----
 .../test/tui/input/image-placeholder.test.ts  | 22 +++++++++++++++++++
 2 files changed, 32 insertions(+), 5 deletions(-)

diff --git a/apps/kimi-code/src/tui/utils/image-placeholder.ts b/apps/kimi-code/src/tui/utils/image-placeholder.ts
index b04d826931..56edcee88b 100644
--- a/apps/kimi-code/src/tui/utils/image-placeholder.ts
+++ b/apps/kimi-code/src/tui/utils/image-placeholder.ts
@@ -153,7 +153,7 @@ export function rewriteMediaPlaceholders(
     if (attachment.kind !== kind) continue;
     out += text.slice(cursor, match.index);
     if (attachment.kind === 'video') {
-      const path = materializeVideoToCache(attachment);
+      const path = materializeVideoToCache(attachment, style === 'plain');
       out += style === 'plain' ? formatMediaReference('video', path) : formatMediaTag('video', path);
       videoAttachmentIds.push(id);
     } else {
@@ -195,10 +195,14 @@ function imagePartForAttachment(att: ImageAttachment): PromptPart {
   };
 }
 
-function materializeVideoToCache(att: VideoAttachment): string {
+function materializeVideoToCache(att: VideoAttachment, escapeProofName = false): string {
   const cacheDir = getCacheDir();
   mkdirSync(cacheDir, { recursive: true });
-  const target = join(cacheDir, `${randomUUID()}-${att.label}`);
+  // The label permits XML boundary chars (`<>&"`); plain references go
+  // through skill-arg escaping, where they would no longer match the file
+  // on disk, so strip them from the cache name in that mode.
+  const label = escapeProofName ? att.label.replaceAll(/[<>&"]/g, '_') : att.label;
+  const target = join(cacheDir, `${randomUUID()}-${label}`);
   copyFileSync(att.sourcePath, target);
   return target;
 }
@@ -249,8 +253,9 @@ function formatMediaTag(tag: 'image' | 'video', path: string): string {
 
 /**
  * Plain-text media reference for channels that XML-escape args (`/skill`).
- * Stays free of `& < > "` in practice (UUID image names; sanitized video
- * labels) so it survives `escapeXml`/`escapeXmlTags` untouched.
+ * Free of `& < > "` (UUID image names; boundary chars stripped from video
+ * cache names — see materializeVideoToCache) so it survives
+ * `escapeXml`/`escapeXmlTags` untouched.
  */
 function formatMediaReference(kind: 'image' | 'video', path: string): string {
   return `Attached ${kind} file: ${path} (open it with ReadMediaFile)`;
diff --git a/apps/kimi-code/test/tui/input/image-placeholder.test.ts b/apps/kimi-code/test/tui/input/image-placeholder.test.ts
index e5c81bda40..477727293a 100644
--- a/apps/kimi-code/test/tui/input/image-placeholder.test.ts
+++ b/apps/kimi-code/test/tui/input/image-placeholder.test.ts
@@ -346,4 +346,26 @@ describe('rewriteMediaPlaceholders', () => {
       rmSync(srcDir, { recursive: true, force: true });
     }
   });
+
+  it("sanitizes XML boundary chars out of plain-style video cache names", () => {
+    const { cleanup } = setupTempCache();
+    const srcDir = makeTempDir();
+    try {
+      // The video label keeps the original filename, and sanitizeVideoLabel
+      // allows `<>&"`; skill args are XML-escaped, so the plain reference
+      // would point at a path that no longer matches the file on disk.
+      const srcVideo = join(srcDir, 'clip<1>&.mov');
+      writeFileSync(srcVideo, 'video-bytes');
+      const store = new ImageAttachmentStore();
+      const att = store.addVideo('video/quicktime', srcVideo);
+      const r = rewriteMediaPlaceholders(att.placeholder, store, 'plain');
+      expect(r.text).not.toMatch(/[<>&"]/);
+      const m = /^Attached video file: (\S+) \(open it with ReadMediaFile\)$/.exec(r.text);
+      if (!m) throw new Error(`no plain reference found in: ${r.text}`);
+      expect(readFileSync(m[1]!, 'utf8')).toBe('video-bytes');
+    } finally {
+      cleanup();
+      rmSync(srcDir, { recursive: true, force: true });
+    }
+  });
 });

From 45811f6b3bd805da5b0e9ac3dc4f6153a1c438e1 Mon Sep 17 00:00:00 2001
From: liruifengv <liruifeng1024@gmail.com>
Date: Mon, 13 Jul 2026 15:32:16 +0800
Subject: [PATCH 7/7] fix(tui): surface media materialization failures as TUI
 errors

The cache copy inside media placeholder rewriting can throw (unwritable cache dir, vanished video source) before any RPC .catch is installed, escaping the fire-and-forget slash-command dispatcher as an unhandled rejection. Catch it in sendSkillActivation, activatePluginCommand, and the Ctrl-S draft extraction, show an error, and leave queue/draft/session state untouched.
---
 .../src/tui/controllers/editor-keyboard.ts    |  9 +++-
 apps/kimi-code/src/tui/kimi-tui.ts            | 18 ++++++-
 .../test/tui/kimi-tui-message-flow.test.ts    | 53 +++++++++++++++++++
 3 files changed, 77 insertions(+), 3 deletions(-)

diff --git a/apps/kimi-code/src/tui/controllers/editor-keyboard.ts b/apps/kimi-code/src/tui/controllers/editor-keyboard.ts
index 5575738ec8..5b6d95e195 100644
--- a/apps/kimi-code/src/tui/controllers/editor-keyboard.ts
+++ b/apps/kimi-code/src/tui/controllers/editor-keyboard.ts
@@ -268,7 +268,14 @@ export class EditorKeyboardController {
       }
       let editorExtraction: ReturnType<typeof extractMediaAttachments> | undefined;
       if (!editorIsBash && text.length > 0) {
-        editorExtraction = extractMediaAttachments(text, this.imageStore);
+        try {
+          editorExtraction = extractMediaAttachments(text, this.imageStore);
+        } catch (error) {
+          // Cache copy failed (e.g. the pasted video's source vanished) —
+          // leave the queue and the editor draft untouched.
+          host.showError(`Failed to prepare media attachment: ${formatErrorMessage(error)}`);
+          return;
+        }
         items.push({
           text,
           parts: editorExtraction.hasMedia ? editorExtraction.parts : undefined,
diff --git a/apps/kimi-code/src/tui/kimi-tui.ts b/apps/kimi-code/src/tui/kimi-tui.ts
index 93d246dfed..a05165ca2b 100644
--- a/apps/kimi-code/src/tui/kimi-tui.ts
+++ b/apps/kimi-code/src/tui/kimi-tui.ts
@@ -1294,7 +1294,15 @@ export class KimiTUI {
     // inline parts. Skill args are XML-escaped on render (renderSkillAttributes
     // + expandSkillParameters), so rewrite placeholders into escape-proof
     // plain-text file references the model can open with ReadMediaFile.
-    const rewrite = rewriteMediaPlaceholders(skillArgs, this.imageStore, 'plain');
+    let rewrite: ReturnType<typeof rewriteMediaPlaceholders>;
+    try {
+      rewrite = rewriteMediaPlaceholders(skillArgs, this.imageStore, 'plain');
+    } catch (error) {
+      // Cache copy failed (unwritable cache dir, vanished video source…);
+      // nothing has been dispatched yet, so just report and keep the input.
+      this.showError(`Failed to prepare media attachment: ${formatErrorMessage(error)}`);
+      return;
+    }
     if (!this.validateMediaCapabilities(rewrite)) return;
     this.beginSessionRequest();
     void session.activateSkill(skillName, rewrite.text).catch((error: unknown) => {
@@ -1312,7 +1320,13 @@ export class KimiTUI {
     // Plugin command args are expanded verbatim (no XML escaping), so the
     // standard <image|video path> tag convention works — see
     // sendSkillActivation for the escaped-channel variant.
-    const rewrite = rewriteMediaPlaceholders(args, this.imageStore, 'tag');
+    let rewrite: ReturnType<typeof rewriteMediaPlaceholders>;
+    try {
+      rewrite = rewriteMediaPlaceholders(args, this.imageStore, 'tag');
+    } catch (error) {
+      this.showError(`Failed to prepare media attachment: ${formatErrorMessage(error)}`);
+      return;
+    }
     if (!this.validateMediaCapabilities(rewrite)) return;
     this.beginSessionRequest();
     void session
diff --git a/apps/kimi-code/test/tui/kimi-tui-message-flow.test.ts b/apps/kimi-code/test/tui/kimi-tui-message-flow.test.ts
index 016fb9ab4e..eb4a385707 100644
--- a/apps/kimi-code/test/tui/kimi-tui-message-flow.test.ts
+++ b/apps/kimi-code/test/tui/kimi-tui-message-flow.test.ts
@@ -1895,6 +1895,59 @@ command = "vim"
     ]);
   });
 
+  it('shows an error instead of throwing when skill media materialization fails', async () => {
+    const session = makeSession();
+    const { driver } = await makeDriver(session);
+    const imageStore = (driver as unknown as { imageStore: ImageAttachmentStore }).imageStore;
+    // The pasted video's source file vanished before submit — the cache copy
+    // throws, and it must surface as a TUI error, not an unhandled rejection.
+    const missing = imageStore.addVideo('video/quicktime', '/tmp/kimi-missing-source.mov');
+
+    (
+      driver as unknown as {
+        sendSkillActivation(s: unknown, name: string, args: string): void;
+      }
+    ).sendSkillActivation(session, 'test', `look ${missing.placeholder}`);
+
+    expect(session.activateSkill).not.toHaveBeenCalled();
+    expect(stripSgr(renderTranscript(driver))).toContain('Failed to prepare media attachment');
+  });
+
+  it('shows an error instead of throwing when plugin command media materialization fails', async () => {
+    const activatePluginCommand = vi.fn(async () => {});
+    const session = makeSession({ activatePluginCommand });
+    const { driver } = await makeDriver(session);
+    const imageStore = (driver as unknown as { imageStore: ImageAttachmentStore }).imageStore;
+    const missing = imageStore.addVideo('video/mp4', '/tmp/kimi-missing-source.mp4');
+
+    (
+      driver as unknown as {
+        activatePluginCommand(s: unknown, pluginId: string, command: string, args: string): void;
+      }
+    ).activatePluginCommand(session, 'plug', 'cmd', missing.placeholder);
+
+    expect(activatePluginCommand).not.toHaveBeenCalled();
+    expect(stripSgr(renderTranscript(driver))).toContain('Failed to prepare media attachment');
+  });
+
+  it('keeps the queue and draft intact when steer media extraction fails', async () => {
+    const session = makeSession();
+    const { driver } = await makeDriver(session);
+    driver.state.appState.model = 'k2';
+    driver.state.appState.streamingPhase = 'waiting';
+    const imageStore = (driver as unknown as { imageStore: ImageAttachmentStore }).imageStore;
+    const missing = imageStore.addVideo('video/quicktime', '/tmp/kimi-missing-source.mov');
+    driver.state.queuedMessages = [{ text: 'queued note', agentId: 'main' }];
+    driver.state.editor.setText(`look ${missing.placeholder}`);
+
+    driver.state.editor.onCtrlS?.();
+
+    expect(session.steer).not.toHaveBeenCalled();
+    expect(driver.state.queuedMessages).toEqual([{ text: 'queued note', agentId: 'main' }]);
+    expect(driver.state.editor.getText()).toBe(`look ${missing.placeholder}`);
+    expect(stripSgr(renderTranscript(driver))).toContain('Failed to prepare media attachment');
+  });
+
   it('recalls a queued bash command back into bash mode on Up', async () => {
     const { driver } = await makeDriver();
     driver.state.appState.streamingPhase = 'waiting';