diff --git a/src-tauri/src/types.rs b/src-tauri/src/types.rs
index 5e3f421f..a9163904 100644
--- a/src-tauri/src/types.rs
+++ b/src-tauri/src/types.rs
@@ -268,10 +268,21 @@ pub(crate) struct WorkspaceSettings {
     pub(crate) codex_args: Option<String>,
     #[serde(default, rename = "launchScript")]
     pub(crate) launch_script: Option<String>,
+    #[serde(default, rename = "launchScripts")]
+    pub(crate) launch_scripts: Option<Vec<LaunchScriptEntry>>,
     #[serde(default, rename = "worktreeSetupScript")]
     pub(crate) worktree_setup_script: Option<String>,
 }
 
+#[derive(Debug, Serialize, Deserialize, Clone)]
+pub(crate) struct LaunchScriptEntry {
+    pub(crate) id: String,
+    pub(crate) script: String,
+    pub(crate) icon: String,
+    #[serde(default)]
+    pub(crate) label: Option<String>,
+}
+
 #[derive(Debug, Serialize, Deserialize, Clone)]
 pub(crate) struct WorktreeSetupStatus {
     #[serde(rename = "shouldRun")]
diff --git a/src-tauri/src/workspaces/tests.rs b/src-tauri/src/workspaces/tests.rs
index c0bda742..2e7a6959 100644
--- a/src-tauri/src/workspaces/tests.rs
+++ b/src-tauri/src/workspaces/tests.rs
@@ -46,6 +46,7 @@ fn workspace_with_id_and_kind(
             codex_home: None,
             codex_args: None,
             launch_script: None,
+            launch_scripts: None,
             worktree_setup_script: None,
         },
     }
diff --git a/src/App.tsx b/src/App.tsx
index 85490fbf..f19840c4 100644
--- a/src/App.tsx
+++ b/src/App.tsx
@@ -91,6 +91,7 @@ import { useLiquidGlassEffect } from "./features/app/hooks/useLiquidGlassEffect"
 import { useCopyThread } from "./features/threads/hooks/useCopyThread";
 import { useTerminalController } from "./features/terminal/hooks/useTerminalController";
 import { useWorkspaceLaunchScript } from "./features/app/hooks/useWorkspaceLaunchScript";
+import { useWorkspaceLaunchScripts } from "./features/app/hooks/useWorkspaceLaunchScripts";
 import { useWorktreeSetupScript } from "./features/app/hooks/useWorktreeSetupScript";
 import { useGitCommitController } from "./features/app/hooks/useGitCommitController";
 import { WorkspaceHome } from "./features/workspaces/components/WorkspaceHome";
@@ -772,6 +773,23 @@ function MainApp() {
     activeTerminalId,
   });
 
