diff --git a/.changeset/new-worktree-mentions.md b/.changeset/new-worktree-mentions.md
new file mode 100644
index 000000000000..e6101887eadc
--- /dev/null
+++ b/.changeset/new-worktree-mentions.md
@@ -0,0 +1,5 @@
+---
+"kilo-code": minor
+---
+
+Add `@model`, `@past-chats`, and `@worktrees` mentions to the Agent Manager New Worktree prompt. Past chats and worktrees are sent as attachments to the new session, and model references stay inline text.
diff --git a/packages/kilo-vscode/tests/unit/agent-manager-worktree-reference.test.ts b/packages/kilo-vscode/tests/unit/agent-manager-worktree-reference.test.ts
index 27aa709ca4f8..3994a81cf75c 100644
--- a/packages/kilo-vscode/tests/unit/agent-manager-worktree-reference.test.ts
+++ b/packages/kilo-vscode/tests/unit/agent-manager-worktree-reference.test.ts
@@ -1,6 +1,10 @@
 import { describe, expect, it } from "bun:test"
 import { createRoot } from "solid-js"
-import { worktreeDropReference, worktreeReferences } from "../../webview-ui/agent-manager/worktree-references"
+import {
+  worktreeDropReference,
+  worktreeReferences,
+  createWorktreeMentionReferences,
+} from "../../webview-ui/agent-manager/worktree-references"
 import { createProjectStore } from "../../webview-ui/agent-manager/project/store"
 import {
   buildMentionResults,
@@ -130,6 +134,27 @@ describe("Agent Manager worktree references", () => {
     scope.dispose()
   })
 
+  it("keeps the selected worktree in the dialog list but leaves stale and busy disabled", () => {
+    const state = createProjectStore("project")
+    state.setWorktrees([tree("current"), tree("stale"), tree("busy"), tree("other")])
+    state.setStaleWorktreeIds(new Set(["stale"]))
+    state.setBusy(new Map([["busy", { reason: "deleting" }]]))
+    let stored: Record<string, unknown> | undefined
+    createRoot((dispose) => {
+      const { dialogRefs } = createWorktreeMentionReferences(
+        { getState: () => stored, setState: (value) => (stored = value) } as never,
+        () => state,
+        () => [],
+        () => "current",
+      )
+      const dialog = dialogRefs()
+      expect(dialog.find((ref) => ref.id === "current")?.disabled).toBe(false)
+      expect(dialog.find((ref) => ref.id === "stale")?.disabled).toBe(true)
+      expect(dialog.find((ref) => ref.id === "busy")?.disabled).toBe(true)
+      dispose()
+    })
+  })
+
   it("keeps project inventories separate even when worktree IDs match", () => {
     const first = createProjectStore("first")
     const second = createProjectStore("second")
diff --git a/packages/kilo-vscode/tests/unit/escape-regexp.test.ts b/packages/kilo-vscode/tests/unit/escape-regexp.test.ts
new file mode 100644
index 000000000000..523e9dd582cb
--- /dev/null
+++ b/packages/kilo-vscode/tests/unit/escape-regexp.test.ts
@@ -0,0 +1,17 @@
+import { describe, expect, it } from "bun:test"
+import { escapeRegExp } from "../../webview-ui/src/utils/escape-regexp"
+
+describe("escapeRegExp", () => {
+  it("escapes regex syntax so the value only matches literally", () => {
+    const value = "a.b(c)+d?[e]\\f^g$h|i{j}"
+    const pattern = new RegExp(`^${escapeRegExp(value)}$`)
+    expect(pattern.test(value)).toBe(true)
+    expect(pattern.test(`${value}x`)).toBe(false)
+    expect(pattern.test(value.slice(0, -1))).toBe(false)
+  })
+
+  it("leaves plain text matchable", () => {
+    expect(new RegExp(`^${escapeRegExp("plain text")}$`).test("plain text")).toBe(true)
+    expect(new RegExp(`^${escapeRegExp("1.2.3")}$`).test("1x2x3")).toBe(false)
+  })
+})
diff --git a/packages/kilo-vscode/tests/unit/file-mention-utils.test.ts b/packages/kilo-vscode/tests/unit/file-mention-utils.test.ts
index 59b7fbd17104..aac2c87b8b11 100644
--- a/packages/kilo-vscode/tests/unit/file-mention-utils.test.ts
+++ b/packages/kilo-vscode/tests/unit/file-mention-utils.test.ts
@@ -12,6 +12,7 @@ import {
   isCursorAtMentionEnd,
   findMentionRange,
   mentionSettled,
+  segmentMentionText,
   sessionMentionFilename,
   sessionMentionText,
   sessionMentionToken,
@@ -921,3 +922,46 @@ describe("modelReferenceToken", () => {
     expect(kept.has(token)).toBe(true)
   })
 })
+
+describe("segmentMentionText", () => {
+  it("marks inserted mention tokens and keeps plain text as-is", () => {
+    const tokens = new Set(["kilo/kilo-auto/free", "Fix auth bug", "/repo/.kilo/worktrees/feature"])
+    const segments = segmentMentionText(
+      "see @Fix auth bug then @/repo/.kilo/worktrees/feature use @kilo/kilo-auto/free",
+      tokens,
+    )
+    expect(segments.map((segment) => [segment.mention, segment.text])).toEqual([
+      [false, "see "],
+      [true, "@Fix auth bug"],
+      [false, " then "],
+      [true, "@/repo/.kilo/worktrees/feature"],
+      [false, " use "],
+      [true, "@kilo/kilo-auto/free"],
+    ])
+  })
+
+  it("keeps multiple spaces and newlines intact", () => {
+    const segments = segmentMentionText("a  b\n @Fix auth bug", new Set(["Fix auth bug"]))
+    expect(segments.map((segment) => segment.text).join("")).toBe("a  b\n @Fix auth bug")
+    expect(segments.filter((segment) => segment.mention).map((segment) => segment.text)).toEqual(["@Fix auth bug"])
+  })
+
+  it("matches the longest token first", () => {
+    const segments = segmentMentionText("@Fix auth bug", new Set(["Fix", "Fix auth bug"]))
+    expect(segments.filter((segment) => segment.mention).map((segment) => segment.text)).toEqual(["@Fix auth bug"])
+  })
+
+  it("matches tokens that contain regex metacharacters literally", () => {
+    const tokens = new Set(["pkg.name(v2)+beta", "C:\\repo\\wt"])
+    const segments = segmentMentionText("@pkg.name(v2)+beta and @C:\\repo\\wt", tokens)
+    expect(segments.filter((segment) => segment.mention).map((segment) => segment.text)).toEqual([
+      "@pkg.name(v2)+beta",
+      "@C:\\repo\\wt",
+    ])
+  })
+
+  it("returns one plain segment when there are no tokens or no text", () => {
+    expect(segmentMentionText("plain", new Set())).toEqual([{ text: "plain", mention: false }])
+    expect(segmentMentionText("", new Set(["model"]))).toEqual([])
+  })
+})
diff --git a/packages/kilo-vscode/tests/unit/worktree-mention.test.ts b/packages/kilo-vscode/tests/unit/worktree-mention.test.ts
new file mode 100644
index 000000000000..fbd101a95e0f
--- /dev/null
+++ b/packages/kilo-vscode/tests/unit/worktree-mention.test.ts
@@ -0,0 +1,236 @@
+import { describe, expect, it } from "bun:test"
+import { createRoot } from "solid-js"
+import {
+  buildWorktreeMentionFiles,
+  buildWorktreeMentionResults,
+  useWorktreeMention,
+  WORKTREE_MENTION_ENTRIES,
+  type WorktreeMention,
+} from "../../webview-ui/agent-manager/worktree-mention"
+import type { WorktreeReference } from "../../webview-ui/src/hooks/file-mention-utils"
+import type { ExtensionMessage, SessionSearchItem, WebviewMessage } from "../../webview-ui/src/types/messages"
+
+const CHAT: SessionSearchItem = { id: "ses_chat", title: "Fix auth bug", updated: 10 }
+const WORKTREE: WorktreeReference = {
+  id: "wt-other",
+  name: "other-worktree",
+  branch: "other-branch",
+  path: "/repo/.kilo/worktrees/other",
+  base: "main",
+  sessions: [{ id: "ses_chat", title: "Fix auth bug" }],
+  disabled: false,
+}
+
+/** Textarea stub whose value and selection mutate like a real prompt box. */
+function area(initial: string, cursor = initial.length) {
+  const state = { value: initial, start: cursor, end: cursor }
+  return {
+    get value() {
+      return state.value
+    },
+    set value(value: string) {
+      state.value = value
+    },
+    get selectionStart() {
+      return state.start
+    },
+    get selectionEnd() {
+      return state.end
+    },
+    isConnected: true,
+    focus: () => {},
+    setSelectionRange: (start: number, end = start) => {
+      state.start = start
+      state.end = end
+    },
+  } as unknown as HTMLTextAreaElement
+}
+
+function harness(worktrees: WorktreeReference[] = [WORKTREE]) {
+  const posted: WebviewMessage[] = []
+  const handlers = new Set<(message: ExtensionMessage) => void>()
+  const ctx = {
+    postMessage: (message: WebviewMessage) => posted.push(message),
+    onMessage: (handler: (message: ExtensionMessage) => void) => {
+      handlers.add(handler)
+      return () => handlers.delete(handler)
+    },
+  }
+  const dispose: { fn?: () => void } = {}
+  const mention = createRoot((root) => {
+    dispose.fn = root
+    return useWorktreeMention(ctx, () => worktrees)
+  })
+  const sessions = (list: SessionSearchItem[]) => {
+    for (const handler of handlers) {
+      handler({ type: "sessionSearchResult", sessions: list, requestId: "worktree-mention-session-1" })
+    }
+  }
+  return { mention, posted, sessions, dispose }
+}
+
+function pick(mention: WorktreeMention, type: string) {
+  return mention.mentionResults().find((item) => item.type === type)
+}
+
+describe("buildWorktreeMentionResults", () => {
+  it("lists only the three worktree-independent entries for a bare @", () => {
+    expect(WORKTREE_MENTION_ENTRIES.map((entry) => entry.type)).toEqual(["model", "past-chats", "worktrees"])
+    expect(buildWorktreeMentionResults("").map((entry) => entry.type)).toEqual(["model", "past-chats", "worktrees"])
+  })
+
+  it("never offers file, folder, terminal or git changes", () => {
+    const types = buildWorktreeMentionResults("src").map((entry) => entry.type)
+    expect(types).not.toContain("file")
+    expect(types).not.toContain("folder")
+    expect(types).not.toContain("terminal")
+    expect(types).not.toContain("git-changes")
+  })
+
+  it("ranks a matching past chat next to the built-in entries", () => {
+    const session = { type: "session", value: CHAT.title, session: CHAT } as const
+    const results = buildWorktreeMentionResults("Fix", [session])
+    expect(results.some((entry) => entry.type === "session")).toBe(true)
+  })
+})
+
+describe("buildWorktreeMentionFiles", () => {
+  it("builds a session: attachment for a mentioned past chat", () => {
+    const files = buildWorktreeMentionFiles("@Fix auth bug ", new Map([[CHAT.title, CHAT]]), [])
+    expect(files).toHaveLength(1)
+    expect(files[0]!.url).toBe("session:ses_chat")
+    expect(files[0]!.source?.text.value).toBe("@Fix auth bug")
+  })
+
+  it("builds a data: metadata attachment for a mentioned worktree", () => {
+    const files = buildWorktreeMentionFiles(`@${WORKTREE.path}`, new Map(), [WORKTREE])
+    expect(files).toHaveLength(1)
+    expect(files[0]!.url.startsWith("data:text/plain")).toBe(true)
+    expect(files[0]!.source?.path).toBe(WORKTREE.path)
+  })
+
+  it("produces no attachment for a model reference or unmatched text", () => {
+    expect(buildWorktreeMentionFiles("@provider/model", new Map(), [WORKTREE])).toEqual([])
+    expect(buildWorktreeMentionFiles("plain prompt", new Map([[CHAT.title, CHAT]]), [WORKTREE])).toEqual([])
+  })
+})
+
+describe("useWorktreeMention", () => {
+  it("opens on a bare @ with the three entries and requests past chats once", () => {
+    const { mention, posted, dispose } = harness()
+    mention.onInput("@", 1)
+    expect(mention.showMention()).toBe(true)
+    expect(mention.mentionResults().map((entry) => entry.type)).toEqual(["model", "past-chats", "worktrees"])
+    expect(posted.filter((message) => message.type === "requestSessionSearch")).toHaveLength(1)
+
+    mention.onInput("@m", 2)
+    expect(posted.filter((message) => message.type === "requestSessionSearch")).toHaveLength(1)
+    dispose.fn?.()
+  })
+
+  it("inserts a past chat as @title and attaches its session id", () => {
+    const { mention, sessions, dispose } = harness()
+    const input = area("@Fix", 4)
+    mention.onInput("@Fix", 4)
+    sessions([CHAT])
+
+    const result = pick(mention, "session")
+    expect(result).toBeDefined()
+    mention.selectMention(result!, input, () => {})
+
+    expect(input.value).toBe("@Fix auth bug ")
+    expect(mention.mentionedSessions().get("Fix auth bug")?.id).toBe("ses_chat")
+    expect(mention.highlightTokens().has("Fix auth bug")).toBe(true)
+    expect(mention.parseAttachments(input.value).map((file) => file.url)).toEqual(["session:ses_chat"])
+    dispose.fn?.()
+  })
+
+  it("inserts a worktree path and attaches metadata only", () => {
+    const { mention, dispose } = harness()
+    const input = area("@", 1)
+    mention.onInput("@", 1)
+    mention.selectWorktree(WORKTREE, input, () => {})
+
+    expect(input.value).toBe(`@${WORKTREE.path} `)
+    expect(mention.highlightTokens().has(WORKTREE.path)).toBe(true)
+    const files = mention.parseAttachments(input.value)
+    expect(files).toHaveLength(1)
+    expect(files[0]!.url.startsWith("data:text/plain")).toBe(true)
+    dispose.fn?.()
+  })
+
+  it("excludes disabled worktrees from the picker and from selection", () => {
+    const stale: WorktreeReference = {
+      ...WORKTREE,
+      id: "wt-stale",
+      name: "stale",
+      path: "/repo/.kilo/worktrees/stale",
+      disabled: true,
+    }
+    const { mention, dispose } = harness([WORKTREE, stale])
+    mention.onInput("@", 1)
+    mention.selectMention(pick(mention, "worktrees")!, area("@", 1), () => {})
+    expect(mention.worktreeCandidates().map((worktree) => worktree.id)).toEqual(["wt-other"])
+
+    const input = area("@", 1)
+    mention.selectWorktree(stale, input, () => {})
+    expect(input.value).toBe("@")
+    dispose.fn?.()
+  })
+
+  it("inserts a model token as plain text with no attachment", () => {
+    const { mention, dispose } = harness()
+    const input = area("@", 1)
+    mention.onInput("@", 1)
+    const model = pick(mention, "model")!
+    mention.selectMention(model, input, () => {})
+    expect(mention.modelPicker()).toBe(true)
+
+    mention.selectModelReference("provider", "model-x")
+    expect(input.value).toBe("@provider/model-x ")
+    expect(mention.highlightTokens().has("provider/model-x")).toBe(true)
+    expect(mention.parseAttachments(input.value)).toEqual([])
+    dispose.fn?.()
+  })
+
+  it("closes the menu once prose follows a completed mention", () => {
+    const { mention, sessions, dispose } = harness()
+    const input = area("@Fix", 4)
+    mention.onInput("@Fix", 4)
+    sessions([CHAT])
+    mention.selectMention(pick(mention, "session")!, input, () => {})
+
+    mention.onInput("@Fix auth bug and then", 21)
+    expect(mention.showMention()).toBe(false)
+    dispose.fn?.()
+  })
+
+  it("closes the past-chat picker when the prompt text changes", () => {
+    const { mention, dispose } = harness()
+    const input = area("@", 1)
+    mention.onInput("@", 1)
+    mention.selectMention(pick(mention, "past-chats")!, input, () => {})
+    expect(mention.sessionPicker()).toBe(true)
+
+    mention.onInput("@q", 2)
+    expect(mention.sessionPicker()).toBe(false)
+    dispose.fn?.()
+  })
+
+  it("keeps the menu closed after Escape until the query is edited", () => {
+    const { mention, dispose } = harness()
+    const event = {
+      key: "Escape",
+      preventDefault: () => {},
+      stopPropagation: () => {},
+      isComposing: false,
+    } as unknown as KeyboardEvent
+
+    mention.onInput("@Fix", 4)
+    expect(mention.onKeyDown(event, area("@Fix", 4), () => {})).toBe(true)
+    expect(mention.showMention()).toBe(false)
+    mention.onInput("@Fix", 4)
+    expect(mention.showMention()).toBe(false)
+    dispose.fn?.()
+  })
+})
diff --git a/packages/kilo-vscode/webview-ui/agent-manager/AgentManagerApp.tsx b/packages/kilo-vscode/webview-ui/agent-manager/AgentManagerApp.tsx
index b83697542b42..3194cad5496f 100644
--- a/packages/kilo-vscode/webview-ui/agent-manager/AgentManagerApp.tsx
+++ b/packages/kilo-vscode/webview-ui/agent-manager/AgentManagerApp.tsx
@@ -186,7 +186,7 @@ import { createRevertFile } from "./revert-file"
 import { FullScreenDiffView } from "../diff-viewer/FullScreenDiffView"
 import { createApplyToLocal } from "./apply-to-local"
 import { createWorktreeDiffs, diffDataKey, wireDiffId } from "./worktree-diffs"
-import { createWorktreeReferences } from "./worktree-references"
+import { createWorktreeMentionReferences as createMentionRefs } from "./worktree-references"
 import type { ReviewComment } from "../diff-viewer/review-comments"
 import { createReviewComposers } from "./review-composers"
 import type { SidebarSearchMenuRef } from "./SidebarSearchMenu"
@@ -831,7 +831,7 @@ const AgentManagerContent: Component = () => {
     managed: managedSessions,
     locals: localSet,
   })
-  const references = createWorktreeReferences(vscode, registry.active, projectSessionsLive.current, selection)
+  const { references, dialogRefs } = createMentionRefs(vscode, registry.active, projectSessionsLive.current, selection)
 
   /** Session ids shown in the project-scoped history view (every session of the project). */
   const historySessionIds = createMemo(() => {
@@ -1812,6 +1812,7 @@ const AgentManagerContent: Component = () => {
         activeProjectId={activeProjectId()}
         defaultBase={defaultBase}
         onCreate={creation.schedule}
+        worktrees={dialogRefs}
       />
     ))
   }
diff --git a/packages/kilo-vscode/webview-ui/agent-manager/NewWorktreeDialog.tsx b/packages/kilo-vscode/webview-ui/agent-manager/NewWorktreeDialog.tsx
index 043fedf6a598..96c043c932bf 100644
--- a/packages/kilo-vscode/webview-ui/agent-manager/NewWorktreeDialog.tsx
+++ b/packages/kilo-vscode/webview-ui/agent-manager/NewWorktreeDialog.tsx
@@ -48,6 +48,12 @@ import { insertSpacedText, undoKey } from "../src/components/chat/prompt-input-u
 import { GoalHeader } from "../src/components/chat/goal/GoalHeader"
 import { isEnterKeyCommitNotIme } from "../src/utils/ime-enter"
 import { useSlashCommand } from "../src/hooks/useSlashCommand"
+import type { MentionResult, WorktreeReference } from "../src/hooks/file-mention-utils"
+import { segmentMentionText } from "../src/hooks/file-mention-utils"
+import { SessionMentionPicker } from "../src/components/chat/SessionMentionPicker"
+import { WorktreeMentionPicker } from "../src/components/chat/WorktreeMentionPicker"
+import { formatRelativeDate } from "../src/utils/date"
+import { useWorktreeMention } from "./worktree-mention"
 import { BranchSelect, BranchSelectPopover } from "../src/components/shared/BranchSelect"
 import { tracker } from "./telemetry"
 import { cycleAgent } from "../src/context/session-agent"
@@ -66,6 +72,10 @@ const VERSION_OPTIONS: VersionCount[] = [1, 2, 3, 4]
 const WORKTREE_PROMPT_COMMANDS = new Set(["models", "agents", "variant", "sandbox", "project"])
 const WORKTREE_PROMPT_HIDDEN = ["init", "review", "resume-claude", "resume-codex"]
 const WORKTREE_PROMPT_SCOPE = "agent-manager-worktree-prompt"
+// The `@model` entry opens the shared model selector through its programmatic
+// open event, keyed to this prompt scope so the footer model selector and slash
+// commands are unaffected.
+const WORKTREE_MENTION_MODEL_TRIGGER = "agent-manager-worktree-mention-model"
 
 type DialogTab = "new" | "import"
 type Model = { providerID: string; modelID: string }
@@ -102,6 +112,50 @@ function restoreAgent(value: string | undefined, list: Array<{ name: string }>,
 
 const isMac = typeof navigator !== "undefined" && /Mac|iPhone|iPad/.test(navigator.userAgent)
 
+/**
+ * One row of the dialog's `@` menu. Only the three worktree-independent
+ * references plus past-chat matches can appear here.
+ */
+function MentionRow(props: { item: MentionResult }) {
+  const { t } = useLanguage()
+  const item = props.item
+  if (item.type === "model")
+    return (
+      <>
+        <Icon name="models" class="file-mention-icon" />
+        <span class="file-mention-name">{item.label}</span>
+        <span class="file-mention-dir">{item.description}</span>
+      </>
+    )
+  if (item.type === "past-chats")
+    return (
+      <>
+        <Icon name="history" class="file-mention-icon" />
+        <span class="file-mention-name">{item.label}</span>
+        <span class="file-mention-dir">{item.description}</span>
+      </>
+    )
+  if (item.type === "worktrees")
+    return (
+      <>
+        <Icon name="branch" class="file-mention-icon" />
+        <span class="file-mention-name">{t("prompt.worktrees.title")}</span>
+        <span class="file-mention-dir">{t("prompt.worktrees.search")}</span>
+      </>
+    )
+  if (item.type === "session")
+    return (
+      <>
+        <Icon name="history" class="file-mention-icon" />
+        <span class="file-mention-name">{item.session.title}</span>
+        <span class="file-mention-dir">
+          {item.session.worktreeName ?? formatRelativeDate(new Date(item.session.updated).toISOString())}
+        </span>
+      </>
+    )
+  return null
+}
+
 export const NewWorktreeDialog: Component<{
   onClose: () => void
   defaultBase?: (projectId: string) => string | undefined
@@ -109,6 +163,7 @@ export const NewWorktreeDialog: Component<{
   projects?: () => AgentProjectSnapshot[]
   activeProjectId?: string
   onCreate?: (projectId: string) => void
+  worktrees?: () => WorktreeReference[]
   mode: ModeRouter
 }> = (props) => {
   const { t } = useLanguage()
@@ -326,6 +381,23 @@ export const NewWorktreeDialog: Component<{
   window.addEventListener("focusPrompt", onFocusPrompt)
   onCleanup(() => window.removeEventListener("focusPrompt", onFocusPrompt))
 
+  const mention = useWorktreeMention(vscode, () => props.worktrees?.() ?? [])
+  let highlightRef: HTMLDivElement | undefined
+  const mentionSegments = createMemo(() => segmentMentionText(prompt(), mention.highlightTokens()))
+  const syncHighlight = () => {
+    if (!highlightRef || !textareaRef) return
+    highlightRef.scrollTop = textareaRef.scrollTop
+    highlightRef.scrollLeft = textareaRef.scrollLeft
+  }
+  // Picking the `@` model entry opens the shared model selector, mounted hidden
+  // and keyed to its own trigger. The mention latch resets first because the
+  // selector owns its open state afterwards.
+  createEffect(() => {
+    if (!mention.modelPicker()) return
+    mention.closeMention()
+    window.dispatchEvent(new CustomEvent("openModelPicker", { detail: { source: WORKTREE_MENTION_MODEL_TRIGGER } }))
+  })
+
   onMount(() => {
     // Server commands must be known before submit so a pasted `/command`
     // prompt can be routed through the command path, not only via the menu.
@@ -378,6 +450,18 @@ export const NewWorktreeDialog: Component<{
   const total = () => (compareMode() ? totalAllocations(modelAllocations()) : versions())
   const mode = () => (compareMode() ? "compare_models" : versions() > 1 ? "multiple_versions" : "single")
 
+  /**
+   * Attachments for the new sessions. Mentions are resolved here, at creation
+   * time: the new worktree does not exist yet, so nothing is read from it. Past
+   * chats and worktrees travel as attachments; model references stay inline.
+   */
+  const resolveFiles = (text: string | undefined) => {
+    const mentionFiles = text ? mention.parseAttachments(text) : []
+    const imgFiles = imageAttach.images().map((img) => ({ mime: img.mime, url: img.dataUrl }))
+    const files = [...mentionFiles, ...imgFiles]
+    return files.length > 0 ? files : undefined
+  }
+
   const handleSubmit = () => {
     if (!canSubmit()) return
     const advanced = showAdvanced()
@@ -405,8 +489,6 @@ export const NewWorktreeDialog: Component<{
     const payload = submitPayload(goalMode(), draft, slash.commands())
     const defaultAgent = session.agents()[0]?.name
     const selectedAgent = agent() !== defaultAgent ? agent() : undefined
-    const imgs = imageAttach.images()
-    const imgFiles = imgs.length > 0 ? imgs.map((img) => ({ mime: img.mime, url: img.dataUrl })) : undefined
 
     const isCompare = compareMode()
     const allocations = isCompare ? allocationsToArray(modelAllocations()) : undefined
@@ -431,7 +513,7 @@ export const NewWorktreeDialog: Component<{
       branchName: customBranch,
       modelAllocations: allocations,
       sandbox: sandboxVisible() ? sandboxOverride() : undefined,
-      files: imgFiles,
+      files: resolveFiles(payload.text),
     })
 
     persistPrompt("")
@@ -477,6 +559,11 @@ export const NewWorktreeDialog: Component<{
       return
     }
 
+    if (mention.onKeyDown(e, textareaRef, setPromptValue, restorePrompt)) {
+      e.stopPropagation()
+      return
+    }
+
     // The chat composer submits on Enter, so mirror that for the two-step goal
     // flow. Use the shared IME guard so confirming a composition does not submit.
     // Plain prompts keep Enter as a newline and still create with Cmd/Ctrl+Enter.
@@ -514,6 +601,7 @@ export const NewWorktreeDialog: Component<{
     box.style.height = "auto"
     const chrome = box.offsetHeight - area.offsetHeight
     box.style.height = `${Math.min(area.scrollHeight, 200) + chrome}px`
+    syncHighlight()
   }
 
   const insertSpeechText = (value: string) => {
@@ -743,6 +831,80 @@ export const NewWorktreeDialog: Component<{
               onDragLeave={imageAttach.handleDragLeave}
               onDrop={imageAttach.handleDrop}
             >
+              <div class="mention-model-anchor" aria-hidden="true">
+                <ModelSelectorBase
+                  value={null}
+                  trigger={WORKTREE_MENTION_MODEL_TRIGGER}
+                  collapsed
+                  placement="top-start"
+                  portal={false}
+                  deferDismiss
+                  onSelect={(providerID, modelID) => {
+                    if (providerID && modelID) mention.selectModelReference(providerID, modelID)
+                  }}
+                  onCancel={() => {
+                    mention.closeMention()
+                    restorePrompt()
+                  }}
+                />
+              </div>
+              <Show when={mention.showMention()}>
+                <div class="file-mention-dropdown am-mention-dropdown" data-component="popover-content">
+                  <Show
+                    when={!mention.sessionPicker()}
+                    fallback={
+                      <SessionMentionPicker
+                        sessions={mention.sessionCandidates()}
+                        onSelect={(picked) => {
+                          if (textareaRef) mention.selectSession(picked, textareaRef, setPromptValue, restorePrompt)
+                        }}
+                        onClose={() => {
+                          mention.closeMention()
+                          restorePrompt()
+                        }}
+                      />
+                    }
+                  >
+                    <Show
+                      when={!mention.worktreePicker()}
+                      fallback={
+                        <WorktreeMentionPicker
+                          worktrees={mention.worktreeCandidates()}
+                          onSelect={(picked) => {
+                            if (textareaRef) mention.selectWorktree(picked, textareaRef, setPromptValue, restorePrompt)
+                          }}
+                          onClose={() => {
+                            mention.closeMention()
+                            restorePrompt()
+                          }}
+                        />
+                      }
+                    >
+                      <Show
+                        when={mention.mentionResults().length > 0}
+                        fallback={<div class="file-mention-empty">No mentions found</div>}
+                      >
+                        <For each={mention.mentionResults()}>
+                          {(item, index) => (
+                            <div
+                              class="file-mention-item"
+                              data-type={item.type}
+                              classList={{ "file-mention-item--active": index() === mention.mentionIndex() }}
+                              onMouseDown={(e) => {
+                                e.preventDefault()
+                                if (textareaRef) mention.selectMention(item, textareaRef, setPromptValue, restorePrompt)
+                              }}
+                              onMouseEnter={() => mention.setMentionIndex(index())}
+                            >
+                              <MentionRow item={item} />
+                            </div>
+                          )}
+                        </For>
+                      </Show>
+                    </Show>
+                  </Show>
+                </div>
+              </Show>
               <Show when={goalMode()}>
                 <GoalHeader onCancel={() => setGoalMode(false)} />
               </Show>
@@ -801,6 +963,18 @@ export const NewWorktreeDialog: Component<{
               </Show>
               <div class="prompt-input-wrapper am-prompt-input-wrapper">
                 <div class="prompt-input-ghost-wrapper am-prompt-input-ghost-wrapper">
+                  <div class="prompt-input-highlight-overlay" ref={highlightRef} aria-hidden="true" dir="auto">
+                    <For each={mentionSegments()}>
+                      {(seg) => (
+                        <Show when={seg.mention} fallback={<span>{seg.text}</span>}>
+                          <span class="prompt-input-file-mention">{seg.text}</span>
+                        </Show>
+                      )}
+                    </For>
+                    <Show when={prompt().endsWith("\n")}>
+                      <br />
+                    </Show>
+                  </div>
                   <textarea
                     ref={textareaRef}
                     class="prompt-input am-prompt-input"
@@ -818,10 +992,12 @@ export const NewWorktreeDialog: Component<{
                       adjustHeight()
                       if (goalMode()) slash.close()
                       else slash.onInput(val, e.currentTarget.selectionStart ?? val.length)
+                      mention.onInput(val, e.currentTarget.selectionStart ?? val.length)
                     }}
                     onKeyDown={onKey}
                     onKeyUp={speechUp}
                     onPaste={(e) => imageAttach.handlePaste(e)}
+                    onScroll={syncHighlight}
                     rows={3}
                     dir="auto"
                   />
diff --git a/packages/kilo-vscode/webview-ui/agent-manager/agent-manager.css b/packages/kilo-vscode/webview-ui/agent-manager/agent-manager.css
index 8ddb8b927f53..6efeb1da0e67 100644
--- a/packages/kilo-vscode/webview-ui/agent-manager/agent-manager.css
+++ b/packages/kilo-vscode/webview-ui/agent-manager/agent-manager.css
@@ -3364,6 +3364,11 @@ body.am-wt-dragging-active * {
   max-width: none;
 }
 
+.am-mention-dropdown {
+  min-width: 0;
+  max-width: none;
+}
+
 .am-nv-dialog .am-prompt-input-ghost-wrapper {
   height: 100%;
 }
@@ -3373,7 +3378,10 @@ body.am-wt-dragging-active * {
 }
 
 .am-nv-dialog .am-prompt-input {
-  color: var(--vscode-input-foreground, var(--text-base));
+  /* The highlight overlay paints the text, so the textarea stays transparent
+     and only its caret shows. Placeholder keeps its own color. */
+  color: transparent;
+  caret-color: var(--vscode-input-foreground, var(--text-base));
   resize: none;
   width: 100%;
   height: 100%;
diff --git a/packages/kilo-vscode/webview-ui/agent-manager/worktree-mention.ts b/packages/kilo-vscode/webview-ui/agent-manager/worktree-mention.ts
new file mode 100644
index 000000000000..7161467fb1fa
--- /dev/null
+++ b/packages/kilo-vscode/webview-ui/agent-manager/worktree-mention.ts
@@ -0,0 +1,418 @@
+import { createSignal, onCleanup, type Accessor } from "solid-js"
+import type { ExtensionMessage, FileAttachment, SessionSearchItem, WebviewMessage } from "../src/types/messages"
+import {
+  AT_PATTERN,
+  MODEL_RESULT,
+  PAST_CHATS_RESULT,
+  WORKTREES_RESULT,
+  buildSessionAttachments,
+  buildWorktreeAttachments,
+  filterSessions,
+  mentionSettled,
+  rankMentionResults,
+  sessionMentionText,
+  sessionMentionToken,
+  type MentionResult,
+  type WorktreeReference,
+} from "../src/hooks/file-mention-utils"
+
+/** Past chats offered inline, bounded so sessions cannot flood the menu. */
+const SESSION_RESULT_LIMIT = 3
+
+interface VSCodeContext {
+  postMessage: (message: WebviewMessage) => void
+  onMessage: (handler: (message: ExtensionMessage) => void) => () => void
+}
+
+/**
+ * The three entries the New Worktree dialog can mention. @file and friends are
+ * deliberately absent: the worktree does not exist yet when the dialog runs, so
+ * resolving file paths against it would be unsafe.
+ */
+export const WORKTREE_MENTION_ENTRIES: MentionResult[] = [MODEL_RESULT, PAST_CHATS_RESULT, WORKTREES_RESULT]
+
+/**
+ * Rank the dialog's mentions for a query. A bare `@` lists the three entries in
+ * order; a query ranks those entries together with any matching past chats, so
+ * the best answer comes first whatever kind of reference it is.
+ */
+export function buildWorktreeMentionResults(query: string, sessions: MentionResult[] = []): MentionResult[] {
+  if (!query) return [...WORKTREE_MENTION_ENTRIES]
+  return rankMentionResults(query, [...WORKTREE_MENTION_ENTRIES, ...sessions])
+}
+
+/**
+ * Build the mention attachments for a prompt. Sessions travel as `session:`
+ * URLs the backend resolves into transcript context; worktrees travel as
+ * metadata-only data URLs. Model references are inline text and never produce
+ * an attachment, so they stay out of this list.
+ */
+export function buildWorktreeMentionFiles(
+  text: string,
+  sessions: Map<string, SessionSearchItem>,
+  worktrees: WorktreeReference[],
+): FileAttachment[] {
+  return [...buildSessionAttachments(text, sessions), ...buildWorktreeAttachments(text, worktrees)]
+}
+
+export interface WorktreeMention {
+  /** Mentioned past chats, keyed by their `@title` token in the text. */
+  mentionedSessions: Accessor<Map<string, SessionSearchItem>>
+  sessionPicker: Accessor<boolean>
+  sessionCandidates: Accessor<SessionSearchItem[]>
+  modelPicker: Accessor<boolean>
+  worktreePicker: Accessor<boolean>
+  worktreeCandidates: Accessor<WorktreeReference[]>
+  mentionResults: Accessor<MentionResult[]>
+  mentionIndex: Accessor<number>
+  showMention: Accessor<boolean>
+  /** Tokens already inserted in the text, for the prompt highlight overlay. */
+  highlightTokens: Accessor<Set<string>>
+  onInput: (text: string, cursor: number) => void
+  onKeyDown: (
+    e: KeyboardEvent,
+    textarea: HTMLTextAreaElement | undefined,
+    setText: (text: string) => void,
+    onSelect?: () => void,
+  ) => boolean
+  selectMention: (
+    result: MentionResult,
+    textarea: HTMLTextAreaElement,
+    setText: (text: string) => void,
+    onSelect?: () => void,
+  ) => void
+  selectSession: (
+    session: SessionSearchItem,
+    textarea: HTMLTextAreaElement,
+    setText: (text: string) => void,
+    onSelect?: () => void,
+  ) => void
+  selectWorktree: (
+    worktree: WorktreeReference,
+    textarea: HTMLTextAreaElement,
+    setText: (text: string) => void,
+    onSelect?: () => void,
+  ) => void
+  selectModelReference: (providerID: string, modelID: string) => void
+  setMentionIndex: (index: number) => void
+  closeMention: () => void
+  /** Attachments for the prompt text the user is about to send. */
+  parseAttachments: (text: string) => FileAttachment[]
+}
+
+/**
+ * `@`-mention state for the New Worktree dialog. Worktree-independent by
+ * design: it offers inline model references, past chats and Agent Manager
+ * worktrees, and builds only attachments that are safe before the new worktree
+ * exists. The shared file/terminal/git entries are intentionally not offered.
+ */
+export function useWorktreeMention(vscode: VSCodeContext, worktrees: Accessor<WorktreeReference[]>): WorktreeMention {
+  const [query, setQuery] = createSignal<string | null>(null)
+  const [results, setResults] = createSignal<MentionResult[]>([])
+  const [index, setIndex] = createSignal(0)
+  const [candidates, setCandidates] = createSignal<SessionSearchItem[]>([])
+  const [sessionPicker, setSessionPicker] = createSignal(false)
+  const [worktreePicker, setWorktreePicker] = createSignal(false)
+  const [modelPicker, setModelPicker] = createSignal(false)
+  const [mentioned, setMentioned] = createSignal<Map<string, SessionSearchItem>>(new Map())
+  // Model references are inline text, not files, so they are tracked apart and
+  // never become attachments. They still count as completed mentions, so prose
+  // typed after one closes the dropdown instead of reopening it.
+  const models = new Set<string>()
+  // The `@` offset the open query belongs to, and the dead query at that offset
+  // that a dismissal or a completed mention closed on.
+  let at = 0
+  let dead: { at: number; query: string } | undefined
+  // Set by onInput so replaceRange can tell whether execCommand produced the
+  // input event that syncs the prompt signal.
+  let sawInput = false
+  let requested = false
+  let ready = false
+  let counter = 0
+  let modelState: {
+    textarea: HTMLTextAreaElement
+    start: number
+    end: number
+    setText: (text: string) => void
+    onSelect?: () => void
+  } | null = null
+
+  // Stale and busy worktrees stay out of the picker, like chat. The dialog
+  // receives a reference list built without a selection, so the worktree the
+  // user is currently in is still offered (see AgentManagerApp's dialog list).
+  const worktreeCandidates = () => worktrees().filter((worktree) => !worktree.disabled)
+  const showMention = () => query() !== null
+
+  /** Every token the query could stand for, for prose detection. */
+  const tokens = () =>
+    new Set<string>([...mentioned().keys(), ...models, ...worktreeCandidates().map((worktree) => worktree.path)])
+
+  const sessionResults = (value: string): MentionResult[] => {
+    if (!value) return []
+    return filterSessions(candidates(), value)
+      .slice(0, SESSION_RESULT_LIMIT)
+      .map((session) => ({ type: "session", value: sessionMentionToken(session, mentioned()), session }))
+  }
+
+  const close = () => {
+    setQuery(null)
+    setResults([])
+    setIndex(0)
+    setSessionPicker(false)
+    setWorktreePicker(false)
+    setModelPicker(false)
+  }
+
+  // The past-chat list is directory-scoped server-side; one fetch per dialog is
+  // enough, since a session title is what a spaced query is matched against.
+  const loadSessions = () => {
+    if (requested) return
+    requested = true
+    vscode.postMessage({ type: "requestSessionSearch", requestId: `worktree-mention-session-${++counter}` })
+  }
+
+  const unsubscribe = vscode.onMessage((message) => {
+    if (message.type !== "sessionSearchResult") return
+    if (message.requestId !== `worktree-mention-session-${counter}`) return
+    ready = true
+    setCandidates(
+      message.sessions
+        .map((session) => ({ ...session, title: sessionMentionText(session.title) }))
+        .filter((session) => session.title)
+        .sort((a, b) => b.updated - a.updated),
+    )
+    const open = query()
+    if (open === null) return
+    const next = buildWorktreeMentionResults(open, sessionResults(open))
+    if (next.length === 0) {
+      close()
+      return
+    }
+    setResults(next)
+  })
+  onCleanup(unsubscribe)
+
+  const onInput = (text: string, cursor: number) => {
+    sawInput = true
+    setSessionPicker(false)
+    setWorktreePicker(false)
+    setModelPicker(false)
+    const before = text.substring(0, cursor)
+    const match = before.match(AT_PATTERN)
+    if (!match) {
+      dead = undefined
+      close()
+      return
+    }
+    at = (match.index ?? 0) + (/^\s/.test(match[0]) ? 1 : 0)
+    const value = match[1] ?? ""
+    if (dead && dead.at === at && value.startsWith(dead.query)) {
+      close()
+      return
+    }
+    // Prose past a completed mention is not a longer query: close on it and
+    // remember the dead query so the next keystroke does not reopen the menu.
+    if (mentionSettled(value, tokens())) {
+      dead = { at, query: value }
+      close()
+      return
+    }
+    dead = undefined
+    loadSessions()
+    const next = buildWorktreeMentionResults(value, sessionResults(value))
+    if (next.length === 0) {
+      // Past chats are the only non-entry match a query can have. Until their
+      // list has arrived, a query that matches nothing yet may still match a
+      // chat title, so the menu waits instead of closing.
+      if (!ready) {
+        setQuery(value)
+        setResults([])
+        setIndex(0)
+        return
+      }
+      close()
+      return
+    }
+    setQuery(value)
+    setResults(next)
+    setIndex(0)
+  }
+
+  /**
+   * Replace a text range with mention text. The dialog's undo uses the native
+   * undo stack, so insert through execCommand when a live textarea is present
+   * (same as the chat composer) and fall back to a direct assignment where no
+   * DOM is available.
+   */
+  const replaceRange = (
+    textarea: HTMLTextAreaElement,
+    start: number,
+    end: number,
+    inserted: string,
+    setText: (text: string) => void,
+  ) => {
+    const pos = start + inserted.length
+    const canExec =
+      typeof document !== "undefined" && typeof document.execCommand === "function" && textarea.isConnected
+    if (canExec) {
+      const snapshot = textarea.value
+      textarea.focus()
+      textarea.setSelectionRange(start, end)
+      // execCommand can silently no-op (for example when focus did not land)
+      // and some edges skip the input event. Verify the insert and fall back to
+      // a direct write so a picked mention is never dropped.
+      sawInput = false
+      document.execCommand("insertText", false, inserted)
+      if (sawInput && textarea.value !== snapshot) {
+        textarea.setSelectionRange(pos, pos)
+        return
+      }
+      textarea.value = `${snapshot.substring(0, start)}${inserted}${snapshot.substring(end)}`
+    } else {
+      textarea.value = `${textarea.value.substring(0, start)}${inserted}${textarea.value.substring(end)}`
+    }
+    textarea.setSelectionRange(pos, pos)
+    textarea.focus()
+    setText(textarea.value)
+  }
+
+  /** Replace the open `@query` with `@token`, keeping a trailing space. */
+  const insertToken = (
+    token: string,
+    textarea: HTMLTextAreaElement,
+    setText: (text: string) => void,
+    onSelect?: () => void,
+  ) => {
+    const cursor = textarea.selectionStart ?? textarea.value.length
+    const before = textarea.value.substring(0, cursor)
+    const match = before.match(AT_PATTERN)
+    if (!match) return
+    const start = (match.index ?? 0) + (/^\s/.test(match[0]) ? 1 : 0)
+    const suffix = /^\s/.test(textarea.value.substring(cursor)) ? "" : " "
+    replaceRange(textarea, start, cursor, `@${token}${suffix}`, setText)
+    close()
+    onSelect?.()
+  }
+
+  const selectMention = (
+    result: MentionResult,
+    textarea: HTMLTextAreaElement,
+    setText: (text: string) => void,
+    onSelect?: () => void,
+  ) => {
+    if (result.type === "worktrees") {
+      setWorktreePicker(true)
+      return
+    }
+    if (result.type === "past-chats") {
+      setSessionPicker(true)
+      return
+    }
+    if (result.type === "model") {
+      const cursor = textarea.selectionStart ?? textarea.value.length
+      const match = textarea.value.substring(0, cursor).match(AT_PATTERN)
+      if (!match) return
+      const start = (match.index ?? 0) + (/^\s/.test(match[0]) ? 1 : 0)
+      modelState = { textarea, start, end: cursor, setText, onSelect }
+      close()
+      setModelPicker(true)
+      return
+    }
+    const token = result.type === "session" ? sessionMentionToken(result.session, mentioned()) : result.value
+    if (result.type === "session") setMentioned((prev) => new Map(prev).set(token, result.session))
+    insertToken(token, textarea, setText, onSelect)
+  }
+
+  const selectSession = (
+    session: SessionSearchItem,
+    textarea: HTMLTextAreaElement,
+    setText: (text: string) => void,
+    onSelect?: () => void,
+  ) => {
+    const token = sessionMentionToken(session, mentioned())
+    setMentioned((prev) => new Map(prev).set(token, session))
+    insertToken(token, textarea, setText, onSelect)
+  }
+
+  const selectWorktree = (
+    worktree: WorktreeReference,
+    textarea: HTMLTextAreaElement,
+    setText: (text: string) => void,
+    onSelect?: () => void,
+  ) => {
+    if (worktree.disabled) return
+    insertToken(worktree.path, textarea, setText, onSelect)
+  }
+
+  const selectModelReference = (providerID: string, modelID: string) => {
+    const state = modelState
+    modelState = null
+    setModelPicker(false)
+    if (!state) return
+    const textarea = state.textarea
+    if (!textarea.isConnected) return
+    const token = `${providerID}/${modelID}`
+    const suffix = /^\s/.test(textarea.value.substring(state.end)) ? "" : " "
+    models.add(token)
+    replaceRange(textarea, state.start, state.end, `@${token}${suffix}`, state.setText)
+    state.onSelect?.()
+  }
+
+  const onKeyDown = (
+    e: KeyboardEvent,
+    textarea: HTMLTextAreaElement | undefined,
+    setText: (text: string) => void,
+    onSelect?: () => void,
+  ): boolean => {
+    if (!showMention()) return false
+    if (e.isComposing) return false
+
+    if (e.key === "ArrowDown") {
+      e.preventDefault()
+      setIndex((i) => Math.min(i + 1, Math.max(results().length - 1, 0)))
+      return true
+    }
+    if (e.key === "ArrowUp") {
+      e.preventDefault()
+      setIndex((i) => Math.max(i - 1, 0))
+      return true
+    }
+    if (e.key === "Enter" || (e.key === "Tab" && !e.shiftKey)) {
+      const result = results()[index()]
+      if (!result) return false
+      e.preventDefault()
+      if (textarea) selectMention(result, textarea, setText, onSelect)
+      return true
+    }
+    if (e.key === "Escape") {
+      e.preventDefault()
+      e.stopPropagation()
+      dead = { at, query: query() ?? "" }
+      close()
+      return true
+    }
+    return false
+  }
+
+  return {
+    mentionedSessions: mentioned,
+    sessionPicker,
+    sessionCandidates: candidates,
+    modelPicker,
+    worktreePicker,
+    worktreeCandidates,
+    mentionResults: results,
+    mentionIndex: index,
+    showMention,
+    highlightTokens: tokens,
+    onInput,
+    onKeyDown,
+    selectMention,
+    selectSession,
+    selectWorktree,
+    selectModelReference,
+    setMentionIndex: setIndex,
+    closeMention: close,
+    parseAttachments: (text) => buildWorktreeMentionFiles(text, mentioned(), worktreeCandidates()),
+  }
+}
diff --git a/packages/kilo-vscode/webview-ui/agent-manager/worktree-references.ts b/packages/kilo-vscode/webview-ui/agent-manager/worktree-references.ts
index c2917cd8bd82..8d6f8a1060f3 100644
--- a/packages/kilo-vscode/webview-ui/agent-manager/worktree-references.ts
+++ b/packages/kilo-vscode/webview-ui/agent-manager/worktree-references.ts
@@ -92,3 +92,26 @@ export function createWorktreeReferences(
   })
   return createMemo(() => worktreeReferences(state(), sessions(), selection(), recency.recent()))
 }
+
+/**
+ * The chat list disables the current, stale, and busy worktrees. The New
+ * Worktree dialog has no current worktree, so it re-enables the selected
+ * worktree when that worktree is neither stale nor busy. The list derives from
+ * the chat list so both share one recency signal; stale and busy worktrees stay
+ * disabled and are filtered out by the mention picker.
+ */
+export function createWorktreeMentionReferences(
+  vscode: Pick<ReturnType<typeof useVSCode>, "getState" | "setState">,
+  state: Accessor<ProjectStore>,
+  sessions: Accessor<Session[]>,
+  selection: Accessor<string | null>,
+) {
+  const references = createWorktreeReferences(vscode, state, sessions, selection)
+  const dialogRefs = createMemo(() => {
+    const store = state()
+    const id = selection()
+    if (!id || store.staleWorktreeIds().has(id) || store.busy().has(id)) return references()
+    return references().map((ref) => (ref.id === id ? { ...ref, disabled: false } : ref))
+  })
+  return { references, dialogRefs }
+}
diff --git a/packages/kilo-vscode/webview-ui/src/components/chat/MessageList.tsx b/packages/kilo-vscode/webview-ui/src/components/chat/MessageList.tsx
index 9a53defb2109..a755b256f2e2 100644
--- a/packages/kilo-vscode/webview-ui/src/components/chat/MessageList.tsx
+++ b/packages/kilo-vscode/webview-ui/src/components/chat/MessageList.tsx
@@ -61,6 +61,7 @@ import {
 import { PromptRail } from "./PromptRail"
 import { capacity, historyAction, promptItems, railEntries, type PromptRailItem } from "./prompt-rail"
 import { onTimelineHighlight, type TimelineHighlight } from "../../utils/timeline/highlight"
+import { escapeRegExp } from "../../utils/escape-regexp"
 import { useTranscriptSearch, type SearchMatch } from "../../context/transcript-search"
 import { applyTranscriptHighlights, clearTranscriptHighlights } from "./transcript-search-highlight"
 import { rowSearchText, type SearchTextRange } from "./transcript-search-text"
@@ -190,7 +191,7 @@ export const MessageList: Component<MessageListProps> = (props) => {
     try {
       let pattern = query
       if (!regex) {
-        pattern = query.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
+        pattern = escapeRegExp(query)
       }
       if (wholeWord) {
         // Unicode-aware boundary: plain `\b` only treats ASCII letters/
diff --git a/packages/kilo-vscode/webview-ui/src/hooks/file-mention-utils.ts b/packages/kilo-vscode/webview-ui/src/hooks/file-mention-utils.ts
index 9d5ed5b8c12a..f0391e4f7eaf 100644
--- a/packages/kilo-vscode/webview-ui/src/hooks/file-mention-utils.ts
+++ b/packages/kilo-vscode/webview-ui/src/hooks/file-mention-utils.ts
@@ -2,6 +2,7 @@ import fuzzysort from "fuzzysort"
 import type { FileAttachment, FileSearchItem, SessionSearchItem } from "../types/messages"
 import { GIT_CHANGES_MENTION } from "./git-changes-context-utils"
 import { TERMINAL_MENTION } from "./terminal-context-utils"
+import { escapeRegExp } from "../utils/escape-regexp"
 
 /**
  * The in-progress `@mention` query ending at the cursor.
@@ -612,3 +613,32 @@ export function buildSessionAttachments(text: string, mentioned: Map<string, Ses
   }
   return result
 }
+
+export interface MentionSegment {
+  text: string
+  mention: boolean
+}
+
+/**
+ * Split prompt text into plain and mention segments for the highlight overlay.
+ * Tokens are matched longest first so a title that contains another token still
+ * highlights as one mention. A leading `@` is required, so bare tokens in prose
+ * stay plain.
+ */
+export function segmentMentionText(text: string, tokens: Set<string>): MentionSegment[] {
+  const list = [...tokens].filter((token) => token.length > 0).sort((a, b) => b.length - a.length)
+  if (list.length === 0 || !text) return text ? [{ text, mention: false }] : []
+  const escaped = list.map((token) => escapeRegExp(token))
+  const pattern = new RegExp(`@(?:${escaped.join("|")})`, "g")
+  const segments: MentionSegment[] = []
+  let last = 0
+  for (const match of text.matchAll(pattern)) {
+    const index = match.index ?? 0
+    const plain = text.slice(last, index)
+    if (plain) segments.push({ text: plain, mention: false })
+    segments.push({ text: match[0], mention: true })
+    last = index + match[0].length
+  }
+  if (last < text.length) segments.push({ text: text.slice(last), mention: false })
+  return segments
+}
diff --git a/packages/kilo-vscode/webview-ui/src/utils/escape-regexp.ts b/packages/kilo-vscode/webview-ui/src/utils/escape-regexp.ts
new file mode 100644
index 000000000000..44878bedce0d
--- /dev/null
+++ b/packages/kilo-vscode/webview-ui/src/utils/escape-regexp.ts
@@ -0,0 +1,10 @@
+// RegExp.escape is ES2025 and exists on current Electron, Chromium, and Bun
+// builds. Older runtimes fall back to escaping the standard regex syntax
+// characters. Keep this the single place that decides how to escape.
+const nativeEscape = (RegExp as { escape?: (value: string) => string }).escape
+
+/** Escape a string so it matches literally inside a RegExp source. */
+export function escapeRegExp(value: string): string {
+  if (typeof nativeEscape === "function") return nativeEscape(value)
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
+}