diff --git a/apps/desktop/src/main/editors.ts b/apps/desktop/src/main/editors.ts
index 0f1ad7e..7830451 100644
--- a/apps/desktop/src/main/editors.ts
+++ b/apps/desktop/src/main/editors.ts
@@ -15,6 +15,14 @@ type EditorSpec = InstalledEditor & {
 
 type ScannedEditor = { editor: InstalledEditor; executable?: string };
 
+function fileArgs(targetPath: string, editorId: string, line: number | undefined, column?: number): string[] {
+  if (line && ["cursor", "vscode", "antigravity", "windsurf", "vscode-insiders", "vscodium"].includes(editorId)) {
+    return ["-g", `${targetPath}:${line}${column ? `:${column}` : ""}`];
+  }
+  if (line && jetBrainsEditors.some(([id]) => id === editorId)) return ["--line", String(line), targetPath];
+  return [targetPath];
+}
+
 /** The platform's own file manager, named the way its own users would name it. */
 export function fileManagerName(): string {
   if (process.platform === "darwin") return "Finder";
@@ -374,11 +382,11 @@ export async function listInstalledEditors(): Promise<InstalledEditor[]> {
  * `open -a`, which also hands the app the target path the way double-clicking
  * a file in Finder would. Windows and Linux executables are launched directly.
  */
-function launchEditor(executable: string, target: string): ChildProcess {
+function launchEditor(executable: string, target: string, args = [target]): ChildProcess {
   if (process.platform === "darwin" && executable.endsWith(".app")) {
     return spawn("open", ["-a", executable, target], { detached: true, stdio: "ignore" });
   }
-  return spawn(executable, [target], { detached: true, stdio: "ignore", windowsHide: true });
+  return spawn(executable, args, { detached: true, stdio: "ignore", windowsHide: true });
 }
 
 export async function openProjectIn(projectDir: string, editorId: string): Promise<void> {
@@ -399,7 +407,7 @@ export async function openProjectIn(projectDir: string, editorId: string): Promi
   });
 }
 
-export async function openFileIn(projectDir: string, file: string, editorId: string): Promise<void> {
+export async function openFileIn(projectDir: string, file: string, editorId: string, line?: number, column?: number): Promise<void> {
   const targetPath = resolve(projectDir, file);
   const relativePath = relative(projectDir, targetPath);
   if (isAbsolute(relativePath) || relativePath === ".." || relativePath.startsWith(`..${sep}`)) {
@@ -413,7 +421,7 @@ export async function openFileIn(projectDir: string, file: string, editorId: str
   if (!target?.executable) throw new Error("That editor is no longer installed.");
   const executable = target.executable;
   await new Promise<void>((resolveSpawn, reject) => {
-    const child = launchEditor(executable, targetPath);
+    const child = launchEditor(executable, targetPath, fileArgs(targetPath, target.editor.id, line, column));
     child.once("spawn", resolveSpawn);
     child.once("error", reject);
     child.unref();
diff --git a/apps/desktop/src/main/ipc.ts b/apps/desktop/src/main/ipc.ts
index b44232e..f6c438b 100644
--- a/apps/desktop/src/main/ipc.ts
+++ b/apps/desktop/src/main/ipc.ts
@@ -24,9 +24,12 @@ import {
   closeTerminal,
   closeProjectTerminals,
   createTerminal,
+  listShellProfiles,
   listTerminals,
   liveTerminalProjects,
+  renameTerminal,
   resizeTerminal,
+  restartTerminal,
   stopAllTerminals,
   terminalSnapshot,
   writeTerminal,
@@ -306,7 +309,7 @@ function toSessionState(data: RpcSessionState): RpcSessionState {
 
 const THINKING_LEVELS = new Set<ThinkingLevel>(["off", "minimal", "low", "medium", "high", "xhigh", "max"]);
 const openProjectInParamsSchema = z.object({ projectDir: z.string().min(1), editorId: z.string().min(1) });
-const openFileInParamsSchema = openProjectInParamsSchema.extend({ file: z.string().min(1) });
+const openFileInParamsSchema = openProjectInParamsSchema.extend({ file: z.string().min(1), line: z.number().int().positive().optional(), column: z.number().int().positive().optional() });
 const saveImageParamsSchema = z.object({
   data: z.string().min(1).max(64 * 1024 * 1024),
   mimeType: z.enum(["image/png", "image/jpeg", "image/gif", "image/webp"]),
@@ -371,6 +374,11 @@ const tuiApplyParamsSchema = tuiCompleteParamsSchema.extend({
   prefix: z.string().max(200),
 });
 const terminalIdParamsSchema = projectDirParamsSchema.extend({ terminalId: z.string().min(1) });
+const terminalCreateParamsSchema = projectDirParamsSchema.extend({
+  shellId: z.string().optional(),
+  name: z.string().optional(),
+});
+const terminalRenameParamsSchema = terminalIdParamsSchema.extend({ name: z.string().min(1).max(64) });
 const terminalResizeParamsSchema = terminalIdParamsSchema.extend({
   cols: z.number().int().min(2).max(1000),
   rows: z.number().int().min(1).max(1000),
@@ -826,8 +834,8 @@ const handlers: HandlerMap = {
   },
   openFileIn: async (params) => {
     try {
-      const { projectDir, file, editorId } = openFileInParamsSchema.parse(params);
-      await openFileIn(projectDir, file, editorId);
+      const { projectDir, file, editorId, line, column } = openFileInParamsSchema.parse(params);
+      await openFileIn(projectDir, file, editorId, line, column);
       return { ok: true };
     } catch (err) {
       return { ok: false, error: errorMessage(err) };
@@ -949,13 +957,15 @@ const handlers: HandlerMap = {
   },
 
   terminalEnsure: (params) => {
-    const { projectDir } = projectDirParamsSchema.parse(params);
+    const { projectDir, shellId } = projectDirParamsSchema.extend({ shellId: z.string().optional() }).parse(params);
     const existing = listTerminals(projectDir);
     if (existing.length > 0) return { terminals: existing };
     return {
       terminals: [
         createTerminal(
           projectDir,
+          shellId,
+          undefined,
           (payload) => push("terminalData", payload),
           (payload) => push("terminalExit", payload),
         ),
@@ -963,15 +973,34 @@ const handlers: HandlerMap = {
     };
   },
   terminalCreate: (params) => {
-    const { projectDir } = projectDirParamsSchema.parse(params);
+    const { projectDir, shellId, name } = terminalCreateParamsSchema.parse(params);
     return {
       terminal: createTerminal(
         projectDir,
+        shellId,
+        name,
         (payload) => push("terminalData", payload),
         (payload) => push("terminalExit", payload),
       ),
     };
   },
+  terminalListShells: () => ({ shells: listShellProfiles() }),
+  terminalRename: (params) => {
+    const { projectDir, terminalId, name } = terminalRenameParamsSchema.parse(params);
+    renameTerminal(projectDir, terminalId, name);
+    return { ok: true };
+  },
+  terminalRestart: (params) => {
+    const { projectDir, terminalId } = terminalIdParamsSchema.parse(params);
+    const terminal = restartTerminal(
+      projectDir,
+      terminalId,
+      (payload) => push("terminalData", payload),
+      (payload) => push("terminalExit", payload),
+    );
+    push("terminalRestart", { projectDir, terminal });
+    return { terminal };
+  },
   terminalSnapshot: (params) => {
     const { projectDir, terminalId } = terminalIdParamsSchema.parse(params);
     return terminalSnapshot(projectDir, terminalId);
diff --git a/apps/desktop/src/main/terminal.ts b/apps/desktop/src/main/terminal.ts
index d402d91..bb73fe2 100644
--- a/apps/desktop/src/main/terminal.ts
+++ b/apps/desktop/src/main/terminal.ts
@@ -3,7 +3,7 @@ import { existsSync } from "node:fs";
 import { delimiter, join } from "node:path";
 import type { IPty } from "node-pty";
 import { spawn } from "node-pty";
-import type { TerminalSession } from "../shared/rpc-schema.ts";
+import type { ShellProfile, TerminalSession } from "../shared/rpc-schema.ts";
 
 const MAX_BUFFER_SIZE = 2 * 1024 * 1024;
 
@@ -16,19 +16,63 @@ type ManagedTerminal = TerminalSession & {
 
 const terminals = new Map<string, ManagedTerminal>();
 
-function resolveShell(): string {
-  if (process.platform !== "win32") return process.env["SHELL"] || "/bin/bash";
+/**
+ * Shells NativePi knows how to look for. Detection is PATH-first with a few
+ * well-known install locations as a fallback, the same shape `editors.ts`
+ * uses for applications — adding a shell for another platform is one entry
+ * here, not a new branch.
+ */
+const SHELL_CANDIDATES: { id: string; name: string; executable: string; paths: string[]; args: string[] }[] = [
+  { id: "pwsh", name: "PowerShell 7", executable: "pwsh.exe", paths: [], args: ["-NoLogo"] },
+  { id: "powershell", name: "Windows PowerShell", executable: "powershell.exe", paths: [], args: ["-NoLogo"] },
+  { id: "cmd", name: "Command Prompt", executable: "cmd.exe", paths: [], args: [] },
+  {
+    id: "gitbash",
+    name: "Git Bash",
+    executable: "bash.exe",
+    paths: [
+      join(process.env["ProgramFiles"] ?? "", "Git", "bin", "bash.exe"),
+      join(process.env["ProgramFiles(x86)"] ?? "", "Git", "bin", "bash.exe"),
+    ],
+    args: ["--login", "-i"],
+  },
+  { id: "wsl", name: "WSL", executable: "wsl.exe", paths: [], args: [] },
+];
+
+function findOnPath(executable: string): string | undefined {
   const path = process.env["PATH"] ?? "";
   for (const dir of path.split(delimiter)) {
     if (!dir) continue;
-    const candidate = join(dir, "pwsh.exe");
+    const candidate = join(dir, executable);
     if (existsSync(candidate)) return candidate;
   }
-  return "powershell.exe";
+  return undefined;
+}
+
+function resolveCandidate(candidate: { executable: string; paths: string[] }): string | undefined {
+  return findOnPath(candidate.executable) ?? candidate.paths.find(existsSync);
+}
+
+export function listShellProfiles(): ShellProfile[] {
+  if (process.platform !== "win32") return [{ id: "default", name: process.env["SHELL"] || "Shell" }];
+  return SHELL_CANDIDATES.filter((candidate) => resolveCandidate(candidate) !== undefined).map(
+    ({ id, name }) => ({ id, name }),
+  );
 }
 
-function shellArgs(): string[] {
-  return process.platform === "win32" ? ["-NoLogo"] : process.platform === "darwin" ? ["-l"] : [];
+function resolveShell(shellId: string | undefined): { id: string; path: string; args: string[] } {
+  if (process.platform !== "win32") {
+    return {
+      id: "default",
+      path: process.env["SHELL"] || "/bin/bash",
+      args: process.platform === "darwin" ? ["-l"] : [],
+    };
+  }
+  const candidate = SHELL_CANDIDATES.find((entry) => entry.id === shellId);
+  const resolved = candidate ? resolveCandidate(candidate) : undefined;
+  if (candidate && resolved) return { id: candidate.id, path: resolved, args: candidate.args };
+  const path = findOnPath("pwsh.exe") ?? "powershell.exe";
+  return { id: "pwsh", path, args: ["-NoLogo"] };
 }
 
 function shellEnv(): Record<string, string> {
@@ -49,6 +93,8 @@ function publicSession(terminal: ManagedTerminal): TerminalSession {
   return {
     id: terminal.id,
     projectDir: terminal.projectDir,
+    name: terminal.name,
+    shellId: terminal.shellId,
     exited: terminal.exited,
     exitCode: terminal.exitCode,
   };
@@ -65,33 +111,39 @@ export function liveTerminalProjects(): string[] {
   return [...terminals.values()].filter((terminal) => !terminal.exited).map((terminal) => terminal.projectDir);
 }
 
-export function createTerminal(
-  projectDir: string,
-  onData: (payload: { projectDir: string; terminalId: string; data: string; sequence: number }) => void,
-  onExit: (payload: { projectDir: string; terminalId: string; exitCode: number }) => void,
-): TerminalSession {
-  const id = randomUUID();
-  const pty = spawn(resolveShell(), shellArgs(), {
+function nextTerminalName(projectDir: string): string {
+  const used = new Set(
+    [...terminals.values()].filter((terminal) => terminal.projectDir === projectDir).map((terminal) => terminal.name),
+  );
+  let index = 1;
+  while (used.has(`Terminal ${index}`)) index += 1;
+  return `Terminal ${index}`;
+}
+
+function spawnPty(projectDir: string, shellId: string | undefined): { pty: IPty; resolvedShellId: string } {
+  const shell = resolveShell(shellId);
+  const pty = spawn(shell.path, shell.args, {
     name: "xterm-256color",
     cols: 100,
     rows: 24,
     cwd: projectDir,
     env: shellEnv(),
   });
-  const terminal: ManagedTerminal = {
-    id,
-    projectDir,
-    process: pty,
-    output: [],
-    outputSize: 0,
-    sequence: 0,
-    exited: false,
-  };
-  terminals.set(id, terminal);
+  return { pty, resolvedShellId: shell.id };
+}
 
-  pty.onData((data) => {
+function attachHandlers(
+  id: string,
+  projectDir: string,
+  onData: (payload: { projectDir: string; terminalId: string; data: string; sequence: number }) => void,
+  onExit: (payload: { projectDir: string; terminalId: string; exitCode: number }) => void,
+): void {
+  const terminal = terminals.get(id);
+  if (!terminal) return;
+  const process = terminal.process;
+  process.onData((data) => {
     const current = terminals.get(id);
-    if (!current) return;
+    if (!current || current.process !== process) return;
     current.output.push(data);
     current.outputSize += data.length;
     while (current.outputSize > MAX_BUFFER_SIZE && current.output.length > 1) {
@@ -101,14 +153,66 @@ export function createTerminal(
     onData({ projectDir, terminalId: id, data, sequence: current.sequence });
   });
 
-  pty.onExit(({ exitCode }) => {
+  process.onExit(({ exitCode }) => {
     const current = terminals.get(id);
-    if (!current) return;
+    if (!current || current.process !== process) return;
     current.exited = true;
     current.exitCode = exitCode;
     onExit({ projectDir, terminalId: id, exitCode });
   });
+}
 
+export function createTerminal(
+  projectDir: string,
+  shellId: string | undefined,
+  name: string | undefined,
+  onData: (payload: { projectDir: string; terminalId: string; data: string; sequence: number }) => void,
+  onExit: (payload: { projectDir: string; terminalId: string; exitCode: number }) => void,
+): TerminalSession {
+  const id = randomUUID();
+  const { pty, resolvedShellId } = spawnPty(projectDir, shellId);
+  const terminal: ManagedTerminal = {
+    id,
+    projectDir,
+    name: name?.trim() || nextTerminalName(projectDir),
+    shellId: resolvedShellId,
+    process: pty,
+    output: [],
+    outputSize: 0,
+    sequence: 0,
+    exited: false,
+  };
+  terminals.set(id, terminal);
+  attachHandlers(id, projectDir, onData, onExit);
+  return publicSession(terminal);
+}
+
+export function renameTerminal(projectDir: string, terminalId: string, name: string): void {
+  const terminal = terminals.get(terminalId);
+  if (!terminal || terminal.projectDir !== projectDir) return;
+  const trimmed = name.trim();
+  if (trimmed) terminal.name = trimmed;
+}
+
+/** Kills the running shell and starts a fresh one under the same id, name, and profile. */
+export function restartTerminal(
+  projectDir: string,
+  terminalId: string,
+  onData: (payload: { projectDir: string; terminalId: string; data: string; sequence: number }) => void,
+  onExit: (payload: { projectDir: string; terminalId: string; exitCode: number }) => void,
+): TerminalSession {
+  const terminal = terminals.get(terminalId);
+  if (!terminal || terminal.projectDir !== projectDir) throw new Error("Terminal not found");
+  if (!terminal.exited) terminal.process.kill();
+  const { pty, resolvedShellId } = spawnPty(projectDir, terminal.shellId);
+  terminal.process = pty;
+  terminal.shellId = resolvedShellId;
+  terminal.output = [];
+  terminal.outputSize = 0;
+  terminal.sequence = 0;
+  terminal.exited = false;
+  terminal.exitCode = undefined;
+  attachHandlers(terminalId, projectDir, onData, onExit);
   return publicSession(terminal);
 }
 
diff --git a/apps/desktop/src/preload/index.ts b/apps/desktop/src/preload/index.ts
index dd1e66c..682ae86 100644
--- a/apps/desktop/src/preload/index.ts
+++ b/apps/desktop/src/preload/index.ts
@@ -37,6 +37,7 @@ const allowedEvents: Record<HostEventName, true> = {
   quitRequested: true,
   terminalData: true,
   terminalExit: true,
+  terminalRestart: true,
   tuiFrame: true,
 };
 
diff --git a/apps/desktop/src/renderer/components/TerminalDock.tsx b/apps/desktop/src/renderer/components/TerminalDock.tsx
index 8239d29..9e8788e 100644
--- a/apps/desktop/src/renderer/components/TerminalDock.tsx
+++ b/apps/desktop/src/renderer/components/TerminalDock.tsx
@@ -1,13 +1,19 @@
 import { useEffect, useRef, useState } from "react";
 import { FitAddon } from "@xterm/addon-fit";
 import { Terminal } from "@xterm/xterm";
+import { CaretDownIcon } from "@phosphor-icons/react/CaretDown";
+import { CheckIcon } from "@phosphor-icons/react/Check";
 import { SplitHorizontalIcon } from "@phosphor-icons/react/SplitHorizontal";
 import { TerminalWindowIcon } from "@phosphor-icons/react/TerminalWindow";
 import { TrashIcon } from "@phosphor-icons/react/Trash";
 import { XIcon } from "@phosphor-icons/react/X";
-import type { TerminalSession } from "../../shared/rpc-schema.ts";
+import { toast } from "sonner";
+import type { ShellProfile, TerminalSession } from "../../shared/rpc-schema.ts";
+import { findTerminalLinks } from "../lib/terminalLinks.ts";
 import { useAppStore } from "../lib/store.ts";
 import { Button } from "@/components/ui/button.tsx";
+import { Input } from "@/components/ui/input.tsx";
+import { Menu, MenuItem, MenuPopup, MenuTrigger } from "@/components/ui/menu.tsx";
 import { ResizableHandle, ResizablePanel, ResizablePanelGroup } from "@/components/ui/resizable.tsx";
 import { rpc } from "@/lib/rpc.ts";
 import {
@@ -18,6 +24,29 @@ import {
   ContextMenuTrigger,
 } from "@/components/ui/context-menu.tsx";
 
+function columnForTextOffset(line: { length: number; getCell(index: number): { getChars(): string; getWidth(): number } | undefined }, offset: number) {
+  let textOffset = 0;
+  for (let index = 0; index < line.length; index += 1) {
+    const cell = line.getCell(index);
+    const chars = cell?.getChars() ?? "";
+    if (!chars) continue;
+    if (textOffset >= offset) return index + 1;
+    textOffset += chars.length;
+    if (textOffset >= offset) return index + cell!.getWidth();
+  }
+  return line.length;
+}
+
+function updateWorkingDirectory(cwdRef: { current: string }, controlRef: { current: string }, data: string) {
+  const control = `${controlRef.current}${data}`;
+  for (const match of control.matchAll(/\x1b]7;file:\/\/[^/]*([^\x07\x1b]*)(?:\x07|\x1b\\)/g)) {
+    try {
+      cwdRef.current = decodeURIComponent(match[1]).replace(/^\/([A-Za-z]:)/, "$1");
+    } catch {}
+  }
+  controlRef.current = control.slice(-4096);
+}
+
 export default function TerminalDock({
   projectDir,
   onMinimize,
@@ -26,12 +55,15 @@ export default function TerminalDock({
   onMinimize: () => void;
 }) {
   const [terminals, setTerminals] = useState<TerminalSession[]>([]);
+  const [shells, setShells] = useState<ShellProfile[]>([]);
   const [error, setError] = useState<string | null>(null);
   const [closing, setClosing] = useState(false);
+  const preferredShellId = useAppStore((s) => s.preferences.preferredShellId);
+  const setPreference = useAppStore((s) => s.setPreference);
 
   useEffect(() => {
     let cancelled = false;
-    void rpc.request.terminalEnsure({ projectDir }).then(
+    void rpc.request.terminalEnsure({ projectDir, shellId: preferredShellId || undefined }).then(
       ({ terminals: next }) => {
         if (!cancelled) setTerminals(next);
       },
@@ -39,6 +71,12 @@ export default function TerminalDock({
         if (!cancelled) setError(reason instanceof Error ? reason.message : String(reason));
       },
     );
+    void rpc.request.terminalListShells({}).then(
+      ({ shells: next }) => {
+        if (!cancelled) setShells(next);
+      },
+      () => {},
+    );
     const offExit = rpc.events.on("terminalExit", ({ projectDir: exitedProject, terminalId, exitCode }) => {
       if (exitedProject !== projectDir) return;
       setTerminals((current) =>
@@ -47,21 +85,52 @@ export default function TerminalDock({
         ),
       );
     });
+    const offRestart = rpc.events.on("terminalRestart", ({ projectDir: restartedProject, terminal }) => {
+      if (restartedProject !== projectDir) return;
+      setTerminals((current) => current.map((session) => (session.id === terminal.id ? terminal : session)));
+    });
     return () => {
       cancelled = true;
       offExit();
+      offRestart();
     };
-  }, [projectDir]);
+  }, [projectDir, preferredShellId]);
 
-  async function addSplit() {
+  async function addSplit(shellId?: string, name?: string) {
     try {
-      const { terminal } = await rpc.request.terminalCreate({ projectDir });
+      const { terminal } = await rpc.request.terminalCreate({ projectDir, shellId, name });
       setTerminals((current) => [...current, terminal]);
     } catch (reason) {
       setError(reason instanceof Error ? reason.message : String(reason));
     }
   }
 
+  async function duplicateSplit(session: TerminalSession) {
+    await addSplit(session.shellId, `${session.name} copy`);
+  }
+
+  async function restartSplit(terminalId: string) {
+    try {
+      const { terminal } = await rpc.request.terminalRestart({ projectDir, terminalId });
+      setTerminals((current) => current.map((session) => (session.id === terminalId ? terminal : session)));
+    } catch (reason) {
+      toast.error(reason instanceof Error ? reason.message : String(reason));
+    }
+  }
+
+  async function renameSplit(terminalId: string, name: string) {
+    const trimmed = name.trim();
+    if (!trimmed) return;
+    setTerminals((current) =>
+      current.map((session) => (session.id === terminalId ? { ...session, name: trimmed } : session)),
+    );
+    try {
+      await rpc.request.terminalRename({ projectDir, terminalId, name: trimmed });
+    } catch (reason) {
+      toast.error(reason instanceof Error ? reason.message : String(reason));
+    }
+  }
+
   async function closeSplit(terminalId: string) {
     if (closing) return;
     setClosing(true);
@@ -100,15 +169,12 @@ export default function TerminalDock({
         <ContextMenuTrigger render={<header className="flex min-h-8 shrink-0 items-center gap-2 border-b bg-sidebar/40 px-2" />}>
         <TerminalWindowIcon aria-hidden="true" className="shrink-0 text-muted-foreground" />
         <span className="flex-1 text-xs font-medium">Terminal</span>
-        <Button
-          variant="ghost"
-          size="icon-xs"
-          onClick={() => void addSplit()}
-          title="Split terminal"
-          aria-label="Split terminal"
-        >
-          <SplitHorizontalIcon />
-        </Button>
+        <ShellSplitButton
+          shells={shells}
+          preferredShellId={preferredShellId}
+          onChoose={(shellId) => setPreference("preferredShellId", shellId)}
+          onSplit={(shellId) => void addSplit(shellId)}
+        />
         <Button
           variant="ghost"
           size="icon-xs"
@@ -123,16 +189,16 @@ export default function TerminalDock({
           <XIcon />
         </Button>
         </ContextMenuTrigger>
-        <TerminalChromeMenu addSplit={addSplit} closeAll={closeAll} closing={closing} />
+        <TerminalChromeMenu addSplit={() => void addSplit(preferredShellId || undefined)} closeAll={closeAll} closing={closing} />
       </ContextMenu>
 
       {error ? (
         <div role="alert" className="flex min-h-0 flex-1 items-center justify-center px-4 text-sm text-destructive">
-          Could not start PowerShell: {error}
+          Could not start a shell: {error}
         </div>
       ) : terminals.length === 0 ? (
         <div className="flex min-h-0 flex-1 items-center justify-center text-xs text-muted-foreground" role="status">
-          Starting PowerShell…
+          Starting a shell…
         </div>
       ) : (
         <ResizablePanelGroup orientation="horizontal">
@@ -143,13 +209,13 @@ export default function TerminalDock({
               projectDir={projectDir}
               defaultSize={`${100 / terminals.length}%`}
               showHandle={index > 0}
-              // A single terminal needs no chrome: the dock header already names it
-              // and can close it. Splits do, or an individual split cannot be closed.
-              showChrome={terminals.length > 1}
               closing={closing}
               onClose={() => void closeSplit(terminal.id)}
-              onSplit={addSplit}
+              onSplit={() => void addSplit(preferredShellId || undefined)}
               onCloseAll={closeAll}
+              onDuplicate={() => void duplicateSplit(terminal)}
+              onRestart={() => void restartSplit(terminal.id)}
+              onRename={(name) => void renameSplit(terminal.id, name)}
             />
           ))}
         </ResizablePanelGroup>
@@ -158,74 +224,201 @@ export default function TerminalDock({
   );
 }
 
+function ShellSplitButton({
+  shells,
+  preferredShellId,
+  onChoose,
+  onSplit,
+}: {
+  shells: ShellProfile[];
+  preferredShellId: string;
+  onChoose: (shellId: string) => void;
+  onSplit: (shellId?: string) => void;
+}) {
+  if (shells.length === 0) {
+    return (
+      <Button variant="ghost" size="icon-xs" onClick={() => onSplit()} title="Split terminal" aria-label="Split terminal">
+        <SplitHorizontalIcon />
+      </Button>
+    );
+  }
+  const selected = shells.find((shell) => shell.id === preferredShellId);
+  return (
+    <div className="flex items-center">
+      <Button
+        variant="ghost"
+        size="icon-xs"
+        onClick={() => onSplit(preferredShellId || undefined)}
+        title={selected ? `Split terminal (${selected.name})` : "Split terminal"}
+        aria-label="Split terminal"
+      >
+        <SplitHorizontalIcon />
+      </Button>
+      <Menu>
+        <MenuTrigger
+          render={<Button variant="ghost" size="icon-xs" className="px-0" />}
+          title="Choose a shell"
+          aria-label="Choose a shell"
+        >
+          <CaretDownIcon />
+        </MenuTrigger>
+        <MenuPopup align="end" className="min-w-44">
+          {shells.map((shell) => (
+            <MenuItem
+              key={shell.id}
+              role="menuitemradio"
+              aria-checked={shell.id === preferredShellId}
+              onClick={() => onChoose(shell.id)}
+              className="text-sm"
+            >
+              <span className="min-w-0 flex-1 truncate">{shell.name}</span>
+              {shell.id === preferredShellId ? <CheckIcon className="ml-auto" aria-hidden /> : null}
+            </MenuItem>
+          ))}
+        </MenuPopup>
+      </Menu>
+    </div>
+  );
+}
+
 function TerminalSplit({
   session,
   projectDir,
   defaultSize,
   showHandle,
-  showChrome,
   closing,
   onClose,
   onSplit,
   onCloseAll,
+  onDuplicate,
+  onRestart,
+  onRename,
 }: {
   session: TerminalSession;
   projectDir: string;
   defaultSize: string;
   showHandle: boolean;
-  showChrome: boolean;
   closing: boolean;
   onClose: () => void;
-  onSplit: () => Promise<void>;
+  onSplit: () => void;
   onCloseAll: () => Promise<void>;
+  onDuplicate: () => void;
+  onRestart: () => void;
+  onRename: (name: string) => void;
 }) {
+  const [editingName, setEditingName] = useState(false);
+
   return (
     <>
       {showHandle ? <ResizableHandle className="hover:bg-ring focus-visible:bg-ring" /> : null}
       <ResizablePanel id={session.id} defaultSize={defaultSize}>
         <div className="flex h-full min-h-0 flex-col">
-          {showChrome ? (
-            <ContextMenu>
-              <ContextMenuTrigger render={<div className="flex min-h-7 shrink-0 items-center justify-end border-b px-2" />}>
+          <ContextMenu>
+            <ContextMenuTrigger render={<div className="flex min-h-7 shrink-0 items-center gap-1.5 border-b px-2" />}>
+              <StatusDot session={session} />
+              {editingName ? (
+                <Input
+                  autoFocus
+                  defaultValue={session.name}
+                  className="h-5 flex-1 px-1 text-xs"
+                  onBlur={(event) => {
+                    onRename(event.currentTarget.value);
+                    setEditingName(false);
+                  }}
+                  onKeyDown={(event) => {
+                    if (event.key === "Enter") event.currentTarget.blur();
+                    if (event.key === "Escape") setEditingName(false);
+                  }}
+                />
+              ) : (
+                <button
+                  type="button"
+                  className="min-w-0 flex-1 truncate text-left text-xs font-medium"
+                  onClick={() => setEditingName(true)}
+                  title={session.exited ? `${session.name} — exited (code ${session.exitCode ?? "unknown"})` : session.name}
+                >
+                  {session.name}
+                </button>
+              )}
               <Button variant="ghost" size="icon-xs" onClick={onClose} disabled={closing} title="Close terminal" aria-label="Close terminal">
                 <XIcon />
               </Button>
-              </ContextMenuTrigger>
-              <TerminalChromeMenu addSplit={onSplit} close={onClose} closeAll={onCloseAll} closing={closing} />
-            </ContextMenu>
-          ) : null}
-          <TerminalSurface session={session} projectDir={projectDir} onSplit={onSplit} onClose={onClose} onCloseAll={onCloseAll} closing={closing} />
+            </ContextMenuTrigger>
+            <TerminalChromeMenu
+              addSplit={onSplit}
+              close={onClose}
+              closeAll={onCloseAll}
+              closing={closing}
+              onDuplicate={onDuplicate}
+              onRestart={onRestart}
+              onRename={() => setEditingName(true)}
+            />
+          </ContextMenu>
+          <TerminalSurface
+            session={session}
+            projectDir={projectDir}
+            onSplit={onSplit}
+            onClose={onClose}
+            onCloseAll={onCloseAll}
+            onDuplicate={onDuplicate}
+            onRestart={onRestart}
+            closing={closing}
+          />
         </div>
       </ResizablePanel>
     </>
   );
 }
 
+function StatusDot({ session }: { session: TerminalSession }) {
+  if (!session.exited) {
+    return <span className="size-1.5 shrink-0 rounded-full bg-success" aria-hidden="true" />;
+  }
+  const failed = (session.exitCode ?? 0) !== 0;
+  return (
+    <span
+      className={`size-1.5 shrink-0 rounded-full ${failed ? "bg-destructive" : "bg-muted-foreground"}`}
+      role="status"
+      aria-label={`Exited with code ${session.exitCode ?? "unknown"}`}
+      title={`Exited (code ${session.exitCode ?? "unknown"})`}
+    />
+  );
+}
+
 function TerminalSurface({
   session,
   projectDir,
   onSplit,
   onClose,
   onCloseAll,
+  onDuplicate,
+  onRestart,
   closing,
 }: {
   session: TerminalSession;
   projectDir: string;
-  onSplit: () => Promise<void>;
+  onSplit: () => void;
   onClose: () => void;
   onCloseAll: () => Promise<void>;
+  onDuplicate: () => void;
+  onRestart: () => void;
   closing: boolean;
 }) {
   const containerRef = useRef<HTMLDivElement>(null);
   const terminalRef = useRef<Terminal | null>(null);
+  const cwdRef = useRef(projectDir);
+  const controlRef = useRef("");
   const [selection, setSelection] = useState("");
   const fontSize = useAppStore((s) => s.preferences.terminalFontSize);
   const scrollback = useAppStore((s) => s.preferences.terminalScrollback);
   const cursorBlink = useAppStore((s) => s.preferences.terminalCursorBlink);
+  const preferredEditorId = useAppStore((s) => s.preferences.preferredEditorId);
 
   useEffect(() => {
     const container = containerRef.current;
     if (!container) return;
+    cwdRef.current = projectDir;
+    controlRef.current = "";
 
     const styles = getComputedStyle(document.documentElement);
     const terminal = new Terminal({
@@ -262,18 +455,49 @@ function TerminalSurface({
     terminal.loadAddon(fit);
     terminal.open(container);
 
+    const linkProvider = terminal.registerLinkProvider({
+      provideLinks(bufferLineNumber, callback) {
+        const line = terminal.buffer.active.getLine(bufferLineNumber - 1);
+        if (!line) return callback(undefined);
+        const text = line.translateToString(true);
+        const found = findTerminalLinks(text);
+        if (found.length === 0) return callback(undefined);
+        callback(
+          found.map((match) => ({
+            text: text.slice(match.start, match.end),
+            range: {
+              start: { x: columnForTextOffset(line, match.start), y: bufferLineNumber },
+              end: { x: columnForTextOffset(line, match.end), y: bufferLineNumber },
+            },
+            activate: () => {
+              if (match.kind === "url") {
+                void rpc.request.openExternal({ url: match.url });
+                return;
+              }
+              void rpc.request
+                .openFileIn({ projectDir: cwdRef.current, file: match.file, editorId: preferredEditorId, line: match.line, column: match.column })
+                .then((result) => {
+                  if (!result.ok) toast.error(result.error ?? `Could not open ${match.file}.`);
+                });
+            },
+          })),
+        );
+      },
+    });
+
     let disposed = false;
     let snapshotSequence = -1;
     let live = false;
     const pending: { data: string; sequence: number }[] = [];
     const offData = rpc.events.on("terminalData", (payload) => {
       if (payload.projectDir !== projectDir || payload.terminalId !== session.id) return;
+      updateWorkingDirectory(cwdRef, controlRef, payload.data);
       if (live) terminal.write(payload.data);
       else pending.push(payload);
     });
     const offExit = rpc.events.on("terminalExit", (payload) => {
       if (payload.projectDir !== projectDir || payload.terminalId !== session.id) return;
-      terminal.write(`\r\n[PowerShell exited with code ${payload.exitCode}]\r\n`);
+      terminal.write(`\r\n[Process exited with code ${payload.exitCode}]\r\n`);
     });
     const input = terminal.onData((data) => {
       void rpc.request.terminalWrite({ projectDir, terminalId: session.id, data });
@@ -283,12 +507,16 @@ function TerminalSurface({
       ({ output, sequence }) => {
         if (disposed) return;
         snapshotSequence = sequence;
+        updateWorkingDirectory(cwdRef, controlRef, output);
         terminal.write(output);
         for (const item of pending) {
-          if (item.sequence > snapshotSequence) terminal.write(item.data);
+          if (item.sequence > snapshotSequence) {
+            updateWorkingDirectory(cwdRef, controlRef, item.data);
+            terminal.write(item.data);
+          }
         }
         live = true;
-        if (session.exited) terminal.write(`\r\n[PowerShell exited with code ${session.exitCode ?? "unknown"}]\r\n`);
+        if (session.exited) terminal.write(`\r\n[Process exited with code ${session.exitCode ?? "unknown"}]\r\n`);
       },
       () => {},
     );
@@ -317,6 +545,7 @@ function TerminalSurface({
       cancelAnimationFrame(frame);
       observer.disconnect();
       input.dispose();
+      linkProvider.dispose();
       offData();
       offExit();
       terminal.dispose();
@@ -325,8 +554,9 @@ function TerminalSurface({
     // A preference change rebuilds the surface rather than mutating the live
     // terminal's options. The pty and its output live in the main process, and
     // the snapshot above restores the scrollback, so a rebuild is invisible —
-    // the same path a project switch already takes.
-  }, [projectDir, session, fontSize, scrollback, cursorBlink]);
+    // the same path a project switch already takes. A restart bumps `session`
+    // (a new object from the main process) for the same reason.
+  }, [projectDir, session, fontSize, scrollback, cursorBlink, preferredEditorId]);
 
   return (
     <ContextMenu>
@@ -352,7 +582,9 @@ function TerminalSurface({
           Clear terminal
         </ContextMenuItem>
         <ContextMenuSeparator />
-        <ContextMenuItem onClick={() => void onSplit()}>Split terminal</ContextMenuItem>
+        <ContextMenuItem onClick={onSplit}>Split terminal</ContextMenuItem>
+        <ContextMenuItem onClick={onDuplicate}>Duplicate terminal</ContextMenuItem>
+        <ContextMenuItem onClick={onRestart}>Restart terminal</ContextMenuItem>
         <ContextMenuItem disabled={closing} onClick={onClose}>Close this terminal</ContextMenuItem>
         <ContextMenuItem disabled={closing} onClick={() => void onCloseAll()}>Kill all terminals</ContextMenuItem>
       </ContextMenuContent>
@@ -365,15 +597,24 @@ function TerminalChromeMenu({
   close,
   closeAll,
   closing,
+  onDuplicate,
+  onRestart,
+  onRename,
 }: {
-  addSplit: () => Promise<void>;
+  addSplit: () => void;
   close?: () => void;
   closeAll: () => Promise<void>;
   closing: boolean;
+  onDuplicate?: () => void;
+  onRestart?: () => void;
+  onRename?: () => void;
 }) {
   return (
     <ContextMenuContent className="w-48">
-      <ContextMenuItem onClick={() => void addSplit()}>Split terminal</ContextMenuItem>
+      <ContextMenuItem onClick={addSplit}>Split terminal</ContextMenuItem>
+      {onRename ? <ContextMenuItem onClick={onRename}>Rename</ContextMenuItem> : null}
+      {onDuplicate ? <ContextMenuItem onClick={onDuplicate}>Duplicate terminal</ContextMenuItem> : null}
+      {onRestart ? <ContextMenuItem onClick={onRestart}>Restart terminal</ContextMenuItem> : null}
       {close ? <ContextMenuItem disabled={closing} onClick={close}>Close this terminal</ContextMenuItem> : null}
       <ContextMenuItem disabled={closing} onClick={() => void closeAll()}>Kill all terminals</ContextMenuItem>
     </ContextMenuContent>
diff --git a/apps/desktop/src/renderer/lib/rpc.ts b/apps/desktop/src/renderer/lib/rpc.ts
index 4a6e299..b5b5ddf 100644
--- a/apps/desktop/src/renderer/lib/rpc.ts
+++ b/apps/desktop/src/renderer/lib/rpc.ts
@@ -98,6 +98,7 @@ const allowedEvents: Record<HostEventName, true> = {
   quitRequested: true,
   terminalData: true,
   terminalExit: true,
+  terminalRestart: true,
   tuiFrame: true,
 };
 
diff --git a/apps/desktop/src/renderer/lib/terminalLinks.test.ts b/apps/desktop/src/renderer/lib/terminalLinks.test.ts
new file mode 100644
index 0000000..6dc46f5
--- /dev/null
+++ b/apps/desktop/src/renderer/lib/terminalLinks.test.ts
@@ -0,0 +1,36 @@
+import { expect, test } from "bun:test";
+import { findTerminalLinks } from "./terminalLinks.ts";
+
+test("links a path with a line and column", () => {
+  const [match] = findTerminalLinks("  at src/main.ts:42:5");
+
+  expect(match).toEqual({ start: 5, end: 21, kind: "file", file: "src/main.ts", line: 42, column: 5 });
+});
+
+test("links a bare code filename without a path separator", () => {
+  const [match] = findTerminalLinks("error in App.tsx:10");
+
+  expect(match?.kind).toBe("file");
+});
+
+test("does not link an ordinary host:port that is not a file", () => {
+  expect(findTerminalLinks("connecting to example.com:8080")).toEqual([]);
+});
+
+test("links a localhost URL and does not also link its port as a file", () => {
+  const matches = findTerminalLinks("Server running at http://localhost:3000/app");
+
+  expect(matches).toEqual([
+    { start: 18, end: 43, kind: "url", url: "http://localhost:3000/app" },
+  ]);
+});
+
+test("links 127.0.0.1 the same as localhost", () => {
+  const [match] = findTerminalLinks("http://127.0.0.1:8080");
+
+  expect(match).toEqual({ start: 0, end: 21, kind: "url", url: "http://127.0.0.1:8080" });
+});
+
+test("ignores a non-localhost URL", () => {
+  expect(findTerminalLinks("https://example.com")).toEqual([]);
+});
diff --git a/apps/desktop/src/renderer/lib/terminalLinks.ts b/apps/desktop/src/renderer/lib/terminalLinks.ts
new file mode 100644
index 0000000..f6668fa
--- /dev/null
+++ b/apps/desktop/src/renderer/lib/terminalLinks.ts
@@ -0,0 +1,74 @@
+/**
+ * Recognizes two kinds of clickable spans in a line of terminal output:
+ * `path/to/file.ts:12` (optionally `:12:5`) and `http(s)://localhost[:port]/...`.
+ *
+ * Kept separate from the xterm link provider that calls it so the matching
+ * logic is a plain, testable function over strings.
+ */
+
+const CODE_EXTENSIONS = new Set([
+  "ts", "tsx", "js", "jsx", "mjs", "cjs", "mts", "cts", "py", "go", "rs", "rb", "java",
+  "c", "cc", "cpp", "h", "hpp", "cs", "php", "swift", "kt", "kts", "json", "yaml", "yml",
+  "toml", "md", "mdx", "txt", "log", "css", "scss", "less", "html", "htm", "sh", "bash",
+  "ps1", "psm1", "sql", "xml", "vue", "svelte",
+]);
+
+const FILE_LINE_RE = /((?:(?:[A-Za-z]:)?[\\/]|\/)?(?:[\w .-]+[\\/])*[\w .-]+\.[A-Za-z0-9]+):(\d+)(?::(\d+))?/g;
+const LOCALHOST_RE = /https?:\/\/(?:localhost|127\.0\.0\.1|\[::1\])(?::\d+)?(?:\/[^\s"'<>)\]]*)?/g;
+
+export interface FileLinkMatch {
+  start: number;
+  end: number;
+  kind: "file";
+  file: string;
+  line: number;
+  column?: number;
+}
+
+export interface UrlLinkMatch {
+  start: number;
+  end: number;
+  kind: "url";
+  url: string;
+}
+
+export type TerminalLinkMatch = FileLinkMatch | UrlLinkMatch;
+
+export function findTerminalLinks(text: string): TerminalLinkMatch[] {
+  const matches: TerminalLinkMatch[] = [];
+  const urlRanges: [number, number][] = [];
+
+  LOCALHOST_RE.lastIndex = 0;
+  let urlMatch: RegExpExecArray | null;
+  while ((urlMatch = LOCALHOST_RE.exec(text))) {
+    const start = urlMatch.index;
+    const end = start + urlMatch[0].length;
+    urlRanges.push([start, end]);
+    matches.push({ start, end, kind: "url", url: urlMatch[0] });
+  }
+
+  FILE_LINE_RE.lastIndex = 0;
+  let fileMatch: RegExpExecArray | null;
+  while ((fileMatch = FILE_LINE_RE.exec(text))) {
+    const [full, file = "", lineStr = "", colStr] = fileMatch;
+    const stackPrefix = file.match(/^\s*at\s+/)?.[0] ?? "";
+    const linkedFile = file.slice(stackPrefix.length);
+    const start = fileMatch.index + stackPrefix.length;
+    const end = fileMatch.index + full.length;
+    // A URL's port already matched above; don't double-link the digits inside it.
+    if (urlRanges.some(([urlStart, urlEnd]) => start < urlEnd && end > urlStart)) continue;
+    const hasSeparator = /[\\/]/.test(linkedFile);
+    const extension = linkedFile.slice(linkedFile.lastIndexOf(".") + 1).toLowerCase();
+    if (!hasSeparator && !CODE_EXTENSIONS.has(extension)) continue;
+    matches.push({
+      start,
+      end,
+      kind: "file",
+      file: linkedFile,
+      line: Number(lineStr),
+      column: colStr ? Number(colStr) : undefined,
+    });
+  }
+
+  return matches.sort((a, b) => a.start - b.start);
+}
diff --git a/apps/desktop/src/shared/rpc-schema.ts b/apps/desktop/src/shared/rpc-schema.ts
index 6a93dde..7d43304 100644
--- a/apps/desktop/src/shared/rpc-schema.ts
+++ b/apps/desktop/src/shared/rpc-schema.ts
@@ -88,10 +88,18 @@ export interface PendingWork {
 export interface TerminalSession {
   id: string;
   projectDir: string;
+  name: string;
+  shellId: string;
   exited: boolean;
   exitCode?: number;
 }
 
+/** A shell executable NativePi found on this machine, offered as a profile when opening a terminal. */
+export interface ShellProfile {
+  id: string;
+  name: string;
+}
+
 export interface AuthProviderInfo {
   id: string;
   name: string;
@@ -226,6 +234,7 @@ export const preferencesSchema = z.object({
   terminalScrollback: clamped(5000, 500, 100000),
   terminalCursorBlink: z.boolean().catch(true),
   preferredEditorId: z.string().min(1).catch("explorer"),
+  preferredShellId: z.string().catch(""),
 });
 
 export type Preferences = z.infer<typeof preferencesSchema>;
@@ -423,7 +432,7 @@ export type HostRequests = {
     response: { ok: boolean; error?: string };
   };
   openFileIn: {
-    params: { projectDir: string; file: string; editorId: string };
+    params: { projectDir: string; file: string; editorId: string; line?: number; column?: number };
     response: { ok: boolean; error?: string };
   };
   versions: { params: Record<string, never>; response: { pi: string; app: string } };
@@ -458,8 +467,20 @@ export type HostRequests = {
     response: { ok: boolean; path?: string; canceled?: boolean; error?: string };
   };
 
-  terminalEnsure: { params: { projectDir: string }; response: { terminals: TerminalSession[] } };
-  terminalCreate: { params: { projectDir: string }; response: { terminal: TerminalSession } };
+  terminalEnsure: { params: { projectDir: string; shellId?: string }; response: { terminals: TerminalSession[] } };
+  terminalCreate: {
+    params: { projectDir: string; shellId?: string; name?: string };
+    response: { terminal: TerminalSession };
+  };
+  terminalListShells: { params: Record<string, never>; response: { shells: ShellProfile[] } };
+  terminalRename: {
+    params: { projectDir: string; terminalId: string; name: string };
+    response: { ok: boolean };
+  };
+  terminalRestart: {
+    params: { projectDir: string; terminalId: string };
+    response: { terminal: TerminalSession };
+  };
   terminalSnapshot: {
     params: { projectDir: string; terminalId: string };
     response: { output: string; sequence: number };
@@ -584,6 +605,7 @@ export type HostEvents = {
   quitRequested: { work: PendingWork };
   terminalData: { projectDir: string; terminalId: string; data: string; sequence: number };
   terminalExit: { projectDir: string; terminalId: string; exitCode: number };
+  terminalRestart: { projectDir: string; terminal: TerminalSession };
   /** A pi-tui surface opening, drawing, closing, or reporting extension UI state. */
   tuiFrame: { projectDir: string; sessionFile?: string; frame: TuiHostFrame };
 };