diff --git a/packages/web-shell/client/components/dialogs/ScheduledTasksDialog.module.css b/packages/web-shell/client/components/dialogs/ScheduledTasksDialog.module.css
index 7870bc9b1ff..810af8227da 100644
--- a/packages/web-shell/client/components/dialogs/ScheduledTasksDialog.module.css
+++ b/packages/web-shell/client/components/dialogs/ScheduledTasksDialog.module.css
@@ -124,13 +124,196 @@
   line-height: 1.5;
 }
 
+.promptEditorWrap {
+  position: relative;
+  width: 100%;
+}
+
+.promptEditor {
+  width: 100%;
+  box-sizing: border-box;
+  border: 1px solid var(--border);
+  border-radius: 8px;
+  padding: 10px;
+  font-size: 13px;
+  background: var(--background);
+  color: var(--foreground);
+  font-family: inherit;
+  resize: vertical;
+  min-height: 72px;
+  max-height: 220px;
+  line-height: 1.5;
+  overflow: auto;
+  white-space: pre-wrap;
+  word-break: break-word;
+}
+
 .input:focus,
 .textarea:focus,
+.promptEditor:focus,
 .select:focus {
   outline: 2px solid var(--primary);
   outline-offset: -1px;
 }
 
+.promptPlaceholder {
+  position: absolute;
+  top: 11px;
+  right: 11px;
+  left: 11px;
+  overflow: hidden;
+  color: var(--muted-foreground);
+  font-size: 13px;
+  line-height: 1.5;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+  pointer-events: none;
+}
+
+.promptTag {
+  display: inline-flex;
+  align-items: center;
+  max-width: min(36ch, 100%);
+  min-height: 22px;
+  margin: 0 0.25ch;
+  border: 1px solid var(--border);
+  border-radius: 4px;
+  background: var(--muted);
+  color: var(--foreground);
+  font-family: var(--font-mono, monospace);
+  font-size: 12px;
+  line-height: 1.2;
+  vertical-align: baseline;
+}
+
+.promptTagIcon {
+  display: block;
+  width: 12px;
+  height: 12px;
+  flex: 0 0 auto;
+  margin-left: 7px;
+  background: currentColor;
+  mask: var(--composer-tag-icon-url) center / contain no-repeat;
+  -webkit-mask: var(--composer-tag-icon-url) center / contain no-repeat;
+}
+
+.promptTagValue {
+  min-width: 0;
+  max-width: 30ch;
+  overflow: hidden;
+  padding: 3px 7px 3px 0.5ch;
+  color: var(--foreground);
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.referencePopover {
+  min-width: 0;
+}
+
+.referenceBar {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 8px;
+  margin-top: -6px;
+}
+
+.referenceButton {
+  appearance: none;
+  display: inline-flex;
+  align-items: center;
+  gap: 6px;
+  border: 1px solid var(--border);
+  border-radius: 999px;
+  padding: 5px 12px;
+  background: var(--muted);
+  color: var(--muted-foreground);
+  font-size: 12px;
+  font-weight: 600;
+  font-family: inherit;
+  cursor: pointer;
+}
+
+.referenceButton:hover,
+.referenceButtonActive {
+  color: var(--foreground);
+  background: var(--background);
+}
+
+.referenceButtonIcon {
+  display: block;
+  width: 13px;
+  height: 13px;
+  flex: 0 0 auto;
+  background: currentColor;
+  mask: var(--composer-tag-icon-url) center / contain no-repeat;
+  -webkit-mask: var(--composer-tag-icon-url) center / contain no-repeat;
+}
+
+.referencePicker {
+  position: fixed;
+  z-index: calc(var(--web-shell-dialog-backdrop-z-index, 1000) + 10);
+  display: flex;
+  flex-direction: column;
+  overflow: auto;
+  border: 1px solid var(--border);
+  border-radius: 8px;
+  background: var(--background);
+  box-shadow: 0 12px 32px rgb(0 0 0 / 18%);
+}
+
+.referenceItem {
+  appearance: none;
+  display: grid;
+  grid-template-columns: minmax(0, 1fr);
+  gap: 2px;
+  border: 0;
+  border-bottom: 1px solid var(--border);
+  padding: 9px 10px;
+  background: transparent;
+  color: var(--foreground);
+  font-family: inherit;
+  text-align: left;
+  cursor: pointer;
+}
+
+.referenceItem:last-child {
+  border-bottom: 0;
+}
+
+.referenceItem:hover {
+  background: var(--muted);
+}
+
+.referenceItemLabel,
+.referenceItemDescription {
+  min-width: 0;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.referenceItemLabel {
+  font-size: 13px;
+  font-weight: 600;
+}
+
+.referenceItemDescription {
+  color: var(--muted-foreground);
+  font-size: 12px;
+}
+
+.referenceEmpty,
+.referenceError {
+  padding: 10px;
+  color: var(--muted-foreground);
+  font-size: 12px;
+}
+
+.referenceError {
+  color: var(--error-color);
+}
+
 .scheduleRow {
   display: flex;
   flex-wrap: wrap;
diff --git a/packages/web-shell/client/components/dialogs/ScheduledTasksDialog.test.tsx b/packages/web-shell/client/components/dialogs/ScheduledTasksDialog.test.tsx
index 2411cdb041d..4dfda564388 100644
--- a/packages/web-shell/client/components/dialogs/ScheduledTasksDialog.test.tsx
+++ b/packages/web-shell/client/components/dialogs/ScheduledTasksDialog.test.tsx
@@ -15,6 +15,10 @@ if (!Element.prototype.scrollIntoView) {
   Element.prototype.scrollIntoView = () => {};
 }
 
+if (!document.execCommand) {
+  document.execCommand = () => true;
+}
+
 interface MockTask {
   id: string;
   name: string | null;
@@ -40,6 +44,9 @@ const { actions } = vi.hoisted(() => ({
     updateScheduledTask: vi.fn(),
     runScheduledTask: vi.fn(),
     deleteScheduledTask: vi.fn(),
+    loadExtensionsStatus: vi.fn(),
+    loadSkillsStatus: vi.fn(),
+    loadMcpStatus: vi.fn(),
   },
 }));
 
@@ -67,6 +74,15 @@ async function mount(
   actions.listScheduledTasks.mockResolvedValue(tasks);
   actions.updateScheduledTask.mockResolvedValue(tasks[0]);
   actions.runScheduledTask.mockResolvedValue(tasks[0]);
+  actions.loadExtensionsStatus.mockResolvedValue({
+    extensions: [],
+  });
+  actions.loadSkillsStatus.mockResolvedValue({
+    skills: [],
+  });
+  actions.loadMcpStatus.mockResolvedValue({
+    servers: [],
+  });
   container = document.createElement('div');
   document.body.appendChild(container);
   root = createRoot(container);
@@ -108,6 +124,12 @@ function findButton(label: string): HTMLButtonElement | undefined {
   );
 }
 
+function findButtonContaining(label: string): HTMLButtonElement | undefined {
+  return Array.from(document.querySelectorAll('button')).find((b) =>
+    b.textContent?.includes(label),
+  );
+}
+
 // The frequency picker is the (only) <select> with a weekdays option.
 function findFrequencySelect(): HTMLSelectElement | undefined {
   return Array.from(document.querySelectorAll('select')).find(
@@ -115,6 +137,26 @@ function findFrequencySelect(): HTMLSelectElement | undefined {
   );
 }
 
+function deferred<T = unknown>() {
+  let resolve!: (value: T) => void;
+  const promise = new Promise<T>((res) => {
+    resolve = res;
+  });
+  return { promise, resolve };
+}
+
+function dispatchClipboardEvent(
+  target: Element,
+  type: 'copy' | 'cut',
+  clipboardData: { setData: ReturnType<typeof vi.fn> },
+) {
+  const event = new Event(type, { bubbles: true, cancelable: true });
+  Object.defineProperty(event, 'clipboardData', { value: clipboardData });
+  act(() => {
+    target.dispatchEvent(event);
+  });
+}
+
 afterEach(() => {
   act(() => root?.unmount());
   container?.remove();
@@ -139,6 +181,19 @@ const baseTask = (over: Partial<MockTask>): MockTask => ({
 });
 
 describe('ScheduledTasksDialog editing', () => {
+  it('keeps the prompt placeholder outside the editable textbox', async () => {
+    await mount([]);
+
+    click(findButton('New scheduled task'));
+
+    const prompt = document.querySelector<HTMLElement>('[role="textbox"]');
+    expect(prompt?.textContent).toBe('');
+    expect(prompt?.getAttribute('aria-placeholder')).toBe(
+      'What should this task do?',
+    );
+    expect(document.body.textContent).toContain('What should this task do?');
+  });
+
   it('prefills the form from the task and saves via updateScheduledTask', async () => {
     await mount([baseTask({})]);
 
@@ -148,11 +203,11 @@ describe('ScheduledTasksDialog editing', () => {
     // The cron reverses onto the structured pickers (weekdays @ 12:30) and the
     // name/prompt are prefilled — not left blank as they would be for create.
     const name = document.querySelector<HTMLInputElement>('input[type="text"]');
-    const prompt = document.querySelector<HTMLTextAreaElement>('textarea');
+    const prompt = document.querySelector<HTMLElement>('[role="textbox"]');
     const frequency = findFrequencySelect();
     const time = document.querySelector<HTMLInputElement>('input[type="time"]');
     expect(name?.value).toBe('Digest');
-    expect(prompt?.value).toBe('summarize the day');
+    expect(prompt?.textContent).toBe('summarize the day');
     expect(frequency?.value).toBe('weekdays');
     expect(time?.value).toBe('12:30');
 
@@ -169,6 +224,350 @@ describe('ScheduledTasksDialog editing', () => {
     expect(actions.createScheduledTask).not.toHaveBeenCalled();
   });
 
+  it('renders saved prompt references as inline tags when editing', async () => {
+    const promptText = '@mcp:amap-maps3 /agent-reproduce-align @ext:clickhouse';
+    await mount([baseTask({ prompt: promptText })]);
+
+    click(document.querySelector('[aria-label="Edit"]'));
+
+    const tags = Array.from(
+      document.querySelectorAll<HTMLElement>('[data-prompt-tag-serialized]'),
+    );
+    expect(tags.map((tag) => tag.dataset.promptTagSerialized)).toEqual([
+      '@mcp:amap-maps3',
+      '/agent-reproduce-align',
+      '@ext:clickhouse',
+    ]);
+    expect(tags.map((tag) => tag.textContent)).toEqual([
+      'amap-maps3',
+      'agent-reproduce-align',
+      'clickhouse',
+    ]);
+
+    click(findButton('Save'));
+    await flush();
+
+    expect(actions.updateScheduledTask).toHaveBeenCalledWith(
+      't1',
+      expect.objectContaining({
+        prompt: promptText,
+      }),
+    );
+  });
+
+  it('copies and cuts prompt references as serialized tokens', async () => {
+    const promptText = '@ext:clickhouse /review @mcp:repo-tools';
+    await mount([baseTask({ prompt: promptText })]);
+
+    click(document.querySelector('[aria-label="Edit"]'));
+    const prompt = document.querySelector<HTMLElement>('[role="textbox"]');
+    if (!prompt) throw new Error('prompt editor not found');
+    const range = document.createRange();
+    range.selectNodeContents(prompt);
+    const selection = window.getSelection();
+    selection?.removeAllRanges();
+    selection?.addRange(range);
+
+    const copyClipboard = { setData: vi.fn() };
+    dispatchClipboardEvent(prompt, 'copy', copyClipboard);
+    expect(copyClipboard.setData).toHaveBeenCalledWith(
+      'text/plain',
+      promptText,
+    );
+
+    const cutClipboard = { setData: vi.fn() };
+    dispatchClipboardEvent(prompt, 'cut', cutClipboard);
+    await flush();
+    expect(cutClipboard.setData).toHaveBeenCalledWith('text/plain', promptText);
+    expect(prompt.textContent).toBe('');
+  });
+
+  it('does not render filesystem paths as skill tags', async () => {
+    await mount([
+      baseTask({ prompt: 'check /var/log and then /agent-reproduce-align' }),
+    ]);
+
+    click(document.querySelector('[aria-label="Edit"]'));
+
+    const tags = Array.from(
+      document.querySelectorAll<HTMLElement>('[data-prompt-tag-serialized]'),
+    );
+    expect(tags.map((tag) => tag.dataset.promptTagSerialized)).toEqual([
+      '/agent-reproduce-align',
+    ]);
+    expect(document.querySelector('[role="textbox"]')?.textContent).toContain(
+      '/var/log',
+    );
+  });
+
+  it('does not hang on escaped slash-reference near-misses', async () => {
+    const promptText = `check /${'\\a'.repeat(30)}/ after`;
+    await mount([baseTask({ prompt: promptText })]);
+
+    click(document.querySelector('[aria-label="Edit"]'));
+
+    expect(document.querySelector('[role="textbox"]')?.textContent).toContain(
+      promptText,
+    );
+  });
+
+  it('inserts extension, skill, and MCP references into the created prompt', async () => {
+    actions.createScheduledTask.mockResolvedValue(baseTask({}));
+
+    await mount([]);
+
+    actions.loadExtensionsStatus.mockResolvedValue({
+      extensions: [
+        {
+          id: 'ext-1',
+          name: 'alibabacloud-compute-suite',
+          displayName: 'Alibaba Cloud',
+          description: '',
+          version: '1.0.0',
+          isActive: true,
+          path: '/ext',
+          capabilities: {},
+        },
+      ],
+    });
+    actions.loadSkillsStatus.mockResolvedValue({
+      skills: [
+        {
+          kind: 'skill',
+          name: 'review',
+          description: 'Review code',
+          level: 'project',
+          modelInvocable: true,
+        },
+      ],
+    });
+    actions.loadMcpStatus.mockResolvedValue({
+      servers: [
+        {
+          kind: 'mcp_server',
+          name: 'repo-tools',
+          transport: 'stdio',
+          disabled: false,
+          mcpStatus: 'connected',
+        },
+      ],
+    });
+    click(findButton('New scheduled task'));
+
+    click(findButtonContaining('Extensions'));
+    await flush();
+    click(findButtonContaining('alibabacloud-compute-suite'));
+    await flush();
+
+    click(findButtonContaining('Skills'));
+    await flush();
+    click(findButtonContaining('review'));
+    await flush();
+
+    click(findButtonContaining('MCP'));
+    await flush();
+    click(findButtonContaining('repo-tools'));
+    await flush();
+
+    expect(document.querySelector('[role="textbox"]')?.textContent).toContain(
+      'alibabacloud-compute-suite',
+    );
+
+    click(findButton('Create'));
+    await flush();
+
+    expect(actions.createScheduledTask).toHaveBeenCalledWith(
+      expect.objectContaining({
+        prompt: '@ext:alibabacloud-compute-suite /review @mcp:repo-tools',
+      }),
+    );
+  });
+
+  it('escapes skill names when inserting references', async () => {
+    actions.createScheduledTask.mockResolvedValue(baseTask({}));
+    await mount([]);
+    actions.loadSkillsStatus.mockResolvedValue({
+      skills: [
+        {
+          kind: 'skill',
+          name: 'review task',
+          description: 'Review code',
+          level: 'project',
+          modelInvocable: true,
+        },
+      ],
+    });
+
+    click(findButton('New scheduled task'));
+    click(findButtonContaining('Skills'));
+    await flush();
+    click(findButtonContaining('review task'));
+    await flush();
+
+    click(findButton('Create'));
+    await flush();
+
+    expect(actions.createScheduledTask).toHaveBeenCalledWith(
+      expect.objectContaining({
+        prompt: '/review\\ task',
+      }),
+    );
+  });
+
+  it('keeps the latest reference picker results when loads resolve out of order', async () => {
+    await mount([]);
+    const extensions = deferred();
+    const skills = deferred();
+    actions.loadExtensionsStatus.mockReturnValueOnce(extensions.promise);
+    actions.loadSkillsStatus.mockReturnValueOnce(skills.promise);
+
+    click(findButton('New scheduled task'));
+    click(findButtonContaining('Extensions'));
+    click(findButtonContaining('Skills'));
+
+    skills.resolve({
+      skills: [
+        {
+          kind: 'skill',
+          name: 'review',
+          description: 'Review code',
+          level: 'project',
+          modelInvocable: true,
+        },
+      ],
+    });
+    await flush();
+    expect(findButtonContaining('review')).toBeTruthy();
+
+    extensions.resolve({
+      extensions: [
+        {
+          id: 'ext-1',
+          name: 'alibabacloud-compute-suite',
+          displayName: 'Alibaba Cloud',
+          description: '',
+          version: '1.0.0',
+          isActive: true,
+          path: '/ext',
+          capabilities: {},
+        },
+      ],
+    });
+    await flush();
+    expect(findButtonContaining('review')).toBeTruthy();
+    expect(findButtonContaining('alibabacloud-compute-suite')).toBeUndefined();
+  });
+
+  it('drops plain text only into the prompt editor', async () => {
+    await mount([]);
+    click(findButton('New scheduled task'));
+    const prompt = document.querySelector<HTMLElement>('[role="textbox"]');
+    if (!prompt) throw new Error('prompt editor not found');
+    const execCommand = vi.spyOn(document, 'execCommand').mockReturnValue(true);
+    const drop = new Event('drop', { bubbles: true, cancelable: true });
+    Object.defineProperty(drop, 'dataTransfer', {
+      value: {
+        getData: (type: string) =>
+          type === 'text/plain' ? 'plain text' : '<b>html</b>',
+      },
+    });
+
+    act(() => {
+      prompt.dispatchEvent(drop);
+    });
+
+    expect(execCommand).toHaveBeenCalledWith('insertText', false, 'plain text');
+    execCommand.mockRestore();
+  });
+
+  it('pastes plain text only into the prompt editor', async () => {
+    await mount([]);
+    click(findButton('New scheduled task'));
+    const prompt = document.querySelector<HTMLElement>('[role="textbox"]');
+    if (!prompt) throw new Error('prompt editor not found');
+    const execCommand = vi.spyOn(document, 'execCommand').mockReturnValue(true);
+    const paste = new Event('paste', { bubbles: true, cancelable: true });
+    Object.defineProperty(paste, 'clipboardData', {
+      value: {
+        getData: (type: string) =>
+          type === 'text/plain' ? 'plain text' : '<b>html</b>',
+      },
+    });
+
+    act(() => {
+      prompt.dispatchEvent(paste);
+    });
+
+    expect(execCommand).toHaveBeenCalledWith('insertText', false, 'plain text');
+    execCommand.mockRestore();
+  });
+
+  it('caps contenteditable input at the scheduled-task prompt limit', async () => {
+    actions.createScheduledTask.mockResolvedValue(baseTask({}));
+    await mount([]);
+    click(findButton('New scheduled task'));
+    const prompt = document.querySelector<HTMLElement>('[role="textbox"]');
+    if (!prompt) throw new Error('prompt editor not found');
+
+    act(() => {
+      prompt.textContent = 'x'.repeat(100_001);
+      prompt.dispatchEvent(new InputEvent('input', { bubbles: true }));
+    });
+    await flush();
+    click(findButton('Create'));
+    await flush();
+
+    expect(actions.createScheduledTask).toHaveBeenCalledWith(
+      expect.objectContaining({
+        prompt: 'x'.repeat(100_000),
+      }),
+    );
+  });
+
+  it('does not preserve empty contenteditable leftovers before an inserted reference', async () => {
+    actions.createScheduledTask.mockResolvedValue(baseTask({}));
+
+    await mount([]);
+
+    actions.loadExtensionsStatus.mockResolvedValue({
+      extensions: [
+        {
+          id: 'ext-1',
+          name: 'alibabacloud-compute-suite',
+          displayName: 'Alibaba Cloud',
+          description: '',
+          version: '1.0.0',
+          isActive: true,
+          path: '/ext',
+          capabilities: {},
+        },
+      ],
+    });
+    click(findButton('New scheduled task'));
+
+    const prompt = document.querySelector<HTMLElement>('[role="textbox"]');
+    if (!prompt) throw new Error('prompt editor not found');
+    act(() => {
+      prompt.innerHTML = '<br>';
+      prompt.dispatchEvent(new InputEvent('input', { bubbles: true }));
+    });
+    await flush();
+
+    click(findButtonContaining('Extensions'));
+    await flush();
+    click(findButtonContaining('alibabacloud-compute-suite'));
+    await flush();
+
+    click(findButton('Create'));
+    await flush();
+
+    expect(actions.createScheduledTask).toHaveBeenCalledWith(
+      expect.objectContaining({
+        prompt: '@ext:alibabacloud-compute-suite',
+      }),
+    );
+  });
+
   it('an unrepresentable cron lands in the custom field, losslessly', async () => {
     await mount([baseTask({ cron: '0 9 * * 1,3,5' })]); // day-of-week list
 
diff --git a/packages/web-shell/client/components/dialogs/ScheduledTasksDialog.tsx b/packages/web-shell/client/components/dialogs/ScheduledTasksDialog.tsx
index 7e533ebbfd9..f59dcf7ed9d 100644
--- a/packages/web-shell/client/components/dialogs/ScheduledTasksDialog.tsx
+++ b/packages/web-shell/client/components/dialogs/ScheduledTasksDialog.tsx
@@ -4,13 +4,27 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { useCallback, useEffect, useRef, useState } from 'react';
+import {
+  useCallback,
+  useEffect,
+  useRef,
+  useState,
+  type CSSProperties,
+} from 'react';
+import { createPortal } from 'react-dom';
 import {
   useWorkspaceActions,
   type DaemonScheduledTask,
   type DaemonScheduledTaskRun,
 } from '@qwen-code/webui/daemon-react-sdk';
+import type {
+  DaemonExtensionEntry,
+  DaemonWorkspaceMcpServerStatus,
+  DaemonWorkspaceSkillStatus,
+} from '@qwen-code/sdk/daemon';
 import { useI18n } from '../../i18n';
+import { getComposerTagIconUrl } from '../composerTagIcons';
+import { cssUrlValue } from '../../utils/cssUrlVar';
 import { DialogShell } from './DialogShell';
 import {
   buildCron,
@@ -89,6 +103,331 @@ const MAX_SET_TIMEOUT_MS = 2_147_483_647;
 // back to the slow lane so a permanently-stuck task can't spin a 1 Hz GET loop.
 const PAST_DUE_FAST_RELOADS = 3;
 const OVERDUE_RELOAD_INTERVAL_MS = 30_000;
+const MAX_PROMPT_LENGTH = 100_000;
+const AT_REFERENCE_UNSAFE_CHARS = /[^\p{L}\p{N}_.-]/gu;
+const PROMPT_REFERENCE_TOKEN =
+  /(^|[\s])(@(?:ext|mcp):(?:\\.[^\s\\]*|[^\s\\])+|\/(?:\\.[^\s\\/]*|[^\s\\/])+)(?=$|\s)/gu;
+const REFERENCE_PICKER_THEME_VARS = [
+  '--background',
+  '--foreground',
+  '--muted',
+  '--muted-foreground',
+  '--border',
+  '--error-color',
+  '--font-mono',
+];
+
+type PromptTagKind = 'extension' | 'skill' | 'mcp';
+
+interface PromptReferenceItem {
+  id: string;
+  kind: PromptTagKind;
+  label: string;
+  description?: string;
+  insertText: string;
+}
+
+interface ReferencePickerPosition {
+  left: number;
+  top: number;
+  width: number;
+  maxHeight: number;
+}
+
+function escapeAtReferenceText(ref: string): string {
+  return ref.replace(AT_REFERENCE_UNSAFE_CHARS, '\\$&');
+}
+
+function unescapeReferenceText(ref: string): string {
+  return ref.replace(/\\(.)/g, '$1');
+}
+
+function promptReferenceItemFromToken(
+  token: string,
+): PromptReferenceItem | null {
+  if (token.startsWith('@ext:')) {
+    const label = unescapeReferenceText(token.slice('@ext:'.length));
+    return {
+      id: `extension:${label}`,
+      kind: 'extension',
+      label,
+      insertText: token,
+    };
+  }
+  if (token.startsWith('@mcp:')) {
+    const label = unescapeReferenceText(token.slice('@mcp:'.length));
+    return {
+      id: `mcp:${label}`,
+      kind: 'mcp',
+      label,
+      insertText: token,
+    };
+  }
+  if (token.startsWith('/')) {
+    const label = unescapeReferenceText(token.slice(1));
+    if (!label) return null;
+    return {
+      id: `skill:${label}`,
+      kind: 'skill',
+      label,
+      insertText: token,
+    };
+  }
+  return null;
+}
+
+function extensionDescription(extension: DaemonExtensionEntry) {
+  if (extension.displayName && extension.displayName !== extension.name) {
+    return extension.displayName;
+  }
+  return extension.description;
+}
+
+function skillDescription(skill: DaemonWorkspaceSkillStatus) {
+  return skill.description || skill.argumentHint || skill.level;
+}
+
+function mcpDescription(server: DaemonWorkspaceMcpServerStatus) {
+  return server.description || server.mcpStatus;
+}
+
+function textFromPromptNode(node: ChildNode): string {
+  if (node.nodeType === Node.TEXT_NODE) {
+    return node.textContent ?? '';
+  }
+  if (!(node instanceof HTMLElement)) return '';
+
+  const serialized = node.dataset.promptTagSerialized;
+  if (serialized) return serialized;
+  if (node.tagName === 'BR') return '\n';
+
+  let text = '';
+  node.childNodes.forEach((child) => {
+    text += textFromPromptNode(child);
+  });
+  return node.tagName === 'DIV' || node.tagName === 'P' ? `${text}\n` : text;
+}
+
+function textFromPromptChildren(root: ParentNode): string {
+  let text = '';
+  root.childNodes.forEach((node) => {
+    text += textFromPromptNode(node);
+  });
+  return text;
+}
+
+function normalizePromptText(text: string): string {
+  return text.replace(/\u00a0/g, ' ').replace(/\n$/, '');
+}
+
+function textFromPromptEditor(root: HTMLElement): string {
+  return normalizePromptText(textFromPromptChildren(root));
+}
+
+function textFromPromptFragment(fragment: DocumentFragment): string {
+  return normalizePromptText(textFromPromptChildren(fragment));
+}
+
+function clearPromptEditor(root: HTMLElement) {
+  while (root.firstChild) root.removeChild(root.firstChild);
+}
+
+function appendPromptText(root: HTMLElement, text: string) {
+  if (text) root.appendChild(document.createTextNode(text));
+}
+
+function setPromptEditorText(root: HTMLElement, text: string) {
+  clearPromptEditor(root);
+  if (!text) return;
+  const lines = text.split('\n');
+  lines.forEach((line, index) => {
+    if (index > 0) root.appendChild(document.createElement('br'));
+    appendPromptLine(root, line);
+  });
+}
+
+function normalizePromptEditor(root: HTMLElement): string {
+  let next = textFromPromptEditor(root);
+  if (next.length > MAX_PROMPT_LENGTH) {
+    next = next.slice(0, MAX_PROMPT_LENGTH);
+    setPromptEditorText(root, next);
+  } else if (next.trim().length === 0) {
+    clearPromptEditor(root);
+    next = '';
+  }
+  return next;
+}
+
+function insertPlainPromptText(root: HTMLElement, text: string) {
+  const remaining = MAX_PROMPT_LENGTH - textFromPromptEditor(root).length;
+  if (remaining <= 0) return;
+  document.execCommand('insertText', false, text.slice(0, remaining));
+}
+
+function selectedPromptText(root: HTMLElement): {
+  selection: Selection;
+  text: string;
+} | null {
+  const selection = window.getSelection();
+  if (!selection || selection.rangeCount === 0) return null;
+  const range = selection.getRangeAt(0);
+  if (!root.contains(range.commonAncestorContainer)) return null;
+  return {
+    selection,
+    text: textFromPromptFragment(range.cloneContents()),
+  };
+}
+
+function makePromptTagElement(item: PromptReferenceItem): HTMLElement {
+  const tag = document.createElement('span');
+  tag.className = styles.promptTag;
+  tag.contentEditable = 'false';
+  tag.dataset.promptTagSerialized = item.insertText.trim();
+
+  const iconUrl = getComposerTagIconUrl(item.kind);
+  if (iconUrl) {
+    const icon = document.createElement('span');
+    icon.className = styles.promptTagIcon;
+    icon.style.setProperty('--composer-tag-icon-url', cssUrlValue(iconUrl));
+    icon.setAttribute('aria-hidden', 'true');
+    tag.appendChild(icon);
+  }
+
+  const value = document.createElement('span');
+  value.className = styles.promptTagValue;
+  value.textContent = item.label;
+  tag.appendChild(value);
+  return tag;
+}
+
+function appendPromptLine(root: HTMLElement, line: string) {
+  let cursor = 0;
+  PROMPT_REFERENCE_TOKEN.lastIndex = 0;
+  for (const match of line.matchAll(PROMPT_REFERENCE_TOKEN)) {
+    const [matched, prefix, token] = match;
+    const index = match.index ?? 0;
+    const item = promptReferenceItemFromToken(token);
+    if (!item) continue;
+    appendPromptText(root, line.slice(cursor, index));
+    appendPromptText(root, prefix);
+    root.appendChild(makePromptTagElement(item));
+    cursor = index + matched.length;
+  }
+  appendPromptText(root, line.slice(cursor));
+}
+
+function insertPromptTagElement(root: HTMLElement, item: PromptReferenceItem) {
+  const selection = window.getSelection();
+  const tag = makePromptTagElement(item);
+  const spacer = document.createTextNode(' ');
+
+  if (textFromPromptEditor(root).trim().length === 0) {
+    clearPromptEditor(root);
+  }
+
+  const lastText = root.lastChild?.textContent ?? '';
+  if (root.childNodes.length > 0 && !/\s$/.test(lastText)) {
+    root.appendChild(document.createTextNode(' '));
+  }
+  root.appendChild(tag);
+  root.appendChild(spacer);
+
+  const range = document.createRange();
+  range.setStartAfter(spacer);
+  range.collapse(true);
+  selection?.removeAllRanges();
+  selection?.addRange(range);
+}
+
+function PromptReferenceEditor({
+  value,
+  label,
+  placeholder,
+  onChange,
+  insertItem,
+  onInserted,
+}: {
+  value: string;
+  label: string;
+  placeholder: string;
+  onChange: (value: string) => void;
+  insertItem: PromptReferenceItem | null;
+  onInserted: () => void;
+}) {
+  const editorRef = useRef<HTMLDivElement | null>(null);
+  const lastAppliedValueRef = useRef('');
+
+  useEffect(() => {
+    const editor = editorRef.current;
+    if (!editor) return;
+    if (value === lastAppliedValueRef.current) return;
+    setPromptEditorText(editor, value);
+    lastAppliedValueRef.current = value;
+  }, [value]);
+
+  useEffect(() => {
+    const editor = editorRef.current;
+    if (!editor || !insertItem) return;
+    insertPromptTagElement(editor, insertItem);
+    const next = textFromPromptEditor(editor);
+    lastAppliedValueRef.current = next;
+    onChange(next);
+    editor.focus();
+    onInserted();
+  }, [insertItem, onChange, onInserted]);
+
+  return (
+    <div className={styles.promptEditorWrap}>
+      <div
+        ref={editorRef}
+        className={styles.promptEditor}
+        contentEditable
+        role="textbox"
+        aria-label={label}
+        aria-multiline="true"
+        aria-placeholder={placeholder}
+        onInput={(event) => {
+          const next = normalizePromptEditor(event.currentTarget);
+          lastAppliedValueRef.current = next;
+          onChange(next);
+        }}
+        onPaste={(event) => {
+          event.preventDefault();
+          insertPlainPromptText(
+            event.currentTarget,
+            event.clipboardData.getData('text/plain'),
+          );
+        }}
+        onDrop={(event) => {
+          event.preventDefault();
+          insertPlainPromptText(
+            event.currentTarget,
+            event.dataTransfer.getData('text/plain'),
+          );
+        }}
+        onCopy={(event) => {
+          const selected = selectedPromptText(event.currentTarget);
+          if (!selected) return;
+          event.preventDefault();
+          event.clipboardData.setData('text/plain', selected.text);
+        }}
+        onCut={(event) => {
+          const selected = selectedPromptText(event.currentTarget);
+          if (!selected) return;
+          event.preventDefault();
+          event.clipboardData.setData('text/plain', selected.text);
+          selected.selection.deleteFromDocument();
+          const next = normalizePromptEditor(event.currentTarget);
+          lastAppliedValueRef.current = next;
+          onChange(next);
+        }}
+      />
+      {value.trim().length === 0 && (
+        <div className={styles.promptPlaceholder}>{placeholder}</div>
+      )}
+    </div>
+  );
+}
 
 export function ScheduledTasksDialog({
   onRunPrompt,
@@ -116,6 +455,22 @@ export function ScheduledTasksDialog({
   const [builder, setBuilder] = useState<BuilderState>(DEFAULT_BUILDER);
   const [submitting, setSubmitting] = useState(false);
   const [formError, setFormError] = useState<string | null>(null);
+  const [referenceKind, setReferenceKind] = useState<PromptTagKind | null>(
+    null,
+  );
+  const [referenceItems, setReferenceItems] = useState<PromptReferenceItem[]>(
+    [],
+  );
+  const [referenceLoading, setReferenceLoading] = useState(false);
+  const [referenceError, setReferenceError] = useState<string | null>(null);
+  const [pendingPromptTag, setPendingPromptTag] =
+    useState<PromptReferenceItem | null>(null);
+  const referencePopoverRef = useRef<HTMLDivElement | null>(null);
+  const referencePickerRef = useRef<HTMLDivElement | null>(null);
+  const [referencePickerPosition, setReferencePickerPosition] =
+    useState<ReferencePickerPosition | null>(null);
+  const [referencePickerThemeVars, setReferencePickerThemeVars] =
+    useState<CSSProperties>({});
 
   // Which task's run history is expanded inline (only one at a time).
   const [expandedRunsId, setExpandedRunsId] = useState<string | null>(null);
@@ -130,6 +485,7 @@ export function ScheduledTasksDialog({
   // create/toggle/delete's reload must not overwrite the newer list with
   // stale data. Only the latest reload is allowed to apply its result.
   const reloadSeqRef = useRef(0);
+  const referenceLoadSeqRef = useRef(0);
   useEffect(() => {
     mountedRef.current = true;
     return () => {
@@ -201,6 +557,155 @@ export function ScheduledTasksDialog({
   const previewCron = buildCron(builder);
   const previewLabel = previewCron ? describeCron(previewCron, t) : null;
 
+  const updateReferencePickerPosition = useCallback(() => {
+    const anchor = referencePopoverRef.current;
+    if (!anchor) {
+      setReferencePickerPosition(null);
+      return;
+    }
+    const computedStyle = getComputedStyle(anchor);
+    setReferencePickerThemeVars(
+      Object.fromEntries(
+        REFERENCE_PICKER_THEME_VARS.map((name) => [
+          name,
+          computedStyle.getPropertyValue(name),
+        ]),
+      ) as CSSProperties,
+    );
+    const rect = anchor.getBoundingClientRect();
+    const width = Math.min(420, window.innerWidth - 24);
+    const left = Math.max(
+      12,
+      Math.min(rect.left, window.innerWidth - width - 12),
+    );
+    const top = rect.bottom + 6;
+    const maxHeight = Math.max(
+      140,
+      Math.min(320, window.innerHeight - top - 12),
+    );
+    setReferencePickerPosition((prev) => {
+      const next = { left, top, width, maxHeight };
+      return prev &&
+        prev.left === next.left &&
+        prev.top === next.top &&
+        prev.width === next.width &&
+        prev.maxHeight === next.maxHeight
+        ? prev
+        : next;
+    });
+  }, []);
+
+  const resetReferenceState = useCallback(() => {
+    referenceLoadSeqRef.current += 1;
+    setReferenceKind(null);
+    setReferenceItems([]);
+    setReferenceLoading(false);
+    setReferenceError(null);
+    setPendingPromptTag(null);
+    setReferencePickerPosition(null);
+    setReferencePickerThemeVars({});
+  }, []);
+
+  const loadReferences = useCallback(
+    async (kind: PromptTagKind) => {
+      const seq = ++referenceLoadSeqRef.current;
+      if (referenceKind === kind) {
+        resetReferenceState();
+        return;
+      }
+      updateReferencePickerPosition();
+      setReferenceKind(kind);
+      setReferenceLoading(true);
+      setReferenceError(null);
+      setReferenceItems([]);
+      try {
+        let items: PromptReferenceItem[];
+        if (kind === 'extension') {
+          const status = await actions.loadExtensionsStatus();
+          items = (status.extensions ?? [])
+            .filter((extension) => extension.isActive)
+            .map((extension) => ({
+              id: extension.id || extension.name,
+              kind,
+              label: extension.name,
+              description: extensionDescription(extension),
+              insertText: `@ext:${escapeAtReferenceText(extension.name)} `,
+            }));
+        } else if (kind === 'skill') {
+          const status = await actions.loadSkillsStatus();
+          items = (status.skills ?? [])
+            .filter((skill) => skill.modelInvocable)
+            .map((skill) => ({
+              id: skill.name,
+              kind,
+              label: skill.name,
+              description: skillDescription(skill),
+              insertText: `/${escapeAtReferenceText(skill.name)} `,
+            }));
+        } else {
+          const status = await actions.loadMcpStatus();
+          items = (status.servers ?? [])
+            .filter((server) => !server.disabled)
+            .map((server) => ({
+              id: server.name,
+              kind,
+              label: server.name,
+              description: mcpDescription(server),
+              insertText: `@mcp:${escapeAtReferenceText(server.name)} `,
+            }));
+        }
+        if (!mountedRef.current || seq !== referenceLoadSeqRef.current) return;
+        setReferenceItems(items);
+      } catch (err) {
+        if (!mountedRef.current || seq !== referenceLoadSeqRef.current) return;
+        setReferenceError(err instanceof Error ? err.message : String(err));
+      } finally {
+        if (mountedRef.current && seq === referenceLoadSeqRef.current) {
+          setReferenceLoading(false);
+        }
+      }
+    },
+    [
+      actions,
+      referenceKind,
+      resetReferenceState,
+      updateReferencePickerPosition,
+    ],
+  );
+
+  useEffect(() => {
+    if (!referenceKind) return;
+    updateReferencePickerPosition();
+
+    const handlePointerDown = (event: PointerEvent) => {
+      const popover = referencePopoverRef.current;
+      const picker = referencePickerRef.current;
+      if (popover?.contains(event.target as Node)) return;
+      if (picker?.contains(event.target as Node)) return;
+      resetReferenceState();
+    };
+    const handleKeyDown = (event: KeyboardEvent) => {
+      if (event.key === 'Escape') {
+        event.preventDefault();
+        event.stopPropagation();
+        resetReferenceState();
+      }
+    };
+
+    const handleReposition = () => updateReferencePickerPosition();
+
+    document.addEventListener('pointerdown', handlePointerDown);
+    document.addEventListener('keydown', handleKeyDown, true);
+    window.addEventListener('resize', handleReposition);
+    window.addEventListener('scroll', handleReposition, true);
+    return () => {
+      document.removeEventListener('pointerdown', handlePointerDown);
+      document.removeEventListener('keydown', handleKeyDown, true);
+      window.removeEventListener('resize', handleReposition);
+      window.removeEventListener('scroll', handleReposition, true);
+    };
+  }, [referenceKind, resetReferenceState, updateReferencePickerPosition]);
+
   const resetForm = useCallback(() => {
     setName('');
     setPrompt('');
@@ -208,7 +713,8 @@ export function ScheduledTasksDialog({
     setFormError(null);
     setShowForm(false);
     setEditingId(null);
-  }, []);
+    resetReferenceState();
+  }, [resetReferenceState]);
 
   const openCreate = useCallback(() => {
     setEditingId(null);
@@ -216,19 +722,24 @@ export function ScheduledTasksDialog({
     setPrompt('');
     setBuilder(DEFAULT_BUILDER);
     setFormError(null);
+    resetReferenceState();
     setShowForm(true);
-  }, []);
+  }, [resetReferenceState]);
 
-  const openEdit = useCallback((task: DaemonScheduledTask) => {
-    setEditingId(task.id);
-    setName(task.name ?? '');
-    setPrompt(task.prompt);
-    // Reverse the cron back onto the pickers; an expression the pickers can't
-    // represent lands in the `custom` field, never silently rewritten.
-    setBuilder(parseCronToBuilder(task.cron));
-    setFormError(null);
-    setShowForm(true);
-  }, []);
+  const openEdit = useCallback(
+    (task: DaemonScheduledTask) => {
+      setEditingId(task.id);
+      setName(task.name ?? '');
+      setPrompt(task.prompt);
+      // Reverse the cron back onto the pickers; an expression the pickers can't
+      // represent lands in the `custom` field, never silently rewritten.
+      setBuilder(parseCronToBuilder(task.cron));
+      setFormError(null);
+      resetReferenceState();
+      setShowForm(true);
+    },
+    [resetReferenceState],
+  );
 
   const handleSubmit = useCallback(async () => {
     const cron = buildCron(builder);
@@ -240,6 +751,14 @@ export function ScheduledTasksDialog({
       setFormError(t('scheduledTasks.error.emptyPrompt'));
       return;
     }
+    if (prompt.length > MAX_PROMPT_LENGTH) {
+      setFormError(
+        t('scheduledTasks.error.promptTooLong', {
+          max: MAX_PROMPT_LENGTH,
+        }),
+      );
+      return;
+    }
     setSubmitting(true);
     setFormError(null);
     try {
@@ -371,6 +890,64 @@ export function ScheduledTasksDialog({
     [actions, onError, reload, t],
   );
 
+  const referencePicker =
+    referenceKind && referencePickerPosition
+      ? createPortal(
+          <div
+            ref={referencePickerRef}
+            className={styles.referencePicker}
+            role="listbox"
+            aria-label={t('scheduledTasks.referencePicker')}
+            style={
+              {
+                ...referencePickerThemeVars,
+                left: referencePickerPosition.left,
+                top: referencePickerPosition.top,
+                width: referencePickerPosition.width,
+                maxHeight: referencePickerPosition.maxHeight,
+              } as CSSProperties
+            }
+          >
+            {referenceLoading ? (
+              <div className={styles.referenceEmpty}>
+                {t('scheduledTasks.reference.loading')}
+              </div>
+            ) : referenceError ? (
+              <div className={styles.referenceError}>{referenceError}</div>
+            ) : referenceItems.length === 0 ? (
+              <div className={styles.referenceEmpty}>
+                {t('scheduledTasks.reference.empty')}
+              </div>
+            ) : (
+              referenceItems.map((item) => (
+                <button
+                  key={`${item.kind}:${item.id}`}
+                  type="button"
+                  className={styles.referenceItem}
+                  role="option"
+                  aria-selected="false"
+                  onMouseDown={(event) => event.preventDefault()}
+                  onClick={() => {
+                    setPendingPromptTag(item);
+                    setReferenceKind(null);
+                  }}
+                >
+                  <span className={styles.referenceItemLabel}>
+                    {item.label}
+                  </span>
+                  {item.description && (
+                    <span className={styles.referenceItemDescription}>
+                      {item.description}
+                    </span>
+                  )}
+                </button>
+              ))
+            )}
+          </div>,
+          document.body,
+        )
+      : null;
+
   return (
     <div className={styles.root}>
       <div className={styles.intro}>{t('scheduledTasks.subtitle')}</div>
@@ -434,15 +1011,48 @@ export function ScheduledTasksDialog({
                 {t('scheduledTasks.prompt')}
                 <span className={styles.required}>*</span>
               </span>
-              <textarea
-                className={styles.textarea}
+              <PromptReferenceEditor
                 value={prompt}
-                rows={4}
-                maxLength={100_000}
+                label={t('scheduledTasks.prompt')}
                 placeholder={t('scheduledTasks.promptPlaceholder')}
-                onChange={(e) => setPrompt(e.target.value)}
+                onChange={setPrompt}
+                insertItem={pendingPromptTag}
+                onInserted={() => setPendingPromptTag(null)}
               />
             </label>
+            <div ref={referencePopoverRef} className={styles.referencePopover}>
+              <div className={styles.referenceBar}>
+                {(['extension', 'skill', 'mcp'] as const).map((kind) => {
+                  const iconUrl = getComposerTagIconUrl(kind);
+                  return (
+                    <button
+                      key={kind}
+                      type="button"
+                      className={`${styles.referenceButton} ${
+                        referenceKind === kind
+                          ? styles.referenceButtonActive
+                          : ''
+                      }`}
+                      aria-expanded={referenceKind === kind}
+                      onClick={() => void loadReferences(kind)}
+                    >
+                      {iconUrl && (
+                        <span
+                          className={styles.referenceButtonIcon}
+                          style={
+                            {
+                              '--composer-tag-icon-url': cssUrlValue(iconUrl),
+                            } as CSSProperties
+                          }
+                          aria-hidden
+                        />
+                      )}
+                      {t(`scheduledTasks.reference.${kind}`)}
+                    </button>
+                  );
+                })}
+              </div>
+            </div>
 
             <div className={styles.scheduleRow}>
               <label className={styles.field}>
@@ -605,6 +1215,7 @@ export function ScheduledTasksDialog({
           </div>
         </DialogShell>
       )}
+      {referencePicker}
 
       {loadError && <div className={styles.loadError}>{loadError}</div>}
 
diff --git a/packages/web-shell/client/i18n.tsx b/packages/web-shell/client/i18n.tsx
index 15df1eb4d00..46e877cce4b 100644
--- a/packages/web-shell/client/i18n.tsx
+++ b/packages/web-shell/client/i18n.tsx
@@ -690,6 +690,12 @@ const EN: Messages = {
   'scheduledTasks.namePlaceholder': 'Optional — defaults to the prompt',
   'scheduledTasks.prompt': 'Prompt',
   'scheduledTasks.promptPlaceholder': 'What should this task do?',
+  'scheduledTasks.reference.extension': 'Extensions',
+  'scheduledTasks.reference.skill': 'Skills',
+  'scheduledTasks.reference.mcp': 'MCP',
+  'scheduledTasks.referencePicker': 'Reference picker',
+  'scheduledTasks.reference.loading': 'Loading…',
+  'scheduledTasks.reference.empty': 'No available items.',
   'scheduledTasks.frequency': 'Frequency',
   'scheduledTasks.freq.daily': 'Daily',
   'scheduledTasks.freq.weekdays': 'Weekdays',
@@ -729,6 +735,8 @@ const EN: Messages = {
   'scheduledTasks.cancel': 'Cancel',
   'scheduledTasks.error.invalidSchedule': 'Invalid schedule',
   'scheduledTasks.error.emptyPrompt': 'Prompt is required',
+  'scheduledTasks.error.promptTooLong': (v) =>
+    `Prompt exceeds ${v?.max ?? 100_000}-character limit`,
   'scheduledTasks.error.toggleFailed': 'Failed to update task',
   'scheduledTasks.error.deleteFailed': 'Failed to delete task',
   'scheduledTasks.edit': 'Edit',
@@ -2426,6 +2434,12 @@ const ZH: Messages = {
   'scheduledTasks.namePlaceholder': '可选 —— 默认取提示词',
   'scheduledTasks.prompt': '提示词',
   'scheduledTasks.promptPlaceholder': '这个任务要做什么？',
+  'scheduledTasks.reference.extension': '扩展',
+  'scheduledTasks.reference.skill': '技能',
+  'scheduledTasks.reference.mcp': 'MCP',
+  'scheduledTasks.referencePicker': '引用选择器',
+  'scheduledTasks.reference.loading': '加载中…',
+  'scheduledTasks.reference.empty': '暂无可选项。',
   'scheduledTasks.frequency': '频率',
   'scheduledTasks.freq.daily': '每天',
   'scheduledTasks.freq.weekdays': '工作日',
@@ -2464,6 +2478,8 @@ const ZH: Messages = {
   'scheduledTasks.cancel': '取消',
   'scheduledTasks.error.invalidSchedule': '计划无效',
   'scheduledTasks.error.emptyPrompt': '提示词不能为空',
+  'scheduledTasks.error.promptTooLong': (v) =>
+    `提示词超过 ${v?.max ?? 100_000} 字符限制`,
   'scheduledTasks.error.toggleFailed': '更新任务失败',
   'scheduledTasks.error.deleteFailed': '删除任务失败',
   'scheduledTasks.edit': '编辑',