diff --git a/src-tauri/src/backend/app_server.rs b/src-tauri/src/backend/app_server.rs
index 659e5d27..a0eb1c8e 100644
--- a/src-tauri/src/backend/app_server.rs
+++ b/src-tauri/src/backend/app_server.rs
@@ -34,6 +34,19 @@ fn extract_thread_id(value: &Value) -> Option<String> {
         })
 }
 
+fn build_initialize_params(client_version: &str) -> Value {
+    json!({
+        "clientInfo": {
+            "name": "codex_monitor",
+            "title": "Codex Monitor",
+            "version": client_version
+        },
+        "capabilities": {
+            "experimentalApi": true
+        }
+    })
+}
+
 pub(crate) struct WorkspaceSession {
     pub(crate) entry: WorkspaceEntry,
     pub(crate) child: Mutex<Child>,
@@ -332,13 +345,7 @@ pub(crate) async fn spawn_workspace_session<E: EventSink>(
         }
     });
 
-    let init_params = json!({
-        "clientInfo": {
-            "name": "codex_monitor",
-            "title": "Codex Monitor",
-            "version": client_version
-        }
-    });
+    let init_params = build_initialize_params(&client_version);
     let init_result = timeout(
         Duration::from_secs(15),
         session.send_request("initialize", init_params),
@@ -372,7 +379,7 @@ pub(crate) async fn spawn_workspace_session<E: EventSink>(
 
 #[cfg(test)]
 mod tests {
-    use super::extract_thread_id;
+    use super::{build_initialize_params, extract_thread_id};
     use serde_json::json;
 
     #[test]
@@ -392,4 +399,16 @@ mod tests {
         let value = json!({ "params": {} });
         assert_eq!(extract_thread_id(&value), None);
     }
+
+    #[test]
+    fn build_initialize_params_enables_experimental_api() {
+        let params = build_initialize_params("1.2.3");
+        assert_eq!(
+            params
+                .get("capabilities")
+                .and_then(|caps| caps.get("experimentalApi"))
+                .and_then(|value| value.as_bool()),
+            Some(true)
+        );
+    }
 }
diff --git a/src-tauri/src/bin/codex_monitor_daemon.rs b/src-tauri/src/bin/codex_monitor_daemon.rs
index 17961cea..7af2b33f 100644
--- a/src-tauri/src/bin/codex_monitor_daemon.rs
+++ b/src-tauri/src/bin/codex_monitor_daemon.rs
@@ -209,6 +209,7 @@ impl DaemonState {
         parent_id: String,
         branch: String,
         name: Option<String>,
+        copy_agents_md: bool,
         client_version: String,
     ) -> Result<WorkspaceInfo, String> {
         let client_version = client_version.clone();
@@ -216,6 +217,7 @@ impl DaemonState {
             parent_id,
             branch,
             name,
+            copy_agents_md,
             &self.data_dir,
             &self.workspaces,
             &self.sessions,
@@ -914,6 +916,13 @@ fn parse_optional_u32(value: &Value, key: &str) -> Option<u32> {
     }
 }
 
+fn parse_optional_bool(value: &Value, key: &str) -> Option<bool> {
+    match value {
+        Value::Object(map) => map.get(key).and_then(|value| value.as_bool()),
+        _ => None,
+    }
+}
+
 fn parse_optional_string_array(value: &Value, key: &str) -> Option<Vec<String>> {
     match value {
         Value::Object(map) => map.get(key).and_then(|value| value.as_array()).map(|items| {
@@ -989,8 +998,9 @@ async fn handle_rpc_request(
             let parent_id = parse_string(&params, "parentId")?;
             let branch = parse_string(&params, "branch")?;
             let name = parse_optional_string(&params, "name");
+            let copy_agents_md = parse_optional_bool(&params, "copyAgentsMd").unwrap_or(true);
             let workspace = state
-                .add_worktree(parent_id, branch, name, client_version)
+                .add_worktree(parent_id, branch, name, copy_agents_md, client_version)
                 .await?;
             serde_json::to_value(workspace).map_err(|err| err.to_string())
         }
diff --git a/src-tauri/src/shared/workspaces_core.rs b/src-tauri/src/shared/workspaces_core.rs
index 2dcba7b9..49a6c7aa 100644
--- a/src-tauri/src/shared/workspaces_core.rs
+++ b/src-tauri/src/shared/workspaces_core.rs
@@ -17,6 +17,44 @@ use uuid::Uuid;
 
 pub(crate) const WORKTREE_SETUP_MARKERS_DIR: &str = "worktree-setup";
 pub(crate) const WORKTREE_SETUP_MARKER_EXT: &str = "ran";
+const AGENTS_MD_FILE_NAME: &str = "AGENTS.md";
+
+fn copy_agents_md_from_parent_to_worktree(
+    parent_repo_root: &PathBuf,
+    worktree_root: &PathBuf,
+) -> Result<(), String> {
+    let source_path = parent_repo_root.join(AGENTS_MD_FILE_NAME);
+    if !source_path.is_file() {
+        return Ok(());
+    }
+
+    let destination_path = worktree_root.join(AGENTS_MD_FILE_NAME);
+    if destination_path.is_file() {
+        return Ok(());
+    }
+
+    let temp_path = worktree_root.join(format!("{AGENTS_MD_FILE_NAME}.tmp"));
+
+    std::fs::copy(&source_path, &temp_path).map_err(|err| {
+        format!(
+            "Failed to copy {} from {} to {}: {err}",
+            AGENTS_MD_FILE_NAME,
+            source_path.display(),
+            temp_path.display()
+        )
+    })?;
+
+    std::fs::rename(&temp_path, &destination_path).map_err(|err| {
+        let _ = std::fs::remove_file(&temp_path);
+        format!(
+            "Failed to finalize {} copy to {}: {err}",
+            AGENTS_MD_FILE_NAME,
+            destination_path.display()
+        )
+    })?;
+
+    Ok(())
+}
 
 pub(crate) fn normalize_setup_script(script: Option<String>) -> Option<String> {
     match script {
@@ -248,6 +286,7 @@ pub(crate) async fn add_worktree_core<
     parent_id: String,
     branch: String,
     name: Option<String>,
+    copy_agents_md: bool,
     data_dir: &PathBuf,
     workspaces: &Mutex<HashMap<String, WorkspaceEntry>>,
     sessions: &Mutex<HashMap<String, Arc<WorkspaceSession>>>,
@@ -337,6 +376,17 @@ where
         .await?;
     }
 
+    if copy_agents_md {
+        if let Err(error) = copy_agents_md_from_parent_to_worktree(&repo_path, &worktree_path) {
+            eprintln!(
+                "add_worktree: optional {} copy failed for {}: {}",
+                AGENTS_MD_FILE_NAME,
+                worktree_path.display(),
+                error
+            );
+        }
+    }
+
     let entry = WorkspaceEntry {
         id: Uuid::new_v4().to_string(),
         name: name.clone().unwrap_or_else(|| branch.clone()),
@@ -1118,3 +1168,56 @@ fn sort_workspaces(workspaces: &mut [WorkspaceInfo]) {
             .then_with(|| a.id.cmp(&b.id))
     });
 }
+
+#[cfg(test)]
+mod tests {
+    use super::copy_agents_md_from_parent_to_worktree;
+    use super::AGENTS_MD_FILE_NAME;
+    use uuid::Uuid;
+
+    fn make_temp_dir() -> std::path::PathBuf {
+        let dir = std::env::temp_dir().join(format!("codex-monitor-{}", Uuid::new_v4()));
+        std::fs::create_dir_all(&dir).expect("failed to create temp dir");
+        dir
+    }
+
+    #[test]
+    fn copies_agents_md_when_missing_in_worktree() {
+        let parent = make_temp_dir();
+        let worktree = make_temp_dir();
+        let parent_agents = parent.join(AGENTS_MD_FILE_NAME);
+        let worktree_agents = worktree.join(AGENTS_MD_FILE_NAME);
+
+        std::fs::write(&parent_agents, "parent").expect("failed to write parent AGENTS.md");
+
+        copy_agents_md_from_parent_to_worktree(&parent, &worktree).expect("copy should succeed");
+
+        let copied = std::fs::read_to_string(&worktree_agents)
+            .expect("worktree AGENTS.md should exist after copy");
+        assert_eq!(copied, "parent");
+
+        let _ = std::fs::remove_dir_all(parent);
+        let _ = std::fs::remove_dir_all(worktree);
+    }
+
+    #[test]
+    fn does_not_overwrite_existing_worktree_agents_md() {
+        let parent = make_temp_dir();
+        let worktree = make_temp_dir();
+        let parent_agents = parent.join(AGENTS_MD_FILE_NAME);
+        let worktree_agents = worktree.join(AGENTS_MD_FILE_NAME);
+
+        std::fs::write(&parent_agents, "parent").expect("failed to write parent AGENTS.md");
+        std::fs::write(&worktree_agents, "branch-specific")
+            .expect("failed to write worktree AGENTS.md");
+
+        copy_agents_md_from_parent_to_worktree(&parent, &worktree).expect("copy should succeed");
+
+        let retained = std::fs::read_to_string(&worktree_agents)
+            .expect("worktree AGENTS.md should still exist");
+        assert_eq!(retained, "branch-specific");
+
+        let _ = std::fs::remove_dir_all(parent);
+        let _ = std::fs::remove_dir_all(worktree);
+    }
+}
diff --git a/src-tauri/src/workspaces/commands.rs b/src-tauri/src/workspaces/commands.rs
index b2f0b278..14d5ff9d 100644
--- a/src-tauri/src/workspaces/commands.rs
+++ b/src-tauri/src/workspaces/commands.rs
@@ -285,15 +285,22 @@ pub(crate) async fn add_worktree(
     parent_id: String,
     branch: String,
     name: Option<String>,
+    copy_agents_md: Option<bool>,
     state: State<'_, AppState>,
     app: AppHandle,
 ) -> Result<WorkspaceInfo, String> {
+    let copy_agents_md = copy_agents_md.unwrap_or(true);
     if remote_backend::is_remote_mode(&*state).await {
         let response = remote_backend::call_remote(
             &*state,
             app,
             "add_worktree",
-            json!({ "parentId": parent_id, "branch": branch, "name": name }),
+            json!({
+                "parentId": parent_id,
+                "branch": branch,
+                "name": name,
+                "copyAgentsMd": copy_agents_md
+            }),
         )
         .await?;
         return serde_json::from_value(response).map_err(|err| err.to_string());
@@ -308,6 +315,7 @@ pub(crate) async fn add_worktree(
         parent_id,
         branch,
         name,
+        copy_agents_md,
         &data_dir,
         &state.workspaces,
         &state.sessions,
diff --git a/src/App.tsx b/src/App.tsx
index 757b50d8..a94f4123 100644
--- a/src/App.tsx
+++ b/src/App.tsx
@@ -67,6 +67,7 @@ import {
 } from "./features/layout/components/SidebarToggleControls";
 import { useAppSettingsController } from "./features/app/hooks/useAppSettingsController";
 import { useUpdaterController } from "./features/app/hooks/useUpdaterController";
+import { useResponseRequiredNotificationsController } from "./features/app/hooks/useResponseRequiredNotificationsController";
 import { useErrorToasts } from "./features/notifications/hooks/useErrorToasts";
 import { useComposerShortcuts } from "./features/composer/hooks/useComposerShortcuts";
 import { useComposerMenuActions } from "./features/composer/hooks/useComposerMenuActions";
@@ -421,8 +422,7 @@ function MainApp() {
     onDebug: addDebugEntry,
   });
 
-  useComposerShortcuts({
-    textareaRef: composerInputRef,
+  const composerShortcuts = {
     modelShortcut: appSettings.composerModelShortcut,
     accessShortcut: appSettings.composerAccessShortcut,
     reasoningShortcut: appSettings.composerReasoningShortcut,
@@ -441,6 +441,16 @@ function MainApp() {
     selectedEffort,
     onSelectEffort: setSelectedEffort,
     reasoningSupported,
+  };
+
+  useComposerShortcuts({
+    textareaRef: composerInputRef,
+    ...composerShortcuts,
+  });
+
+  useComposerShortcuts({
+    textareaRef: workspaceHomeTextareaRef,
+    ...composerShortcuts,
   });
 
   useComposerMenuActions({
@@ -703,6 +713,15 @@ function MainApp() {
     customPrompts: prompts,
     onMessageActivity: queueGitStatusRefresh
   });
+
+  useResponseRequiredNotificationsController({
+    systemNotificationsEnabled: appSettings.systemNotificationsEnabled,
+    approvals,
+    userInputRequests,
+    getWorkspaceName,
+    onDebug: addDebugEntry,
+  });
+
   const {
     activeAccount,
     accountSwitching,
@@ -898,6 +917,7 @@ function MainApp() {
     cancelPrompt: cancelWorktreePrompt,
     updateName: updateWorktreeName,
     updateBranch: updateWorktreeBranch,
+    updateCopyAgentsMd: updateWorktreeCopyAgentsMd,
     updateSetupScript: updateWorktreeSetupScript,
   } = useWorktreePrompt({
     addWorktreeAgent,
@@ -1046,9 +1066,12 @@ function MainApp() {
   const activePlan = activeThreadId
     ? planByThread[activeThreadId] ?? null
     : null;
-  const hasActivePlan = Boolean(
-    activePlan && (activePlan.steps.length > 0 || activePlan.explanation)
-  );
+  const activeThreadProcessing = activeThreadId
+    ? threadStatusById[activeThreadId]?.isProcessing ?? false
+    : false;
+  const hasActivePlan =
+    Boolean(activePlan && (activePlan.steps.length > 0 || activePlan.explanation)) ||
+    activeThreadProcessing;
   const showHome = !activeWorkspace;
   const showWorkspaceHome = Boolean(activeWorkspace && !activeThreadId && !isNewAgentDraftMode);
   const showComposer = (!isCompact
@@ -1925,6 +1948,7 @@ function MainApp() {
     selectedDiffPath,
     diffScrollRequestId,
     onSelectDiff: handleSelectDiff,
+    diffSource,
     gitLogEntries,
     gitLogTotal,
     gitLogAhead,
@@ -2282,6 +2306,7 @@ function MainApp() {
         worktreePrompt={worktreePrompt}
         onWorktreePromptNameChange={updateWorktreeName}
         onWorktreePromptChange={updateWorktreeBranch}
+        onWorktreePromptCopyAgentsMdChange={updateWorktreeCopyAgentsMd}
         onWorktreeSetupScriptChange={updateWorktreeSetupScript}
         onWorktreePromptCancel={cancelWorktreePrompt}
         onWorktreePromptConfirm={confirmWorktreePrompt}
diff --git a/src/features/app/components/AppModals.tsx b/src/features/app/components/AppModals.tsx
index 190edab1..e64abddf 100644
--- a/src/features/app/components/AppModals.tsx
+++ b/src/features/app/components/AppModals.tsx
@@ -6,6 +6,7 @@ import { useRenameThreadPrompt } from "../../threads/hooks/useRenameThreadPrompt
 import { useClonePrompt } from "../../workspaces/hooks/useClonePrompt";
 import { useWorktreePrompt } from "../../workspaces/hooks/useWorktreePrompt";
 import type { BranchSwitcherState } from "../../git/hooks/useBranchSwitcher";
+import { useGitBranches } from "../../git/hooks/useGitBranches";
 
 const RenameThreadPrompt = lazy(() =>
   import("../../threads/components/RenameThreadPrompt").then((module) => ({
@@ -42,6 +43,7 @@ type AppModalsProps = {
   worktreePrompt: WorktreePromptState;
   onWorktreePromptNameChange: (value: string) => void;
   onWorktreePromptChange: (value: string) => void;
+  onWorktreePromptCopyAgentsMdChange: (value: boolean) => void;
   onWorktreeSetupScriptChange: (value: string) => void;
   onWorktreePromptCancel: () => void;
   onWorktreePromptConfirm: () => void;
@@ -74,6 +76,7 @@ export const AppModals = memo(function AppModals({
   worktreePrompt,
   onWorktreePromptNameChange,
   onWorktreePromptChange,
+  onWorktreePromptCopyAgentsMdChange,
   onWorktreeSetupScriptChange,
   onWorktreePromptCancel,
   onWorktreePromptConfirm,
@@ -97,6 +100,10 @@ export const AppModals = memo(function AppModals({
   SettingsViewComponent,
   settingsProps,
 }: AppModalsProps) {
+  const { branches: worktreeBranches } = useGitBranches({
+    activeWorkspace: worktreePrompt?.workspace ?? null,
+  });
+
   return (
     <>
       {renamePrompt && (
@@ -116,6 +123,9 @@ export const AppModals = memo(function AppModals({
             workspaceName={worktreePrompt.workspace.name}
             name={worktreePrompt.name}
             branch={worktreePrompt.branch}
+            branchWasEdited={worktreePrompt.branchWasEdited}
+            branchSuggestions={worktreeBranches}
+            copyAgentsMd={worktreePrompt.copyAgentsMd}
             setupScript={worktreePrompt.setupScript}
             scriptError={worktreePrompt.scriptError}
             error={worktreePrompt.error}
@@ -123,6 +133,7 @@ export const AppModals = memo(function AppModals({
             isSavingScript={worktreePrompt.isSavingScript}
             onNameChange={onWorktreePromptNameChange}
             onChange={onWorktreePromptChange}
+            onCopyAgentsMdChange={onWorktreePromptCopyAgentsMdChange}
             onSetupScriptChange={onWorktreeSetupScriptChange}
             onCancel={onWorktreePromptCancel}
             onConfirm={onWorktreePromptConfirm}
diff --git a/src/features/app/hooks/useResponseRequiredNotificationsController.ts b/src/features/app/hooks/useResponseRequiredNotificationsController.ts
new file mode 100644
index 00000000..905bd5b2
--- /dev/null
+++ b/src/features/app/hooks/useResponseRequiredNotificationsController.ts
@@ -0,0 +1,31 @@
+import type { ApprovalRequest, DebugEntry, RequestUserInputRequest } from "../../../types";
+import { useWindowFocusState } from "../../layout/hooks/useWindowFocusState";
+import { useAgentResponseRequiredNotifications } from "../../notifications/hooks/useAgentResponseRequiredNotifications";
+
+type Params = {
+  systemNotificationsEnabled: boolean;
+  approvals: ApprovalRequest[];
+  userInputRequests: RequestUserInputRequest[];
+  getWorkspaceName?: (workspaceId: string) => string | undefined;
+  onDebug?: (entry: DebugEntry) => void;
+};
+
+export function useResponseRequiredNotificationsController({
+  systemNotificationsEnabled,
+  approvals,
+  userInputRequests,
+  getWorkspaceName,
+  onDebug,
+}: Params) {
+  const isWindowFocused = useWindowFocusState();
+
+  useAgentResponseRequiredNotifications({
+    enabled: systemNotificationsEnabled,
+    isWindowFocused,
+    approvals,
+    userInputRequests,
+    getWorkspaceName,
+    onDebug,
+  });
+}
+
diff --git a/src/features/collaboration/hooks/useCollaborationModes.test.tsx b/src/features/collaboration/hooks/useCollaborationModes.test.tsx
index 43830e31..37ee58e3 100644
--- a/src/features/collaboration/hooks/useCollaborationModes.test.tsx
+++ b/src/features/collaboration/hooks/useCollaborationModes.test.tsx
@@ -32,10 +32,16 @@ const workspaceTwoConnected: WorkspaceInfo = {
 
 const makeModesResponse = () => ({
   result: {
-    data: [{ mode: "plan" }, { mode: "code" }],
+    data: [{ mode: "plan" }, { mode: "default" }],
   },
 });
 
+const makeModesResponseArrayResult = () => ({
+  result: [{ mode: "plan" }, { mode: "default" }],
+});
+
+const makeModesResponseTopLevelArray = () => [{ mode: "plan" }, { mode: "default" }];
+
 describe("useCollaborationModes", () => {
   afterEach(() => {
     vi.clearAllMocks();
@@ -52,7 +58,7 @@ describe("useCollaborationModes", () => {
       },
     );
 
-    await waitFor(() => expect(result.current.selectedCollaborationModeId).toBe("code"));
+    await waitFor(() => expect(result.current.selectedCollaborationModeId).toBe("default"));
 
     act(() => {
       result.current.setSelectedCollaborationModeId("plan");
@@ -82,7 +88,7 @@ describe("useCollaborationModes", () => {
       },
     );
 
-    await waitFor(() => expect(result.current.selectedCollaborationModeId).toBe("code"));
+    await waitFor(() => expect(result.current.selectedCollaborationModeId).toBe("default"));
 
     act(() => {
       result.current.setSelectedCollaborationModeId("plan");
@@ -94,5 +100,34 @@ describe("useCollaborationModes", () => {
     expect(result.current.selectedCollaborationModeId).toBeNull();
     expect(result.current.collaborationModes).toEqual([]);
   });
-});
 
+  it("accepts alternate response shapes from the backend", async () => {
+    vi.mocked(getCollaborationModes)
+      .mockResolvedValueOnce(makeModesResponseArrayResult() as any)
+      .mockResolvedValueOnce(makeModesResponseTopLevelArray() as any);
+
+    const { result, rerender } = renderHook(
+      ({ workspace }: { workspace: WorkspaceInfo | null }) =>
+        useCollaborationModes({ activeWorkspace: workspace, enabled: true }),
+      {
+        initialProps: { workspace: workspaceOne },
+      },
+    );
+
+    await waitFor(() =>
+      expect(result.current.collaborationModes.map((mode) => mode.id)).toEqual([
+        "plan",
+        "default",
+      ]),
+    );
+
+    rerender({ workspace: { ...workspaceOne, id: "workspace-1b" } });
+
+    await waitFor(() =>
+      expect(result.current.collaborationModes.map((mode) => mode.id)).toEqual([
+        "plan",
+        "default",
+      ]),
+    );
+  });
+});
diff --git a/src/features/collaboration/hooks/useCollaborationModes.ts b/src/features/collaboration/hooks/useCollaborationModes.ts
index b7d060b5..71ab17e7 100644
--- a/src/features/collaboration/hooks/useCollaborationModes.ts
+++ b/src/features/collaboration/hooks/useCollaborationModes.ts
@@ -5,7 +5,6 @@ import type {
   WorkspaceInfo,
 } from "../../../types";
 import { getCollaborationModes } from "../../../services/tauri";
-import { formatCollaborationModeLabel } from "../../../utils/collaborationModes";
 
 type UseCollaborationModesOptions = {
   activeWorkspace: WorkspaceInfo | null;
@@ -28,6 +27,35 @@ export function useCollaborationModes({
   const workspaceId = activeWorkspace?.id ?? null;
   const isConnected = Boolean(activeWorkspace?.connected);
 
+  const extractModeList = useCallback((response: any): any[] => {
+    const candidates = [
+      response?.result?.data,
+      response?.result?.modes,
+      response?.result,
+      response?.data,
+      response?.modes,
+      response,
+    ];
+    for (const candidate of candidates) {
+      if (Array.isArray(candidate)) {
+        return candidate;
+      }
+      if (candidate && typeof candidate === "object") {
+        const nested = (candidate as any).data ?? (candidate as any).modes;
+        if (Array.isArray(nested)) {
+          return nested;
+        }
+        if (nested && typeof nested === "object") {
+          const deep = (nested as any).data ?? (nested as any).modes;
+          if (Array.isArray(deep)) {
+            return deep;
+          }
+        }
+      }
+    }
+    return [];
+  }, []);
+
   const selectedMode = useMemo(
     () => modes.find((mode) => mode.id === selectedModeId) ?? null,
     [modes, selectedModeId],
@@ -57,18 +85,14 @@ export function useCollaborationModes({
         label: "collaborationMode/list response",
         payload: response,
       });
-      const rawData = response.result?.data ?? response.data ?? [];
+      const rawData = extractModeList(response);
       const data: CollaborationModeOption[] = rawData
         .map((item: any) => {
           if (!item || typeof item !== "object") {
             return null;
           }
-          const mode = String(item.mode ?? item.name ?? "");
-          if (!mode) {
-            return null;
-          }
-          const normalizedMode = mode.trim().toLowerCase();
-          if (normalizedMode && normalizedMode !== "plan" && normalizedMode !== "code") {
+          const modeId = String(item.mode ?? item.name ?? "").trim();
+          if (!modeId) {
             return null;
           }
 
@@ -89,30 +113,40 @@ export function useCollaborationModes({
           const reasoningEffort = settings.reasoning_effort ?? null;
           const developerInstructions = settings.developer_instructions ?? null;
 
-          const labelSource = String(item.name ?? item.label ?? mode);
-
-          const normalizedValue = {
-            ...(item as Record<string, unknown>),
-            mode: normalizedMode,
-          };
+          const labelSource =
+            typeof item.label === "string" && item.label.trim()
+              ? item.label
+              : typeof item.name === "string" && item.name.trim()
+                ? item.name
+                : modeId;
 
-          return {
-            id: normalizedMode,
-            label: formatCollaborationModeLabel(labelSource),
-            mode: normalizedMode,
+          const option: CollaborationModeOption = {
+            id: modeId,
+            label: labelSource,
+            mode: modeId,
             model,
             reasoningEffort: reasoningEffort ? String(reasoningEffort) : null,
             developerInstructions: developerInstructions
               ? String(developerInstructions)
               : null,
-            value: normalizedValue,
+            value: item as Record<string, unknown>,
           };
+          return option;
         })
-        .filter(Boolean);
+        .filter((mode): mode is CollaborationModeOption => mode !== null);
       setModes(data);
       lastFetchedWorkspaceId.current = workspaceId;
       const preferredModeId =
-        data.find((mode) => mode.mode === "code" || mode.id === "code")?.id ??
+        data.find(
+          (mode) =>
+            mode.id.trim().toLowerCase() === "default" ||
+            mode.mode.trim().toLowerCase() === "default",
+        )?.id ??
+        data.find(
+          (mode) =>
+            mode.id.trim().toLowerCase() === "code" ||
+            mode.mode.trim().toLowerCase() === "code",
+        )?.id ??
         data[0]?.id ??
         null;
       setSelectedModeId((currentSelection) => {
@@ -136,7 +170,7 @@ export function useCollaborationModes({
     } finally {
       inFlight.current = false;
     }
-  }, [enabled, isConnected, onDebug, workspaceId]);
+  }, [enabled, extractModeList, isConnected, onDebug, workspaceId]);
 
   useEffect(() => {
     selectedModeIdRef.current = selectedModeId;
diff --git a/src/features/composer/components/ComposerMetaBar.tsx b/src/features/composer/components/ComposerMetaBar.tsx
index 439feebf..138cb5f6 100644
--- a/src/features/composer/components/ComposerMetaBar.tsx
+++ b/src/features/composer/components/ComposerMetaBar.tsx
@@ -1,6 +1,5 @@
 import type { CSSProperties } from "react";
 import type { AccessMode, ThreadTokenUsage } from "../../../types";
-import { formatCollaborationModeLabel } from "../../../utils/collaborationModes";
 
 type ComposerMetaBarProps = {
   disabled: boolean;
@@ -74,7 +73,7 @@ export function ComposerMetaBar({
             >
               {collaborationModes.map((mode) => (
                 <option key={mode.id} value={mode.id}>
-                  {formatCollaborationModeLabel(mode.label || mode.id)}
+                  {mode.label || mode.id}
                 </option>
               ))}
             </select>
diff --git a/src/features/composer/hooks/useComposerShortcuts.test.tsx b/src/features/composer/hooks/useComposerShortcuts.test.tsx
new file mode 100644
index 00000000..e5f73e8d
--- /dev/null
+++ b/src/features/composer/hooks/useComposerShortcuts.test.tsx
@@ -0,0 +1,92 @@
+// @vitest-environment jsdom
+
+import { render } from "@testing-library/react";
+import { useRef } from "react";
+import { describe, expect, it, vi } from "vitest";
+import { useComposerShortcuts } from "./useComposerShortcuts";
+
+function ShortcutHarness(props: {
+  collaborationShortcut: string | null;
+  collaborationModes: { id: string; label: string }[];
+  selectedCollaborationModeId: string | null;
+  onSelectCollaborationMode: (id: string | null) => void;
+}) {
+  const textareaRef = useRef<HTMLTextAreaElement | null>(null);
+  useComposerShortcuts({
+    textareaRef,
+    modelShortcut: null,
+    accessShortcut: null,
+    reasoningShortcut: null,
+    collaborationShortcut: props.collaborationShortcut,
+    models: [],
+    collaborationModes: props.collaborationModes,
+    selectedModelId: null,
+    onSelectModel: () => {},
+    selectedCollaborationModeId: props.selectedCollaborationModeId,
+    onSelectCollaborationMode: props.onSelectCollaborationMode,
+    accessMode: "read-only",
+    onSelectAccessMode: () => {},
+    reasoningOptions: [],
+    selectedEffort: null,
+    onSelectEffort: () => {},
+    reasoningSupported: false,
+  });
+
+  return <textarea ref={textareaRef} aria-label="prompt" />;
+}
+
+describe("useComposerShortcuts", () => {
+  it("cycles collaboration mode on shift+tab while focused", () => {
+    const onSelectCollaborationMode = vi.fn();
+    const { getByLabelText } = render(
+      <ShortcutHarness
+        collaborationShortcut="shift+tab"
+        collaborationModes={[
+          { id: "default", label: "Default" },
+          { id: "plan", label: "Plan" },
+        ]}
+        selectedCollaborationModeId="default"
+        onSelectCollaborationMode={onSelectCollaborationMode}
+      />,
+    );
+
+    const textarea = getByLabelText("prompt") as HTMLTextAreaElement;
+    textarea.focus();
+    expect(document.activeElement).toBe(textarea);
+
+    const event = new KeyboardEvent("keydown", {
+      key: "Tab",
+      shiftKey: true,
+      bubbles: true,
+      cancelable: true,
+    });
+    window.dispatchEvent(event);
+
+    expect(onSelectCollaborationMode).toHaveBeenCalledWith("plan");
+  });
+
+  it("does nothing when textarea is not focused", () => {
+    const onSelectCollaborationMode = vi.fn();
+    render(
+      <ShortcutHarness
+        collaborationShortcut="shift+tab"
+        collaborationModes={[
+          { id: "default", label: "Default" },
+          { id: "plan", label: "Plan" },
+        ]}
+        selectedCollaborationModeId="default"
+        onSelectCollaborationMode={onSelectCollaborationMode}
+      />,
+    );
+
+    const event = new KeyboardEvent("keydown", {
+      key: "Tab",
+      shiftKey: true,
+      bubbles: true,
+      cancelable: true,
+    });
+    window.dispatchEvent(event);
+
+    expect(onSelectCollaborationMode).not.toHaveBeenCalled();
+  });
+});
diff --git a/src/features/debug/hooks/useDebugLog.ts b/src/features/debug/hooks/useDebugLog.ts
index 15d135a4..f6bc7065 100644
--- a/src/features/debug/hooks/useDebugLog.ts
+++ b/src/features/debug/hooks/useDebugLog.ts
@@ -9,7 +9,7 @@ export function useDebugLog() {
   const [hasDebugAlerts, setHasDebugAlerts] = useState(false);
   const [debugPinned, setDebugPinned] = useState(false);
 
-  const shouldLogEntry = useCallback((entry: DebugEntry) => {
+  const isAlertEntry = useCallback((entry: DebugEntry) => {
     if (entry.source === "error" || entry.source === "stderr") {
       return true;
     }
@@ -24,15 +24,27 @@ export function useDebugLog() {
     return false;
   }, []);
 
+  const shouldStoreEntry = useCallback(
+    (entry: DebugEntry) => {
+      if (debugOpen) {
+        return true;
+      }
+      return isAlertEntry(entry);
+    },
+    [debugOpen, isAlertEntry],
+  );
+
   const addDebugEntry = useCallback(
     (entry: DebugEntry) => {
-      if (!shouldLogEntry(entry)) {
+      if (!shouldStoreEntry(entry)) {
         return;
       }
-      setHasDebugAlerts(true);
+      if (isAlertEntry(entry)) {
+        setHasDebugAlerts(true);
+      }
       setDebugEntries((prev) => [...prev, entry].slice(-MAX_DEBUG_ENTRIES));
     },
-    [shouldLogEntry],
+    [isAlertEntry, shouldStoreEntry],
   );
 
   const handleCopyDebug = useCallback(async () => {
diff --git a/src/features/git/components/GitDiffViewer.tsx b/src/features/git/components/GitDiffViewer.tsx
index 280329d2..74c4087b 100644
--- a/src/features/git/components/GitDiffViewer.tsx
+++ b/src/features/git/components/GitDiffViewer.tsx
@@ -1,8 +1,10 @@
 import { memo, useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { ask } from "@tauri-apps/plugin-dialog";
 import { useVirtualizer } from "@tanstack/react-virtual";
 import { FileDiff, WorkerPoolContextProvider } from "@pierre/diffs/react";
 import type { FileDiffMetadata } from "@pierre/diffs";
 import { parsePatchFiles } from "@pierre/diffs";
+import RotateCcw from "lucide-react/dist/esm/icons/rotate-ccw";
 import { workerFactory } from "../../../utils/diffsWorker";
 import type { GitHubPullRequest, GitHubPullRequestComment } from "../../../types";
 import { formatRelativeTime } from "../../../utils/time";
@@ -34,6 +36,8 @@ type GitDiffViewerProps = {
   pullRequestComments?: GitHubPullRequestComment[];
   pullRequestCommentsLoading?: boolean;
   pullRequestCommentsError?: string | null;
+  canRevert?: boolean;
+  onRevertFile?: (path: string) => Promise<void> | void;
   onActivePathChange?: (path: string) => void;
 };
 
@@ -107,6 +111,8 @@ type DiffCardProps = {
   diffStyle: "split" | "unified";
   isLoading: boolean;
   ignoreWhitespaceChanges: boolean;
+  showRevert: boolean;
+  onRequestRevert?: (path: string) => void;
 };
 
 const DiffCard = memo(function DiffCard({
@@ -115,6 +121,8 @@ const DiffCard = memo(function DiffCard({
   diffStyle,
   isLoading,
   ignoreWhitespaceChanges,
+  showRevert,
+  onRequestRevert,
 }: DiffCardProps) {
   const diffOptions = useMemo(
     () => ({
@@ -169,6 +177,21 @@ const DiffCard = memo(function DiffCard({
           {entry.status}
         </span>
         <span className="diff-viewer-path">{entry.path}</span>
+        {showRevert && (
+          <button
+            type="button"
+            className="diff-viewer-header-action diff-viewer-header-action--discard"
+            title="Discard changes in this file"
+            aria-label="Discard changes in this file"
+            onClick={(event) => {
+              event.preventDefault();
+              event.stopPropagation();
+              onRequestRevert?.(entry.path);
+            }}
+          >
+            <RotateCcw size={14} aria-hidden />
+          </button>
+        )}
       </div>
       {entry.diff.trim().length > 0 && fileDiff ? (
         <div className="diff-viewer-output diff-viewer-output-flat">
@@ -386,6 +409,8 @@ export function GitDiffViewer({
   pullRequestComments,
   pullRequestCommentsLoading = false,
   pullRequestCommentsError = null,
+  canRevert = false,
+  onRevertFile,
   onActivePathChange,
 }: GitDiffViewerProps) {
   const containerRef = useRef<HTMLDivElement>(null);
@@ -456,6 +481,24 @@ export function GitDiffViewer({
     return diffs[0];
   }, [diffs, selectedPath, indexByPath]);
 
+  const showRevert = canRevert && Boolean(onRevertFile);
+  const handleRequestRevert = useCallback(
+    async (path: string) => {
+      if (!onRevertFile) {
+        return;
+      }
+      const confirmed = await ask(
+        `Discard changes in:\n\n${path}\n\nThis cannot be undone.`,
+        { title: "Discard changes", kind: "warning" },
+      );
+      if (!confirmed) {
+        return;
+      }
+      await onRevertFile(path);
+    },
+    [onRevertFile],
+  );
+
   useEffect(() => {
     if (!selectedPath || !scrollRequestId) {
       return;
@@ -619,6 +662,21 @@ export function GitDiffViewer({
                 {stickyEntry.status}
               </span>
               <span className="diff-viewer-path">{stickyEntry.path}</span>
+              {showRevert && (
+                <button
+                  type="button"
+                  className="diff-viewer-header-action diff-viewer-header-action--discard"
+                  title="Discard changes in this file"
+                  aria-label="Discard changes in this file"
+                  onClick={(event) => {
+                    event.preventDefault();
+                    event.stopPropagation();
+                    void handleRequestRevert(stickyEntry.path);
+                  }}
+                >
+                  <RotateCcw size={14} aria-hidden />
+                </button>
+              )}
             </div>
           </div>
         )}
@@ -660,6 +718,8 @@ export function GitDiffViewer({
                       oldImageMime={entry.oldImageMime}
                       newImageMime={entry.newImageMime}
                       isSelected={entry.path === selectedPath}
+                      showRevert={showRevert}
+                      onRequestRevert={(path) => void handleRequestRevert(path)}
                     />
                   ) : (
                     <DiffCard
@@ -668,6 +728,8 @@ export function GitDiffViewer({
                       diffStyle={diffStyle}
                       isLoading={isLoading}
                       ignoreWhitespaceChanges={ignoreWhitespaceChanges}
+                      showRevert={showRevert}
+                      onRequestRevert={(path) => void handleRequestRevert(path)}
                     />
                   )}
                 </div>
diff --git a/src/features/git/components/ImageDiffCard.tsx b/src/features/git/components/ImageDiffCard.tsx
index e05e8a0f..dd8cb0d6 100644
--- a/src/features/git/components/ImageDiffCard.tsx
+++ b/src/features/git/components/ImageDiffCard.tsx
@@ -1,5 +1,6 @@
 import { memo, useMemo } from "react";
 import ImageOff from "lucide-react/dist/esm/icons/image-off";
+import RotateCcw from "lucide-react/dist/esm/icons/rotate-ccw";
 
 type ImageDiffCardProps = {
   path: string;
@@ -9,6 +10,8 @@ type ImageDiffCardProps = {
   oldImageMime?: string | null;
   newImageMime?: string | null;
   isSelected: boolean;
+  showRevert?: boolean;
+  onRequestRevert?: (path: string) => void;
 };
 
 function getImageMimeType(path: string): string {
@@ -37,6 +40,8 @@ export const ImageDiffCard = memo(function ImageDiffCard({
   oldImageMime,
   newImageMime,
   isSelected,
+  showRevert = false,
+  onRequestRevert,
 }: ImageDiffCardProps) {
   const oldDataUri = useMemo(
     () => {
@@ -89,6 +94,21 @@ export const ImageDiffCard = memo(function ImageDiffCard({
           {status}
         </span>
         <span className="diff-viewer-path">{path}</span>
+        {showRevert && (
+          <button
+            type="button"
+            className="diff-viewer-header-action diff-viewer-header-action--discard"
+            title="Discard changes in this file"
+            aria-label="Discard changes in this file"
+            onClick={(event) => {
+              event.preventDefault();
+              event.stopPropagation();
+              onRequestRevert?.(path);
+            }}
+          >
+            <RotateCcw size={14} aria-hidden />
+          </button>
+        )}
       </div>
       <div className="image-diff-content">
         {isModified && (
diff --git a/src/features/layout/hooks/useLayoutNodes.tsx b/src/features/layout/hooks/useLayoutNodes.tsx
index c08d140c..fa8a268a 100644
--- a/src/features/layout/hooks/useLayoutNodes.tsx
+++ b/src/features/layout/hooks/useLayoutNodes.tsx
@@ -294,6 +294,7 @@ type LayoutNodesOptions = {
   onUnstageGitFile: (path: string) => Promise<void>;
   onRevertGitFile: (path: string) => Promise<void>;
   onRevertAllGitChanges: () => Promise<void>;
+  diffSource: "local" | "pr" | "commit";
   gitDiffs: GitDiffViewerItem[];
   gitDiffLoading: boolean;
   gitDiffError: string | null;
@@ -878,6 +879,8 @@ export function useLayoutNodes(options: LayoutNodesOptions): LayoutNodesResult {
       pullRequestComments={options.selectedPullRequestComments}
       pullRequestCommentsLoading={options.selectedPullRequestCommentsLoading}
       pullRequestCommentsError={options.selectedPullRequestCommentsError}
+      canRevert={options.diffSource === "local"}
+      onRevertFile={options.onRevertGitFile}
       onActivePathChange={options.onDiffActivePathChange}
     />
   );
diff --git a/src/features/messages/components/Messages.tsx b/src/features/messages/components/Messages.tsx
index 112c391a..087a4c50 100644
--- a/src/features/messages/components/Messages.tsx
+++ b/src/features/messages/components/Messages.tsx
@@ -1113,6 +1113,7 @@ export const Messages = memo(function Messages({
   const containerRef = useRef<HTMLDivElement | null>(null);
   const autoScrollRef = useRef(true);
   const [expandedItems, setExpandedItems] = useState<Set<string>>(new Set());
+  const manuallyToggledExpandedRef = useRef<Set<string>>(new Set());
   const [collapsedToolGroups, setCollapsedToolGroups] = useState<Set<string>>(
     new Set(),
   );
@@ -1163,6 +1164,7 @@ export const Messages = memo(function Messages({
     autoScrollRef.current = true;
   }, [threadId]);
   const toggleExpanded = useCallback((id: string) => {
+    manuallyToggledExpandedRef.current.add(id);
     setExpandedItems((prev) => {
       const next = new Set(prev);
       if (next.has(id)) {
@@ -1224,6 +1226,30 @@ export const Messages = memo(function Messages({
     [items, reasoningMetaById],
   );
 
+  useEffect(() => {
+    for (let index = visibleItems.length - 1; index >= 0; index -= 1) {
+      const item = visibleItems[index];
+      if (
+        item.kind === "tool" &&
+        item.toolType === "plan" &&
+        (item.output ?? "").trim().length > 0
+      ) {
+        if (manuallyToggledExpandedRef.current.has(item.id)) {
+          return;
+        }
+        setExpandedItems((prev) => {
+          if (prev.has(item.id)) {
+            return prev;
+          }
+          const next = new Set(prev);
+          next.add(item.id);
+          return next;
+        });
+        return;
+      }
+    }
+  }, [visibleItems]);
+
   useEffect(() => {
     return () => {
       if (copyTimeoutRef.current) {
diff --git a/src/features/notifications/hooks/useAgentResponseRequiredNotifications.test.tsx b/src/features/notifications/hooks/useAgentResponseRequiredNotifications.test.tsx
new file mode 100644
index 00000000..1953e9cd
--- /dev/null
+++ b/src/features/notifications/hooks/useAgentResponseRequiredNotifications.test.tsx
@@ -0,0 +1,248 @@
+// @vitest-environment jsdom
+import { act, renderHook } from "@testing-library/react";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import type {
+  ApprovalRequest,
+  RequestUserInputRequest,
+} from "../../../types";
+import { sendNotification } from "../../../services/tauri";
+import { useAgentResponseRequiredNotifications } from "./useAgentResponseRequiredNotifications";
+
+const useAppServerEventsMock = vi.fn();
+
+vi.mock("../../../services/tauri", () => ({
+  sendNotification: vi.fn(),
+}));
+
+vi.mock("../../app/hooks/useAppServerEvents", () => ({
+  useAppServerEvents: (handlers: unknown) => useAppServerEventsMock(handlers),
+}));
+
+describe("useAgentResponseRequiredNotifications", () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+    vi.mocked(sendNotification).mockReset();
+    vi.mocked(sendNotification).mockResolvedValue();
+    useAppServerEventsMock.mockReset();
+  });
+
+  afterEach(() => {
+    vi.clearAllTimers();
+    vi.useRealTimers();
+    vi.clearAllMocks();
+  });
+
+  it("retries throttled response-required question notifications", async () => {
+    const approvals: ApprovalRequest[] = [
+      {
+        workspace_id: "ws-1",
+        request_id: 1,
+        method: "workspace/requestApproval",
+        params: { command: "npm run lint" },
+      },
+    ];
+    const userInputRequests: RequestUserInputRequest[] = [
+      {
+        workspace_id: "ws-1",
+        request_id: 2,
+        params: {
+          thread_id: "thread-1",
+          turn_id: "turn-1",
+          item_id: "item-1",
+          questions: [
+            {
+              id: "question-1",
+              header: "Need input",
+              question: "Pick one",
+              options: [{ label: "A", description: "Option A" }],
+            },
+          ],
+        },
+      },
+    ];
+
+    renderHook(() =>
+      useAgentResponseRequiredNotifications({
+        enabled: true,
+        isWindowFocused: false,
+        approvals,
+        userInputRequests,
+      }),
+    );
+
+    await act(async () => {
+      await Promise.resolve();
+    });
+    expect(sendNotification).toHaveBeenCalledTimes(1);
+
+    act(() => {
+      vi.advanceTimersByTime(1_500);
+    });
+
+    await act(async () => {
+      await Promise.resolve();
+    });
+    expect(sendNotification).toHaveBeenCalledTimes(2);
+    expect(vi.mocked(sendNotification).mock.calls[1]?.[2]).toMatchObject({
+      extra: { type: "question" },
+    });
+  });
+
+  it("notifies each pending approval request without suppressing older ones", async () => {
+    const approvals: ApprovalRequest[] = [
+      {
+        workspace_id: "ws-1",
+        request_id: 1,
+        method: "workspace/requestApproval",
+        params: { command: "npm run lint" },
+      },
+      {
+        workspace_id: "ws-1",
+        request_id: 2,
+        method: "workspace/requestApproval",
+        params: { command: "npm run test" },
+      },
+    ];
+
+    renderHook(() =>
+      useAgentResponseRequiredNotifications({
+        enabled: true,
+        isWindowFocused: false,
+        approvals,
+        userInputRequests: [],
+      }),
+    );
+
+    await act(async () => {
+      await Promise.resolve();
+    });
+    expect(sendNotification).toHaveBeenCalledTimes(1);
+    expect(vi.mocked(sendNotification).mock.calls[0]?.[2]).toMatchObject({
+      extra: { type: "approval", requestId: 2 },
+    });
+
+    act(() => {
+      vi.advanceTimersByTime(1_500);
+    });
+
+    await act(async () => {
+      await Promise.resolve();
+    });
+    expect(sendNotification).toHaveBeenCalledTimes(2);
+    expect(vi.mocked(sendNotification).mock.calls[1]?.[2]).toMatchObject({
+      extra: { type: "approval", requestId: 1 },
+    });
+  });
+
+  it("notifies each pending question request without suppressing older ones", async () => {
+    const userInputRequests: RequestUserInputRequest[] = [
+      {
+        workspace_id: "ws-1",
+        request_id: 10,
+        params: {
+          thread_id: "thread-1",
+          turn_id: "turn-1",
+          item_id: "item-1",
+          questions: [{ id: "q-1", header: "Question one", question: "Choose one" }],
+        },
+      },
+      {
+        workspace_id: "ws-1",
+        request_id: 11,
+        params: {
+          thread_id: "thread-1",
+          turn_id: "turn-2",
+          item_id: "item-2",
+          questions: [{ id: "q-2", header: "Question two", question: "Choose two" }],
+        },
+      },
+    ];
+
+    renderHook(() =>
+      useAgentResponseRequiredNotifications({
+        enabled: true,
+        isWindowFocused: false,
+        approvals: [],
+        userInputRequests,
+      }),
+    );
+
+    await act(async () => {
+      await Promise.resolve();
+    });
+    expect(sendNotification).toHaveBeenCalledTimes(1);
+    expect(vi.mocked(sendNotification).mock.calls[0]?.[2]).toMatchObject({
+      extra: { type: "question", requestId: 11 },
+    });
+
+    act(() => {
+      vi.advanceTimersByTime(1_500);
+    });
+
+    await act(async () => {
+      await Promise.resolve();
+    });
+    expect(sendNotification).toHaveBeenCalledTimes(2);
+    expect(vi.mocked(sendNotification).mock.calls[1]?.[2]).toMatchObject({
+      extra: { type: "question", requestId: 10 },
+    });
+  });
+
+  it("queues plan notifications that arrive inside the throttle window", async () => {
+    renderHook(() =>
+      useAgentResponseRequiredNotifications({
+        enabled: true,
+        isWindowFocused: false,
+        approvals: [],
+        userInputRequests: [],
+      }),
+    );
+
+    const lastCall = useAppServerEventsMock.mock.calls[
+      useAppServerEventsMock.mock.calls.length - 1
+    ];
+    const handlers = lastCall?.[0] as {
+      onItemCompleted?: (
+        workspaceId: string,
+        threadId: string,
+        item: Record<string, unknown>,
+      ) => void;
+    };
+    expect(typeof handlers?.onItemCompleted).toBe("function");
+
+    act(() => {
+      handlers.onItemCompleted?.("ws-1", "thread-1", {
+        id: "plan-1",
+        type: "plan",
+        status: "completed",
+        text: "First plan",
+      });
+      handlers.onItemCompleted?.("ws-1", "thread-1", {
+        id: "plan-2",
+        type: "plan",
+        status: "completed",
+        text: "Second plan",
+      });
+    });
+
+    await act(async () => {
+      await Promise.resolve();
+    });
+    expect(sendNotification).toHaveBeenCalledTimes(1);
+    expect(vi.mocked(sendNotification).mock.calls[0]?.[2]).toMatchObject({
+      extra: { type: "plan", itemId: "plan-1" },
+    });
+
+    act(() => {
+      vi.advanceTimersByTime(1_500);
+    });
+
+    await act(async () => {
+      await Promise.resolve();
+    });
+    expect(sendNotification).toHaveBeenCalledTimes(2);
+    expect(vi.mocked(sendNotification).mock.calls[1]?.[2]).toMatchObject({
+      extra: { type: "plan", itemId: "plan-2" },
+    });
+  });
+});
diff --git a/src/features/notifications/hooks/useAgentResponseRequiredNotifications.ts b/src/features/notifications/hooks/useAgentResponseRequiredNotifications.ts
new file mode 100644
index 00000000..73784ea9
--- /dev/null
+++ b/src/features/notifications/hooks/useAgentResponseRequiredNotifications.ts
@@ -0,0 +1,334 @@
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import type {
+  ApprovalRequest,
+  DebugEntry,
+  RequestUserInputRequest,
+} from "../../../types";
+import { sendNotification } from "../../../services/tauri";
+import { getApprovalCommandInfo } from "../../../utils/approvalRules";
+import { useAppServerEvents } from "../../app/hooks/useAppServerEvents";
+
+const MAX_BODY_LENGTH = 200;
+const MIN_NOTIFICATION_SPACING_MS = 1500;
+
+function truncateText(text: string, maxLength: number): string {
+  if (text.length <= maxLength) {
+    return text;
+  }
+  return text.slice(0, maxLength - 1) + "…";
+}
+
+function buildApprovalKey(workspaceId: string, requestId: string | number) {
+  return `${workspaceId}:${requestId}`;
+}
+
+function buildUserInputKey(workspaceId: string, requestId: string | number) {
+  return `${workspaceId}:${requestId}`;
+}
+
+function buildPlanKey(workspaceId: string, threadId: string, itemId: string) {
+  return `${workspaceId}:${threadId}:${itemId}`;
+}
+
+function isCompletedStatus(status: unknown) {
+  const normalized = String(status ?? "").toLowerCase();
+  if (!normalized) {
+    return false;
+  }
+  return (
+    normalized === "completed" ||
+    normalized === "complete" ||
+    normalized === "done" ||
+    normalized.includes("complete")
+  );
+}
+
+type ResponseRequiredNotificationOptions = {
+  enabled: boolean;
+  isWindowFocused: boolean;
+  approvals: ApprovalRequest[];
+  userInputRequests: RequestUserInputRequest[];
+  getWorkspaceName?: (workspaceId: string) => string | undefined;
+  onDebug?: (entry: DebugEntry) => void;
+};
+
+type PendingPlanNotification = {
+  title: string;
+  body: string;
+  extra: Record<string, unknown>;
+};
+
+export function useAgentResponseRequiredNotifications({
+  enabled,
+  isWindowFocused,
+  approvals,
+  userInputRequests,
+  getWorkspaceName,
+  onDebug,
+}: ResponseRequiredNotificationOptions) {
+  const lastNotifiedAtRef = useRef(0);
+  const notifiedApprovalsRef = useRef(new Set<string>());
+  const notifiedUserInputsRef = useRef(new Set<string>());
+  const notifiedPlanItemsRef = useRef(new Set<string>());
+  const pendingPlanNotificationsRef = useRef(new Map<string, PendingPlanNotification>());
+  const retryTimeoutRef = useRef<ReturnType<typeof setTimeout> | null>(null);
+  const [retrySignal, setRetrySignal] = useState(0);
+  const [pendingPlansSignal, setPendingPlansSignal] = useState(0);
+
+  const canNotifyNow = useCallback(() => {
+    if (!enabled) {
+      return false;
+    }
+    if (isWindowFocused) {
+      return false;
+    }
+    const lastNotifiedAt = lastNotifiedAtRef.current;
+    if (lastNotifiedAt && Date.now() - lastNotifiedAt < MIN_NOTIFICATION_SPACING_MS) {
+      return false;
+    }
+    lastNotifiedAtRef.current = Date.now();
+    return true;
+  }, [enabled, isWindowFocused]);
+
+  const scheduleRetry = useCallback(() => {
+    if (!enabled || isWindowFocused || retryTimeoutRef.current) {
+      return;
+    }
+    const elapsed = lastNotifiedAtRef.current
+      ? Date.now() - lastNotifiedAtRef.current
+      : MIN_NOTIFICATION_SPACING_MS;
+    const delay = Math.max(0, MIN_NOTIFICATION_SPACING_MS - elapsed);
+    retryTimeoutRef.current = setTimeout(() => {
+      retryTimeoutRef.current = null;
+      setRetrySignal((value) => value + 1);
+    }, delay);
+  }, [enabled, isWindowFocused]);
+
+  const notify = useCallback(
+    async (
+      title: string,
+      body: string,
+      extra?: Record<string, unknown>,
+    ) => {
+      try {
+        await sendNotification(title, body, {
+          autoCancel: true,
+          extra,
+        });
+        onDebug?.({
+          id: `${Date.now()}-client-notification-attention`,
+          timestamp: Date.now(),
+          source: "client",
+          label: "notification/attention",
+          payload: { title, body },
+        });
+      } catch (error) {
+        onDebug?.({
+          id: `${Date.now()}-client-notification-attention-error`,
+          timestamp: Date.now(),
+          source: "error",
+          label: "notification/error",
+          payload: error instanceof Error ? error.message : String(error),
+        });
+      }
+    },
+    [onDebug],
+  );
+
+  useEffect(
+    () => () => {
+      if (retryTimeoutRef.current) {
+        clearTimeout(retryTimeoutRef.current);
+        retryTimeoutRef.current = null;
+      }
+    },
+    [],
+  );
+
+  const latestUnnotifiedApproval = (() => {
+    for (let index = approvals.length - 1; index >= 0; index -= 1) {
+      const approval = approvals[index];
+      if (!approval) {
+        continue;
+      }
+      const key = buildApprovalKey(approval.workspace_id, approval.request_id);
+      if (!notifiedApprovalsRef.current.has(key)) {
+        return approval;
+      }
+    }
+    return null;
+  })();
+
+  useEffect(() => {
+    if (!latestUnnotifiedApproval) {
+      return;
+    }
+    if (!canNotifyNow()) {
+      scheduleRetry();
+      return;
+    }
+
+    const approvalKey = buildApprovalKey(
+      latestUnnotifiedApproval.workspace_id,
+      latestUnnotifiedApproval.request_id,
+    );
+    notifiedApprovalsRef.current.add(approvalKey);
+
+    const workspaceName = getWorkspaceName?.(latestUnnotifiedApproval.workspace_id);
+    const title = workspaceName
+      ? `Approval needed — ${workspaceName}`
+      : "Approval needed";
+    const commandInfo = getApprovalCommandInfo(latestUnnotifiedApproval.params ?? {});
+    const body = commandInfo?.preview
+      ? truncateText(commandInfo.preview, MAX_BODY_LENGTH)
+      : truncateText(latestUnnotifiedApproval.method, MAX_BODY_LENGTH);
+
+    void notify(title, body, {
+      kind: "response_required",
+      type: "approval",
+      workspaceId: latestUnnotifiedApproval.workspace_id,
+      requestId: latestUnnotifiedApproval.request_id,
+    });
+    scheduleRetry();
+  }, [
+    canNotifyNow,
+    getWorkspaceName,
+    latestUnnotifiedApproval,
+    notify,
+    retrySignal,
+    scheduleRetry,
+  ]);
+
+  const latestUnnotifiedQuestion = (() => {
+    for (let index = userInputRequests.length - 1; index >= 0; index -= 1) {
+      const request = userInputRequests[index];
+      if (!request) {
+        continue;
+      }
+      const key = buildUserInputKey(request.workspace_id, request.request_id);
+      if (!notifiedUserInputsRef.current.has(key)) {
+        return request;
+      }
+    }
+    return null;
+  })();
+
+  useEffect(() => {
+    if (!latestUnnotifiedQuestion) {
+      return;
+    }
+    if (!canNotifyNow()) {
+      scheduleRetry();
+      return;
+    }
+
+    const questionKey = buildUserInputKey(
+      latestUnnotifiedQuestion.workspace_id,
+      latestUnnotifiedQuestion.request_id,
+    );
+    notifiedUserInputsRef.current.add(questionKey);
+
+    const workspaceName = getWorkspaceName?.(latestUnnotifiedQuestion.workspace_id);
+    const title = workspaceName ? `Question — ${workspaceName}` : "Question";
+    const first = latestUnnotifiedQuestion.params.questions[0];
+    const bodyRaw = first?.header?.trim() || first?.question?.trim() || "Your input is needed.";
+    const body = truncateText(bodyRaw, MAX_BODY_LENGTH);
+
+    void notify(title, body, {
+      kind: "response_required",
+      type: "question",
+      workspaceId: latestUnnotifiedQuestion.workspace_id,
+      requestId: latestUnnotifiedQuestion.request_id,
+      threadId: latestUnnotifiedQuestion.params.thread_id,
+      turnId: latestUnnotifiedQuestion.params.turn_id,
+      itemId: latestUnnotifiedQuestion.params.item_id,
+    });
+    scheduleRetry();
+  }, [
+    canNotifyNow,
+    getWorkspaceName,
+    latestUnnotifiedQuestion,
+    notify,
+    retrySignal,
+    scheduleRetry,
+  ]);
+
+  useEffect(() => {
+    if (!pendingPlanNotificationsRef.current.size) {
+      return;
+    }
+    if (!canNotifyNow()) {
+      scheduleRetry();
+      return;
+    }
+    const next = pendingPlanNotificationsRef.current.entries().next().value as
+      | [string, PendingPlanNotification]
+      | undefined;
+    if (!next) {
+      return;
+    }
+    const [key, pending] = next;
+    pendingPlanNotificationsRef.current.delete(key);
+    notifiedPlanItemsRef.current.add(key);
+    setPendingPlansSignal((value) => value + 1);
+    void notify(pending.title, pending.body, pending.extra);
+    if (pendingPlanNotificationsRef.current.size) {
+      scheduleRetry();
+    }
+  }, [canNotifyNow, notify, pendingPlansSignal, retrySignal, scheduleRetry]);
+
+  const onItemCompleted = useCallback(
+    (workspaceId: string, threadId: string, item: Record<string, unknown>) => {
+      const type = String(item.type ?? "");
+      if (type !== "plan") {
+        return;
+      }
+      if (!isCompletedStatus(item.status)) {
+        return;
+      }
+      const itemId = String(item.id ?? "");
+      if (!itemId) {
+        return;
+      }
+      const key = buildPlanKey(workspaceId, threadId, itemId);
+      if (
+        notifiedPlanItemsRef.current.has(key) ||
+        pendingPlanNotificationsRef.current.has(key)
+      ) {
+        return;
+      }
+      const workspaceName = getWorkspaceName?.(workspaceId);
+      const title = workspaceName ? `Plan ready — ${workspaceName}` : "Plan ready";
+      const text = String(item.text ?? "").trim();
+      const body = text
+        ? truncateText(text.split("\n")[0] ?? text, MAX_BODY_LENGTH)
+        : "Plan is ready. Open CodexMonitor to respond.";
+      const extra = {
+        kind: "response_required",
+        type: "plan",
+        workspaceId,
+        threadId,
+        itemId,
+      };
+      if (!canNotifyNow()) {
+        pendingPlanNotificationsRef.current.set(key, { title, body, extra });
+        setPendingPlansSignal((value) => value + 1);
+        scheduleRetry();
+        return;
+      }
+      notifiedPlanItemsRef.current.add(key);
+
+      void notify(title, body, extra);
+    },
+    [canNotifyNow, getWorkspaceName, notify, scheduleRetry],
+  );
+
+  useAppServerEvents(
+    useMemo(
+      () => ({
+        onItemCompleted,
+      }),
+      [onItemCompleted],
+    ),
+  );
+}
diff --git a/src/features/settings/components/SettingsView.test.tsx b/src/features/settings/components/SettingsView.test.tsx
index ba21683c..a5a0564a 100644
--- a/src/features/settings/components/SettingsView.test.tsx
+++ b/src/features/settings/components/SettingsView.test.tsx
@@ -194,6 +194,96 @@ const renderFeaturesSection = (
   return { onUpdateAppSettings };
 };
 
+const workspace = (
+  overrides: Omit<Partial<WorkspaceInfo>, "settings"> &
+    Pick<WorkspaceInfo, "id" | "name"> & {
+      settings?: Partial<WorkspaceInfo["settings"]>;
+    },
+): WorkspaceInfo => ({
+  id: overrides.id,
+  name: overrides.name,
+  path: overrides.path ?? `/tmp/${overrides.id}`,
+  connected: overrides.connected ?? false,
+  codex_bin: overrides.codex_bin ?? null,
+  kind: overrides.kind ?? "main",
+  parentId: overrides.parentId ?? null,
+  worktree: overrides.worktree ?? null,
+  settings: {
+    sidebarCollapsed: false,
+    sortOrder: null,
+    groupId: null,
+    gitRoot: null,
+    codexHome: null,
+    codexArgs: null,
+    launchScript: null,
+    launchScripts: null,
+    worktreeSetupScript: null,
+    ...overrides.settings,
+  },
+});
+
+const renderEnvironmentsSection = (
+  options: {
+    groupedWorkspaces?: ComponentProps<typeof SettingsView>["groupedWorkspaces"];
+    onUpdateWorkspaceSettings?: ComponentProps<typeof SettingsView>["onUpdateWorkspaceSettings"];
+  } = {},
+) => {
+  cleanup();
+  const onUpdateWorkspaceSettings =
+    options.onUpdateWorkspaceSettings ?? vi.fn().mockResolvedValue(undefined);
+
+  const props: ComponentProps<typeof SettingsView> = {
+    reduceTransparency: false,
+    onToggleTransparency: vi.fn(),
+    appSettings: baseSettings,
+    openAppIconById: {},
+    onUpdateAppSettings: vi.fn().mockResolvedValue(undefined),
+    workspaceGroups: [],
+    groupedWorkspaces:
+      options.groupedWorkspaces ??
+      [
+        {
+          id: null,
+          name: "Ungrouped",
+          workspaces: [
+            workspace({
+              id: "w1",
+              name: "Project One",
+              settings: {
+                sidebarCollapsed: false,
+                worktreeSetupScript: "echo one",
+              },
+            }),
+          ],
+        },
+      ],
+    ungroupedLabel: "Ungrouped",
+    onClose: vi.fn(),
+    onMoveWorkspace: vi.fn(),
+    onDeleteWorkspace: vi.fn(),
+    onCreateWorkspaceGroup: vi.fn().mockResolvedValue(null),
+    onRenameWorkspaceGroup: vi.fn().mockResolvedValue(null),
+    onMoveWorkspaceGroup: vi.fn().mockResolvedValue(null),
+    onDeleteWorkspaceGroup: vi.fn().mockResolvedValue(null),
+    onAssignWorkspaceGroup: vi.fn().mockResolvedValue(null),
+    onRunDoctor: vi.fn().mockResolvedValue(createDoctorResult()),
+    onUpdateWorkspaceCodexBin: vi.fn().mockResolvedValue(undefined),
+    onUpdateWorkspaceSettings,
+    scaleShortcutTitle: "Scale shortcut",
+    scaleShortcutText: "Use Command +/-",
+    onTestNotificationSound: vi.fn(),
+    onTestSystemNotification: vi.fn(),
+    dictationModelStatus: null,
+    onDownloadDictationModel: vi.fn(),
+    onCancelDictationDownload: vi.fn(),
+    onRemoveDictationModel: vi.fn(),
+    initialSection: "environments",
+  };
+
+  render(<SettingsView {...props} />);
+  return { onUpdateWorkspaceSettings };
+};
+
 describe("SettingsView Display", () => {
   it("updates the theme selection", async () => {
     const onUpdateAppSettings = vi.fn().mockResolvedValue(undefined);
@@ -366,6 +456,69 @@ describe("SettingsView Display", () => {
   });
 });
 
+describe("SettingsView Environments", () => {
+  it("saves the setup script for the selected project", async () => {
+    const onUpdateWorkspaceSettings = vi.fn().mockResolvedValue(undefined);
+    renderEnvironmentsSection({ onUpdateWorkspaceSettings });
+
+    expect(
+      screen.getByText("Environments", { selector: ".settings-section-title" }),
+    ).toBeTruthy();
+    const textarea = screen.getByPlaceholderText("pnpm install");
+    expect((textarea as HTMLTextAreaElement).value).toBe("echo one");
+
+    fireEvent.change(textarea, { target: { value: "echo updated" } });
+    fireEvent.click(screen.getByRole("button", { name: "Save" }));
+
+    await waitFor(() => {
+      expect(onUpdateWorkspaceSettings).toHaveBeenCalledWith("w1", {
+        worktreeSetupScript: "echo updated",
+      });
+    });
+  });
+
+  it("normalizes whitespace-only scripts to null", async () => {
+    const onUpdateWorkspaceSettings = vi.fn().mockResolvedValue(undefined);
+    renderEnvironmentsSection({ onUpdateWorkspaceSettings });
+
+    const textarea = screen.getByPlaceholderText("pnpm install");
+    fireEvent.change(textarea, { target: { value: "   \n\t" } });
+    fireEvent.click(screen.getByRole("button", { name: "Save" }));
+
+    await waitFor(() => {
+      expect(onUpdateWorkspaceSettings).toHaveBeenCalledWith("w1", {
+        worktreeSetupScript: null,
+      });
+    });
+  });
+
+  it("copies the setup script to the clipboard", async () => {
+    const originalDescriptor = Object.getOwnPropertyDescriptor(navigator, "clipboard");
+    const writeText = vi.fn().mockResolvedValue(undefined);
+    Object.defineProperty(navigator, "clipboard", {
+      value: { writeText },
+      configurable: true,
+    });
+
+    try {
+      renderEnvironmentsSection();
+
+      fireEvent.click(screen.getByRole("button", { name: "Copy" }));
+
+      await waitFor(() => {
+        expect(writeText).toHaveBeenCalledWith("echo one");
+      });
+    } finally {
+      if (originalDescriptor) {
+        Object.defineProperty(navigator, "clipboard", originalDescriptor);
+      } else {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        delete (navigator as any).clipboard;
+      }
+    }
+  });
+});
+
 describe("SettingsView Codex overrides", () => {
   it("updates workspace Codex args override on blur", async () => {
     const onUpdateWorkspaceSettings = vi.fn().mockResolvedValue(undefined);
diff --git a/src/features/settings/components/SettingsView.tsx b/src/features/settings/components/SettingsView.tsx
index 762f9ae3..a58200e2 100644
--- a/src/features/settings/components/SettingsView.tsx
+++ b/src/features/settings/components/SettingsView.tsx
@@ -15,6 +15,7 @@ import Trash2 from "lucide-react/dist/esm/icons/trash-2";
 import X from "lucide-react/dist/esm/icons/x";
 import FlaskConical from "lucide-react/dist/esm/icons/flask-conical";
 import ExternalLink from "lucide-react/dist/esm/icons/external-link";
+import Layers from "lucide-react/dist/esm/icons/layers";
 import type {
   AppSettings,
   CodexDoctorResult,
@@ -32,6 +33,7 @@ import {
 } from "../../../utils/shortcuts";
 import { clampUiScale } from "../../../utils/uiScale";
 import { getCodexConfigPath } from "../../../services/tauri";
+import { pushErrorToast } from "../../../services/toasts";
 import {
   DEFAULT_CODE_FONT_FAMILY,
   DEFAULT_UI_FONT_FAMILY,
@@ -113,6 +115,13 @@ const normalizeOverrideValue = (value: string): string | null => {
   return trimmed ? trimmed : null;
 };
 
+const normalizeWorktreeSetupScript = (
+  value: string | null | undefined,
+): string | null => {
+  const next = value ?? "";
+  return next.trim().length > 0 ? next : null;
+};
+
 const buildWorkspaceOverrideDrafts = (
   projects: WorkspaceInfo[],
   prev: Record<string, string>,
@@ -172,6 +181,7 @@ export type SettingsViewProps = {
 
 type SettingsSection =
   | "projects"
+  | "environments"
   | "display"
   | "composer"
   | "dictation"
@@ -313,6 +323,18 @@ export function SettingsView({
   initialSection,
 }: SettingsViewProps) {
   const [activeSection, setActiveSection] = useState<CodexSection>("projects");
+  const [environmentWorkspaceId, setEnvironmentWorkspaceId] = useState<string | null>(
+    null,
+  );
+  const [environmentDraftScript, setEnvironmentDraftScript] = useState("");
+  const [environmentSavedScript, setEnvironmentSavedScript] = useState<string | null>(
+    null,
+  );
+  const [environmentLoadedWorkspaceId, setEnvironmentLoadedWorkspaceId] = useState<
+    string | null
+  >(null);
+  const [environmentError, setEnvironmentError] = useState<string | null>(null);
+  const [environmentSaving, setEnvironmentSaving] = useState(false);
   const [codexPathDraft, setCodexPathDraft] = useState(appSettings.codexBin ?? "");
   const [codexArgsDraft, setCodexArgsDraft] = useState(appSettings.codexArgs ?? "");
   const [remoteHostDraft, setRemoteHostDraft] = useState(appSettings.remoteBackendHost);
@@ -441,6 +463,29 @@ export function SettingsView({
     () => groupedWorkspaces.flatMap((group) => group.workspaces),
     [groupedWorkspaces],
   );
+  const mainWorkspaces = useMemo(
+    () => projects.filter((workspace) => (workspace.kind ?? "main") !== "worktree"),
+    [projects],
+  );
+  const environmentWorkspace = useMemo(() => {
+    if (mainWorkspaces.length === 0) {
+      return null;
+    }
+    if (environmentWorkspaceId) {
+      const found = mainWorkspaces.find((workspace) => workspace.id === environmentWorkspaceId);
+      if (found) {
+        return found;
+      }
+    }
+    return mainWorkspaces[0] ?? null;
+  }, [environmentWorkspaceId, mainWorkspaces]);
+  const environmentSavedScriptFromWorkspace = useMemo(() => {
+    return normalizeWorktreeSetupScript(environmentWorkspace?.settings.worktreeSetupScript);
+  }, [environmentWorkspace?.settings.worktreeSetupScript]);
+  const environmentDraftNormalized = useMemo(() => {
+    return normalizeWorktreeSetupScript(environmentDraftScript);
+  }, [environmentDraftScript]);
+  const environmentDirty = environmentDraftNormalized !== environmentSavedScript;
   const hasCodexHomeOverrides = useMemo(
     () => projects.some((workspace) => workspace.settings.codexHome != null),
     [projects],
@@ -604,6 +649,48 @@ export function SettingsView({
     }
   }, [initialSection]);
 
+  useEffect(() => {
+    if (!environmentWorkspace) {
+      setEnvironmentWorkspaceId(null);
+      setEnvironmentLoadedWorkspaceId(null);
+      setEnvironmentSavedScript(null);
+      setEnvironmentDraftScript("");
+      setEnvironmentError(null);
+      setEnvironmentSaving(false);
+      return;
+    }
+
+    if (environmentWorkspaceId !== environmentWorkspace.id) {
+      setEnvironmentWorkspaceId(environmentWorkspace.id);
+    }
+  }, [environmentWorkspace, environmentWorkspaceId]);
+
+  useEffect(() => {
+    if (!environmentWorkspace) {
+      return;
+    }
+
+    if (environmentLoadedWorkspaceId !== environmentWorkspace.id) {
+      setEnvironmentLoadedWorkspaceId(environmentWorkspace.id);
+      setEnvironmentSavedScript(environmentSavedScriptFromWorkspace);
+      setEnvironmentDraftScript(environmentSavedScriptFromWorkspace ?? "");
+      setEnvironmentError(null);
+      return;
+    }
+
+    if (!environmentDirty && environmentSavedScript !== environmentSavedScriptFromWorkspace) {
+      setEnvironmentSavedScript(environmentSavedScriptFromWorkspace);
+      setEnvironmentDraftScript(environmentSavedScriptFromWorkspace ?? "");
+      setEnvironmentError(null);
+    }
+  }, [
+    environmentDirty,
+    environmentLoadedWorkspaceId,
+    environmentSavedScript,
+    environmentSavedScriptFromWorkspace,
+    environmentWorkspace,
+  ]);
+
   const nextCodexBin = codexPathDraft.trim() ? codexPathDraft.trim() : null;
   const nextCodexArgs = codexArgsDraft.trim() ? codexArgsDraft.trim() : null;
   const codexDirty =
@@ -922,6 +1009,26 @@ export function SettingsView({
     void updateShortcut(key, value);
   };
 
+  const handleSaveEnvironmentSetup = async () => {
+    if (!environmentWorkspace || environmentSaving) {
+      return;
+    }
+    const nextScript = environmentDraftNormalized;
+    setEnvironmentSaving(true);
+    setEnvironmentError(null);
+    try {
+      await onUpdateWorkspaceSettings(environmentWorkspace.id, {
+        worktreeSetupScript: nextScript,
+      });
+      setEnvironmentSavedScript(nextScript);
+      setEnvironmentDraftScript(nextScript ?? "");
+    } catch (error) {
+      setEnvironmentError(error instanceof Error ? error.message : String(error));
+    } finally {
+      setEnvironmentSaving(false);
+    }
+  };
+
   const trimmedGroupName = newGroupName.trim();
   const canCreateGroup = Boolean(trimmedGroupName);
 
@@ -1043,6 +1150,14 @@ export function SettingsView({
               <LayoutGrid aria-hidden />
               Projects
             </button>
+            <button
+              type="button"
+              className={`settings-nav ${activeSection === "environments" ? "active" : ""}`}
+              onClick={() => setActiveSection("environments")}
+            >
+              <Layers aria-hidden />
+              Environments
+            </button>
             <button
               type="button"
               className={`settings-nav ${activeSection === "display" ? "active" : ""}`}
@@ -1323,6 +1438,109 @@ export function SettingsView({
                 </div>
               </section>
             )}
+            {activeSection === "environments" && (
+              <section className="settings-section">
+                <div className="settings-section-title">Environments</div>
+                <div className="settings-section-subtitle">
+                  Configure per-project setup scripts that run after worktree creation.
+                </div>
+                {mainWorkspaces.length === 0 ? (
+                  <div className="settings-empty">No projects yet.</div>
+                ) : (
+                  <>
+                    <div className="settings-field">
+                      <label
+                        className="settings-field-label"
+                        htmlFor="settings-environment-project"
+                      >
+                        Project
+                      </label>
+                      <select
+                        id="settings-environment-project"
+                        className="settings-select"
+                        value={environmentWorkspace?.id ?? ""}
+                        onChange={(event) => setEnvironmentWorkspaceId(event.target.value)}
+                        disabled={environmentSaving}
+                      >
+                        {mainWorkspaces.map((workspace) => (
+                          <option key={workspace.id} value={workspace.id}>
+                            {workspace.name}
+                          </option>
+                        ))}
+                      </select>
+                      {environmentWorkspace ? (
+                        <div className="settings-help">{environmentWorkspace.path}</div>
+                      ) : null}
+                    </div>
+
+                    <div className="settings-field">
+                      <div className="settings-field-label">Setup script</div>
+                      <div className="settings-help">
+                        Runs once in a dedicated terminal after each new worktree is created.
+                      </div>
+                      {environmentError ? (
+                        <div className="settings-agents-error">{environmentError}</div>
+                      ) : null}
+                      <textarea
+                        className="settings-agents-textarea"
+                        value={environmentDraftScript}
+                        onChange={(event) => setEnvironmentDraftScript(event.target.value)}
+                        placeholder="pnpm install"
+                        spellCheck={false}
+                        disabled={environmentSaving}
+                      />
+                      <div className="settings-field-actions">
+                        <button
+                          type="button"
+                          className="ghost settings-button-compact"
+                          onClick={() => {
+                            const clipboard =
+                              typeof navigator === "undefined" ? null : navigator.clipboard;
+                            if (!clipboard?.writeText) {
+                              pushErrorToast({
+                                title: "Copy failed",
+                                message:
+                                  "Clipboard access is unavailable in this environment. Copy the script manually instead.",
+                              });
+                              return;
+                            }
+
+                            void clipboard.writeText(environmentDraftScript).catch(() => {
+                              pushErrorToast({
+                                title: "Copy failed",
+                                message:
+                                  "Could not write to the clipboard. Copy the script manually instead.",
+                              });
+                            });
+                          }}
+                          disabled={environmentSaving || environmentDraftScript.length === 0}
+                        >
+                          Copy
+                        </button>
+                        <button
+                          type="button"
+                          className="ghost settings-button-compact"
+                          onClick={() => setEnvironmentDraftScript(environmentSavedScript ?? "")}
+                          disabled={environmentSaving || !environmentDirty}
+                        >
+                          Reset
+                        </button>
+                        <button
+                          type="button"
+                          className="primary settings-button-compact"
+                          onClick={() => {
+                            void handleSaveEnvironmentSetup();
+                          }}
+                          disabled={environmentSaving || !environmentDirty}
+                        >
+                          {environmentSaving ? "Saving..." : "Save"}
+                        </button>
+                      </div>
+                    </div>
+                  </>
+                )}
+              </section>
+            )}
             {activeSection === "display" && (
               <section className="settings-section">
                 <div className="settings-section-title">Display &amp; Sound</div>
diff --git a/src/features/threads/hooks/useThreadTurnEvents.test.tsx b/src/features/threads/hooks/useThreadTurnEvents.test.tsx
index 9822c3a1..e16e40af 100644
--- a/src/features/threads/hooks/useThreadTurnEvents.test.tsx
+++ b/src/features/threads/hooks/useThreadTurnEvents.test.tsx
@@ -267,6 +267,27 @@ describe("useThreadTurnEvents", () => {
     });
   });
 
+  it("does not clear a completed plan for a different turn", () => {
+    const { result, dispatch } = makeOptions({
+      planByThread: {
+        "thread-1": {
+          turnId: "turn-2",
+          explanation: "Done",
+          steps: [{ step: "Finish task", status: "completed" }],
+        },
+      },
+    });
+
+    act(() => {
+      result.current.onTurnCompleted("ws-1", "thread-1", "turn-1");
+    });
+
+    expect(dispatch).not.toHaveBeenCalledWith({
+      type: "clearThreadPlan",
+      threadId: "thread-1",
+    });
+  });
+
   it("keeps the active plan when at least one step is not completed", () => {
     const { result, dispatch } = makeOptions({
       planByThread: {
diff --git a/src/features/threads/hooks/useThreadTurnEvents.ts b/src/features/threads/hooks/useThreadTurnEvents.ts
index c12fa517..d0ab9b33 100644
--- a/src/features/threads/hooks/useThreadTurnEvents.ts
+++ b/src/features/threads/hooks/useThreadTurnEvents.ts
@@ -38,11 +38,14 @@ export function useThreadTurnEvents({
   safeMessageActivity,
   recordThreadActivity,
 }: UseThreadTurnEventsOptions) {
-  const shouldClearCompletedPlan = useCallback((threadId: string) => {
+  const shouldClearCompletedPlan = useCallback((threadId: string, turnId: string) => {
     const plan = planByThreadRef.current[threadId];
     if (!plan || plan.steps.length === 0) {
       return false;
     }
+    if (turnId && plan.turnId !== turnId) {
+      return false;
+    }
     return plan.steps.every((step) => step.status === "completed");
   }, [planByThreadRef]);
 
@@ -124,11 +127,11 @@ export function useThreadTurnEvents({
   );
 
   const onTurnCompleted = useCallback(
-    (_workspaceId: string, threadId: string, _turnId: string) => {
+    (_workspaceId: string, threadId: string, turnId: string) => {
       markProcessing(threadId, false);
       setActiveTurnId(threadId, null);
       pendingInterruptsRef.current.delete(threadId);
-      if (shouldClearCompletedPlan(threadId)) {
+      if (shouldClearCompletedPlan(threadId, turnId)) {
         dispatch({ type: "clearThreadPlan", threadId });
       }
     },
diff --git a/src/features/threads/utils/threadNormalize.test.ts b/src/features/threads/utils/threadNormalize.test.ts
new file mode 100644
index 00000000..5cf50491
--- /dev/null
+++ b/src/features/threads/utils/threadNormalize.test.ts
@@ -0,0 +1,32 @@
+import { describe, expect, it } from "vitest";
+import { normalizePlanUpdate } from "./threadNormalize";
+
+describe("normalizePlanUpdate", () => {
+  it("normalizes a plan when the payload uses an array", () => {
+    expect(
+      normalizePlanUpdate("turn-1", " Note ", [{ step: "Do it", status: "in_progress" }]),
+    ).toEqual({
+      turnId: "turn-1",
+      explanation: "Note",
+      steps: [{ step: "Do it", status: "inProgress" }],
+    });
+  });
+
+  it("normalizes a plan when the payload uses an object with steps", () => {
+    expect(
+      normalizePlanUpdate("turn-2", null, {
+        explanation: "Hello",
+        steps: [{ step: "Ship it", status: "completed" }],
+      }),
+    ).toEqual({
+      turnId: "turn-2",
+      explanation: "Hello",
+      steps: [{ step: "Ship it", status: "completed" }],
+    });
+  });
+
+  it("returns null when there is no explanation or steps", () => {
+    expect(normalizePlanUpdate("turn-3", "", { steps: [] })).toBeNull();
+  });
+});
+
diff --git a/src/features/threads/utils/threadNormalize.ts b/src/features/threads/utils/threadNormalize.ts
index 8961646b..dbcc0625 100644
--- a/src/features/threads/utils/threadNormalize.ts
+++ b/src/features/threads/utils/threadNormalize.ts
@@ -203,23 +203,42 @@ export function normalizePlanUpdate(
   explanation: unknown,
   plan: unknown,
 ): TurnPlan | null {
-  const steps = Array.isArray(plan)
-    ? plan
-        .map((entry) => {
-          const step = asString((entry as Record<string, unknown>)?.step ?? "");
-          if (!step) {
-            return null;
-          }
-          return {
-            step,
-            status: normalizePlanStepStatus(
-              (entry as Record<string, unknown>)?.status,
-            ),
-          } satisfies TurnPlanStep;
-        })
-        .filter((entry): entry is TurnPlanStep => Boolean(entry))
-    : [];
-  const note = asString(explanation).trim();
+  const planRecord =
+    plan && typeof plan === "object" && !Array.isArray(plan)
+      ? (plan as Record<string, unknown>)
+      : null;
+  const rawSteps = (() => {
+    if (Array.isArray(plan)) {
+      return plan;
+    }
+    if (planRecord) {
+      const candidate =
+        planRecord.steps ??
+        planRecord.plan ??
+        planRecord.items ??
+        planRecord.entries ??
+        null;
+      return Array.isArray(candidate) ? candidate : [];
+    }
+    return [];
+  })();
+  const steps = rawSteps
+    .map((entry) => {
+      if (!entry || typeof entry !== "object") {
+        return null;
+      }
+      const record = entry as Record<string, unknown>;
+      const step = asString(record.step ?? record.text ?? record.title ?? "");
+      if (!step) {
+        return null;
+      }
+      return {
+        step,
+        status: normalizePlanStepStatus(record.status),
+      } satisfies TurnPlanStep;
+    })
+    .filter((entry): entry is TurnPlanStep => Boolean(entry));
+  const note = asString(explanation ?? planRecord?.explanation ?? planRecord?.note).trim();
   if (!steps.length && !note) {
     return null;
   }
diff --git a/src/features/workspaces/components/WorkspaceHome.tsx b/src/features/workspaces/components/WorkspaceHome.tsx
index c8735cbe..dd578331 100644
--- a/src/features/workspaces/components/WorkspaceHome.tsx
+++ b/src/features/workspaces/components/WorkspaceHome.tsx
@@ -17,7 +17,6 @@ import type {
   SkillOption,
   WorkspaceInfo,
 } from "../../../types";
-import { formatCollaborationModeLabel } from "../../../utils/collaborationModes";
 import { ComposerInput } from "../../composer/components/ComposerInput";
 import { useComposerImages } from "../../composer/hooks/useComposerImages";
 import { useComposerAutocompleteState } from "../../composer/hooks/useComposerAutocompleteState";
@@ -733,7 +732,7 @@ export function WorkspaceHome({
               >
                 {collaborationModes.map((mode) => (
                   <option key={mode.id} value={mode.id}>
-                    {formatCollaborationModeLabel(mode.label || mode.id)}
+                    {mode.label || mode.id}
                   </option>
                 ))}
               </select>
diff --git a/src/features/workspaces/components/WorktreePrompt.tsx b/src/features/workspaces/components/WorktreePrompt.tsx
index 3efbd93a..5b50da90 100644
--- a/src/features/workspaces/components/WorktreePrompt.tsx
+++ b/src/features/workspaces/components/WorktreePrompt.tsx
@@ -1,14 +1,22 @@
-import { useEffect, useRef } from "react";
+import { useEffect, useMemo, useRef, useState } from "react";
+import type { FocusEvent } from "react";
+import type { BranchInfo } from "../../../types";
+import { BranchList } from "../../git/components/BranchList";
+import { filterBranches } from "../../git/utils/branchSearch";
 
 type WorktreePromptProps = {
   workspaceName: string;
   name: string;
   branch: string;
+  branchWasEdited?: boolean;
+  branchSuggestions?: BranchInfo[];
+  copyAgentsMd: boolean;
   setupScript: string;
   scriptError?: string | null;
   error?: string | null;
   onNameChange: (value: string) => void;
   onChange: (value: string) => void;
+  onCopyAgentsMdChange: (value: boolean) => void;
   onSetupScriptChange: (value: string) => void;
   onCancel: () => void;
   onConfirm: () => void;
@@ -20,11 +28,15 @@ export function WorktreePrompt({
   workspaceName,
   name,
   branch,
+  branchWasEdited = false,
+  branchSuggestions = [],
+  copyAgentsMd,
   setupScript,
   scriptError = null,
   error = null,
   onNameChange,
   onChange,
+  onCopyAgentsMdChange,
   onSetupScriptChange,
   onCancel,
   onConfirm,
@@ -32,12 +44,63 @@ export function WorktreePrompt({
   isSavingScript = false,
 }: WorktreePromptProps) {
   const inputRef = useRef<HTMLInputElement | null>(null);
+  const branchContainerRef = useRef<HTMLDivElement | null>(null);
+  const branchListRef = useRef<HTMLDivElement | null>(null);
+  const [branchMenuOpen, setBranchMenuOpen] = useState(false);
+  const [selectedBranchIndex, setSelectedBranchIndex] = useState(0);
+  const [didNavigateBranches, setDidNavigateBranches] = useState(false);
 
   useEffect(() => {
     inputRef.current?.focus();
     inputRef.current?.select();
   }, []);
 
+  const filteredBranches = useMemo(() => {
+    const query = !branchWasEdited && branchMenuOpen ? "" : branch;
+    return filterBranches(branchSuggestions, query, { mode: "fuzzy", whenEmptyLimit: 8 });
+  }, [branch, branchMenuOpen, branchSuggestions, branchWasEdited]);
+
+  useEffect(() => {
+    if (!branchMenuOpen) {
+      return;
+    }
+    setDidNavigateBranches(false);
+    setSelectedBranchIndex(0);
+  }, [branchMenuOpen, filteredBranches.length]);
+
+  useEffect(() => {
+    if (!branchMenuOpen) {
+      return;
+    }
+    const itemEl = branchListRef.current?.children[selectedBranchIndex] as
+      | HTMLElement
+      | undefined;
+    itemEl?.scrollIntoView({ block: "nearest" });
+  }, [branchMenuOpen, selectedBranchIndex]);
+
+  const handleBranchSelect = (branchInfo: BranchInfo) => {
+    onChange(branchInfo.name);
+    setBranchMenuOpen(false);
+    requestAnimationFrame(() => {
+      const input = branchContainerRef.current?.querySelector(
+        "input",
+      ) as HTMLInputElement | null;
+      input?.focus();
+    });
+  };
+
+  const handleBranchContainerBlur = (event: FocusEvent<HTMLDivElement>) => {
+    const nextFocus = event.relatedTarget;
+    if (!nextFocus) {
+      setBranchMenuOpen(false);
+      return;
+    }
+    if (event.currentTarget.contains(nextFocus)) {
+      return;
+    }
+    setBranchMenuOpen(false);
+  };
+
   return (
     <div className="worktree-modal" role="dialog" aria-modal="true">
       <div
@@ -79,28 +142,113 @@ export function WorktreePrompt({
         <label className="worktree-modal-label" htmlFor="worktree-branch">
           Branch name
         </label>
-        <input
-          id="worktree-branch"
-          className="worktree-modal-input"
-          value={branch}
-          onChange={(event) => onChange(event.target.value)}
-          onKeyDown={(event) => {
-            if (event.key === "Escape") {
-              event.preventDefault();
-              if (!isBusy) {
-                onCancel();
+        <div
+          className="worktree-modal-branch"
+          ref={branchContainerRef}
+          onFocusCapture={() => setBranchMenuOpen(true)}
+          onBlurCapture={handleBranchContainerBlur}
+        >
+          <input
+            id="worktree-branch"
+            className="worktree-modal-input"
+            value={branch}
+            onChange={(event) => {
+              setDidNavigateBranches(false);
+              onChange(event.target.value);
+            }}
+            onKeyDown={(event) => {
+              if (event.key === "Escape") {
+                event.preventDefault();
+                if (!isBusy) {
+                  onCancel();
+                }
+                return;
               }
-            }
-            if (event.key === "Enter" && !isBusy) {
-              event.preventDefault();
-              onConfirm();
-            }
-          }}
-        />
+
+              if (!branchMenuOpen || filteredBranches.length === 0) {
+                if (event.key === "Enter" && !isBusy) {
+                  event.preventDefault();
+                  onConfirm();
+                }
+                if (event.key === "ArrowDown") {
+                  setBranchMenuOpen(true);
+                }
+                return;
+              }
+
+              if (event.key === "ArrowDown") {
+                event.preventDefault();
+                setDidNavigateBranches(true);
+                setSelectedBranchIndex((prev) =>
+                  prev < filteredBranches.length - 1 ? prev + 1 : prev,
+                );
+                return;
+              }
+              if (event.key === "ArrowUp") {
+                event.preventDefault();
+                setDidNavigateBranches(true);
+                setSelectedBranchIndex((prev) => (prev > 0 ? prev - 1 : prev));
+                return;
+              }
+              if (event.key === "Enter") {
+                event.preventDefault();
+                if (didNavigateBranches) {
+                  const picked = filteredBranches[selectedBranchIndex];
+                  if (picked) {
+                    handleBranchSelect(picked);
+                    return;
+                  }
+                }
+                if (!isBusy) {
+                  onConfirm();
+                }
+              }
+            }}
+          />
+          {branchMenuOpen && (
+            <BranchList
+              branches={filteredBranches}
+              currentBranch={null}
+              selectedIndex={selectedBranchIndex}
+              listClassName="worktree-modal-branch-list"
+              listRef={branchListRef}
+              itemClassName="worktree-modal-branch-item"
+              itemLabelClassName="worktree-modal-branch-item-name"
+              selectedItemClassName="selected"
+              emptyClassName="worktree-modal-branch-empty"
+              emptyText={
+                branch.trim().length > 0
+                  ? "No matching branches"
+                  : "No branches found"
+              }
+              onMouseEnter={(index) => {
+                setDidNavigateBranches(true);
+                setSelectedBranchIndex(index);
+              }}
+              onSelect={handleBranchSelect}
+            />
+          )}
+        </div>
+        <div className="worktree-modal-checkbox-row">
+          <input
+            id="worktree-copy-agents"
+            type="checkbox"
+            className="worktree-modal-checkbox-input"
+            checked={copyAgentsMd}
+            disabled={isBusy}
+            onChange={(event) => onCopyAgentsMdChange(event.target.checked)}
+          />
+          <label
+            className="worktree-modal-checkbox-label"
+            htmlFor="worktree-copy-agents"
+          >
+            Copy <code>AGENTS.md</code> into the worktree
+          </label>
+        </div>
         <div className="worktree-modal-divider" />
-        <div className="worktree-modal-section-title">Worktree setup script</div>
+        <div className="worktree-modal-section-title">Environment setup script</div>
         <div className="worktree-modal-hint">
-          Runs once in a dedicated terminal after each new worktree is created.
+          Stored on the project (Settings → Environments) and runs once in a dedicated terminal after each new worktree is created.
         </div>
         <textarea
           id="worktree-setup-script"
diff --git a/src/features/workspaces/hooks/useWorkspaces.ts b/src/features/workspaces/hooks/useWorkspaces.ts
index 9fca3c57..0d245357 100644
--- a/src/features/workspaces/hooks/useWorkspaces.ts
+++ b/src/features/workspaces/hooks/useWorkspaces.ts
@@ -275,22 +275,37 @@ export function useWorkspaces(options: UseWorkspacesOptions = {}) {
   async function addWorktreeAgent(
     parent: WorkspaceInfo,
     branch: string,
-    options?: { activate?: boolean; displayName?: string | null },
+    options?: {
+      activate?: boolean;
+      displayName?: string | null;
+      copyAgentsMd?: boolean;
+    },
   ) {
     const trimmed = branch.trim();
     if (!trimmed) {
       return null;
     }
     const trimmedName = options?.displayName?.trim() || null;
+    const copyAgentsMd = options?.copyAgentsMd ?? true;
     onDebug?.({
       id: `${Date.now()}-client-add-worktree`,
       timestamp: Date.now(),
       source: "client",
       label: "worktree/add",
-      payload: { parentId: parent.id, branch: trimmed, name: trimmedName },
+      payload: {
+        parentId: parent.id,
+        branch: trimmed,
+        name: trimmedName,
+        copyAgentsMd,
+      },
     });
     try {
-      const workspace = await addWorktreeService(parent.id, trimmed, trimmedName);
+      const workspace = await addWorktreeService(
+        parent.id,
+        trimmed,
+        trimmedName,
+        copyAgentsMd,
+      );
       setWorkspaces((prev) => [...prev, workspace]);
       if (options?.activate !== false) {
         setActiveWorkspaceId(workspace.id);
diff --git a/src/features/workspaces/hooks/useWorktreePrompt.test.tsx b/src/features/workspaces/hooks/useWorktreePrompt.test.tsx
index 0f94127b..332bb283 100644
--- a/src/features/workspaces/hooks/useWorktreePrompt.test.tsx
+++ b/src/features/workspaces/hooks/useWorktreePrompt.test.tsx
@@ -33,6 +33,8 @@ describe("useWorktreePrompt", () => {
       result.current.openPrompt(parentWorkspace);
     });
 
+    expect(result.current.worktreePrompt?.copyAgentsMd).toBe(true);
+
     act(() => {
       result.current.updateName("My New Feature!");
     });
@@ -70,6 +72,8 @@ describe("useWorktreePrompt", () => {
       result.current.openPrompt(parentWorkspace);
     });
 
+    expect(result.current.worktreePrompt?.copyAgentsMd).toBe(true);
+
     const originalBranch = result.current.worktreePrompt?.branch;
 
     act(() => {
@@ -79,4 +83,50 @@ describe("useWorktreePrompt", () => {
     expect(result.current.worktreePrompt?.branch).toBe(originalBranch);
     expect(addWorktreeAgent).not.toHaveBeenCalled();
   });
+
+  it("passes copyAgentsMd to addWorktreeAgent", async () => {
+    const worktreeWorkspace: WorkspaceInfo = {
+      id: "wt-1",
+      name: "Worktree",
+      path: "/tmp/wt-1",
+      connected: true,
+      kind: "worktree",
+      parentId: parentWorkspace.id,
+      worktree: { branch: "codex/example" },
+      settings: { sidebarCollapsed: false },
+    };
+    const addWorktreeAgent = vi.fn().mockResolvedValue(worktreeWorkspace);
+    const updateWorkspaceSettings = vi.fn().mockResolvedValue(parentWorkspace);
+    const connectWorkspace = vi.fn().mockResolvedValue(undefined);
+    const onSelectWorkspace = vi.fn();
+
+    const { result } = renderHook(() =>
+      useWorktreePrompt({
+        addWorktreeAgent,
+        updateWorkspaceSettings,
+        connectWorkspace,
+        onSelectWorkspace,
+      }),
+    );
+
+    act(() => {
+      result.current.openPrompt(parentWorkspace);
+    });
+
+    const branch = result.current.worktreePrompt?.branch;
+    expect(branch).toBeTruthy();
+
+    act(() => {
+      result.current.updateCopyAgentsMd(false);
+    });
+
+    await act(async () => {
+      await result.current.confirmPrompt();
+    });
+
+    expect(addWorktreeAgent).toHaveBeenCalledWith(parentWorkspace, branch, {
+      displayName: null,
+      copyAgentsMd: false,
+    });
+  });
 });
diff --git a/src/features/workspaces/hooks/useWorktreePrompt.ts b/src/features/workspaces/hooks/useWorktreePrompt.ts
index 02e74804..ffb40854 100644
--- a/src/features/workspaces/hooks/useWorktreePrompt.ts
+++ b/src/features/workspaces/hooks/useWorktreePrompt.ts
@@ -6,6 +6,7 @@ type WorktreePromptState = {
   name: string;
   branch: string;
   branchWasEdited: boolean;
+  copyAgentsMd: boolean;
   setupScript: string;
   savedSetupScript: string | null;
   isSubmitting: boolean;
@@ -18,7 +19,7 @@ type UseWorktreePromptOptions = {
   addWorktreeAgent: (
     workspace: WorkspaceInfo,
     branch: string,
-    options?: { displayName?: string | null },
+    options?: { displayName?: string | null; copyAgentsMd?: boolean },
   ) => Promise<WorkspaceInfo | null>;
   updateWorkspaceSettings: (
     id: string,
@@ -38,6 +39,7 @@ type UseWorktreePromptResult = {
   cancelPrompt: () => void;
   updateName: (value: string) => void;
   updateBranch: (value: string) => void;
+  updateCopyAgentsMd: (value: boolean) => void;
   updateSetupScript: (value: string) => void;
 };
 
@@ -82,6 +84,7 @@ export function useWorktreePrompt({
       name: "",
       branch: defaultBranch,
       branchWasEdited: false,
+      copyAgentsMd: true,
       setupScript: savedSetupScript ?? "",
       savedSetupScript,
       isSubmitting: false,
@@ -118,6 +121,10 @@ export function useWorktreePrompt({
     );
   }, []);
 
+  const updateCopyAgentsMd = useCallback((value: boolean) => {
+    setWorktreePrompt((prev) => (prev ? { ...prev, copyAgentsMd: value } : prev));
+  }, []);
+
   const updateSetupScript = useCallback((value: string) => {
     setWorktreePrompt((prev) =>
       prev ? { ...prev, setupScript: value, scriptError: null, error: null } : prev,
@@ -191,6 +198,7 @@ export function useWorktreePrompt({
       const displayName = snapshot.name.trim();
       const worktreeWorkspace = await addWorktreeAgent(parentWorkspace, snapshot.branch, {
         displayName: displayName.length > 0 ? displayName : null,
+        copyAgentsMd: snapshot.copyAgentsMd,
       });
       if (!worktreeWorkspace) {
         setWorktreePrompt(null);
@@ -233,6 +241,7 @@ export function useWorktreePrompt({
     cancelPrompt,
     updateName,
     updateBranch,
+    updateCopyAgentsMd,
     updateSetupScript,
   };
 }
diff --git a/src/services/tauri.ts b/src/services/tauri.ts
index 9000fbdd..25507ba8 100644
--- a/src/services/tauri.ts
+++ b/src/services/tauri.ts
@@ -157,8 +157,9 @@ export async function addWorktree(
   parentId: string,
   branch: string,
   name: string | null,
+  copyAgentsMd = true,
 ): Promise<WorkspaceInfo> {
-  return invoke<WorkspaceInfo>("add_worktree", { parentId, branch, name });
+  return invoke<WorkspaceInfo>("add_worktree", { parentId, branch, name, copyAgentsMd });
 }
 
 export type WorktreeSetupStatus = {
diff --git a/src/styles/diff-viewer.css b/src/styles/diff-viewer.css
index f7060edf..74a46ae9 100644
--- a/src/styles/diff-viewer.css
+++ b/src/styles/diff-viewer.css
@@ -363,6 +363,41 @@
 .diff-viewer-path {
   color: var(--text-emphasis);
   word-break: break-word;
+  flex: 1;
+  min-width: 0;
+}
+
+.diff-viewer-header-action {
+  width: 24px;
+  height: 24px;
+  border-radius: 6px;
+  padding: 0;
+  border: 1px solid transparent;
+  background: transparent;
+  color: var(--text-faint);
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  cursor: pointer;
+  flex: 0 0 auto;
+  transition: background 160ms ease, border-color 160ms ease, color 160ms ease;
+}
+
+.diff-viewer-header-action:hover {
+  background: var(--surface-control-hover);
+  border-color: var(--border-subtle);
+  color: var(--text-emphasis);
+}
+
+.diff-viewer-header-action:focus-visible {
+  outline: 2px solid var(--border-accent-soft);
+  outline-offset: 2px;
+}
+
+.diff-viewer-header-action--discard:hover {
+  background: rgba(255, 107, 107, 0.14);
+  border-color: rgba(255, 107, 107, 0.35);
+  color: #ff6b6b;
 }
 
 .diff-viewer-output pre {
diff --git a/src/styles/worktree-modal.css b/src/styles/worktree-modal.css
index bdfcd1c1..b0b03220 100644
--- a/src/styles/worktree-modal.css
+++ b/src/styles/worktree-modal.css
@@ -63,12 +63,80 @@
   outline-offset: 1px;
 }
 
+.worktree-modal-branch {
+  display: flex;
+  flex-direction: column;
+  gap: 6px;
+}
+
+.worktree-modal-branch-list {
+  border: 1px solid var(--border-subtle);
+  border-radius: 10px;
+  background: var(--surface-card-muted);
+  padding: 6px;
+  max-height: 220px;
+  overflow-y: auto;
+}
+
+.worktree-modal-branch-empty {
+  padding: 12px;
+  text-align: center;
+  color: var(--text-faint);
+  font-size: 12px;
+}
+
+.worktree-modal-branch-item {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  width: 100%;
+  padding: 8px 10px;
+  border: none;
+  background: transparent;
+  color: var(--text-strong);
+  font-size: 13px;
+  text-align: left;
+  border-radius: 8px;
+  cursor: pointer;
+  transition: background 0.1s ease;
+}
+
+.worktree-modal-branch-item:hover,
+.worktree-modal-branch-item.selected {
+  background: var(--surface-card-strong);
+}
+
+.worktree-modal-branch-item-name {
+  flex: 1;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+  font-family: var(--code-font-family, Menlo, Monaco, "Courier New", monospace);
+}
+
 .worktree-modal-divider {
   height: 1px;
   background: var(--border-subtle);
   margin: 4px 0 2px;
 }
 
+.worktree-modal-checkbox-row {
+  display: flex;
+  align-items: flex-start;
+  gap: 10px;
+  font-size: 12px;
+  color: var(--text-subtle);
+}
+
+.worktree-modal-checkbox-input {
+  margin-top: 2px;
+}
+
+.worktree-modal-checkbox-label code {
+  font-family: var(--code-font-family, Menlo, Monaco, "Courier New", monospace);
+  color: var(--text-strong);
+}
+
 .worktree-modal-section-title {
   font-size: 13px;
   font-weight: 600;
diff --git a/src/utils/collaborationModes.ts b/src/utils/collaborationModes.ts
deleted file mode 100644
index 58a573ff..00000000
--- a/src/utils/collaborationModes.ts
+++ /dev/null
@@ -1,33 +0,0 @@
-export function formatCollaborationModeLabel(value: string) {
-  if (!value) {
-    return value;
-  }
-  const trimmed = value.trim();
-  if (!trimmed) {
-    return value;
-  }
-  const normalized = trimmed
-    .replace(/[_-]+/g, " ")
-    .replace(/([a-z])([A-Z])/g, "$1 $2");
-  const lower = normalized.toLowerCase().replace(/\s+/g, " ").trim();
-  if (lower === "pairprogramming" || lower === "pair programming") {
-    return "Pair Programming";
-  }
-  if (lower === "plan") {
-    return "Plan";
-  }
-  if (lower === "execute") {
-    return "Execute";
-  }
-  if (lower === "custom") {
-    return "Custom";
-  }
-  if (lower === "code") {
-    return "Code";
-  }
-  return normalized
-    .split(" ")
-    .filter(Boolean)
-    .map((word) => `${word[0].toUpperCase()}${word.slice(1)}`)
-    .join(" ");
-}
diff --git a/src/utils/threadItems.test.ts b/src/utils/threadItems.test.ts
index ac10b89f..1f62867c 100644
--- a/src/utils/threadItems.test.ts
+++ b/src/utils/threadItems.test.ts
@@ -7,6 +7,7 @@ import {
   mergeThreadItems,
   normalizeItem,
   prepareThreadItems,
+  upsertItem,
 } from "./threadItems";
 
 describe("threadItems", () => {
@@ -430,7 +431,7 @@ describe("threadItems", () => {
     }
   });
 
-  it("merges thread items preferring richer local tool output", () => {
+  it("merges thread items preferring non-empty remote tool output", () => {
     const remote: ConversationItem = {
       id: "tool-2",
       kind: "tool",
@@ -452,11 +453,119 @@ describe("threadItems", () => {
     expect(merged).toHaveLength(1);
     expect(merged[0].kind).toBe("tool");
     if (merged[0].kind === "tool") {
-      expect(merged[0].output).toBe("much longer output");
+      expect(merged[0].output).toBe("short");
       expect(merged[0].status).toBe("ok");
     }
   });
 
+  it("keeps local tool output when remote output is empty", () => {
+    const remote: ConversationItem = {
+      id: "tool-3",
+      kind: "tool",
+      toolType: "webSearch",
+      title: "Web search",
+      detail: "query",
+      status: "completed",
+      output: " ",
+    };
+    const local: ConversationItem = {
+      id: "tool-3",
+      kind: "tool",
+      toolType: "webSearch",
+      title: "Web search",
+      detail: "query",
+      output: "streamed output",
+    };
+    const merged = mergeThreadItems([remote], [local]);
+    expect(merged).toHaveLength(1);
+    expect(merged[0].kind).toBe("tool");
+    if (merged[0].kind === "tool") {
+      expect(merged[0].output).toBe("streamed output");
+      expect(merged[0].status).toBe("completed");
+    }
+  });
+
+  it("preserves streamed plan output when completion item has empty output", () => {
+    const existing: ConversationItem = {
+      id: "plan-1",
+      kind: "tool",
+      toolType: "plan",
+      title: "Plan",
+      detail: "Generating plan...",
+      status: "in_progress",
+      output: "## Plan\n- Step 1\n- Step 2",
+    };
+    const completed: ConversationItem = {
+      id: "plan-1",
+      kind: "tool",
+      toolType: "plan",
+      title: "Plan",
+      detail: "",
+      status: "completed",
+      output: "",
+    };
+
+    const next = upsertItem([existing], completed);
+    expect(next).toHaveLength(1);
+    expect(next[0].kind).toBe("tool");
+    if (next[0].kind === "tool") {
+      expect(next[0].output).toBe(existing.output);
+      expect(next[0].status).toBe("completed");
+    }
+  });
+
+  it("uses incoming tool output even when shorter than existing output", () => {
+    const existing: ConversationItem = {
+      id: "tool-4",
+      kind: "tool",
+      toolType: "webSearch",
+      title: "Web search",
+      detail: "query",
+      status: "in_progress",
+      output: "verbose streamed output that will be replaced",
+    };
+    const incoming: ConversationItem = {
+      id: "tool-4",
+      kind: "tool",
+      toolType: "webSearch",
+      title: "Web search",
+      detail: "query",
+      status: "completed",
+      output: "final",
+    };
+
+    const next = upsertItem([existing], incoming);
+    expect(next).toHaveLength(1);
+    expect(next[0].kind).toBe("tool");
+    if (next[0].kind === "tool") {
+      expect(next[0].output).toBe("final");
+      expect(next[0].status).toBe("completed");
+    }
+  });
+
+  it("preserves streamed reasoning content when completion item is empty", () => {
+    const existing: ConversationItem = {
+      id: "reasoning-1",
+      kind: "reasoning",
+      summary: "Thinking",
+      content: "More detail",
+    };
+    const completed: ConversationItem = {
+      id: "reasoning-1",
+      kind: "reasoning",
+      summary: "",
+      content: "",
+    };
+
+    const next = upsertItem([existing], completed);
+    expect(next).toHaveLength(1);
+    expect(next[0].kind).toBe("reasoning");
+    if (next[0].kind === "reasoning") {
+      expect(next[0].summary).toBe("Thinking");
+      expect(next[0].content).toBe("More detail");
+    }
+  });
+
   it("builds user message text from mixed inputs", () => {
     const item = buildConversationItemFromThreadItem({
       type: "userMessage",
diff --git a/src/utils/threadItems.ts b/src/utils/threadItems.ts
index 682bd77e..5faf814d 100644
--- a/src/utils/threadItems.ts
+++ b/src/utils/threadItems.ts
@@ -462,8 +462,90 @@ export function upsertItem(list: ConversationItem[], item: ConversationItem) {
   if (index === -1) {
     return [...list, item];
   }
+  const existing = list[index];
   const next = [...list];
-  next[index] = { ...next[index], ...item };
+
+  if (existing.kind !== item.kind) {
+    next[index] = item;
+    return next;
+  }
+
+  if (existing.kind === "message" && item.kind === "message") {
+    const existingText = existing.text ?? "";
+    const incomingText = item.text ?? "";
+    next[index] = {
+      ...existing,
+      ...item,
+      text: incomingText.length >= existingText.length ? incomingText : existingText,
+      images: item.images?.length ? item.images : existing.images,
+    };
+    return next;
+  }
+
+  if (existing.kind === "reasoning" && item.kind === "reasoning") {
+    const existingSummary = existing.summary ?? "";
+    const incomingSummary = item.summary ?? "";
+    const existingContent = existing.content ?? "";
+    const incomingContent = item.content ?? "";
+    next[index] = {
+      ...existing,
+      ...item,
+      summary:
+        incomingSummary.length >= existingSummary.length
+          ? incomingSummary
+          : existingSummary,
+      content:
+        incomingContent.length >= existingContent.length
+          ? incomingContent
+          : existingContent,
+    };
+    return next;
+  }
+
+  if (existing.kind === "tool" && item.kind === "tool") {
+    const existingOutput = existing.output ?? "";
+    const incomingOutput = item.output ?? "";
+    const hasIncomingOutput = incomingOutput.trim().length > 0;
+    const hasIncomingChanges = (item.changes?.length ?? 0) > 0;
+    next[index] = {
+      ...existing,
+      ...item,
+      title: item.title?.trim() ? item.title : existing.title,
+      detail: item.detail?.trim() ? item.detail : existing.detail,
+      status: item.status?.trim() ? item.status : existing.status,
+      output: hasIncomingOutput ? incomingOutput : existingOutput,
+      changes: hasIncomingChanges ? item.changes : existing.changes,
+      durationMs:
+        typeof item.durationMs === "number" ? item.durationMs : existing.durationMs,
+    };
+    return next;
+  }
+
+  if (existing.kind === "diff" && item.kind === "diff") {
+    const existingDiff = existing.diff ?? "";
+    const incomingDiff = item.diff ?? "";
+    next[index] = {
+      ...existing,
+      ...item,
+      title: item.title?.trim() ? item.title : existing.title,
+      status: item.status?.trim() ? item.status : existing.status,
+      diff: incomingDiff.length >= existingDiff.length ? incomingDiff : existingDiff,
+    };
+    return next;
+  }
+
+  if (existing.kind === "review" && item.kind === "review") {
+    const existingText = existing.text ?? "";
+    const incomingText = item.text ?? "";
+    next[index] = {
+      ...existing,
+      ...item,
+      text: incomingText.length >= existingText.length ? incomingText : existingText,
+    };
+    return next;
+  }
+
+  next[index] = { ...existing, ...item };
   return next;
 }
 
@@ -817,13 +899,13 @@ function chooseRicherItem(remote: ConversationItem, local: ConversationItem) {
     return localLength > remoteLength ? local : remote;
   }
   if (remote.kind === "tool" && local.kind === "tool") {
-    const remoteLength = (remote.output ?? "").length;
-    const localLength = (local.output ?? "").length;
-    const base = localLength > remoteLength ? local : remote;
+    const remoteOutput = remote.output ?? "";
+    const localOutput = local.output ?? "";
+    const hasRemoteOutput = remoteOutput.trim().length > 0;
     return {
-      ...base,
+      ...remote,
       status: remote.status ?? local.status,
-      output: localLength > remoteLength ? local.output : remote.output,
+      output: hasRemoteOutput ? remoteOutput : localOutput,
       changes: remote.changes ?? local.changes,
     };
   }