diff --git a/.gitignore b/.gitignore
index a757a9427..cc60eeaaf 100644
--- a/.gitignore
+++ b/.gitignore
@@ -25,3 +25,4 @@ dist-ssr
 /release-artifacts
 CodexMonitor.zip
 .codex-worktrees/
+.codexmonitor/
diff --git a/src-tauri/Cargo.lock b/src-tauri/Cargo.lock
index 6f2831d07..89aa1f74f 100644
--- a/src-tauri/Cargo.lock
+++ b/src-tauri/Cargo.lock
@@ -568,6 +568,7 @@ dependencies = [
  "fix-path-env",
  "git2",
  "ignore",
+ "libc",
  "portable-pty",
  "reqwest",
  "serde",
diff --git a/src-tauri/Cargo.toml b/src-tauri/Cargo.toml
index f00e6e18e..764c66769 100644
--- a/src-tauri/Cargo.toml
+++ b/src-tauri/Cargo.toml
@@ -35,6 +35,7 @@ reqwest = { version = "0.12", default-features = false, features = ["rustls-tls"
 cpal = "0.15"
 whisper-rs = "0.12"
 sha2 = "0.10"
+libc = "0.2"
 
 [target."cfg(not(any(target_os = \"android\", target_os = \"ios\")))".dependencies]
 tauri-plugin-updater = "2"
diff --git a/src-tauri/src/lib.rs b/src-tauri/src/lib.rs
index 9b6c3f68e..df2e15ffe 100644
--- a/src-tauri/src/lib.rs
+++ b/src-tauri/src/lib.rs
@@ -180,6 +180,12 @@ pub fn run() {
             codex::account_rate_limits,
             codex::skills_list,
             prompts::prompts_list,
+            prompts::prompts_create,
+            prompts::prompts_update,
+            prompts::prompts_delete,
+            prompts::prompts_move,
+            prompts::prompts_workspace_dir,
+            prompts::prompts_global_dir,
             terminal::terminal_open,
             terminal::terminal_write,
             terminal::terminal_resize,
diff --git a/src-tauri/src/prompts.rs b/src-tauri/src/prompts.rs
index caa09663c..26e541f31 100644
--- a/src-tauri/src/prompts.rs
+++ b/src-tauri/src/prompts.rs
@@ -1,8 +1,13 @@
 use serde::Serialize;
+use std::collections::HashMap;
 use std::env;
 use std::fs;
 use std::path::{Path, PathBuf};
 use tokio::task;
+use tauri::State;
+
+use crate::state::AppState;
+use crate::types::WorkspaceEntry;
 
 #[derive(Serialize, Clone)]
 pub(crate) struct CustomPromptEntry {
@@ -12,6 +17,8 @@ pub(crate) struct CustomPromptEntry {
     #[serde(rename = "argumentHint")]
     pub(crate) argument_hint: Option<String>,
     pub(crate) content: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub(crate) scope: Option<String>,
 }
 
 fn resolve_home_dir() -> Option<PathBuf> {
@@ -45,6 +52,82 @@ fn default_prompts_dir() -> Option<PathBuf> {
     resolve_codex_home().map(|home| home.join("prompts"))
 }
 
+fn require_workspace_entry(
+    workspaces: &HashMap<String, WorkspaceEntry>,
+    workspace_id: &str,
+) -> Result<WorkspaceEntry, String> {
+    workspaces
+        .get(workspace_id)
+        .cloned()
+        .ok_or_else(|| "workspace not found".to_string())
+}
+
+fn app_data_dir(state: &State<'_, AppState>) -> Result<PathBuf, String> {
+    state
+        .settings_path
+        .parent()
+        .map(|path| path.to_path_buf())
+        .ok_or_else(|| "Unable to resolve app data dir.".to_string())
+}
+
+fn workspace_prompts_dir(
+    state: &State<'_, AppState>,
+    entry: &WorkspaceEntry,
+) -> Result<PathBuf, String> {
+    let data_dir = app_data_dir(state)?;
+    Ok(data_dir
+        .join("workspaces")
+        .join(&entry.id)
+        .join("prompts"))
+}
+
+fn prompt_roots_for_workspace(
+    state: &State<'_, AppState>,
+    entry: &WorkspaceEntry,
+) -> Result<Vec<PathBuf>, String> {
+    let mut roots = Vec::new();
+    roots.push(workspace_prompts_dir(state, entry)?);
+    if let Some(global_dir) = default_prompts_dir() {
+        roots.push(global_dir);
+    }
+    Ok(roots)
+}
+
+fn ensure_path_within_roots(path: &Path, roots: &[PathBuf]) -> Result<(), String> {
+    let canonical_path = path
+        .canonicalize()
+        .map_err(|_| "Invalid prompt path.".to_string())?;
+    for root in roots {
+        if let Ok(canonical_root) = root.canonicalize() {
+            if canonical_path.starts_with(&canonical_root) {
+                return Ok(());
+            }
+        }
+    }
+    Err("Prompt path is not within allowed directories.".to_string())
+}
+
+#[cfg(unix)]
+fn is_cross_device_error(err: &std::io::Error) -> bool {
+    err.raw_os_error() == Some(libc::EXDEV)
+}
+
+#[cfg(not(unix))]
+fn is_cross_device_error(_err: &std::io::Error) -> bool {
+    false
+}
+
+fn move_file(src: &Path, dest: &Path) -> Result<(), String> {
+    match fs::rename(src, dest) {
+        Ok(()) => Ok(()),
+        Err(err) if is_cross_device_error(&err) => {
+            fs::copy(src, dest).map_err(|err| err.to_string())?;
+            fs::remove_file(src).map_err(|err| err.to_string())
+        }
+        Err(err) => Err(err.to_string()),
+    }
+}
+
 fn parse_frontmatter(content: &str) -> (Option<String>, Option<String>, String) {
     let mut segments = content.split_inclusive('\n');
     let Some(first_segment) = segments.next() else {
@@ -107,7 +190,54 @@ fn parse_frontmatter(content: &str) -> (Option<String>, Option<String>, String)
     (description, argument_hint, body)
 }
 
-fn discover_prompts_in(dir: &Path) -> Vec<CustomPromptEntry> {
+fn build_prompt_contents(
+    description: Option<String>,
+    argument_hint: Option<String>,
+    content: String,
+) -> String {
+    let has_meta = description.as_ref().is_some_and(|value| !value.trim().is_empty())
+        || argument_hint
+            .as_ref()
+            .is_some_and(|value| !value.trim().is_empty());
+    if !has_meta {
+        return content;
+    }
+    let mut output = String::from("---\n");
+    if let Some(description) = description {
+        let trimmed = description.trim();
+        if !trimmed.is_empty() {
+            output.push_str(&format!("description: \"{}\"\n", trimmed.replace('"', "\\\"")));
+        }
+    }
+    if let Some(argument_hint) = argument_hint {
+        let trimmed = argument_hint.trim();
+        if !trimmed.is_empty() {
+            output.push_str(&format!(
+                "argument-hint: \"{}\"\n",
+                trimmed.replace('"', "\\\"")
+            ));
+        }
+    }
+    output.push_str("---\n");
+    output.push_str(&content);
+    output
+}
+
+fn sanitize_prompt_name(name: &str) -> Result<String, String> {
+    let trimmed = name.trim();
+    if trimmed.is_empty() {
+        return Err("Prompt name is required.".to_string());
+    }
+    if trimmed.chars().any(|ch| ch.is_whitespace()) {
+        return Err("Prompt name cannot include whitespace.".to_string());
+    }
+    if trimmed.contains('/') || trimmed.contains('\\') {
+        return Err("Prompt name cannot include path separators.".to_string());
+    }
+    Ok(trimmed.to_string())
+}
+
+fn discover_prompts_in(dir: &Path, scope: Option<&str>) -> Vec<CustomPromptEntry> {
     let mut out: Vec<CustomPromptEntry> = Vec::new();
     let entries = match fs::read_dir(dir) {
         Ok(entries) => entries,
@@ -146,6 +276,7 @@ fn discover_prompts_in(dir: &Path) -> Vec<CustomPromptEntry> {
             description,
             argument_hint,
             content: body,
+            scope: scope.map(|value| value.to_string()),
         });
     }
 
@@ -154,11 +285,227 @@ fn discover_prompts_in(dir: &Path) -> Vec<CustomPromptEntry> {
 }
 
 #[tauri::command]
-pub(crate) async fn prompts_list(_workspace_id: String) -> Result<Vec<CustomPromptEntry>, String> {
-    let Some(dir) = default_prompts_dir() else {
-        return Ok(Vec::new());
+pub(crate) async fn prompts_list(
+    state: State<'_, AppState>,
+    workspace_id: String,
+) -> Result<Vec<CustomPromptEntry>, String> {
+    let (workspace_dir, global_dir) = {
+        let workspaces = state.workspaces.lock().await;
+        let entry = workspaces.get(&workspace_id).cloned();
+        let workspace_dir = entry
+            .as_ref()
+            .and_then(|entry| workspace_prompts_dir(&state, entry).ok());
+        (workspace_dir, default_prompts_dir())
+    };
+
+    task::spawn_blocking(move || {
+        let mut out = Vec::new();
+        if let Some(dir) = workspace_dir {
+            let _ = fs::create_dir_all(&dir);
+            out.extend(discover_prompts_in(&dir, Some("workspace")));
+        }
+        if let Some(dir) = global_dir {
+            let _ = fs::create_dir_all(&dir);
+            out.extend(discover_prompts_in(&dir, Some("global")));
+        }
+        out
+    })
+    .await
+    .map_err(|_| "prompt discovery failed".to_string())
+}
+
+#[tauri::command]
+pub(crate) async fn prompts_workspace_dir(
+    state: State<'_, AppState>,
+    workspace_id: String,
+) -> Result<String, String> {
+    let dir = {
+        let workspaces = state.workspaces.lock().await;
+        let entry = require_workspace_entry(&workspaces, &workspace_id)?;
+        workspace_prompts_dir(&state, &entry)?
+    };
+    fs::create_dir_all(&dir).map_err(|err| err.to_string())?;
+    Ok(dir.to_string_lossy().to_string())
+}
+
+#[tauri::command]
+pub(crate) async fn prompts_global_dir() -> Result<String, String> {
+    let dir = default_prompts_dir().ok_or("Unable to resolve CODEX_HOME".to_string())?;
+    fs::create_dir_all(&dir).map_err(|err| err.to_string())?;
+    Ok(dir.to_string_lossy().to_string())
+}
+
+#[tauri::command]
+pub(crate) async fn prompts_create(
+    state: State<'_, AppState>,
+    workspace_id: String,
+    scope: String,
+    name: String,
+    description: Option<String>,
+    argument_hint: Option<String>,
+    content: String,
+) -> Result<CustomPromptEntry, String> {
+    let name = sanitize_prompt_name(&name)?;
+    let (target_dir, resolved_scope) = {
+        let workspaces = state.workspaces.lock().await;
+        let entry = require_workspace_entry(&workspaces, &workspace_id)?;
+        match scope.as_str() {
+            "workspace" => {
+                let dir = workspace_prompts_dir(&state, &entry)?;
+                (dir, "workspace")
+            }
+            "global" => {
+                let dir = default_prompts_dir().ok_or("Unable to resolve CODEX_HOME".to_string())?;
+                (dir, "global")
+            }
+            _ => return Err("Invalid scope.".to_string()),
+        }
     };
-    task::spawn_blocking(move || discover_prompts_in(&dir))
-        .await
-        .map_err(|_| "prompt discovery failed".to_string())
+    let path = target_dir.join(format!("{name}.md"));
+    if path.exists() {
+        return Err("Prompt already exists.".to_string());
+    }
+    if let Some(parent) = path.parent() {
+        fs::create_dir_all(parent).map_err(|err| err.to_string())?;
+    }
+    let body = build_prompt_contents(description.clone(), argument_hint.clone(), content.clone());
+    fs::write(&path, body).map_err(|err| err.to_string())?;
+    Ok(CustomPromptEntry {
+        name,
+        path: path.to_string_lossy().to_string(),
+        description,
+        argument_hint,
+        content,
+        scope: Some(resolved_scope.to_string()),
+    })
+}
+
+#[tauri::command]
+pub(crate) async fn prompts_update(
+    state: State<'_, AppState>,
+    workspace_id: String,
+    path: String,
+    name: String,
+    description: Option<String>,
+    argument_hint: Option<String>,
+    content: String,
+) -> Result<CustomPromptEntry, String> {
+    let name = sanitize_prompt_name(&name)?;
+    let target_path = PathBuf::from(&path);
+    if !target_path.exists() {
+        return Err("Prompt not found.".to_string());
+    }
+    {
+        let workspaces = state.workspaces.lock().await;
+        let entry = require_workspace_entry(&workspaces, &workspace_id)?;
+        let roots = prompt_roots_for_workspace(&state, &entry)?;
+        ensure_path_within_roots(&target_path, &roots)?;
+    }
+    let dir = target_path
+        .parent()
+        .ok_or("Unable to resolve prompt directory.".to_string())?;
+    let next_path = dir.join(format!("{name}.md"));
+    if next_path != target_path && next_path.exists() {
+        return Err("Prompt with that name already exists.".to_string());
+    }
+    let body = build_prompt_contents(description.clone(), argument_hint.clone(), content.clone());
+    fs::write(&next_path, body).map_err(|err| err.to_string())?;
+    if next_path != target_path {
+        fs::remove_file(&target_path).map_err(|err| err.to_string())?;
+    }
+    let scope = {
+        let workspaces = state.workspaces.lock().await;
+        let entry = require_workspace_entry(&workspaces, &workspace_id)?;
+        let workspace_dir = workspace_prompts_dir(&state, &entry)?;
+        if next_path.starts_with(&workspace_dir) {
+            Some("workspace".to_string())
+        } else {
+            Some("global".to_string())
+        }
+    };
+    Ok(CustomPromptEntry {
+        name,
+        path: next_path.to_string_lossy().to_string(),
+        description,
+        argument_hint,
+        content,
+        scope,
+    })
+}
+
+#[tauri::command]
+pub(crate) async fn prompts_delete(
+    state: State<'_, AppState>,
+    workspace_id: String,
+    path: String,
+) -> Result<(), String> {
+    let target = PathBuf::from(path);
+    if !target.exists() {
+        return Ok(());
+    }
+    {
+        let workspaces = state.workspaces.lock().await;
+        let entry = require_workspace_entry(&workspaces, &workspace_id)?;
+        let roots = prompt_roots_for_workspace(&state, &entry)?;
+        ensure_path_within_roots(&target, &roots)?;
+    }
+    fs::remove_file(&target).map_err(|err| err.to_string())
+}
+
+#[tauri::command]
+pub(crate) async fn prompts_move(
+    state: State<'_, AppState>,
+    workspace_id: String,
+    path: String,
+    scope: String,
+) -> Result<CustomPromptEntry, String> {
+    let target_path = PathBuf::from(&path);
+    if !target_path.exists() {
+        return Err("Prompt not found.".to_string());
+    }
+    let roots = {
+        let workspaces = state.workspaces.lock().await;
+        let entry = require_workspace_entry(&workspaces, &workspace_id)?;
+        prompt_roots_for_workspace(&state, &entry)?
+    };
+    ensure_path_within_roots(&target_path, &roots)?;
+    let file_name = target_path
+        .file_name()
+        .and_then(|value| value.to_str())
+        .ok_or("Invalid prompt path.".to_string())?;
+    let target_dir = {
+        let workspaces = state.workspaces.lock().await;
+        let entry = require_workspace_entry(&workspaces, &workspace_id)?;
+        match scope.as_str() {
+            "workspace" => workspace_prompts_dir(&state, &entry)?,
+            "global" => default_prompts_dir().ok_or("Unable to resolve CODEX_HOME".to_string())?,
+            _ => return Err("Invalid scope.".to_string()),
+        }
+    };
+    let next_path = target_dir.join(file_name);
+    if next_path == target_path {
+        return Err("Prompt is already in that scope.".to_string());
+    }
+    if next_path.exists() {
+        return Err("Prompt with that name already exists.".to_string());
+    }
+    if let Some(parent) = next_path.parent() {
+        fs::create_dir_all(parent).map_err(|err| err.to_string())?;
+    }
+    move_file(&target_path, &next_path)?;
+    let content = fs::read_to_string(&next_path).unwrap_or_default();
+    let (description, argument_hint, body) = parse_frontmatter(&content);
+    let name = next_path
+        .file_stem()
+        .and_then(|value| value.to_str())
+        .unwrap_or("")
+        .to_string();
+    Ok(CustomPromptEntry {
+        name,
+        path: next_path.to_string_lossy().to_string(),
+        description,
+        argument_hint,
+        content: body,
+        scope: Some(scope),
+    })
 }
diff --git a/src/App.tsx b/src/App.tsx
index 843ad4eb7..b8fd92bb7 100644
--- a/src/App.tsx
+++ b/src/App.tsx
@@ -11,6 +11,8 @@ import "./styles/composer.css";
 import "./styles/diff.css";
 import "./styles/diff-viewer.css";
 import "./styles/file-tree.css";
+import "./styles/panel-tabs.css";
+import "./styles/prompts.css";
 import "./styles/debug.css";
 import "./styles/terminal.css";
 import "./styles/plan.css";
@@ -56,6 +58,7 @@ import { useLayoutMode } from "./features/layout/hooks/useLayoutMode";
 import { useSidebarToggles } from "./features/layout/hooks/useSidebarToggles";
 import { useTransparencyPreference } from "./features/layout/hooks/useTransparencyPreference";
 import { useWindowLabel } from "./features/layout/hooks/useWindowLabel";
+import { revealItemInDir } from "@tauri-apps/plugin-opener";
 import {
   RightPanelCollapseButton,
   SidebarCollapseButton,
@@ -162,7 +165,9 @@ function MainApp() {
   const [gitPanelMode, setGitPanelMode] = useState<
     "diff" | "log" | "issues" | "prs"
   >("diff");
-  const [filePanelMode, setFilePanelMode] = useState<"git" | "files">("git");
+  const [filePanelMode, setFilePanelMode] = useState<
+    "git" | "files" | "prompts"
+  >("git");
   const [selectedPullRequest, setSelectedPullRequest] =
     useState<GitHubPullRequest | null>(null);
   const [diffSource, setDiffSource] = useState<"local" | "pr">("local");
@@ -414,7 +419,15 @@ function MainApp() {
     onDebug: addDebugEntry,
   });
   const { skills } = useSkills({ activeWorkspace, onDebug: addDebugEntry });
-  const { prompts } = useCustomPrompts({ activeWorkspace, onDebug: addDebugEntry });
+  const {
+    prompts,
+    createPrompt,
+    updatePrompt,
+    deletePrompt,
+    movePrompt,
+    getWorkspacePromptsDir,
+    getGlobalPromptsDir,
+  } = useCustomPrompts({ activeWorkspace, onDebug: addDebugEntry });
   const { files, isLoading: isFilesLoading } = useWorkspaceFiles({
     activeWorkspace,
     onDebug: addDebugEntry,
@@ -583,6 +596,7 @@ function MainApp() {
     listThreadsForWorkspace,
     loadOlderThreadsForWorkspace,
     sendUserMessage,
+    sendUserMessageToThread,
     startReview,
     handleApprovalDecision
   } = useThreads({
@@ -738,6 +752,114 @@ function MainApp() {
     },
     [activeThreadId]
   );
+
+  const handleSendPrompt = useCallback(
+    (text: string) => {
+      if (!text.trim()) {
+        return;
+      }
+      void handleSend(text, []);
+    },
+    [handleSend],
+  );
+
+  const handleSendPromptToNewAgent = useCallback(
+    async (text: string) => {
+      const trimmed = text.trim();
+      if (!activeWorkspace || !trimmed) {
+        return;
+      }
+      if (!activeWorkspace.connected) {
+        await connectWorkspace(activeWorkspace);
+      }
+      const threadId = await startThreadForWorkspace(activeWorkspace.id, {
+        activate: false,
+      });
+      if (!threadId) {
+        return;
+      }
+      await sendUserMessageToThread(activeWorkspace, threadId, trimmed, []);
+    },
+    [activeWorkspace, connectWorkspace, sendUserMessageToThread, startThreadForWorkspace],
+  );
+
+  const alertError = useCallback((error: unknown) => {
+    alert(error instanceof Error ? error.message : String(error));
+  }, []);
+
+  const handleCreatePrompt = useCallback(
+    async (data: {
+      scope: "workspace" | "global";
+      name: string;
+      description?: string | null;
+      argumentHint?: string | null;
+      content: string;
+    }) => {
+      try {
+        await createPrompt(data);
+      } catch (error) {
+        alertError(error);
+      }
+    },
+    [alertError, createPrompt],
+  );
+
+  const handleUpdatePrompt = useCallback(
+    async (data: {
+      path: string;
+      name: string;
+      description?: string | null;
+      argumentHint?: string | null;
+      content: string;
+    }) => {
+      try {
+        await updatePrompt(data);
+      } catch (error) {
+        alertError(error);
+      }
+    },
+    [alertError, updatePrompt],
+  );
+
+  const handleDeletePrompt = useCallback(
+    async (path: string) => {
+      try {
+        await deletePrompt(path);
+      } catch (error) {
+        alertError(error);
+      }
+    },
+    [alertError, deletePrompt],
+  );
+
+  const handleMovePrompt = useCallback(
+    async (data: { path: string; scope: "workspace" | "global" }) => {
+      try {
+        await movePrompt(data);
+      } catch (error) {
+        alertError(error);
+      }
+    },
+    [alertError, movePrompt],
+  );
+
+  const handleRevealWorkspacePrompts = useCallback(async () => {
+    try {
+      const path = await getWorkspacePromptsDir();
+      await revealItemInDir(path);
+    } catch (error) {
+      alertError(error);
+    }
+  }, [alertError, getWorkspacePromptsDir]);
+
+  const handleRevealGeneralPrompts = useCallback(async () => {
+    try {
+      const path = await getGlobalPromptsDir();
+      await revealItemInDir(path);
+    } catch (error) {
+      alertError(error);
+    }
+  }, [alertError, getGlobalPromptsDir]);
   const isWorktreeWorkspace = activeWorkspace?.kind === "worktree";
   const activeParentWorkspace = isWorktreeWorkspace
     ? workspaces.find((entry) => entry.id === activeWorkspace?.parentId) ?? null
@@ -1092,9 +1214,7 @@ function MainApp() {
       <RightPanelCollapseButton {...sidebarToggleProps} />
     ) : null,
     filePanelMode,
-    onToggleFilePanel: () => {
-      setFilePanelMode((prev) => (prev === "git" ? "files" : "git"));
-    },
+    onFilePanelModeChange: setFilePanelMode,
     fileTreeLoading: isFilesLoading,
     centerMode,
     onExitDiff: () => {
@@ -1156,6 +1276,14 @@ function MainApp() {
     gitDiffLoading: activeDiffLoading,
     gitDiffError: activeDiffError,
     onDiffActivePathChange: handleActiveDiffPath,
+    onSendPrompt: handleSendPrompt,
+    onSendPromptToNewAgent: handleSendPromptToNewAgent,
+    onCreatePrompt: handleCreatePrompt,
+    onUpdatePrompt: handleUpdatePrompt,
+    onDeletePrompt: handleDeletePrompt,
+    onMovePrompt: handleMovePrompt,
+    onRevealWorkspacePrompts: handleRevealWorkspacePrompts,
+    onRevealGeneralPrompts: handleRevealGeneralPrompts,
     onSend: handleSend,
     onQueue: queueMessage,
     onStop: interruptTurn,
diff --git a/src/features/files/components/FileTreePanel.tsx b/src/features/files/components/FileTreePanel.tsx
index 75d2f332e..5da06985b 100644
--- a/src/features/files/components/FileTreePanel.tsx
+++ b/src/features/files/components/FileTreePanel.tsx
@@ -5,7 +5,6 @@ import { LogicalPosition } from "@tauri-apps/api/dpi";
 import { getCurrentWindow } from "@tauri-apps/api/window";
 import { revealItemInDir } from "@tauri-apps/plugin-opener";
 import {
-  ArrowLeftRight,
   ChevronsUpDown,
   File,
   FileArchive,
@@ -19,6 +18,7 @@ import {
   Folder,
   Search,
 } from "lucide-react";
+import { PanelTabs, type PanelTabId } from "../../layout/components/PanelTabs";
 
 type FileTreeNode = {
   name: string;
@@ -31,7 +31,8 @@ type FileTreePanelProps = {
   workspacePath: string;
   files: string[];
   isLoading: boolean;
-  onToggleFilePanel: () => void;
+  filePanelMode: PanelTabId;
+  onFilePanelModeChange: (mode: PanelTabId) => void;
 };
 
 type FileTreeBuildNode = {
@@ -177,7 +178,8 @@ export function FileTreePanel({
   workspacePath,
   files,
   isLoading,
-  onToggleFilePanel,
+  filePanelMode,
+  onFilePanelModeChange,
 }: FileTreePanelProps) {
   const [expandedFolders, setExpandedFolders] = useState<Set<string>>(new Set());
   const [query, setQuery] = useState("");
@@ -326,17 +328,7 @@ export function FileTreePanel({
   return (
     <aside className="diff-panel file-tree-panel">
       <div className="git-panel-header">
-        <button
-          type="button"
-          className="git-panel-title git-panel-title-button"
-          onClick={onToggleFilePanel}
-          aria-label="Show git panel"
-          title="Show git panel"
-        >
-          <Folder className="git-panel-icon" />
-          Files
-          <ArrowLeftRight className="git-panel-switch-icon" aria-hidden />
-        </button>
+        <PanelTabs active={filePanelMode} onSelect={onFilePanelModeChange} />
         <div className="file-tree-meta">
           <div className="file-tree-count">
           {filteredFiles.length
diff --git a/src/features/git/components/GitDiffPanel.tsx b/src/features/git/components/GitDiffPanel.tsx
index f69cf8ecf..78729f4f6 100644
--- a/src/features/git/components/GitDiffPanel.tsx
+++ b/src/features/git/components/GitDiffPanel.tsx
@@ -4,13 +4,15 @@ import { Menu, MenuItem } from "@tauri-apps/api/menu";
 import { LogicalPosition } from "@tauri-apps/api/dpi";
 import { getCurrentWindow } from "@tauri-apps/api/window";
 import { openUrl } from "@tauri-apps/plugin-opener";
-import { ArrowLeftRight, GitBranch } from "lucide-react";
+import { ArrowLeftRight } from "lucide-react";
 import { formatRelativeTime } from "../../../utils/time";
+import { PanelTabs, type PanelTabId } from "../../layout/components/PanelTabs";
 
 type GitDiffPanelProps = {
   mode: "diff" | "log" | "issues" | "prs";
   onModeChange: (mode: "diff" | "log" | "issues" | "prs") => void;
-  onToggleFilePanel: () => void;
+  filePanelMode: PanelTabId;
+  onFilePanelModeChange: (mode: PanelTabId) => void;
   branchName: string;
   totalAdditions: number;
   totalDeletions: number;
@@ -143,7 +145,8 @@ function isMissingRepo(error: string | null | undefined) {
 export function GitDiffPanel({
   mode,
   onModeChange,
-  onToggleFilePanel,
+  filePanelMode,
+  onFilePanelModeChange,
   branchName,
   totalAdditions,
   totalDeletions,
@@ -332,17 +335,7 @@ export function GitDiffPanel({
   return (
     <aside className="diff-panel">
       <div className="git-panel-header">
-        <button
-          type="button"
-          className="git-panel-title git-panel-title-button"
-          onClick={onToggleFilePanel}
-          aria-label="Show file tree"
-          title="Show file tree"
-        >
-          <GitBranch className="git-panel-icon" />
-          Git
-          <ArrowLeftRight className="git-panel-switch-icon" aria-hidden />
-        </button>
+        <PanelTabs active={filePanelMode} onSelect={onFilePanelModeChange} />
         <div className="git-panel-select" role="group" aria-label="Git panel">
           <select
             className="git-panel-select-input"
diff --git a/src/features/layout/components/PanelTabs.tsx b/src/features/layout/components/PanelTabs.tsx
new file mode 100644
index 000000000..6d05340eb
--- /dev/null
+++ b/src/features/layout/components/PanelTabs.tsx
@@ -0,0 +1,47 @@
+import type { ReactNode } from "react";
+import { Folder, GitBranch, ScrollText } from "lucide-react";
+
+export type PanelTabId = "git" | "files" | "prompts";
+
+type PanelTab = {
+  id: PanelTabId;
+  label: string;
+  icon: ReactNode;
+};
+
+type PanelTabsProps = {
+  active: PanelTabId;
+  onSelect: (id: PanelTabId) => void;
+  tabs?: PanelTab[];
+};
+
+const defaultTabs: PanelTab[] = [
+  { id: "git", label: "Git", icon: <GitBranch aria-hidden /> },
+  { id: "files", label: "Files", icon: <Folder aria-hidden /> },
+  { id: "prompts", label: "Prompts", icon: <ScrollText aria-hidden /> },
+];
+
+export function PanelTabs({ active, onSelect, tabs = defaultTabs }: PanelTabsProps) {
+  return (
+    <div className="panel-tabs" role="tablist" aria-label="Panel">
+      {tabs.map((tab) => {
+        const isActive = active === tab.id;
+        return (
+          <button
+            key={tab.id}
+            type="button"
+            className={`panel-tab${isActive ? " is-active" : ""}`}
+            onClick={() => onSelect(tab.id)}
+            aria-current={isActive ? "page" : undefined}
+            aria-label={tab.label}
+            title={tab.label}
+          >
+            <span className="panel-tab-icon" aria-hidden>
+              {tab.icon}
+            </span>
+          </button>
+        );
+      })}
+    </div>
+  );
+}
diff --git a/src/features/layout/hooks/useLayoutNodes.tsx b/src/features/layout/hooks/useLayoutNodes.tsx
index d1b20a131..5fd71e37c 100644
--- a/src/features/layout/hooks/useLayoutNodes.tsx
+++ b/src/features/layout/hooks/useLayoutNodes.tsx
@@ -10,6 +10,7 @@ import { Composer } from "../../composer/components/Composer";
 import { GitDiffPanel } from "../../git/components/GitDiffPanel";
 import { GitDiffViewer } from "../../git/components/GitDiffViewer";
 import { FileTreePanel } from "../../files/components/FileTreePanel";
+import { PromptPanel } from "../../prompts/components/PromptPanel";
 import { DebugPanel } from "../../debug/components/DebugPanel";
 import { PlanPanel } from "../../plan/components/PlanPanel";
 import { TabBar } from "../../app/components/TabBar";
@@ -132,8 +133,8 @@ type LayoutNodesOptions = {
   tabletNavTab: "codex" | "git" | "log";
   gitPanelMode: "diff" | "log" | "issues" | "prs";
   onGitPanelModeChange: (mode: "diff" | "log" | "issues" | "prs") => void;
-  filePanelMode: "git" | "files";
-  onToggleFilePanel: () => void;
+  filePanelMode: "git" | "files" | "prompts";
+  onFilePanelModeChange: (mode: "git" | "files" | "prompts") => void;
   fileTreeLoading: boolean;
   gitStatus: {
     branchName: string;
@@ -189,6 +190,26 @@ type LayoutNodesOptions = {
   gitDiffLoading: boolean;
   gitDiffError: string | null;
   onDiffActivePathChange?: (path: string) => void;
+  onSendPrompt: (text: string) => void | Promise<void>;
+  onSendPromptToNewAgent: (text: string) => void | Promise<void>;
+  onCreatePrompt: (data: {
+    scope: "workspace" | "global";
+    name: string;
+    description?: string | null;
+    argumentHint?: string | null;
+    content: string;
+  }) => void | Promise<void>;
+  onUpdatePrompt: (data: {
+    path: string;
+    name: string;
+    description?: string | null;
+    argumentHint?: string | null;
+    content: string;
+  }) => void | Promise<void>;
+  onDeletePrompt: (path: string) => void | Promise<void>;
+  onMovePrompt: (data: { path: string; scope: "workspace" | "global" }) => void | Promise<void>;
+  onRevealWorkspacePrompts: () => void | Promise<void>;
+  onRevealGeneralPrompts: () => void | Promise<void>;
   onSend: (text: string, images: string[]) => void | Promise<void>;
   onQueue: (text: string, images: string[]) => void | Promise<void>;
   onStop: () => void;
@@ -453,18 +474,41 @@ export function useLayoutNodes(options: LayoutNodesOptions): LayoutNodesResult {
     <TabBar activeTab={options.activeTab} onSelect={options.onSelectTab} />
   );
 
-  const gitDiffPanelNode =
-    options.filePanelMode === "files" && options.activeWorkspace ? (
+  let gitDiffPanelNode: ReactNode;
+  if (options.filePanelMode === "files" && options.activeWorkspace) {
+    gitDiffPanelNode = (
       <FileTreePanel
         workspacePath={options.activeWorkspace.path}
         files={options.files}
         isLoading={options.fileTreeLoading}
-        onToggleFilePanel={options.onToggleFilePanel}
+        filePanelMode={options.filePanelMode}
+        onFilePanelModeChange={options.onFilePanelModeChange}
       />
-    ) : (
+    );
+  } else if (options.filePanelMode === "prompts") {
+    gitDiffPanelNode = (
+      <PromptPanel
+        prompts={options.prompts}
+        workspacePath={options.activeWorkspace?.path ?? null}
+        filePanelMode={options.filePanelMode}
+        onFilePanelModeChange={options.onFilePanelModeChange}
+        onSendPrompt={options.onSendPrompt}
+        onSendPromptToNewAgent={options.onSendPromptToNewAgent}
+        onCreatePrompt={options.onCreatePrompt}
+        onUpdatePrompt={options.onUpdatePrompt}
+        onDeletePrompt={options.onDeletePrompt}
+        onMovePrompt={options.onMovePrompt}
+        onRevealWorkspacePrompts={options.onRevealWorkspacePrompts}
+        onRevealGeneralPrompts={options.onRevealGeneralPrompts}
+      />
+    );
+  } else {
+    gitDiffPanelNode = (
       <GitDiffPanel
         mode={options.gitPanelMode}
         onModeChange={options.onGitPanelModeChange}
+        filePanelMode={options.filePanelMode}
+        onFilePanelModeChange={options.onFilePanelModeChange}
         branchName={options.gitStatus.branchName || "unknown"}
         totalAdditions={options.gitStatus.totalAdditions}
         totalDeletions={options.gitStatus.totalDeletions}
@@ -494,7 +538,6 @@ export function useLayoutNodes(options: LayoutNodesOptions): LayoutNodesResult {
         selectedPullRequest={options.selectedPullRequestNumber}
         onSelectPullRequest={options.onSelectPullRequest}
         gitRemoteUrl={options.gitRemoteUrl}
-        onToggleFilePanel={options.onToggleFilePanel}
         gitRoot={options.gitRoot}
         gitRootCandidates={options.gitRootCandidates}
         gitRootScanDepth={options.gitRootScanDepth}
@@ -511,6 +554,7 @@ export function useLayoutNodes(options: LayoutNodesOptions): LayoutNodesResult {
         onRevertFile={options.onRevertGitFile}
       />
     );
+  }
 
   const gitDiffViewerNode = (
     <GitDiffViewer
diff --git a/src/features/prompts/components/PromptPanel.tsx b/src/features/prompts/components/PromptPanel.tsx
new file mode 100644
index 000000000..f8b2014d7
--- /dev/null
+++ b/src/features/prompts/components/PromptPanel.tsx
@@ -0,0 +1,581 @@
+import {
+  useEffect,
+  useMemo,
+  useRef,
+  useState,
+  type MouseEvent as ReactMouseEvent,
+} from "react";
+import type { CustomPromptOption } from "../../../types";
+import { expandCustomPromptText, getPromptArgumentHint } from "../../../utils/customPrompts";
+import { PanelTabs, type PanelTabId } from "../../layout/components/PanelTabs";
+import { Menu, MenuItem } from "@tauri-apps/api/menu";
+import { LogicalPosition } from "@tauri-apps/api/dpi";
+import { getCurrentWindow } from "@tauri-apps/api/window";
+import { MoreHorizontal, Plus, ScrollText, Search } from "lucide-react";
+
+type PromptPanelProps = {
+  prompts: CustomPromptOption[];
+  workspacePath: string | null;
+  filePanelMode: PanelTabId;
+  onFilePanelModeChange: (mode: PanelTabId) => void;
+  onSendPrompt: (text: string) => void | Promise<void>;
+  onSendPromptToNewAgent: (text: string) => void | Promise<void>;
+  onCreatePrompt: (data: {
+    scope: "workspace" | "global";
+    name: string;
+    description?: string | null;
+    argumentHint?: string | null;
+    content: string;
+  }) => void | Promise<void>;
+  onUpdatePrompt: (data: {
+    path: string;
+    name: string;
+    description?: string | null;
+    argumentHint?: string | null;
+    content: string;
+  }) => void | Promise<void>;
+  onDeletePrompt: (path: string) => void | Promise<void>;
+  onMovePrompt: (data: { path: string; scope: "workspace" | "global" }) => void | Promise<void>;
+  onRevealWorkspacePrompts: () => void | Promise<void>;
+  onRevealGeneralPrompts: () => void | Promise<void>;
+};
+
+const PROMPTS_PREFIX = "prompts:";
+
+type PromptEditorState = {
+  mode: "create" | "edit";
+  scope: "workspace" | "global";
+  name: string;
+  description: string;
+  argumentHint: string;
+  content: string;
+  path?: string;
+};
+
+function buildPromptCommand(name: string, args: string) {
+  const trimmedArgs = args.trim();
+  return `/${PROMPTS_PREFIX}${name}${trimmedArgs ? ` ${trimmedArgs}` : ""}`;
+}
+
+function isWorkspacePrompt(prompt: CustomPromptOption) {
+  return prompt.scope === "workspace";
+}
+
+export function PromptPanel({
+  prompts,
+  workspacePath,
+  filePanelMode,
+  onFilePanelModeChange,
+  onSendPrompt,
+  onSendPromptToNewAgent,
+  onCreatePrompt,
+  onUpdatePrompt,
+  onDeletePrompt,
+  onMovePrompt,
+  onRevealWorkspacePrompts,
+  onRevealGeneralPrompts,
+}: PromptPanelProps) {
+  const [query, setQuery] = useState("");
+  const [argsByPrompt, setArgsByPrompt] = useState<Record<string, string>>({});
+  const [editor, setEditor] = useState<PromptEditorState | null>(null);
+  const [editorError, setEditorError] = useState<string | null>(null);
+  const [isSaving, setIsSaving] = useState(false);
+  const [pendingDeletePath, setPendingDeletePath] = useState<string | null>(null);
+  const [highlightKey, setHighlightKey] = useState<string | null>(null);
+  const highlightTimer = useRef<number | null>(null);
+  const normalizedQuery = query.trim().toLowerCase();
+
+  const showError = (error: unknown) => {
+    window.alert(error instanceof Error ? error.message : String(error));
+  };
+
+  const resetEditorState = () => {
+    setEditorError(null);
+    setPendingDeletePath(null);
+  };
+
+  const updateEditor = (patch: Partial<PromptEditorState>) => {
+    setEditor((prev) => (prev ? { ...prev, ...patch } : prev));
+  };
+
+  useEffect(() => {
+    return () => {
+      if (highlightTimer.current) {
+        window.clearTimeout(highlightTimer.current);
+      }
+    };
+  }, []);
+
+  useEffect(() => {
+    if (!pendingDeletePath) {
+      return;
+    }
+    const stillExists = prompts.some((prompt) => prompt.path === pendingDeletePath);
+    if (!stillExists) {
+      setPendingDeletePath(null);
+    }
+  }, [pendingDeletePath, prompts]);
+
+  const triggerHighlight = (key: string) => {
+    if (!key) {
+      return;
+    }
+    if (highlightTimer.current) {
+      window.clearTimeout(highlightTimer.current);
+    }
+    setHighlightKey(key);
+    highlightTimer.current = window.setTimeout(() => {
+      setHighlightKey(null);
+    }, 650);
+  };
+
+  const buildPromptText = (prompt: CustomPromptOption, args: string) => {
+    const command = buildPromptCommand(prompt.name, args);
+    const expansion = expandCustomPromptText(command, [prompt]);
+    if (expansion && "error" in expansion) {
+      showError(expansion.error);
+      return null;
+    }
+    if (expansion && "expanded" in expansion) {
+      return expansion.expanded;
+    }
+    return prompt.content;
+  };
+
+  const filteredPrompts = useMemo(() => {
+    if (!normalizedQuery) {
+      return prompts;
+    }
+    return prompts.filter((prompt) => {
+      const haystack = `${prompt.name} ${prompt.description ?? ""} ${prompt.path}`.toLowerCase();
+      return haystack.includes(normalizedQuery);
+    });
+  }, [normalizedQuery, prompts]);
+
+  const { workspacePrompts, globalPrompts } = useMemo(() => {
+    const workspaceEntries: CustomPromptOption[] = [];
+    const globalEntries: CustomPromptOption[] = [];
+    filteredPrompts.forEach((prompt) => {
+      if (isWorkspacePrompt(prompt)) {
+        workspaceEntries.push(prompt);
+      } else {
+        globalEntries.push(prompt);
+      }
+    });
+    return { workspacePrompts: workspaceEntries, globalPrompts: globalEntries };
+  }, [filteredPrompts]);
+
+  const totalCount = filteredPrompts.length;
+  const hasPrompts = totalCount > 0;
+
+  const handleArgsChange = (key: string, value: string) => {
+    setArgsByPrompt((prev) => ({ ...prev, [key]: value }));
+  };
+
+  const startCreate = (scope: "workspace" | "global") => {
+    resetEditorState();
+    setEditor({
+      mode: "create",
+      scope,
+      name: "",
+      description: "",
+      argumentHint: "",
+      content: "",
+    });
+  };
+
+  const startEdit = (prompt: CustomPromptOption) => {
+    const scope = isWorkspacePrompt(prompt) ? "workspace" : "global";
+    resetEditorState();
+    setEditor({
+      mode: "edit",
+      scope,
+      name: prompt.name,
+      description: prompt.description ?? "",
+      argumentHint: prompt.argumentHint ?? "",
+      content: prompt.content ?? "",
+      path: prompt.path,
+    });
+  };
+
+  const handleSave = async () => {
+    if (!editor || isSaving) {
+      return;
+    }
+    const name = editor.name.trim();
+    if (!name) {
+      setEditorError("Name is required.");
+      return;
+    }
+    if (/\s/.test(name)) {
+      setEditorError("Name cannot include whitespace.");
+      return;
+    }
+    setEditorError(null);
+    setIsSaving(true);
+    const description = editor.description.trim() || null;
+    const argumentHint = editor.argumentHint.trim() || null;
+    const content = editor.content;
+    try {
+      if (editor.mode === "create") {
+        await onCreatePrompt({
+          scope: editor.scope,
+          name,
+          description,
+          argumentHint,
+          content,
+        });
+        triggerHighlight(name);
+      } else if (editor.path) {
+        await onUpdatePrompt({
+          path: editor.path,
+          name,
+          description,
+          argumentHint,
+          content,
+        });
+        triggerHighlight(editor.path ?? name);
+      }
+      setEditor(null);
+    } catch (error) {
+      setEditorError(error instanceof Error ? error.message : String(error));
+    } finally {
+      setIsSaving(false);
+    }
+  };
+
+  const handleDeleteRequest = (prompt: CustomPromptOption) => {
+    if (!prompt.path) {
+      return;
+    }
+    setPendingDeletePath(prompt.path);
+  };
+
+  const handleDeleteConfirm = async (prompt: CustomPromptOption) => {
+    if (!prompt.path) {
+      return;
+    }
+    try {
+      await onDeletePrompt(prompt.path);
+      setPendingDeletePath((current) =>
+        current === prompt.path ? null : current,
+      );
+    } catch (error) {
+      showError(error);
+    }
+  };
+
+  const handleMove = async (prompt: CustomPromptOption, scope: "workspace" | "global") => {
+    if (!prompt.path) {
+      return;
+    }
+    try {
+      await onMovePrompt({ path: prompt.path, scope });
+      triggerHighlight(prompt.name);
+    } catch (error) {
+      showError(error);
+    }
+  };
+
+  const showPromptMenu = async (
+    event: ReactMouseEvent<HTMLButtonElement>,
+    prompt: CustomPromptOption,
+  ) => {
+    event.preventDefault();
+    event.stopPropagation();
+    const scope = isWorkspacePrompt(prompt) ? "workspace" : "global";
+    const nextScope = scope === "workspace" ? "global" : "workspace";
+    const menu = await Menu.new({
+      items: [
+        await MenuItem.new({
+          text: "Edit",
+          action: () => startEdit(prompt),
+        }),
+        await MenuItem.new({
+          text: `Move to ${nextScope === "workspace" ? "workspace" : "general"}`,
+          action: () => void handleMove(prompt, nextScope),
+        }),
+        await MenuItem.new({
+          text: "Delete",
+          action: () => handleDeleteRequest(prompt),
+        }),
+      ],
+    });
+    const position = new LogicalPosition(event.clientX, event.clientY);
+    const window = getCurrentWindow();
+    await menu.popup(position, window);
+  };
+
+  const renderPromptRow = (prompt: CustomPromptOption) => {
+    const hint = getPromptArgumentHint(prompt);
+    const showArgsInput = Boolean(hint);
+    const key = prompt.path || prompt.name;
+    const argsValue = argsByPrompt[key] ?? "";
+    const effectiveArgs = showArgsInput ? argsValue : "";
+    const isHighlighted = highlightKey === prompt.path || highlightKey === prompt.name;
+    return (
+      <div className={`prompt-row${isHighlighted ? " is-highlight" : ""}`} key={key}>
+        <div className="prompt-row-header">
+          <div className="prompt-name">{prompt.name}</div>
+          {prompt.description && (
+            <div className="prompt-description">{prompt.description}</div>
+          )}
+        </div>
+        {hint && <div className="prompt-hint">{hint}</div>}
+        <div className="prompt-actions">
+          {showArgsInput ? (
+            <input
+              className="prompt-args-input"
+              type="text"
+              placeholder={hint ?? "Arguments"}
+              value={argsValue}
+              onChange={(event) => handleArgsChange(key, event.target.value)}
+              aria-label={`Arguments for ${prompt.name}`}
+            />
+          ) : null}
+          <button
+            type="button"
+            className="ghost prompt-action"
+            onClick={() => {
+              const text = buildPromptText(prompt, effectiveArgs);
+              if (!text) {
+                return;
+              }
+              void onSendPrompt(text);
+            }}
+            title="Send to current agent"
+          >
+            Send
+          </button>
+          <button
+            type="button"
+            className="ghost prompt-action"
+            onClick={() => {
+              const text = buildPromptText(prompt, effectiveArgs);
+              if (!text) {
+                return;
+              }
+              void onSendPromptToNewAgent(text);
+            }}
+            title="Send to a new agent"
+          >
+            New agent
+          </button>
+          <button
+            type="button"
+            className="ghost icon-button prompt-action-menu"
+            onClick={(event) => void showPromptMenu(event, prompt)}
+            aria-label="Prompt actions"
+            title="Prompt actions"
+          >
+            <MoreHorizontal aria-hidden />
+          </button>
+        </div>
+        {pendingDeletePath === prompt.path && (
+          <div className="prompt-delete-confirm">
+            <span>Delete this prompt?</span>
+            <button
+              type="button"
+              className="ghost prompt-action"
+              onClick={() => void handleDeleteConfirm(prompt)}
+            >
+              Delete
+            </button>
+            <button
+              type="button"
+              className="ghost prompt-action"
+              onClick={() => setPendingDeletePath(null)}
+            >
+              Cancel
+            </button>
+          </div>
+        )}
+      </div>
+    );
+  };
+
+  return (
+    <aside className="diff-panel prompt-panel">
+      <div className="git-panel-header">
+        <PanelTabs active={filePanelMode} onSelect={onFilePanelModeChange} />
+        <div className="prompt-panel-meta">
+          {hasPrompts ? `${totalCount} prompt${totalCount === 1 ? "" : "s"}` : "No prompts"}
+        </div>
+      </div>
+      {editor && (
+        <div className="prompt-editor">
+          <div className="prompt-editor-row">
+            <label className="prompt-editor-label">
+              Name
+              <input
+                className="prompt-args-input"
+                type="text"
+                value={editor.name}
+                onChange={(event) => updateEditor({ name: event.target.value })}
+                placeholder="Prompt name"
+              />
+            </label>
+            <label className="prompt-editor-label">
+              Scope
+              <select
+                className="prompt-scope-select"
+                value={editor.scope}
+                onChange={(event) =>
+                  updateEditor({
+                    scope: event.target.value as PromptEditorState["scope"],
+                  })
+                }
+                disabled={editor.mode === "edit"}
+              >
+                <option value="workspace">Workspace</option>
+                <option value="global">General</option>
+              </select>
+            </label>
+          </div>
+          <div className="prompt-editor-row">
+            <label className="prompt-editor-label">
+              Description
+              <input
+                className="prompt-args-input"
+                type="text"
+                value={editor.description}
+                onChange={(event) => updateEditor({ description: event.target.value })}
+                placeholder="Optional description"
+              />
+            </label>
+            <label className="prompt-editor-label">
+              Argument hint
+              <input
+                className="prompt-args-input"
+                type="text"
+                value={editor.argumentHint}
+                onChange={(event) => updateEditor({ argumentHint: event.target.value })}
+                placeholder="Optional argument hint"
+              />
+            </label>
+          </div>
+          <label className="prompt-editor-label">
+            Content
+            <textarea
+              className="prompt-editor-textarea"
+              value={editor.content}
+              onChange={(event) => updateEditor({ content: event.target.value })}
+              placeholder="Prompt content"
+              rows={6}
+            />
+          </label>
+          {editorError && <div className="prompt-editor-error">{editorError}</div>}
+          <div className="prompt-editor-actions">
+            <button
+              type="button"
+              className="ghost prompt-action"
+              onClick={() => setEditor(null)}
+              disabled={isSaving}
+            >
+              Cancel
+            </button>
+            <button
+              type="button"
+              className="ghost prompt-action"
+              onClick={() => void handleSave()}
+              disabled={isSaving}
+            >
+              {editor.mode === "create" ? "Create" : "Save"}
+            </button>
+          </div>
+        </div>
+      )}
+      <div className="file-tree-search">
+        <Search className="file-tree-search-icon" aria-hidden />
+        <input
+          className="file-tree-search-input"
+          type="search"
+          placeholder="Filter prompts"
+          value={query}
+          onChange={(event) => setQuery(event.target.value)}
+          aria-label="Filter prompts"
+        />
+      </div>
+      <div className="prompt-section">
+        <div className="prompt-section-header">
+          <div className="prompt-section-title">Workspace prompts</div>
+          <button
+            type="button"
+            className="ghost icon-button prompt-section-add"
+            onClick={() => startCreate("workspace")}
+            aria-label="Add workspace prompt"
+            title="Add workspace prompt"
+          >
+            <Plus aria-hidden />
+          </button>
+        </div>
+        {workspacePrompts.length > 0 ? (
+          <div className="prompt-list">
+            {workspacePrompts.map((prompt) => renderPromptRow(prompt))}
+          </div>
+        ) : (
+          <div className="prompt-empty-card">
+            <ScrollText className="prompt-empty-icon" aria-hidden />
+            <div className="prompt-empty-text">
+              <div className="prompt-empty-title">No workspace prompts yet</div>
+              <div className="prompt-empty-subtitle">
+                Create one here or drop a .md file into the{" "}
+                {workspacePath ? (
+                  <button
+                    type="button"
+                    className="prompt-empty-link"
+                    onClick={() => void onRevealWorkspacePrompts()}
+                  >
+                    workspace prompts folder
+                  </button>
+                ) : (
+                  <span className="prompt-empty-link is-disabled">
+                    workspace prompts folder
+                  </span>
+                )}
+                .
+              </div>
+            </div>
+          </div>
+        )}
+      </div>
+      <div className="prompt-section">
+        <div className="prompt-section-header">
+          <div className="prompt-section-title">General prompts</div>
+          <button
+            type="button"
+            className="ghost icon-button prompt-section-add"
+            onClick={() => startCreate("global")}
+            aria-label="Add general prompt"
+            title="Add general prompt"
+          >
+            <Plus aria-hidden />
+          </button>
+        </div>
+        {globalPrompts.length > 0 ? (
+          <div className="prompt-list">
+            {globalPrompts.map((prompt) => renderPromptRow(prompt))}
+          </div>
+        ) : (
+          <div className="prompt-empty-card">
+            <ScrollText className="prompt-empty-icon" aria-hidden />
+            <div className="prompt-empty-text">
+              <div className="prompt-empty-title">No general prompts yet</div>
+              <div className="prompt-empty-subtitle">
+                Create one here or drop a .md file into{" "}
+                <button
+                  type="button"
+                  className="prompt-empty-link"
+                  onClick={() => void onRevealGeneralPrompts()}
+                >
+                  ~/.codex/prompts
+                </button>
+                .
+              </div>
+            </div>
+          </div>
+        )}
+      </div>
+    </aside>
+  );
+}
diff --git a/src/features/prompts/hooks/useCustomPrompts.ts b/src/features/prompts/hooks/useCustomPrompts.ts
index b555f054d..e45a3ae10 100644
--- a/src/features/prompts/hooks/useCustomPrompts.ts
+++ b/src/features/prompts/hooks/useCustomPrompts.ts
@@ -1,6 +1,14 @@
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import type { CustomPromptOption, DebugEntry, WorkspaceInfo } from "../../../types";
-import { getPromptsList } from "../../../services/tauri";
+import {
+  createPrompt as createPromptService,
+  deletePrompt as deletePromptService,
+  getPromptsList,
+  getGlobalPromptsDir as getGlobalPromptsDirService,
+  getWorkspacePromptsDir as getWorkspacePromptsDirService,
+  movePrompt as movePromptService,
+  updatePrompt as updatePromptService,
+} from "../../../services/tauri";
 
 type UseCustomPromptsOptions = {
   activeWorkspace: WorkspaceInfo | null;
@@ -15,6 +23,20 @@ export function useCustomPrompts({ activeWorkspace, onDebug }: UseCustomPromptsO
   const workspaceId = activeWorkspace?.id ?? null;
   const isConnected = Boolean(activeWorkspace?.connected);
 
+  const logPromptError = useCallback(
+    (idSuffix: string, label: string, error: unknown) => {
+      const timestamp = Date.now();
+      onDebug?.({
+        id: `${timestamp}-${idSuffix}`,
+        timestamp,
+        source: "error",
+        label,
+        payload: error instanceof Error ? error.message : String(error),
+      });
+    },
+    [onDebug],
+  );
+
   const refreshPrompts = useCallback(async () => {
     if (!workspaceId || !isConnected) {
       return;
@@ -39,40 +61,47 @@ export function useCustomPrompts({ activeWorkspace, onDebug }: UseCustomPromptsO
         label: "prompts/list response",
         payload: response,
       });
-      const rawPrompts = Array.isArray(response)
-        ? response
-        : Array.isArray((response as any)?.prompts)
-          ? (response as any).prompts
-          : Array.isArray((response as any)?.result?.prompts)
-            ? (response as any).result.prompts
-            : Array.isArray((response as any)?.result)
-              ? (response as any).result
-              : [];
-      const data: CustomPromptOption[] = rawPrompts.map((item: any) => ({
-        name: String(item.name ?? ""),
-        path: String(item.path ?? ""),
-        description: item.description ? String(item.description) : undefined,
-        argumentHint: item.argumentHint
-          ? String(item.argumentHint)
-          : item.argument_hint
-            ? String(item.argument_hint)
-            : undefined,
-        content: String(item.content ?? ""),
-      }));
+      const responsePayload = response as any;
+      let rawPrompts: any[] = [];
+      if (Array.isArray(response)) {
+        rawPrompts = response;
+      } else if (Array.isArray(responsePayload?.prompts)) {
+        rawPrompts = responsePayload.prompts;
+      } else if (Array.isArray(responsePayload?.result?.prompts)) {
+        rawPrompts = responsePayload.result.prompts;
+      } else if (Array.isArray(responsePayload?.result)) {
+        rawPrompts = responsePayload.result;
+      }
+      const data: CustomPromptOption[] = rawPrompts.map((item: any) => {
+        let argumentHint: string | undefined;
+        if (item.argumentHint) {
+          argumentHint = String(item.argumentHint);
+        } else if (item.argument_hint) {
+          argumentHint = String(item.argument_hint);
+        }
+
+        let scope: CustomPromptOption["scope"];
+        if (item.scope === "workspace" || item.scope === "global") {
+          scope = item.scope;
+        }
+
+        return {
+          name: String(item.name ?? ""),
+          path: String(item.path ?? ""),
+          description: item.description ? String(item.description) : undefined,
+          argumentHint,
+          content: String(item.content ?? ""),
+          scope,
+        };
+      });
       setPrompts(data);
       lastFetchedWorkspaceId.current = workspaceId;
     } catch (error) {
-      onDebug?.({
-        id: `${Date.now()}-client-prompts-list-error`,
-        timestamp: Date.now(),
-        source: "error",
-        label: "prompts/list error",
-        payload: error instanceof Error ? error.message : String(error),
-      });
+      logPromptError("client-prompts-list-error", "prompts/list error", error);
     } finally {
       inFlight.current = false;
     }
-  }, [isConnected, onDebug, workspaceId]);
+  }, [isConnected, logPromptError, onDebug, workspaceId]);
 
   useEffect(() => {
     if (!workspaceId || !isConnected) {
@@ -89,8 +118,108 @@ export function useCustomPrompts({ activeWorkspace, onDebug }: UseCustomPromptsO
     [prompts],
   );
 
+  const requireWorkspaceId = useCallback(() => {
+    if (!workspaceId) {
+      throw new Error("No workspace selected.");
+    }
+    return workspaceId;
+  }, [workspaceId]);
+
+  const createPrompt = useCallback(
+    async (data: {
+      scope: "workspace" | "global";
+      name: string;
+      description?: string | null;
+      argumentHint?: string | null;
+      content: string;
+    }) => {
+      const id = requireWorkspaceId();
+      try {
+        await createPromptService(id, data);
+        await refreshPrompts();
+      } catch (error) {
+        logPromptError("client-prompts-create-error", "prompts/create error", error);
+        throw error;
+      }
+    },
+    [logPromptError, refreshPrompts, requireWorkspaceId],
+  );
+
+  const updatePrompt = useCallback(
+    async (data: {
+      path: string;
+      name: string;
+      description?: string | null;
+      argumentHint?: string | null;
+      content: string;
+    }) => {
+      const id = requireWorkspaceId();
+      try {
+        await updatePromptService(id, data);
+        await refreshPrompts();
+      } catch (error) {
+        logPromptError("client-prompts-update-error", "prompts/update error", error);
+        throw error;
+      }
+    },
+    [logPromptError, refreshPrompts, requireWorkspaceId],
+  );
+
+  const deletePrompt = useCallback(
+    async (path: string) => {
+      const id = requireWorkspaceId();
+      try {
+        await deletePromptService(id, path);
+        await refreshPrompts();
+      } catch (error) {
+        logPromptError("client-prompts-delete-error", "prompts/delete error", error);
+        throw error;
+      }
+    },
+    [logPromptError, refreshPrompts, requireWorkspaceId],
+  );
+
+  const movePrompt = useCallback(
+    async (data: { path: string; scope: "workspace" | "global" }) => {
+      const id = requireWorkspaceId();
+      try {
+        await movePromptService(id, data);
+        await refreshPrompts();
+      } catch (error) {
+        logPromptError("client-prompts-move-error", "prompts/move error", error);
+        throw error;
+      }
+    },
+    [logPromptError, refreshPrompts, requireWorkspaceId],
+  );
+
+  const getWorkspacePromptsDir = useCallback(async () => {
+    const id = requireWorkspaceId();
+    try {
+      return await getWorkspacePromptsDirService(id);
+    } catch (error) {
+      logPromptError("client-prompts-dir-error", "prompts/workspace dir error", error);
+      throw error;
+    }
+  }, [logPromptError, requireWorkspaceId]);
+
+  const getGlobalPromptsDir = useCallback(async () => {
+    try {
+      return await getGlobalPromptsDirService();
+    } catch (error) {
+      logPromptError("client-prompts-global-dir-error", "prompts/global dir error", error);
+      throw error;
+    }
+  }, [logPromptError]);
+
   return {
     prompts: promptOptions,
     refreshPrompts,
+    createPrompt,
+    updatePrompt,
+    deletePrompt,
+    movePrompt,
+    getWorkspacePromptsDir,
+    getGlobalPromptsDir,
   };
 }
diff --git a/src/features/threads/hooks/useThreads.ts b/src/features/threads/hooks/useThreads.ts
index cfb497e8f..db4779f70 100644
--- a/src/features/threads/hooks/useThreads.ts
+++ b/src/features/threads/hooks/useThreads.ts
@@ -783,7 +783,8 @@ export function useThreads({
   useAppServerEvents(handlers);
 
   const startThreadForWorkspace = useCallback(
-    async (workspaceId: string) => {
+    async (workspaceId: string, options?: { activate?: boolean }) => {
+      const shouldActivate = options?.activate !== false;
       onDebug?.({
         id: `${Date.now()}-client-thread-start`,
         timestamp: Date.now(),
@@ -804,7 +805,9 @@ export function useThreads({
         const threadId = String(thread?.id ?? "");
         if (threadId) {
           dispatch({ type: "ensureThread", workspaceId, threadId });
-          dispatch({ type: "setActiveThreadId", workspaceId, threadId });
+          if (shouldActivate) {
+            dispatch({ type: "setActiveThreadId", workspaceId, threadId });
+          }
           loadedThreads.current[threadId] = true;
           return threadId;
         }
@@ -1202,37 +1205,32 @@ export function useThreads({
     return threadId;
   }, [activeWorkspace, activeThreadId, resumeThreadForWorkspace, startThreadForWorkspace]);
 
-  const sendUserMessage = useCallback(
-    async (text: string, images: string[] = []) => {
-      if (!activeWorkspace || (!text.trim() && images.length === 0)) {
+  const sendMessageToThread = useCallback(
+    async (
+      workspace: WorkspaceInfo,
+      threadId: string,
+      text: string,
+      images: string[] = [],
+      options?: { skipPromptExpansion?: boolean },
+    ) => {
+      const messageText = text.trim();
+      if (!messageText && images.length === 0) {
         return;
       }
-      const messageText = text.trim();
-      const promptExpansion = expandCustomPromptText(messageText, customPrompts);
-      if (promptExpansion && "error" in promptExpansion) {
-        if (activeThreadId) {
-          pushThreadErrorMessage(activeThreadId, promptExpansion.error);
+      let finalText = messageText;
+      if (!options?.skipPromptExpansion) {
+        const promptExpansion = expandCustomPromptText(messageText, customPrompts);
+        if (promptExpansion && "error" in promptExpansion) {
+          pushThreadErrorMessage(threadId, promptExpansion.error);
           safeMessageActivity();
-        } else {
-          onDebug?.({
-            id: `${Date.now()}-client-prompt-expand-error`,
-            timestamp: Date.now(),
-            source: "error",
-            label: "prompt/expand error",
-            payload: promptExpansion.error,
-          });
+          return;
         }
-        return;
-      }
-      const finalText = promptExpansion?.expanded ?? messageText;
-      const threadId = await ensureThreadForActiveWorkspace();
-      if (!threadId) {
-        return;
+        finalText = promptExpansion?.expanded ?? messageText;
       }
-      recordThreadActivity(activeWorkspace.id, threadId);
+      recordThreadActivity(workspace.id, threadId);
       dispatch({
         type: "addUserMessage",
-        workspaceId: activeWorkspace.id,
+        workspaceId: workspace.id,
         threadId,
         text: finalText,
         images,
@@ -1244,23 +1242,23 @@ export function useThreads({
         timestamp: Date.now(),
         source: "client",
         label: "turn/start",
-          payload: {
-            workspaceId: activeWorkspace.id,
-            threadId,
-            text: finalText,
-            images,
-            model,
-            effort,
-            collaborationMode,
-          },
-        });
+        payload: {
+          workspaceId: workspace.id,
+          threadId,
+          text: finalText,
+          images,
+          model,
+          effort,
+          collaborationMode,
+        },
+      });
       try {
         const response =
           (await sendUserMessageService(
-          activeWorkspace.id,
-          threadId,
-          finalText,
-          { model, effort, collaborationMode, accessMode, images },
+            workspace.id,
+            threadId,
+            finalText,
+            { model, effort, collaborationMode, accessMode, images },
           )) as Record<string, unknown>;
         onDebug?.({
           id: `${Date.now()}-server-turn-start`,
@@ -1308,22 +1306,77 @@ export function useThreads({
       }
     },
     [
-      activeWorkspace,
-      markProcessing,
-      activeThreadId,
-      effort,
-      collaborationMode,
       accessMode,
+      collaborationMode,
       customPrompts,
+      effort,
+      markProcessing,
       model,
       onDebug,
       pushThreadErrorMessage,
       recordThreadActivity,
+      safeMessageActivity,
+    ],
+  );
+
+  const sendUserMessage = useCallback(
+    async (text: string, images: string[] = []) => {
+      if (!activeWorkspace) {
+        return;
+      }
+      const messageText = text.trim();
+      if (!messageText && images.length === 0) {
+        return;
+      }
+      const promptExpansion = expandCustomPromptText(messageText, customPrompts);
+      if (promptExpansion && "error" in promptExpansion) {
+        if (activeThreadId) {
+          pushThreadErrorMessage(activeThreadId, promptExpansion.error);
+          safeMessageActivity();
+        } else {
+          onDebug?.({
+            id: `${Date.now()}-client-prompt-expand-error`,
+            timestamp: Date.now(),
+            source: "error",
+            label: "prompt/expand error",
+            payload: promptExpansion.error,
+          });
+        }
+        return;
+      }
+      const finalText = promptExpansion?.expanded ?? messageText;
+      const threadId = await ensureThreadForActiveWorkspace();
+      if (!threadId) {
+        return;
+      }
+      await sendMessageToThread(activeWorkspace, threadId, finalText, images, {
+        skipPromptExpansion: true,
+      });
+    },
+    [
+      activeThreadId,
+      activeWorkspace,
+      customPrompts,
       ensureThreadForActiveWorkspace,
+      onDebug,
+      pushThreadErrorMessage,
       safeMessageActivity,
+      sendMessageToThread,
     ],
   );
 
+  const sendUserMessageToThread = useCallback(
+    async (
+      workspace: WorkspaceInfo,
+      threadId: string,
+      text: string,
+      images: string[] = [],
+    ) => {
+      await sendMessageToThread(workspace, threadId, text, images);
+    },
+    [sendMessageToThread],
+  );
+
   const interruptTurn = useCallback(async () => {
     if (!activeWorkspace || !activeThreadId) {
       return;
@@ -1536,6 +1589,7 @@ export function useThreads({
     listThreadsForWorkspace,
     loadOlderThreadsForWorkspace,
     sendUserMessage,
+    sendUserMessageToThread,
     startReview,
     handleApprovalDecision,
   };
diff --git a/src/services/tauri.ts b/src/services/tauri.ts
index 3cd3ad963..14202a708 100644
--- a/src/services/tauri.ts
+++ b/src/services/tauri.ts
@@ -251,6 +251,69 @@ export async function getPromptsList(workspaceId: string) {
   return invoke<any>("prompts_list", { workspaceId });
 }
 
+export async function getWorkspacePromptsDir(workspaceId: string) {
+  return invoke<string>("prompts_workspace_dir", { workspaceId });
+}
+
+export async function getGlobalPromptsDir() {
+  return invoke<string>("prompts_global_dir");
+}
+
+export async function createPrompt(
+  workspaceId: string,
+  data: {
+    scope: "workspace" | "global";
+    name: string;
+    description?: string | null;
+    argumentHint?: string | null;
+    content: string;
+  },
+) {
+  return invoke<any>("prompts_create", {
+    workspaceId,
+    scope: data.scope,
+    name: data.name,
+    description: data.description ?? null,
+    argumentHint: data.argumentHint ?? null,
+    content: data.content,
+  });
+}
+
+export async function updatePrompt(
+  workspaceId: string,
+  data: {
+    path: string;
+    name: string;
+    description?: string | null;
+    argumentHint?: string | null;
+    content: string;
+  },
+) {
+  return invoke<any>("prompts_update", {
+    workspaceId,
+    path: data.path,
+    name: data.name,
+    description: data.description ?? null,
+    argumentHint: data.argumentHint ?? null,
+    content: data.content,
+  });
+}
+
+export async function deletePrompt(workspaceId: string, path: string) {
+  return invoke<any>("prompts_delete", { workspaceId, path });
+}
+
+export async function movePrompt(
+  workspaceId: string,
+  data: { path: string; scope: "workspace" | "global" },
+) {
+  return invoke<any>("prompts_move", {
+    workspaceId,
+    path: data.path,
+    scope: data.scope,
+  });
+}
+
 export async function getAppSettings(): Promise<AppSettings> {
   return invoke<AppSettings>("get_app_settings");
 }
diff --git a/src/styles/panel-tabs.css b/src/styles/panel-tabs.css
new file mode 100644
index 000000000..0b3323547
--- /dev/null
+++ b/src/styles/panel-tabs.css
@@ -0,0 +1,47 @@
+.panel-tabs {
+  display: inline-flex;
+  align-items: center;
+  gap: 6px;
+  padding: 4px;
+  border-radius: 999px;
+  background: var(--surface-control);
+  border: 1px solid var(--border-subtle);
+}
+
+.panel-tab {
+  display: inline-flex;
+  align-items: center;
+  gap: 0;
+  padding: 6px 8px;
+  border-radius: 999px;
+  background: transparent;
+  color: var(--text-subtle);
+  box-shadow: none;
+  transition: background 160ms ease, color 160ms ease;
+}
+
+.panel-tab:hover:not(:disabled) {
+  transform: none;
+  box-shadow: none;
+  color: var(--text-emphasis);
+}
+
+.panel-tab.is-active {
+  background: var(--surface-control-hover);
+  color: var(--text-emphasis);
+}
+
+.panel-tab:focus-visible {
+  outline: 2px solid var(--border-accent-soft);
+  outline-offset: 2px;
+}
+
+.panel-tab-icon {
+  display: inline-flex;
+  align-items: center;
+}
+
+.panel-tab-icon svg {
+  width: 12px;
+  height: 12px;
+}
diff --git a/src/styles/prompts.css b/src/styles/prompts.css
new file mode 100644
index 000000000..ec5d46e4e
--- /dev/null
+++ b/src/styles/prompts.css
@@ -0,0 +1,284 @@
+.prompt-panel {
+  gap: 12px;
+}
+
+.prompt-panel-meta {
+  font-size: 11px;
+  color: var(--text-faint);
+}
+
+.prompt-section {
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+}
+
+.prompt-section-header {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 8px;
+}
+
+.prompt-section-title {
+  font-size: 11px;
+  letter-spacing: 0.08em;
+  text-transform: uppercase;
+  color: var(--text-muted);
+}
+
+.prompt-section-add svg {
+  width: 14px;
+  height: 14px;
+}
+
+.prompt-list {
+  display: flex;
+  flex-direction: column;
+  gap: 10px;
+}
+
+.prompt-row {
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+  padding: 10px;
+  border-radius: 12px;
+  background: var(--surface-control);
+  border: 1px solid var(--border-subtle);
+  transition:
+    background 180ms ease-out,
+    border-color 180ms ease-out,
+    box-shadow 180ms ease-out,
+    transform 180ms ease-out;
+}
+
+.prompt-row-header {
+  display: flex;
+  flex-direction: column;
+  gap: 4px;
+}
+
+.prompt-name {
+  font-size: 13px;
+  font-weight: 600;
+  color: var(--text-emphasis);
+}
+
+.prompt-description {
+  font-size: 12px;
+  color: var(--text-subtle);
+}
+
+.prompt-hint {
+  font-size: 11px;
+  color: var(--text-faint);
+}
+
+.prompt-actions {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  flex-wrap: wrap;
+}
+
+.prompt-args-input {
+  flex: 1;
+  min-width: 160px;
+  border-radius: 8px;
+  border: 1px solid var(--border-subtle);
+  background: var(--surface-card);
+  color: var(--text-emphasis);
+  padding: 6px 8px;
+  font-size: 12px;
+}
+
+.prompt-args-input::placeholder {
+  color: var(--text-dim);
+}
+
+.prompt-action {
+  padding: 6px 10px;
+  font-size: 11px;
+  letter-spacing: 0.04em;
+  text-transform: uppercase;
+}
+
+.prompt-action-menu svg {
+  width: 14px;
+  height: 14px;
+}
+
+.prompt-delete-confirm {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  font-size: 11px;
+  color: var(--text-subtle);
+  padding-top: 2px;
+  animation: prompt-fade-in 180ms ease-out;
+}
+
+.prompt-delete-confirm span {
+  flex: 1;
+}
+
+.prompt-row.is-highlight {
+  animation: prompt-row-flash 650ms ease-out;
+}
+
+.prompt-empty-card {
+  display: flex;
+  align-items: center;
+  gap: 12px;
+  padding: 12px;
+  border-radius: 12px;
+  border: 1px dashed var(--border-subtle);
+  background: var(--surface-card);
+  color: var(--text-faint);
+  animation: prompt-fade-in 220ms ease-out;
+}
+
+.prompt-empty-icon {
+  width: 24px;
+  height: 24px;
+  opacity: 0.6;
+}
+
+.prompt-empty-title {
+  font-size: 12px;
+  color: var(--text-subtle);
+  font-weight: 600;
+}
+
+.prompt-empty-subtitle {
+  font-size: 12px;
+  color: var(--text-faint);
+}
+
+.prompt-empty-link {
+  border: none;
+  background: none;
+  padding: 0;
+  margin: 0;
+  font: inherit;
+  color: var(--text-accent);
+  cursor: pointer;
+  text-decoration: underline;
+  text-underline-offset: 2px;
+}
+
+.prompt-empty-link:hover {
+  color: var(--text-emphasis);
+}
+
+.prompt-empty-link.is-disabled {
+  color: var(--text-faint);
+  cursor: default;
+  text-decoration: none;
+}
+
+.prompt-editor {
+  display: flex;
+  flex-direction: column;
+  gap: 10px;
+  padding: 12px;
+  border-radius: 12px;
+  background: var(--surface-card);
+  border: 1px solid var(--border-subtle);
+  animation: prompt-editor-in 240ms ease-out;
+}
+
+.prompt-editor-row {
+  display: flex;
+  gap: 12px;
+  flex-wrap: wrap;
+}
+
+.prompt-editor-label {
+  display: flex;
+  flex-direction: column;
+  gap: 6px;
+  font-size: 11px;
+  color: var(--text-faint);
+  flex: 1;
+  min-width: 160px;
+}
+
+.prompt-editor-textarea {
+  width: 100%;
+  border-radius: 8px;
+  border: 1px solid var(--border-subtle);
+  background: var(--surface-card);
+  color: var(--text-emphasis);
+  padding: 8px;
+  font-size: 12px;
+  resize: vertical;
+  min-height: 120px;
+}
+
+.prompt-scope-select {
+  border: 1px solid var(--border-subtle);
+  background: var(--surface-card);
+  color: var(--text-emphasis);
+  font-size: 12px;
+  border-radius: 8px;
+  padding: 6px 8px;
+}
+
+.prompt-editor-actions {
+  display: flex;
+  gap: 8px;
+  justify-content: flex-end;
+}
+
+.prompt-editor-error {
+  font-size: 12px;
+  color: var(--status-error);
+}
+
+@keyframes prompt-row-flash {
+  0% {
+    background: color-mix(in srgb, var(--surface-active) 65%, var(--surface-control));
+    border-color: var(--border-accent);
+    box-shadow: 0 0 0 1px var(--border-accent-soft);
+    transform: translateY(-2px);
+  }
+  100% {
+    background: var(--surface-control);
+    border-color: var(--border-subtle);
+    box-shadow: 0 0 0 0 rgba(0, 0, 0, 0);
+    transform: translateY(0);
+  }
+}
+
+@keyframes prompt-editor-in {
+  0% {
+    opacity: 0;
+    transform: translateY(-4px);
+  }
+  100% {
+    opacity: 1;
+    transform: translateY(0);
+  }
+}
+
+@keyframes prompt-fade-in {
+  0% {
+    opacity: 0;
+    transform: translateY(4px);
+  }
+  100% {
+    opacity: 1;
+    transform: translateY(0);
+  }
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .prompt-row,
+  .prompt-empty-card,
+  .prompt-editor {
+    animation: none;
+    transition: none;
+  }
+}
diff --git a/src/types.ts b/src/types.ts
index 77ae1d111..8836ae4f4 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -275,6 +275,7 @@ export type CustomPromptOption = {
   description?: string;
   argumentHint?: string;
   content: string;
+  scope?: "workspace" | "global";
 };
 
 export type BranchInfo = {