+  const launchScriptsState = useWorkspaceLaunchScripts({
+    activeWorkspace,
+    updateWorkspaceSettings,
+    openTerminal,
+    ensureLaunchTerminal: (workspaceId, entry, title) => {
+      const label = entry.label?.trim() || entry.icon;
+      return ensureTerminalWithTitle(
+        workspaceId,
+        `launch:${entry.id}`,
+        title || `Launch ${label}`,
+      );
+    },
+    restartLaunchSession: restartTerminalSession,
+    terminalState,
+    activeTerminalId,
+  });
+
   const worktreeSetupScriptState = useWorktreeSetupScript({
     ensureTerminalWithTitle,
     restartTerminalSession,
@@ -1717,6 +1735,7 @@ function MainApp() {
     onCloseLaunchScriptEditor: launchScriptState.onCloseEditor,
     onLaunchScriptDraftChange: launchScriptState.onDraftScriptChange,
     onSaveLaunchScript: launchScriptState.onSaveLaunchScript,
+    launchScriptsState,
     mainHeaderActionsNode: (
       <MainHeaderActions
         centerMode={centerMode}
diff --git a/src/features/app/components/LaunchScriptButton.tsx b/src/features/app/components/LaunchScriptButton.tsx
index 4f4d47b3..43897c29 100644
--- a/src/features/app/components/LaunchScriptButton.tsx
+++ b/src/features/app/components/LaunchScriptButton.tsx
@@ -1,5 +1,8 @@
 import { useEffect, useRef } from "react";
 import Play from "lucide-react/dist/esm/icons/play";
+import type { LaunchScriptIconId } from "../../../types";
+import { LaunchScriptIconPicker } from "./LaunchScriptIconPicker";
+import { DEFAULT_LAUNCH_SCRIPT_ICON } from "../utils/launchScriptIcons";
 
 type LaunchScriptButtonProps = {
   launchScript: string | null;
@@ -12,6 +15,18 @@ type LaunchScriptButtonProps = {
   onCloseEditor: () => void;
   onDraftChange: (value: string) => void;
   onSave: () => void;
+  showNew?: boolean;
+  newEditorOpen?: boolean;
+  newDraftScript?: string;
+  newDraftIcon?: LaunchScriptIconId;
+  newDraftLabel?: string;
+  newError?: string | null;
+  onOpenNew?: () => void;
+  onCloseNew?: () => void;
+  onNewDraftChange?: (value: string) => void;
+  onNewDraftIconChange?: (value: LaunchScriptIconId) => void;
+  onNewDraftLabelChange?: (value: string) => void;
+  onCreateNew?: () => void;
 };
 
 export function LaunchScriptButton({
@@ -25,6 +40,18 @@ export function LaunchScriptButton({
   onCloseEditor,
   onDraftChange,
   onSave,
+  showNew = false,
+  newEditorOpen = false,
+  newDraftScript = "",
+  newDraftIcon = DEFAULT_LAUNCH_SCRIPT_ICON,
+  newDraftLabel = "",
+  newError = null,
+  onOpenNew,
+  onCloseNew,
+  onNewDraftChange,
+  onNewDraftIconChange,
+  onNewDraftLabelChange,
+  onCreateNew,
 }: LaunchScriptButtonProps) {
   const popoverRef = useRef<HTMLDivElement | null>(null);
   const hasLaunchScript = Boolean(launchScript?.trim());
@@ -39,12 +66,13 @@ export function LaunchScriptButton({
         return;
       }
       onCloseEditor();
+      onCloseNew?.();
     };
     window.addEventListener("mousedown", handleClick);
     return () => {
       window.removeEventListener("mousedown", handleClick);
     };
-  }, [editorOpen, onCloseEditor]);
+  }, [editorOpen, onCloseEditor, onCloseNew]);
 
   return (
     <div className="launch-script-menu" ref={popoverRef}>
@@ -80,11 +108,24 @@ export function LaunchScriptButton({
             <button
               type="button"
               className="ghost"
-              onClick={onCloseEditor}
+              onClick={() => {
+                onCloseEditor();
+                onCloseNew?.();
+              }}
               data-tauri-drag-region="false"
             >
               Cancel
             </button>
+            {showNew && onOpenNew && (
+              <button
+                type="button"
+                className="ghost"
+                onClick={onOpenNew}
+                data-tauri-drag-region="false"
+              >
+                New
+              </button>
+            )}
             <button
               type="button"
               className="primary"
@@ -95,6 +136,51 @@ export function LaunchScriptButton({
               {isSaving ? "Saving..." : "Save"}
             </button>
           </div>
+          {showNew && newEditorOpen && onNewDraftChange && onNewDraftIconChange && onCreateNew && (
+            <div className="launch-script-new">
+              <div className="launch-script-title">New launch script</div>
+              <LaunchScriptIconPicker
+                value={newDraftIcon}
+                onChange={onNewDraftIconChange}
+              />
+              <input
+                className="launch-script-input"
+                type="text"
+                placeholder="Optional label"
+                value={newDraftLabel}
+                onChange={(event) => onNewDraftLabelChange?.(event.target.value)}
+                data-tauri-drag-region="false"
+              />
+              <textarea
+                className="launch-script-textarea"
+                placeholder="e.g. npm run dev"
+                value={newDraftScript}
+                onChange={(event) => onNewDraftChange(event.target.value)}
+                rows={5}
+                data-tauri-drag-region="false"
+              />
+              {newError && <div className="launch-script-error">{newError}</div>}
+              <div className="launch-script-actions">
+                <button
+                  type="button"
+                  className="ghost"
+                  onClick={onCloseNew}
+                  data-tauri-drag-region="false"
+                >
+                  Cancel
+                </button>
+                <button
+                  type="button"
+                  className="primary"
+                  onClick={onCreateNew}
+                  disabled={isSaving}
+                  data-tauri-drag-region="false"
+                >
+                  {isSaving ? "Saving..." : "Create"}
+                </button>
+              </div>
+            </div>
+          )}
         </div>
       )}
     </div>
diff --git a/src/features/app/components/LaunchScriptEntryButton.tsx b/src/features/app/components/LaunchScriptEntryButton.tsx
new file mode 100644
index 00000000..f5357d10
--- /dev/null
+++ b/src/features/app/components/LaunchScriptEntryButton.tsx
@@ -0,0 +1,134 @@
+import { useEffect, useRef } from "react";
+import type { LaunchScriptEntry, LaunchScriptIconId } from "../../../types";
+import { LaunchScriptIconPicker } from "./LaunchScriptIconPicker";
+import { getLaunchScriptIcon, getLaunchScriptIconLabel } from "../utils/launchScriptIcons";
+
+type LaunchScriptEntryButtonProps = {
+  entry: LaunchScriptEntry;
+  editorOpen: boolean;
+  draftScript: string;
+  draftIcon: LaunchScriptIconId;
+  draftLabel: string;
+  isSaving: boolean;
+  error: string | null;
+  onRun: () => void;
+  onOpenEditor: () => void;
+  onCloseEditor: () => void;
+  onDraftChange: (value: string) => void;
+  onDraftIconChange: (value: LaunchScriptIconId) => void;
+  onDraftLabelChange: (value: string) => void;
+  onSave: () => void;
+  onDelete: () => void;
+};
+
+export function LaunchScriptEntryButton({
+  entry,
+  editorOpen,
+  draftScript,
+  draftIcon,
+  draftLabel,
+  isSaving,
+  error,
+  onRun,
+  onOpenEditor,
+  onCloseEditor,
+  onDraftChange,
+  onDraftIconChange,
+  onDraftLabelChange,
+  onSave,
+  onDelete,
+}: LaunchScriptEntryButtonProps) {
+  const popoverRef = useRef<HTMLDivElement | null>(null);
+  const Icon = getLaunchScriptIcon(entry.icon);
+  const iconLabel = getLaunchScriptIconLabel(entry.icon);
+
+  useEffect(() => {
+    if (!editorOpen) {
+      return;
+    }
+    const handleClick = (event: MouseEvent) => {
+      const target = event.target as Node;
+      if (popoverRef.current?.contains(target)) {
+        return;
+      }
+      onCloseEditor();
+    };
+    window.addEventListener("mousedown", handleClick);
+    return () => {
+      window.removeEventListener("mousedown", handleClick);
+    };
+  }, [editorOpen, onCloseEditor]);
+
+  return (
+    <div className="launch-script-menu" ref={popoverRef}>
+      <div className="launch-script-buttons">
+        <button
+          type="button"
+          className="ghost main-header-action launch-script-run"
+          onClick={onRun}
+          onContextMenu={(event) => {
+            event.preventDefault();
+            onOpenEditor();
+          }}
+          data-tauri-drag-region="false"
+          aria-label={entry.label?.trim() || iconLabel}
+          title={entry.label?.trim() || iconLabel}
+        >
+          <Icon size={14} aria-hidden />
+        </button>
+      </div>
+      {editorOpen && (
+        <div className="launch-script-popover popover-surface" role="dialog">
+          <div className="launch-script-title">
+            {entry.label?.trim() || "Launch script"}
+          </div>
+          <LaunchScriptIconPicker value={draftIcon} onChange={onDraftIconChange} />
+          <input
+            className="launch-script-input"
+            type="text"
+            placeholder="Optional label"
+            value={draftLabel}
+            onChange={(event) => onDraftLabelChange(event.target.value)}
+            data-tauri-drag-region="false"
+          />
+          <textarea
+            className="launch-script-textarea"
+            placeholder="e.g. npm run dev"
+            value={draftScript}
+            onChange={(event) => onDraftChange(event.target.value)}
+            rows={6}
+            data-tauri-drag-region="false"
+          />
+          {error && <div className="launch-script-error">{error}</div>}
+          <div className="launch-script-actions">
+            <button
+              type="button"
+              className="ghost"
+              onClick={onCloseEditor}
+              data-tauri-drag-region="false"
+            >
+              Cancel
+            </button>
+            <button
+              type="button"
+              className="ghost launch-script-delete"
+              onClick={onDelete}
+              data-tauri-drag-region="false"
+            >
+              Delete
+            </button>
+            <button
+              type="button"
+              className="primary"
+              onClick={onSave}
+              disabled={isSaving}
+              data-tauri-drag-region="false"
+            >
+              {isSaving ? "Saving..." : "Save"}
+            </button>
+          </div>
+        </div>
+      )}
+    </div>
+  );
+}
diff --git a/src/features/app/components/LaunchScriptIconPicker.tsx b/src/features/app/components/LaunchScriptIconPicker.tsx
new file mode 100644
index 00000000..31c1c8df
--- /dev/null
+++ b/src/features/app/components/LaunchScriptIconPicker.tsx
@@ -0,0 +1,34 @@
+import type { LaunchScriptIconId } from "../utils/launchScriptIcons";
+import {
+  LAUNCH_SCRIPT_ICON_OPTIONS,
+  getLaunchScriptIcon,
+} from "../utils/launchScriptIcons";
+
+type LaunchScriptIconPickerProps = {
+  value: LaunchScriptIconId;
+  onChange: (value: LaunchScriptIconId) => void;
+};
+
+export function LaunchScriptIconPicker({ value, onChange }: LaunchScriptIconPickerProps) {
+  return (
+    <div className="launch-script-icon-picker">
+      {LAUNCH_SCRIPT_ICON_OPTIONS.map((option) => {
+        const Icon = getLaunchScriptIcon(option.id);
+        const selected = option.id === value;
+        return (
+          <button
+            key={option.id}
+            type="button"
+            className={`launch-script-icon-option${selected ? " is-selected" : ""}`}
+            onClick={() => onChange(option.id)}
+            aria-label={option.label}
+            aria-pressed={selected}
+            data-tauri-drag-region="false"
+          >
+            <Icon size={14} aria-hidden />
+          </button>
+        );
+      })}
+    </div>
+  );
+}
diff --git a/src/features/app/components/MainHeader.tsx b/src/features/app/components/MainHeader.tsx
index 96174a8e..867f4086 100644
--- a/src/features/app/components/MainHeader.tsx
+++ b/src/features/app/components/MainHeader.tsx
@@ -7,6 +7,8 @@ import type { BranchInfo, OpenAppTarget, WorkspaceInfo } from "../../../types";
 import type { ReactNode } from "react";
 import { OpenAppMenu } from "./OpenAppMenu";
 import { LaunchScriptButton } from "./LaunchScriptButton";
+import { LaunchScriptEntryButton } from "./LaunchScriptEntryButton";
+import type { WorkspaceLaunchScriptsState } from "../hooks/useWorkspaceLaunchScripts";
 
 type MainHeaderProps = {
   workspace: WorkspaceInfo;
@@ -39,6 +41,7 @@ type MainHeaderProps = {
   onCloseLaunchScriptEditor?: () => void;
   onLaunchScriptDraftChange?: (value: string) => void;
   onSaveLaunchScript?: () => void;
+  launchScriptsState?: WorkspaceLaunchScriptsState;
   worktreeRename?: {
     name: string;
     error: string | null;
@@ -90,6 +93,7 @@ export function MainHeader({
   onCloseLaunchScriptEditor,
   onLaunchScriptDraftChange,
   onSaveLaunchScript,
+  launchScriptsState,
   worktreeRename,
 }: MainHeaderProps) {
   const [menuOpen, setMenuOpen] = useState(false);
@@ -527,18 +531,52 @@ export function MainHeader({
           onCloseLaunchScriptEditor &&
           onLaunchScriptDraftChange &&
           onSaveLaunchScript && (
-            <LaunchScriptButton
-              launchScript={launchScript}
-              editorOpen={launchScriptEditorOpen}
-              draftScript={launchScriptDraft}
-              isSaving={launchScriptSaving}
-              error={launchScriptError}
-              onRun={onRunLaunchScript}
-              onOpenEditor={onOpenLaunchScriptEditor}
-              onCloseEditor={onCloseLaunchScriptEditor}
-              onDraftChange={onLaunchScriptDraftChange}
-              onSave={onSaveLaunchScript}
-            />
+            <div className="launch-script-cluster">
+              <LaunchScriptButton
+                launchScript={launchScript}
+                editorOpen={launchScriptEditorOpen}
+                draftScript={launchScriptDraft}
+                isSaving={launchScriptSaving}
+                error={launchScriptError}
+                onRun={onRunLaunchScript}
+                onOpenEditor={onOpenLaunchScriptEditor}
+                onCloseEditor={onCloseLaunchScriptEditor}
+                onDraftChange={onLaunchScriptDraftChange}
+                onSave={onSaveLaunchScript}
+                showNew={Boolean(launchScriptsState)}
+                newEditorOpen={launchScriptsState?.newEditorOpen}
+                newDraftScript={launchScriptsState?.newDraftScript}
+                newDraftIcon={launchScriptsState?.newDraftIcon}
+                newDraftLabel={launchScriptsState?.newDraftLabel}
+                newError={launchScriptsState?.newError ?? null}
+                onOpenNew={launchScriptsState?.onOpenNew}
+                onCloseNew={launchScriptsState?.onCloseNew}
+                onNewDraftChange={launchScriptsState?.onNewDraftScriptChange}
+                onNewDraftIconChange={launchScriptsState?.onNewDraftIconChange}
+                onNewDraftLabelChange={launchScriptsState?.onNewDraftLabelChange}
+                onCreateNew={launchScriptsState?.onCreateNew}
+              />
+              {launchScriptsState?.launchScripts.map((entry) => (
+                <LaunchScriptEntryButton
+                  key={entry.id}
+                  entry={entry}
+                  editorOpen={launchScriptsState.editorOpenId === entry.id}
+                  draftScript={launchScriptsState.draftScript}
+                  draftIcon={launchScriptsState.draftIcon}
+                  draftLabel={launchScriptsState.draftLabel}
+                  isSaving={launchScriptsState.isSaving}
+                  error={launchScriptsState.errorById[entry.id] ?? null}
+                  onRun={() => launchScriptsState.onRunScript(entry.id)}
+                  onOpenEditor={() => launchScriptsState.onOpenEditor(entry.id)}
+                  onCloseEditor={launchScriptsState.onCloseEditor}
+                  onDraftChange={launchScriptsState.onDraftScriptChange}
+                  onDraftIconChange={launchScriptsState.onDraftIconChange}
+                  onDraftLabelChange={launchScriptsState.onDraftLabelChange}
+                  onSave={launchScriptsState.onSaveScript}
+                  onDelete={launchScriptsState.onDeleteScript}
+                />
+              ))}
+            </div>
           )}
         <OpenAppMenu
           path={resolvedWorktreePath}
diff --git a/src/features/app/hooks/useWorkspaceLaunchScripts.test.tsx b/src/features/app/hooks/useWorkspaceLaunchScripts.test.tsx
new file mode 100644
index 00000000..e6d871b7
--- /dev/null
+++ b/src/features/app/hooks/useWorkspaceLaunchScripts.test.tsx
@@ -0,0 +1,264 @@
+// @vitest-environment jsdom
+import { act, renderHook, waitFor } from "@testing-library/react";
+import { describe, expect, it, vi } from "vitest";
+import type { TerminalSessionState } from "../../terminal/hooks/useTerminalSession";
+import type { LaunchScriptEntry, LaunchScriptIconId, WorkspaceInfo } from "../../../types";
+import { writeTerminalSession } from "../../../services/tauri";
+import { useWorkspaceLaunchScripts } from "./useWorkspaceLaunchScripts";
+
+vi.mock("../../../services/tauri", () => ({
+  writeTerminalSession: vi.fn(),
+}));
+
+const baseWorkspace: WorkspaceInfo = {
+  id: "workspace-1",
+  name: "Workspace",
+  path: "/tmp/workspace",
+  connected: true,
+  settings: { sidebarCollapsed: false },
+};
+
+const terminalState: TerminalSessionState = {
+  status: "ready",
+  message: "",
+  containerRef: { current: null },
+  hasSession: false,
+  readyKey: null,
+  cleanupTerminalSession: vi.fn(),
+};
+
+function makeWorkspace(launchScripts: LaunchScriptEntry[]): WorkspaceInfo {
+  return {
+    ...baseWorkspace,
+    settings: { ...baseWorkspace.settings, launchScripts },
+  };
+}
+
+function getUpdatedLaunchScripts(updateWorkspaceSettings: ReturnType<typeof vi.fn>) {
+  const lastCall =
+    updateWorkspaceSettings.mock.calls[updateWorkspaceSettings.mock.calls.length - 1];
+  const [, settings] = lastCall ?? [];
+  return (settings?.launchScripts ?? []) as LaunchScriptEntry[];
+}
+
+describe("useWorkspaceLaunchScripts", () => {
+  it("opens the editor when script is empty", () => {
+    const scripts: LaunchScriptEntry[] = [
+      { id: "one", script: "", icon: "play", label: null },
+    ];
+    const workspace = makeWorkspace(scripts);
+
+    const { result } = renderHook(() =>
+      useWorkspaceLaunchScripts({
+        activeWorkspace: workspace,
+        updateWorkspaceSettings: vi.fn(),
+        openTerminal: vi.fn(),
+        ensureLaunchTerminal: vi.fn(),
+        restartLaunchSession: vi.fn(),
+        terminalState,
+        activeTerminalId: null,
+      }),
+    );
+
+    act(() => {
+      result.current.onRunScript("one");
+    });
+
+    expect(result.current.editorOpenId).toBe("one");
+  });
+
+  it("runs the script when terminal session is ready", async () => {
+    const writeTerminalSessionMock = vi.mocked(writeTerminalSession);
+    writeTerminalSessionMock.mockResolvedValue(undefined);
+    const scripts: LaunchScriptEntry[] = [
+      { id: "one", script: "npm run dev", icon: "play", label: null },
+    ];
+    const workspace = makeWorkspace(scripts);
+    const updateWorkspaceSettings = vi.fn();
+    const openTerminal = vi.fn();
+    const ensureLaunchTerminal = vi.fn(() => "launch-one");
+    const restartLaunchSession = vi.fn().mockResolvedValue(undefined);
+
+    type HookProps = {
+      activeWorkspace: WorkspaceInfo;
+      terminalState: TerminalSessionState;
+      activeTerminalId: string | null;
+    };
+
+    const initialProps: HookProps = {
+      activeWorkspace: workspace,
+      terminalState,
+      activeTerminalId: null,
+    };
+
+    const { result, rerender } = renderHook(
+      (props: HookProps) =>
+        useWorkspaceLaunchScripts({
+          activeWorkspace: props.activeWorkspace,
+          updateWorkspaceSettings,
+          openTerminal,
+          ensureLaunchTerminal,
+          restartLaunchSession,
+          terminalState: props.terminalState,
+          activeTerminalId: props.activeTerminalId,
+        }),
+      { initialProps },
+    );
+
+    await act(async () => {
+      result.current.onRunScript("one");
+      await Promise.resolve();
+    });
+
+    expect(openTerminal).toHaveBeenCalled();
+    expect(ensureLaunchTerminal).toHaveBeenCalledWith(
+      "workspace-1",
+      scripts[0],
+      "Launch: Play",
+    );
+    expect(restartLaunchSession).toHaveBeenCalledWith("workspace-1", "launch-one");
+
+    rerender({
+      activeWorkspace: workspace,
+      terminalState: { ...terminalState, hasSession: true, readyKey: "workspace-1:launch-one" },
+      activeTerminalId: "launch-one",
+    });
+
+    await waitFor(() => {
+      expect(writeTerminalSession).toHaveBeenCalledWith(
+        "workspace-1",
+        "launch-one",
+        "npm run dev\n",
+      );
+    });
+  });
+
+  it("creates, edits, and deletes launch scripts", async () => {
+    const workspace = makeWorkspace([]);
+    const updateWorkspaceSettings = vi.fn().mockResolvedValue(workspace);
+
+    const { result } = renderHook(() =>
+      useWorkspaceLaunchScripts({
+        activeWorkspace: workspace,
+        updateWorkspaceSettings,
+        openTerminal: vi.fn(),
+        ensureLaunchTerminal: vi.fn(() => "launch-one"),
+        restartLaunchSession: vi.fn().mockResolvedValue(undefined),
+        terminalState,
+        activeTerminalId: null,
+      }),
+    );
+
+    act(() => {
+      result.current.onOpenNew();
+      result.current.onNewDraftScriptChange("npm run dev");
+      result.current.onNewDraftIconChange("server");
+      result.current.onNewDraftLabelChange("Dev server");
+    });
+
+    await act(async () => {
+      await result.current.onCreateNew();
+    });
+
+    const createdScripts = getUpdatedLaunchScripts(updateWorkspaceSettings);
+    expect(createdScripts).toHaveLength(1);
+    expect(createdScripts[0]).toEqual(
+      expect.objectContaining({
+        script: "npm run dev",
+        icon: "server",
+        label: "Dev server",
+      }),
+    );
+
+    const createdId = createdScripts[0].id;
+    const workspaceWithCreated = makeWorkspace(createdScripts);
+    updateWorkspaceSettings.mockClear();
+    updateWorkspaceSettings.mockResolvedValue(workspaceWithCreated);
+
+    const { result: editResult } = renderHook(() =>
+      useWorkspaceLaunchScripts({
+        activeWorkspace: workspaceWithCreated,
+        updateWorkspaceSettings,
+        openTerminal: vi.fn(),
+        ensureLaunchTerminal: vi.fn(() => "launch-one"),
+        restartLaunchSession: vi.fn().mockResolvedValue(undefined),
+        terminalState,
+        activeTerminalId: null,
+      }),
+    );
+
+    act(() => {
+      editResult.current.onOpenEditor(createdId);
+      editResult.current.onDraftScriptChange("npm run build");
+      editResult.current.onDraftIconChange("build");
+      editResult.current.onDraftLabelChange("Build");
+    });
+
+    await act(async () => {
+      await editResult.current.onSaveScript();
+    });
+
+    const editedScripts = getUpdatedLaunchScripts(updateWorkspaceSettings);
+    expect(editedScripts).toHaveLength(1);
+    expect(editedScripts[0]).toEqual(
+      expect.objectContaining({
+        id: createdId,
+        script: "npm run build",
+        icon: "build",
+        label: "Build",
+      }),
+    );
+
+    const workspaceWithEdited = makeWorkspace(editedScripts);
+    updateWorkspaceSettings.mockClear();
+    updateWorkspaceSettings.mockResolvedValue(workspaceWithEdited);
+
+    const { result: deleteResult } = renderHook(() =>
+      useWorkspaceLaunchScripts({
+        activeWorkspace: workspaceWithEdited,
+        updateWorkspaceSettings,
+        openTerminal: vi.fn(),
+        ensureLaunchTerminal: vi.fn(() => "launch-one"),
+        restartLaunchSession: vi.fn().mockResolvedValue(undefined),
+        terminalState,
+        activeTerminalId: null,
+      }),
+    );
+
+    await act(async () => {
+      deleteResult.current.onOpenEditor(createdId);
+      await deleteResult.current.onDeleteScript();
+    });
+
+    const deletedScripts = getUpdatedLaunchScripts(updateWorkspaceSettings);
+    expect(deletedScripts).toHaveLength(0);
+  });
+
+  it("coerces invalid icon ids to the default", () => {
+    const invalidIcon = "not-a-real-icon" as unknown as LaunchScriptIconId;
+    const scripts: LaunchScriptEntry[] = [
+      { id: "one", script: "npm run dev", icon: invalidIcon, label: null },
+    ];
+    const workspace = makeWorkspace(scripts);
+
+    const { result } = renderHook(() =>
+      useWorkspaceLaunchScripts({
+        activeWorkspace: workspace,
+        updateWorkspaceSettings: vi.fn(),
+        openTerminal: vi.fn(),
+        ensureLaunchTerminal: vi.fn(() => "launch-one"),
+        restartLaunchSession: vi.fn().mockResolvedValue(undefined),
+        terminalState,
+        activeTerminalId: null,
+      }),
+    );
+
+    expect(result.current.launchScripts[0].icon).toBe("play");
+
+    act(() => {
+      result.current.onOpenEditor("one");
+    });
+
+    expect(result.current.draftIcon).toBe("play");
+  });
+});
diff --git a/src/features/app/hooks/useWorkspaceLaunchScripts.ts b/src/features/app/hooks/useWorkspaceLaunchScripts.ts
new file mode 100644
index 00000000..3d7c7213
--- /dev/null
+++ b/src/features/app/hooks/useWorkspaceLaunchScripts.ts
@@ -0,0 +1,383 @@
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import type {
+  LaunchScriptEntry,
+  LaunchScriptIconId,
+  WorkspaceInfo,
+  WorkspaceSettings,
+} from "../../../types";
+import type { TerminalSessionState } from "../../terminal/hooks/useTerminalSession";
+import { writeTerminalSession } from "../../../services/tauri";
+import { pushErrorToast } from "../../../services/toasts";
+import {
+  DEFAULT_LAUNCH_SCRIPT_ICON,
+  coerceLaunchScriptIconId,
+  getLaunchScriptIconLabel,
+} from "../utils/launchScriptIcons";
+
+type PendingLaunch = {
+  workspaceId: string;
+  terminalId: string;
+  script: string;
+  entryId: string;
+};
+
+type UseWorkspaceLaunchScriptsOptions = {
+  activeWorkspace: WorkspaceInfo | null;
+  updateWorkspaceSettings: (id: string, settings: WorkspaceSettings) => Promise<WorkspaceInfo>;
+  openTerminal: () => void;
+  ensureLaunchTerminal: (workspaceId: string, entry: LaunchScriptEntry, title: string) => string;
+  restartLaunchSession: (workspaceId: string, terminalId: string) => Promise<void>;
+  terminalState: TerminalSessionState | null;
+  activeTerminalId: string | null;
+};
+
+export type WorkspaceLaunchScriptsState = {
+  launchScripts: LaunchScriptEntry[];
+  editorOpenId: string | null;
+  draftScript: string;
+  draftIcon: LaunchScriptIconId;
+  draftLabel: string;
+  newEditorOpen: boolean;
+  newDraftScript: string;
+  newDraftIcon: LaunchScriptIconId;
+  newDraftLabel: string;
+  newError: string | null;
+  isSaving: boolean;
+  error: string | null;
+  errorById: Record<string, string | null>;
+  onRunScript: (id: string) => void;
+  onOpenEditor: (id: string) => void;
+  onCloseEditor: () => void;
+  onDraftScriptChange: (value: string) => void;
+  onDraftIconChange: (value: LaunchScriptIconId) => void;
+  onDraftLabelChange: (value: string) => void;
+  onSaveScript: () => Promise<void>;
+  onDeleteScript: () => Promise<void>;
+  onOpenNew: () => void;
+  onCloseNew: () => void;
+  onNewDraftScriptChange: (value: string) => void;
+  onNewDraftIconChange: (value: LaunchScriptIconId) => void;
+  onNewDraftLabelChange: (value: string) => void;
+  onCreateNew: () => Promise<void>;
+};
+
+function buildLaunchTitle(entry: LaunchScriptEntry) {
+  const label = entry.label?.trim();
+  if (label) {
+    return `Launch: ${label}`;
+  }
+  return `Launch: ${getLaunchScriptIconLabel(entry.icon)}`;
+}
+
+export function useWorkspaceLaunchScripts({
+  activeWorkspace,
+  updateWorkspaceSettings,
+  openTerminal,
+  ensureLaunchTerminal,
+  restartLaunchSession,
+  terminalState,
+  activeTerminalId,
+}: UseWorkspaceLaunchScriptsOptions): WorkspaceLaunchScriptsState {
+  const [editorOpenId, setEditorOpenId] = useState<string | null>(null);
+  const [draftScript, setDraftScript] = useState("");
+  const [draftIcon, setDraftIcon] = useState<LaunchScriptIconId>(DEFAULT_LAUNCH_SCRIPT_ICON);
+  const [draftLabel, setDraftLabel] = useState("");
+  const [newEditorOpen, setNewEditorOpen] = useState(false);
+  const [newDraftScript, setNewDraftScript] = useState("");
+  const [newDraftIcon, setNewDraftIcon] = useState<LaunchScriptIconId>(DEFAULT_LAUNCH_SCRIPT_ICON);
+  const [newDraftLabel, setNewDraftLabel] = useState("");
+  const [newError, setNewError] = useState<string | null>(null);
+  const [isSaving, setIsSaving] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+  const [errorById, setErrorById] = useState<Record<string, string | null>>({});
+  const pendingRunRef = useRef<PendingLaunch | null>(null);
+
+  const launchScripts = useMemo(
+    () =>
+      (activeWorkspace?.settings.launchScripts ?? []).map((entry) => ({
+        ...entry,
+        icon: coerceLaunchScriptIconId(entry.icon),
+      })),
+    [activeWorkspace?.settings.launchScripts],
+  );
+
+  useEffect(() => {
+    setEditorOpenId(null);
+    setDraftScript("");
+    setDraftIcon(DEFAULT_LAUNCH_SCRIPT_ICON);
+    setDraftLabel("");
+    setNewEditorOpen(false);
+    setNewDraftScript("");
+    setNewDraftIcon(DEFAULT_LAUNCH_SCRIPT_ICON);
+    setNewDraftLabel("");
+    setNewError(null);
+    setError(null);
+    setErrorById({});
+    pendingRunRef.current = null;
+  }, [activeWorkspace?.id]);
+
+  const onOpenEditor = useCallback(
+    (id: string) => {
+      const entry = launchScripts.find((script) => script.id === id);
+      if (!entry) {
+        return;
+      }
+      setDraftScript(entry.script);
+      setDraftIcon(coerceLaunchScriptIconId(entry.icon));
+      setDraftLabel(entry.label ?? "");
+      setEditorOpenId(id);
+      setError(null);
+      setErrorById((prev) => ({ ...prev, [id]: null }));
+    },
+    [launchScripts],
+  );
+
+  const onCloseEditor = useCallback(() => {
+    setEditorOpenId(null);
+    setError(null);
+  }, []);
+
+  const onDraftScriptChange = useCallback((value: string) => {
+    setDraftScript(value);
+  }, []);
+
+  const onDraftIconChange = useCallback((value: LaunchScriptIconId) => {
+    setDraftIcon(value);
+  }, []);
+
+  const onDraftLabelChange = useCallback((value: string) => {
+    setDraftLabel(value);
+  }, []);
+
+  const onOpenNew = useCallback(() => {
+    setNewDraftScript("");
+    setNewDraftIcon(DEFAULT_LAUNCH_SCRIPT_ICON);
+    setNewDraftLabel("");
+    setNewEditorOpen(true);
+    setNewError(null);
+  }, []);
+
+  const onCloseNew = useCallback(() => {
+    setNewEditorOpen(false);
+    setNewError(null);
+  }, []);
+
+  const onNewDraftScriptChange = useCallback((value: string) => {
+    setNewDraftScript(value);
+  }, []);
+
+  const onNewDraftIconChange = useCallback((value: LaunchScriptIconId) => {
+    setNewDraftIcon(value);
+  }, []);
+
+  const onNewDraftLabelChange = useCallback((value: string) => {
+    setNewDraftLabel(value);
+  }, []);
+
+  const onCreateNew = useCallback(async () => {
+    if (!activeWorkspace) {
+      return;
+    }
+    const trimmed = newDraftScript.trim();
+    if (!trimmed) {
+      setNewError("Script cannot be empty.");
+      return;
+    }
+    setIsSaving(true);
+    setNewError(null);
+    try {
+      const nextScripts = [
+        ...launchScripts,
+        {
+          id: `${Date.now()}-${Math.random().toString(16).slice(2)}`,
+          script: newDraftScript,
+          icon: newDraftIcon || DEFAULT_LAUNCH_SCRIPT_ICON,
+          label: newDraftLabel.trim() ? newDraftLabel.trim() : null,
+        },
+      ];
+      await updateWorkspaceSettings(activeWorkspace.id, {
+        ...activeWorkspace.settings,
+        launchScripts: nextScripts,
+      });
+      setNewEditorOpen(false);
+    } catch (err) {
+      setNewError(err instanceof Error ? err.message : String(err));
+    } finally {
+      setIsSaving(false);
+    }
+  }, [
+    activeWorkspace,
+    launchScripts,
+    newDraftIcon,
+    newDraftLabel,
+    newDraftScript,
+    updateWorkspaceSettings,
+  ]);
+
+  const onSaveScript = useCallback(async () => {
+    if (!activeWorkspace || !editorOpenId) {
+      return;
+    }
+    const trimmed = draftScript.trim();
+    if (!trimmed) {
+      setError("Script cannot be empty.");
+      setErrorById((prev) => ({ ...prev, [editorOpenId]: "Script cannot be empty." }));
+      return;
+    }
+    setIsSaving(true);
+    setError(null);
+    setErrorById((prev) => ({ ...prev, [editorOpenId]: null }));
+    try {
+      const nextScripts = launchScripts.map((entry) => {
+        if (entry.id !== editorOpenId) {
+          return entry;
+        }
+        return {
+          ...entry,
+          script: draftScript,
+          icon: draftIcon || DEFAULT_LAUNCH_SCRIPT_ICON,
+          label: draftLabel.trim() ? draftLabel.trim() : null,
+        };
+      });
+      await updateWorkspaceSettings(activeWorkspace.id, {
+        ...activeWorkspace.settings,
+        launchScripts: nextScripts,
+      });
+      setEditorOpenId(null);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      setError(message);
+      setErrorById((prev) => ({ ...prev, [editorOpenId]: message }));
+    } finally {
+      setIsSaving(false);
+    }
+  }, [
+    activeWorkspace,
+    draftIcon,
+    draftLabel,
+    draftScript,
+    editorOpenId,
+    launchScripts,
+    updateWorkspaceSettings,
+  ]);
+
+  const onDeleteScript = useCallback(async () => {
+    if (!activeWorkspace || !editorOpenId) {
+      return;
+    }
+    setIsSaving(true);
+    setError(null);
+    setErrorById((prev) => ({ ...prev, [editorOpenId]: null }));
+    try {
+      const nextScripts = launchScripts.filter((entry) => entry.id !== editorOpenId);
+      await updateWorkspaceSettings(activeWorkspace.id, {
+        ...activeWorkspace.settings,
+        launchScripts: nextScripts,
+      });
+      setEditorOpenId(null);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      setError(message);
+      setErrorById((prev) => ({ ...prev, [editorOpenId]: message }));
+    } finally {
+      setIsSaving(false);
+    }
+  }, [activeWorkspace, editorOpenId, launchScripts, updateWorkspaceSettings]);
+
+  const onRunScript = useCallback(
+    (id: string) => {
+      if (!activeWorkspace) {
+        return;
+      }
+      const entry = launchScripts.find((script) => script.id === id);
+      if (!entry || !entry.script.trim()) {
+        if (entry) {
+          onOpenEditor(id);
+        }
+        return;
+      }
+      setError(null);
+      setErrorById((prev) => ({ ...prev, [id]: null }));
+      const title = buildLaunchTitle(entry);
+      const terminalId = ensureLaunchTerminal(activeWorkspace.id, entry, title);
+      pendingRunRef.current = {
+        workspaceId: activeWorkspace.id,
+        terminalId,
+        script: entry.script,
+        entryId: entry.id,
+      };
+      openTerminal();
+      restartLaunchSession(activeWorkspace.id, terminalId).catch((err) => {
+        pendingRunRef.current = null;
+        const message = err instanceof Error ? err.message : String(err);
+        setError(message);
+        setErrorById((prev) => ({ ...prev, [id]: message }));
+      });
+    },
+    [
+      activeWorkspace,
+      ensureLaunchTerminal,
+      launchScripts,
+      onOpenEditor,
+      openTerminal,
+      restartLaunchSession,
+    ],
+  );
+
+  useEffect(() => {
+    const pending = pendingRunRef.current;
+    const pendingKey = pending
+      ? `${pending.workspaceId}:${pending.terminalId}`
+      : null;
+    if (
+      !pending ||
+      terminalState?.readyKey !== pendingKey ||
+      activeTerminalId !== pending.terminalId ||
+      activeWorkspace?.id !== pending.workspaceId
+    ) {
+      return;
+    }
+    pendingRunRef.current = null;
+    writeTerminalSession(pending.workspaceId, pending.terminalId, `${pending.script}\n`).catch(
+      (err) => {
+        const message = err instanceof Error ? err.message : String(err);
+        setError(message);
+        setErrorById((prev) => ({ ...prev, [pending.entryId]: message }));
+        pushErrorToast({
+          title: "Launch script error",
+          message,
+        });
+      },
+    );
+  }, [activeTerminalId, activeWorkspace?.id, terminalState?.readyKey]);
+
+  return {
+    launchScripts,
+    editorOpenId,
+    draftScript,
+    draftIcon,
+    draftLabel,
+    newEditorOpen,
+    newDraftScript,
+    newDraftIcon,
+    newDraftLabel,
+    newError,
+    isSaving,
+    error,
+    errorById,
+    onRunScript,
+    onOpenEditor,
+    onCloseEditor,
+    onDraftScriptChange,
+    onDraftIconChange,
+    onDraftLabelChange,
+    onSaveScript,
+    onDeleteScript,
+    onOpenNew,
+    onCloseNew,
+    onNewDraftScriptChange,
+    onNewDraftIconChange,
+    onNewDraftLabelChange,
+    onCreateNew,
+  };
+}
diff --git a/src/features/app/utils/launchScriptIcons.ts b/src/features/app/utils/launchScriptIcons.ts
new file mode 100644
index 00000000..62b5c60f
--- /dev/null
+++ b/src/features/app/utils/launchScriptIcons.ts
@@ -0,0 +1,84 @@
+import type { LucideIcon } from "lucide-react";
+import type { LaunchScriptIconId } from "../../../types";
+export type { LaunchScriptIconId } from "../../../types";
+import Play from "lucide-react/dist/esm/icons/play";
+import Hammer from "lucide-react/dist/esm/icons/hammer";
+import Bug from "lucide-react/dist/esm/icons/bug";
+import Wrench from "lucide-react/dist/esm/icons/wrench";
+import TerminalSquare from "lucide-react/dist/esm/icons/terminal-square";
+import Code2 from "lucide-react/dist/esm/icons/code-2";
+import Server from "lucide-react/dist/esm/icons/server";
+import Database from "lucide-react/dist/esm/icons/database";
+import Package from "lucide-react/dist/esm/icons/package";
+import TestTube2 from "lucide-react/dist/esm/icons/test-tube-2";
+import RefreshCw from "lucide-react/dist/esm/icons/refresh-cw";
+import GitBranch from "lucide-react/dist/esm/icons/git-branch";
+import Settings from "lucide-react/dist/esm/icons/settings";
+import Search from "lucide-react/dist/esm/icons/search";
+
+export const DEFAULT_LAUNCH_SCRIPT_ICON: LaunchScriptIconId = "play";
+
+const ICON_MAP: Record<LaunchScriptIconId, LucideIcon> = {
+  play: Play,
+  build: Hammer,
+  debug: Bug,
+  wrench: Wrench,
+  terminal: TerminalSquare,
+  code: Code2,
+  server: Server,
+  database: Database,
+  package: Package,
+  test: TestTube2,
+  lint: RefreshCw,
+  dev: Play,
+  git: GitBranch,
+  config: Settings,
+  logs: Search,
+};
+
+const ICON_LABELS: Record<LaunchScriptIconId, string> = {
+  play: "Play",
+  build: "Build",
+  debug: "Debug",
+  wrench: "Wrench",
+  terminal: "Terminal",
+  code: "Code",
+  server: "Server",
+  database: "Database",
+  package: "Package",
+  test: "Test",
+  lint: "Lint",
+  dev: "Dev",
+  git: "Git",
+  config: "Config",
+  logs: "Logs",
+};
+
+function isLaunchScriptIconId(value: string): value is LaunchScriptIconId {
+  return value in ICON_MAP;
+}
+
+export function coerceLaunchScriptIconId(value?: string | null): LaunchScriptIconId {
+  if (!value) {
+    return DEFAULT_LAUNCH_SCRIPT_ICON;
+  }
+  return isLaunchScriptIconId(value) ? value : DEFAULT_LAUNCH_SCRIPT_ICON;
+}
+
+export const LAUNCH_SCRIPT_ICON_OPTIONS = Object.keys(ICON_MAP).map((id) => {
+  const iconId = coerceLaunchScriptIconId(id);
+  return {
+    id: iconId,
+    label: ICON_LABELS[iconId],
+  };
+});
+
+export function getLaunchScriptIcon(id?: string | null): LucideIcon {
+  const iconId = coerceLaunchScriptIconId(id);
+  return ICON_MAP[iconId];
+}
+
+export function getLaunchScriptIconLabel(id?: string | null): string {
+  const iconId = coerceLaunchScriptIconId(id);
+  return ICON_LABELS[iconId];
+}
diff --git a/src/features/layout/hooks/useLayoutNodes.tsx b/src/features/layout/hooks/useLayoutNodes.tsx
index c10dfb20..f1c67486 100644
--- a/src/features/layout/hooks/useLayoutNodes.tsx
+++ b/src/features/layout/hooks/useLayoutNodes.tsx
@@ -19,6 +19,7 @@ import { TabletNav } from "../../app/components/TabletNav";
 import { TerminalDock } from "../../terminal/components/TerminalDock";
 import { TerminalPanel } from "../../terminal/components/TerminalPanel";
 import type { ReviewPromptState, ReviewPromptStep } from "../../threads/hooks/useReviewPrompt";
+import type { WorkspaceLaunchScriptsState } from "../../app/hooks/useWorkspaceLaunchScripts";
 import type {
   AccessMode,
   ApprovalRequest,
@@ -213,6 +214,7 @@ type LayoutNodesOptions = {
   onCloseLaunchScriptEditor: () => void;
   onLaunchScriptDraftChange: (value: string) => void;
   onSaveLaunchScript: () => void;
+  launchScriptsState?: WorkspaceLaunchScriptsState;
   mainHeaderActionsNode?: ReactNode;
   centerMode: "chat" | "diff";
   onExitDiff: () => void;
@@ -678,6 +680,7 @@ export function useLayoutNodes(options: LayoutNodesOptions): LayoutNodesResult {
       onCloseLaunchScriptEditor={options.onCloseLaunchScriptEditor}
       onLaunchScriptDraftChange={options.onLaunchScriptDraftChange}
       onSaveLaunchScript={options.onSaveLaunchScript}
+      launchScriptsState={options.launchScriptsState}
       extraActionsNode={options.mainHeaderActionsNode}
     />
   ) : null;
diff --git a/src/styles/main.css b/src/styles/main.css
index 52d40d97..a5f04ad3 100644
--- a/src/styles/main.css
+++ b/src/styles/main.css
@@ -220,6 +220,17 @@
   min-height: 96px;
 }
 
+.launch-script-input {
+  width: 100%;
+  border-radius: 8px;
+  border: 1px solid var(--border-muted);
+  background: var(--surface-control);
+  color: var(--text-strong);
+  padding: 6px 8px;
+  font-size: 12px;
+  margin-bottom: 8px;
+}
+
 .launch-script-help {
   margin-top: 6px;
   font-size: 11px;
@@ -239,6 +250,50 @@
   gap: 8px;
 }
 
+.launch-script-delete {
+  color: var(--text-danger);
+}
+
+.launch-script-delete:hover:not(:disabled) {
+  background: rgba(239, 68, 68, 0.12);
+}
+
+.launch-script-icon-picker {
+  display: grid;
+  grid-template-columns: repeat(5, minmax(0, 1fr));
+  gap: 6px;
+  margin-bottom: 10px;
+}
+
+.launch-script-icon-option {
+  border-radius: 8px;
+  border: 1px solid var(--border-muted);
+  background: var(--surface-control);
+  color: var(--text-strong);
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  padding: 6px;
+}
+
+.launch-script-icon-option.is-selected {
+  border-color: var(--border-strong);
+  background: var(--surface-hover);
+  color: var(--text-stronger);
+}
+
+.launch-script-new {
+  margin-top: 12px;
+  padding-top: 10px;
+  border-top: 1px solid var(--border-muted);
+}
+
+.launch-script-cluster {
+  display: inline-flex;
+  align-items: center;
+  gap: 4px;
+}
+
 .main-header-action {
   padding: 6px;
   border-radius: 8px;
diff --git a/src/types.ts b/src/types.ts
index a42ceda8..613e9b8a 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -6,9 +6,34 @@ export type WorkspaceSettings = {
   codexHome?: string | null;
   codexArgs?: string | null;
   launchScript?: string | null;
+  launchScripts?: LaunchScriptEntry[] | null;
   worktreeSetupScript?: string | null;
 };
 
+export type LaunchScriptIconId =
+  | "play"
+  | "build"
+  | "debug"
+  | "wrench"
+  | "terminal"
+  | "code"
+  | "server"
+  | "database"
+  | "package"
+  | "test"
+  | "lint"
+  | "dev"
+  | "git"
+  | "config"
+  | "logs";
+
+export type LaunchScriptEntry = {
+  id: string;
+  script: string;
+  icon: LaunchScriptIconId;
+  label?: string | null;
+};
+
 export type WorkspaceGroup = {
   id: string;
   name: string;