@couralabs/claudin 0.1.3 → 0.1.5

package/claudin.js

@@ -6148,6 +6148,7 @@ var agentRequestSchemas = [
   object({ type: literal("agent.prompt.queue.requested"), agentSessionId, content }),
   object({ type: literal("agent.prompt.steer.requested"), agentSessionId, content }),
   object({ type: literal("agent.prompt.cancel.requested"), agentSessionId }),
+  object({ type: literal("agent.task.stop.requested"), agentSessionId, taskId: string2() }),
   object({
     type: literal("agent.tool.approval.answered"),
     agentSessionId,
@@ -6161,7 +6162,6 @@ var agentRequestSchemas = [
     answers: record(string2(), string2())
   }),
   object({ type: literal("agent.model.set.requested"), agentSessionId, model: string2() }),
-  object({ type: literal("agent.model.cycle.requested"), agentSessionId }),
   object({
     type: literal("agent.permission_mode.set.requested"),
     agentSessionId,
@@ -6175,6 +6175,17 @@ var agentRequestSchemas = [
   object({ type: literal("agent.commands.requested"), agentSessionId }),
   object({ type: literal("agent.models.requested"), agentSessionId }),
   object({ type: literal("agent.mcp.status.requested"), agentSessionId }),
+  object({
+    type: literal("agent.mcp.login.requested"),
+    agentSessionId,
+    serverName: string2()
+  }),
+  object({
+    type: literal("agent.mcp.callback.submitted"),
+    agentSessionId,
+    serverName: string2(),
+    callbackUrl: string2()
+  }),
   object({ type: literal("agent.usage.requested"), agentSessionId }),
   object({ type: literal("agent.rate_limit.requested"), agentSessionId }),
   object({ type: literal("agent.rate_limit.cached.requested") }),
@@ -6207,6 +6218,7 @@ var createSessionState = (sessionId) => ({
   models: [],
   sessionList: [],
   queuedTurns: 0,
+  tasks: [],
   transcript: [],
   entryCounter: 0,
   now: Date.now(),
@@ -6217,7 +6229,8 @@ var createSessionState = (sessionId) => ({
     backgroundEditor: null,
     question: null,
     history: null,
-    diffViewer: null
+    diffViewer: null,
+    toast: null
   }
 });
 
@@ -6514,6 +6527,56 @@ function reduceTaskProgress(state, message) {
   return updateToolCall(state, toolUseId, (call) => ({ ...call, progress: summary }));
 }
 
+// packages/events/src/reducers/reduceTasks.ts
+var FINISHED_STATUSES = ["completed", "failed", "killed"];
+var isTaskMessage = (message) => message.type === "system" && ["task_started", "task_progress", "task_updated", "task_notification"].includes(message.subtype);
+var patchTask = (tasks, id, patch) => tasks.map((task) => task.id === id ? patch(task) : task);
+var startTask = (state, message) => {
+  if (message.ambient || message.skip_transcript)
+    return state.tasks;
+  const task = {
+    id: message.task_id,
+    kind: message.subagent_type ?? message.task_type ?? "task",
+    description: message.description,
+    startedAt: state.now,
+    tokens: 0,
+    paused: false
+  };
+  return [...state.tasks.filter(({ id }) => id !== task.id), task];
+};
+var updateTask = (tasks, message) => {
+  const { status, description } = message.patch;
+  if (status && FINISHED_STATUSES.includes(status)) {
+    return tasks.filter(({ id }) => id !== message.task_id);
+  }
+  return patchTask(tasks, message.task_id, (task) => ({
+    ...task,
+    description: description ?? task.description,
+    paused: status ? status === "paused" : task.paused
+  }));
+};
+var readTasks = (state, message) => {
+  switch (message.subtype) {
+    case "task_started":
+      return startTask(state, message);
+    case "task_progress":
+      return patchTask(state.tasks, message.task_id, (task) => ({
+        ...task,
+        lastToolName: message.last_tool_name ?? task.lastToolName,
+        summary: message.summary ?? task.summary,
+        tokens: message.usage.total_tokens
+      }));
+    case "task_updated":
+      return updateTask(state.tasks, message);
+    case "task_notification":
+      return state.tasks.filter(({ id }) => id !== message.task_id);
+  }
+};
+var reduceTasks = (state, message) => ({
+  ...state,
+  tasks: readTasks(state, message)
+});
+
 // packages/events/src/reducers/reduceToolResults.ts
 function applyResult(state, block) {
   if (block.type !== "tool_result" || !block.tool_use_id)
@@ -6531,10 +6594,10 @@ function reduceToolResults(state, message) {
 
 // packages/events/src/reducers/reduceAgentMessage.ts
 function reduceAgentMessage(state, message) {
+  if (isTaskMessage(message))
+    return reduceTaskMessage(reduceTasks(state, message), message);
   switch (message.type) {
     case "system":
-      if (message.subtype === "task_progress")
-        return reduceTaskProgress(state, message);
       if (message.subtype !== "init")
         return reduceNoticeMessage(state, message);
       return {
@@ -6560,6 +6623,15 @@ function reduceAgentMessage(state, message) {
       return reduceNoticeMessage(state, message);
   }
 }
+function reduceTaskMessage(state, message) {
+  if (message.type === "system" && message.subtype === "task_progress") {
+    return reduceTaskProgress(state, message);
+  }
+  if (message.type === "system" && message.subtype === "task_notification") {
+    return reduceNoticeMessage(state, message);
+  }
+  return state;
+}
 function reduceNoticeMessage(state, message) {
   const text = describeSystemMessage(message);
   return text ? appendNotice(state, text) : state;
@@ -6632,7 +6704,7 @@ var applyLoadedBackground = (state, background = TRANSPARENT_BACKGROUND) => ({ .
 var applySavedBackground = (state, color) => appendNotice(closeBackgroundEditor({ ...state, background: color }), "Background color saved");
 
 // packages/events/src/reducers/reduceDiffViewer.ts
-var NO_DIFFS_NOTICE = "No changes in the files this session edited";
+var NO_DIFFS_NOTICE = "No git changes or session edits to show";
 function openDiffViewer(state, files) {
   if (files.length === 0)
     return appendNotice(state, NO_DIFFS_NOTICE);
@@ -6651,7 +6723,10 @@ var closeDiffViewer = (state) => ({
 });
 
 // packages/events/src/reducers/reduceNotices.ts
-var describeServers = (servers) => servers.length === 0 ? "No MCP servers configured" : `MCP servers: ${servers.map((s) => `${s.name} (${s.status})`).join(", ")}`;
+var LOGIN_HINT = "needs-auth: sign in with /mcp login <name>";
+var describeServer = ({ name, status }) => `${name} (${status === "needs-auth" ? LOGIN_HINT.replace("<name>", name) : status})`;
+var describeServers = (servers) => servers.length === 0 ? "No MCP servers configured" : `MCP servers: ${servers.map(describeServer).join(", ")}`;
+var describeLoginStarted = (serverName, authUrl) => `Signing in to ${serverName}. If the browser did not open, visit: ${authUrl}`;
 function reduceModelChanged(state, model) {
   const changed = { ...state, model };
   return appendNotice(changed, `Model set to ${readModelLabel(changed)}`);
@@ -6703,6 +6778,13 @@ function moveQuestionCursor(state, delta) {
     return state;
   return withDraft(state, { ...question, cursor: (question.cursor + delta + size) % size });
 }
+function setQuestionCursor(state, cursor) {
+  const { question } = state.ui;
+  const current = question ? readCurrentQuestion(question) : undefined;
+  if (!question || !current || cursor < 0 || cursor > current.options.length)
+    return state;
+  return withDraft(state, { ...question, cursor });
+}
 function toggleQuestionPick(state) {
   const { question } = state.ui;
   const current = question ? readCurrentQuestion(question) : undefined;
@@ -6730,6 +6812,14 @@ function changeQuestionCustom(state, text) {
   return question ? withDraft(state, { ...question, custom: text }) : state;
 }
 
+// packages/events/src/reducers/reduceToast.ts
+var withToast = (state, toast) => ({
+  ...state,
+  ui: { ...state.ui, toast }
+});
+var postToast = (state, toast) => withToast(state, { id: toast.id, text: toast.text });
+var dismissToast = (state, id) => state.ui.toast?.id === id ? withToast(state, null) : state;
+
 // packages/events/src/reducers/reduceUi.ts
 var FOCUS_ORDER = ["input", "scrollback"];
 function cycleFocus(state, direction) {
@@ -6817,6 +6907,8 @@ function reduceUi(state, event) {
       return adjustBackgroundValue(state, event.delta);
     case "ui.question.moved":
       return moveQuestionCursor(state, event.delta);
+    case "ui.question.cursor.set":
+      return setQuestionCursor(state, event.cursor);
     case "ui.question.toggled":
       return toggleQuestionPick(state);
     case "ui.question.custom.changed":
@@ -6824,9 +6916,14 @@ function reduceUi(state, event) {
     case "ui.question.recorded":
       return recordQuestionAnswer(state, event);
     case "ui.exit.requested":
+    case "ui.title.set":
       return state;
     case "ui.notice.posted":
       return appendNotice(state, event.text);
+    case "ui.toast.posted":
+      return postToast(state, event);
+    case "ui.toast.dismissed":
+      return dismissToast(state, event.id);
     case "ui.clock.ticked":
       return { ...state, now: event.now };
   }
@@ -6847,7 +6944,8 @@ function restoreSession(state, sessionId, stored, notice) {
   return appendNotice({ ...adoptReplay(state, settled, sessionId), status: "idle", queuedTurns: 0 }, notice);
 }
 var syncSession = (state, sessionId, stored) => appendNotice(adoptReplay(state, replayEvents(sessionId, stored), sessionId), "Attached to the live session");
-function openModelPicker(state, models) {
+function openModelPicker(state, allModels) {
+  const models = allModels.filter((model) => model.value !== "default");
   const current = models.findIndex((model) => model.value === state.model);
   const picker = { kind: "model", selected: Math.max(current, 0) };
   return { ...state, models, ui: { ...state.ui, picker } };
@@ -6937,6 +7035,8 @@ function reduceSessionState(state, event) {
       return reduceModeChanged(state, event.mode);
     case "agent.mcp.status.received":
       return appendNotice(state, describeServers(event.servers));
+    case "agent.mcp.login.started":
+      return appendNotice(state, describeLoginStarted(event.serverName, event.authUrl));
     case "workspace.info.received":
       return { ...state, cwd: event.cwd, gitBranch: event.gitBranch, gitStats: event.gitStats };
     case "options.loaded":
@@ -7059,6 +7159,11 @@ var agentResponseSchemas = [
     type: literal("agent.mcp.status.received"),
     servers: sdkValue()
   }),
+  object({
+    type: literal("agent.mcp.login.started"),
+    serverName: string2(),
+    authUrl: string2()
+  }),
   object({
     type: literal("agent.usage.received"),
     usage: sdkValue()
@@ -7156,6 +7261,9 @@ var PRIVATE_TYPES = new Set([
   "agent.commands.requested",
   "agent.mcp.status.requested",
   "agent.mcp.status.received",
+  "agent.mcp.login.requested",
+  "agent.mcp.callback.submitted",
+  "agent.mcp.login.started",
   "agent.usage.requested",
   "agent.usage.received",
   "agent.rate_limit.requested",
@@ -7396,12 +7504,41 @@ import {
   getSessionMessages,
   query
 } from "@anthropic-ai/claude-agent-sdk";
+
+// packages/agent/src/runtime/muteShadowedWarning.ts
+var SHADOWED_WARNING_CODE = "CLAUDE_SDK_CAN_USE_TOOL_SHADOWED";
+function readWarningCode(args) {
+  const [first, second] = args;
+  if (typeof first === "object" && first !== null)
+    return first.code;
+  return typeof first === "string" && typeof second === "string" ? second : undefined;
+}
+function muteShadowedWarning() {
+  const original = process.emitWarning.bind(process);
+  process.emitWarning = (warning, ...args) => {
+    if (readWarningCode(args) === SHADOWED_WARNING_CODE)
+      return;
+    return original(warning, ...args);
+  };
+}
+
+// packages/agent/src/runtime/agentRuntime.ts
+muteShadowedWarning();
 var sdkRuntime = {
-  open: query,
+  open: (params) => query(params),
   getInfo: getSessionInfo,
   getMessages: getSessionMessages,
   fork: forkSession
 };
+// packages/agent/src/runtime/buildUserMessage.ts
+var isSlashCommand = (content) => readPromptText(content).trimStart().startsWith("/");
+var buildUserMessage = (content, priority) => ({
+  type: "user",
+  message: { role: "user", content },
+  parent_tool_use_id: null,
+  priority,
+  client_composed: isSlashCommand(content) ? undefined : true
+});
 // node_modules/.bun/p-defer@4.0.1/node_modules/p-defer/index.js
 function pDefer() {
   const deferred = {};
@@ -7684,6 +7821,846 @@ function _pushable(getNext, options) {
   };
   return pushable;
 }
+// packages/agent/src/mcp/waitForMcpLogin.ts
+var DEFAULT_LOGIN_WAIT = { intervalMs: 2000, timeoutMs: 180000 };
+async function waitForMcpLogin(fetchStatus, serverName, { intervalMs, timeoutMs } = DEFAULT_LOGIN_WAIT) {
+  const deadline = Date.now() + timeoutMs;
+  let servers = await fetchStatus();
+  while (Date.now() < deadline && isAwaitingLogin(servers, serverName)) {
+    await Bun.sleep(intervalMs);
+    servers = await fetchStatus();
+  }
+  return servers;
+}
+var isAwaitingLogin = (servers, serverName) => servers.some((server) => server.name === serverName && server.status === "needs-auth");
+
+// node_modules/.bun/open@11.0.4/node_modules/open/index.js
+import process9 from "process";
+import path2 from "path";
+import { fileURLToPath } from "url";
+import childProcess3 from "child_process";
+import fs5, { constants as fsConstants2 } from "fs/promises";
+
+// node_modules/.bun/wsl-utils@1.0.1/node_modules/wsl-utils/index.js
+import path from "path";
+import { promisify as promisify2 } from "util";
+import childProcess2 from "child_process";
+import fs4, { constants as fsConstants } from "fs/promises";
+
+// node_modules/.bun/is-wsl@3.1.1/node_modules/is-wsl/index.js
+import process2 from "process";
+import os from "os";
+import fs3 from "fs";
+
+// node_modules/.bun/is-inside-container@1.0.0/node_modules/is-inside-container/index.js
+import fs2 from "fs";
+
+// node_modules/.bun/is-docker@3.0.0/node_modules/is-docker/index.js
+import fs from "fs";
+var isDockerCached;
+function hasDockerEnv() {
+  try {
+    fs.statSync("/.dockerenv");
+    return true;
+  } catch {
+    return false;
+  }
+}
+function hasDockerCGroup() {
+  try {
+    return fs.readFileSync("/proc/self/cgroup", "utf8").includes("docker");
+  } catch {
+    return false;
+  }
+}
+function isDocker() {
+  if (isDockerCached === undefined) {
+    isDockerCached = hasDockerEnv() || hasDockerCGroup();
+  }
+  return isDockerCached;
+}
+
+// node_modules/.bun/is-inside-container@1.0.0/node_modules/is-inside-container/index.js
+var cachedResult;
+var hasContainerEnv = () => {
+  try {
+    fs2.statSync("/run/.containerenv");
+    return true;
+  } catch {
+    return false;
+  }
+};
+function isInsideContainer() {
+  if (cachedResult === undefined) {
+    cachedResult = hasContainerEnv() || isDocker();
+  }
+  return cachedResult;
+}
+
+// node_modules/.bun/is-wsl@3.1.1/node_modules/is-wsl/index.js
+var isWsl = () => {
+  if (process2.platform !== "linux") {
+    return false;
+  }
+  if (os.release().toLowerCase().includes("microsoft")) {
+    if (isInsideContainer()) {
+      return false;
+    }
+    return true;
+  }
+  try {
+    if (fs3.readFileSync("/proc/version", "utf8").toLowerCase().includes("microsoft")) {
+      return !isInsideContainer();
+    }
+  } catch {}
+  if (fs3.existsSync("/proc/sys/fs/binfmt_misc/WSLInterop") || fs3.existsSync("/run/WSL")) {
+    return !isInsideContainer();
+  }
+  return false;
+};
+var is_wsl_default = process2.env.__IS_WSL_TEST__ ? isWsl : isWsl();
+
+// node_modules/.bun/powershell-utils@0.2.1/node_modules/powershell-utils/index.js
+import process3 from "process";
+import { Buffer as Buffer2 } from "buffer";
+import { promisify } from "util";
+import childProcess from "child_process";
+var execFile = promisify(childProcess.execFile);
+var powerShellPath = () => `${process3.env.SYSTEMROOT || process3.env.windir || String.raw`C:\Windows`}\\System32\\WindowsPowerShell\\v1.0\\powershell.exe`;
+var argumentsPrefix = [
+  "-NoProfile",
+  "-NonInteractive",
+  "-ExecutionPolicy",
+  "Bypass",
+  "-EncodedCommand"
+];
+var encodeCommand = (command) => Buffer2.from(command, "utf16le").toString("base64");
+var escapeArgument = (value) => `'${String(value).replaceAll(/['\u2018\u2019\u201A\u201B]/g, (match) => match + match)}'`;
+var createArguments = (command) => [...argumentsPrefix, encodeCommand(command)];
+var createExecFileOptions = (options) => ({
+  encoding: "utf8",
+  ...options,
+  shell: false
+});
+var executePowerShell = async (command, options = {}) => {
+  const {
+    powerShellPath: psPath,
+    ...execFileOptions
+  } = options;
+  return execFile(psPath ?? powerShellPath(), createArguments(command), createExecFileOptions(execFileOptions));
+};
+executePowerShell.argumentsPrefix = argumentsPrefix;
+executePowerShell.encodeCommand = encodeCommand;
+executePowerShell.escapeArgument = escapeArgument;
+executePowerShell.createArguments = createArguments;
+
+// node_modules/.bun/wsl-utils@1.0.1/node_modules/wsl-utils/utilities.js
+function parseMountPointFromConfig(content) {
+  for (const line of content.split(`
+`)) {
+    if (/^\s*#/.test(line)) {
+      continue;
+    }
+    const match = /^\s*root\s*=\s*(?<mountPoint>"[^"]*"|'[^']*'|[^#]*)/.exec(line);
+    if (!match) {
+      continue;
+    }
+    return match.groups.mountPoint.trim().replaceAll(/^["']|["']$/g, "");
+  }
+}
+
+// node_modules/.bun/wsl-utils@1.0.1/node_modules/wsl-utils/index.js
+var execFile2 = promisify2(childProcess2.execFile);
+var wslDrivesMountPoint = (() => {
+  const defaultMountPoint = "/mnt/";
+  let mountPoint;
+  return async function() {
+    if (mountPoint) {
+      return mountPoint;
+    }
+    const configFilePath = "/etc/wsl.conf";
+    let isConfigFileExists = false;
+    try {
+      await fs4.access(configFilePath, fsConstants.F_OK);
+      isConfigFileExists = true;
+    } catch {}
+    if (!isConfigFileExists) {
+      return defaultMountPoint;
+    }
+    const configContent = await fs4.readFile(configFilePath, { encoding: "utf8" });
+    const parsedMountPoint = parseMountPointFromConfig(configContent);
+    if (parsedMountPoint === undefined) {
+      return defaultMountPoint;
+    }
+    mountPoint = parsedMountPoint;
+    mountPoint = mountPoint.endsWith("/") ? mountPoint : `${mountPoint}/`;
+    return mountPoint;
+  };
+})();
+var powerShellPathFromWsl = async () => {
+  const mountPoint = await wslDrivesMountPoint();
+  return `${mountPoint}c/Windows/System32/WindowsPowerShell/v1.0/powershell.exe`;
+};
+var powerShellPath2 = is_wsl_default ? powerShellPathFromWsl : powerShellPath;
+var canAccessPowerShellPromise;
+var canAccessPowerShell = async () => {
+  canAccessPowerShellPromise ??= (async () => {
+    try {
+      const psPath = await powerShellPath2();
+      await fs4.access(psPath, fsConstants.X_OK);
+      return true;
+    } catch {
+      return false;
+    }
+  })();
+  return canAccessPowerShellPromise;
+};
+var wslDefaultBrowser = async () => {
+  const psPath = await powerShellPath2();
+  const command = String.raw`(Get-ItemProperty -Path "HKCU:\Software\Microsoft\Windows\Shell\Associations\UrlAssociations\http\UserChoice").ProgId`;
+  const { stdout } = await executePowerShell(command, {
+    powerShellPath: psPath,
+    cwd: path.dirname(psPath)
+  });
+  return stdout.trim();
+};
+var isUrl = (path2) => /^[a-z]+:\/\//i.test(path2);
+var convertPath = async (flag, path2) => {
+  const wslpathArguments = path2.startsWith("-") ? [flag, "--", path2] : [flag, path2];
+  try {
+    const { stdout } = await execFile2("wslpath", wslpathArguments, { encoding: "utf8" });
+    return stdout.replace(/\r?\n$/, "") || path2;
+  } catch {
+    return path2;
+  }
+};
+var convertWslPathToWindows = async (paths) => {
+  const isBatch = Array.isArray(paths);
+  const pathArray = isBatch ? paths : [paths];
+  const results = await Promise.all(pathArray.map((path2) => isUrl(path2) ? path2 : convertPath("-aw", path2)));
+  return isBatch ? results : results[0];
+};
+
+// node_modules/.bun/define-lazy-prop@3.0.0/node_modules/define-lazy-prop/index.js
+function defineLazyProperty(object, propertyName, valueGetter) {
+  const define = (value) => Object.defineProperty(object, propertyName, { value, enumerable: true, writable: true });
+  Object.defineProperty(object, propertyName, {
+    configurable: true,
+    enumerable: true,
+    get() {
+      const result = valueGetter();
+      define(result);
+      return result;
+    },
+    set(value) {
+      define(value);
+    }
+  });
+  return object;
+}
+
+// node_modules/.bun/default-browser@5.5.1/node_modules/default-browser/index.js
+import { promisify as promisify6 } from "util";
+import process7 from "process";
+import { execFile as execFile6 } from "child_process";
+
+// node_modules/.bun/default-browser-id@5.0.1/node_modules/default-browser-id/index.js
+import { promisify as promisify3 } from "util";
+import process4 from "process";
+import { execFile as execFile3 } from "child_process";
+var execFileAsync = promisify3(execFile3);
+async function defaultBrowserId() {
+  if (process4.platform !== "darwin") {
+    throw new Error("macOS only");
+  }
+  const { stdout } = await execFileAsync("defaults", ["read", "com.apple.LaunchServices/com.apple.launchservices.secure", "LSHandlers"]);
+  const match = /LSHandlerRoleAll = "(?!-)(?<id>[^"]+?)";\s+?LSHandlerURLScheme = (?:http|https);/.exec(stdout);
+  const browserId = match?.groups.id ?? "com.apple.Safari";
+  if (browserId === "com.apple.safari") {
+    return "com.apple.Safari";
+  }
+  return browserId;
+}
+
+// node_modules/.bun/run-applescript@7.1.0/node_modules/run-applescript/index.js
+import process5 from "process";
+import { promisify as promisify4 } from "util";
+import { execFile as execFile4, execFileSync } from "child_process";
+var execFileAsync2 = promisify4(execFile4);
+async function runAppleScript(script, { humanReadableOutput = true, signal } = {}) {
+  if (process5.platform !== "darwin") {
+    throw new Error("macOS only");
+  }
+  const outputArguments = humanReadableOutput ? [] : ["-ss"];
+  const execOptions = {};
+  if (signal) {
+    execOptions.signal = signal;
+  }
+  const { stdout } = await execFileAsync2("osascript", ["-e", script, outputArguments], execOptions);
+  return stdout.trim();
+}
+
+// node_modules/.bun/bundle-name@4.1.1/node_modules/bundle-name/index.js
+var bundleIdentifierPattern = /^[^\n\r"\\]+$/u;
+async function bundleName(bundleId) {
+  if (typeof bundleId !== "string") {
+    throw new TypeError("Expected a string bundle identifier");
+  }
+  if (!bundleIdentifierPattern.test(bundleId)) {
+    throw new TypeError(`Invalid bundle identifier: ${JSON.stringify(bundleId)}`);
+  }
+  return runAppleScript(`tell application "Finder" to set app_path to application file id "${bundleId}" as string
+tell application "System Events" to get value of property list item "CFBundleName" of property list file (app_path & ":Contents:Info.plist")`);
+}
+
+// node_modules/.bun/default-browser@5.5.1/node_modules/default-browser/windows.js
+import process6 from "process";
+import { promisify as promisify5 } from "util";
+import { execFile as execFile5 } from "child_process";
+var execFileAsync3 = promisify5(execFile5);
+var windowsBrowserProgIds = {
+  MSEdgeHTM: { name: "Edge", id: "com.microsoft.edge" },
+  MSEdgeBHTML: { name: "Edge Beta", id: "com.microsoft.edge.beta" },
+  MSEdgeDHTML: { name: "Edge Dev", id: "com.microsoft.edge.dev" },
+  AppXq0fevzme2pys62n3e0fbqa7peapykr8v: { name: "Edge", id: "com.microsoft.edge.old" },
+  ChromeHTML: { name: "Chrome", id: "com.google.chrome" },
+  ChromeBHTML: { name: "Chrome Beta", id: "com.google.chrome.beta" },
+  ChromeDHTML: { name: "Chrome Dev", id: "com.google.chrome.dev" },
+  ChromiumHTM: { name: "Chromium", id: "org.chromium.Chromium" },
+  BraveHTML: { name: "Brave", id: "com.brave.Browser" },
+  BraveBHTML: { name: "Brave Beta", id: "com.brave.Browser.beta" },
+  BraveDHTML: { name: "Brave Dev", id: "com.brave.Browser.dev" },
+  BraveSSHTM: { name: "Brave Nightly", id: "com.brave.Browser.nightly" },
+  FirefoxURL: { name: "Firefox", id: "org.mozilla.firefox" },
+  OperaStable: { name: "Opera", id: "com.operasoftware.Opera" },
+  VivaldiHTM: { name: "Vivaldi", id: "com.vivaldi.Vivaldi" },
+  "IE.HTTP": { name: "Internet Explorer", id: "com.microsoft.ie" }
+};
+var _windowsBrowserProgIdMap = new Map(Object.entries(windowsBrowserProgIds));
+
+class UnknownBrowserError extends Error {
+}
+async function defaultBrowser(_execFileAsync = execFileAsync3) {
+  const regPath = `${process6.env.SYSTEMROOT ?? process6.env.windir ?? "C:\\Windows"}\\System32\\reg.exe`;
+  const { stdout } = await _execFileAsync(regPath, [
+    "QUERY",
+    " HKEY_CURRENT_USER\\Software\\Microsoft\\Windows\\Shell\\Associations\\UrlAssociations\\http\\UserChoice",
+    "/v",
+    "ProgId"
+  ]);
+  const match = /ProgId\s*REG_SZ\s*(?<id>\S+)/.exec(stdout);
+  if (!match) {
+    throw new UnknownBrowserError(`Cannot find Windows browser in stdout: ${JSON.stringify(stdout)}`);
+  }
+  const { id } = match.groups;
+  const dotIndex = id.lastIndexOf(".");
+  const hyphenIndex = id.lastIndexOf("-");
+  const baseIdByDot = dotIndex === -1 ? undefined : id.slice(0, dotIndex);
+  const baseIdByHyphen = hyphenIndex === -1 ? undefined : id.slice(0, hyphenIndex);
+  return windowsBrowserProgIds[id] ?? windowsBrowserProgIds[baseIdByDot] ?? windowsBrowserProgIds[baseIdByHyphen] ?? { name: id, id };
+}
+
+// node_modules/.bun/default-browser@5.5.1/node_modules/default-browser/index.js
+var execFileAsync4 = promisify6(execFile6);
+var titleize = (string) => string.toLowerCase().replaceAll(/(?:^|\s|-)\S/g, (x) => x.toUpperCase());
+async function defaultBrowser2() {
+  if (process7.platform === "darwin") {
+    const id = await defaultBrowserId();
+    const name = await bundleName(id);
+    return { name, id };
+  }
+  if (process7.platform === "linux") {
+    const { stdout } = await execFileAsync4("xdg-mime", ["query", "default", "x-scheme-handler/http"]);
+    const id = stdout.trim();
+    const name = titleize(id.replace(/.desktop$/, "").replace("-", " "));
+    return { name, id };
+  }
+  if (process7.platform === "win32") {
+    return defaultBrowser();
+  }
+  throw new Error("Only macOS, Linux, and Windows are supported");
+}
+
+// node_modules/.bun/is-in-ssh@1.0.0/node_modules/is-in-ssh/index.js
+import process8 from "process";
+var isInSsh = Boolean(process8.env.SSH_CONNECTION || process8.env.SSH_CLIENT || process8.env.SSH_TTY);
+var is_in_ssh_default = isInSsh;
+
+// node_modules/.bun/open@11.0.4/node_modules/open/index.js
+var fallbackAttemptSymbol = Symbol("fallbackAttempt");
+var __dirname2 = import.meta.url ? path2.dirname(fileURLToPath(import.meta.url)) : "";
+var localXdgOpenPath = path2.join(__dirname2, "xdg-open");
+var { platform, arch } = process9;
+var tryEachApp = async (apps, opener) => {
+  if (apps.length === 0) {
+    return;
+  }
+  const errors = [];
+  for (const app of apps) {
+    try {
+      return await opener(app);
+    } catch (error) {
+      errors.push(error);
+    }
+  }
+  throw new AggregateError(errors, "Failed to open in all supported apps");
+};
+var baseOpen = async (options) => {
+  options = {
+    wait: false,
+    background: false,
+    newInstance: false,
+    allowNonzeroExitCode: false,
+    ...options
+  };
+  const isFallbackAttempt = options[fallbackAttemptSymbol] === true;
+  delete options[fallbackAttemptSymbol];
+  if (Array.isArray(options.app)) {
+    return tryEachApp(options.app, (singleApp) => baseOpen({
+      ...options,
+      app: singleApp,
+      [fallbackAttemptSymbol]: true
+    }));
+  }
+  let { name: app, arguments: appArguments = [] } = options.app ?? {};
+  appArguments = [...appArguments];
+  if (Array.isArray(app)) {
+    return tryEachApp(app, (appName) => baseOpen({
+      ...options,
+      app: {
+        name: appName,
+        arguments: appArguments
+      },
+      [fallbackAttemptSymbol]: true
+    }));
+  }
+  if (app === "browser" || app === "browserPrivate") {
+    const ids = {
+      "com.google.chrome": "chrome",
+      "google-chrome.desktop": "chrome",
+      "com.brave.browser": "brave",
+      "org.mozilla.firefox": "firefox",
+      "firefox.desktop": "firefox",
+      "com.microsoft.msedge": "edge",
+      "com.microsoft.edge": "edge",
+      "com.microsoft.edgemac": "edge",
+      "microsoft-edge.desktop": "edge",
+      "com.apple.safari": "safari"
+    };
+    const flags = {
+      chrome: "--incognito",
+      brave: "--incognito",
+      firefox: "--private-window",
+      edge: "--inPrivate"
+    };
+    let browser;
+    if (is_wsl_default) {
+      const progId = await wslDefaultBrowser();
+      const browserInfo = _windowsBrowserProgIdMap.get(progId);
+      browser = browserInfo ?? {};
+    } else {
+      browser = await defaultBrowser2();
+    }
+    const browserId = browser.id?.toLowerCase();
+    if (Object.hasOwn(ids, browserId)) {
+      const browserName = ids[browserId];
+      if (app === "browserPrivate") {
+        if (browserName === "safari") {
+          throw new Error("Safari doesn't support opening in private mode via command line");
+        }
+        appArguments.push(flags[browserName]);
+      }
+      return baseOpen({
+        ...options,
+        app: {
+          name: apps[browserName],
+          arguments: appArguments
+        }
+      });
+    }
+    throw new Error(`${browser.name} is not supported as a default browser`);
+  }
+  let command;
+  const cliArguments = [];
+  const childProcessOptions = {};
+  let shouldUseWindowsInWsl = false;
+  if (is_wsl_default && !isInsideContainer() && !is_in_ssh_default && !app) {
+    shouldUseWindowsInWsl = await canAccessPowerShell();
+  }
+  if (platform === "darwin") {
+    command = "open";
+    if (options.wait) {
+      cliArguments.push("--wait-apps");
+    }
+    if (options.background) {
+      cliArguments.push("--background");
+    }
+    if (options.newInstance) {
+      cliArguments.push("--new");
+    }
+    if (app) {
+      cliArguments.push("-a", app);
+    }
+  } else if (platform === "win32" || shouldUseWindowsInWsl) {
+    command = await powerShellPath2();
+    cliArguments.push(...executePowerShell.argumentsPrefix);
+    if (!is_wsl_default) {
+      childProcessOptions.windowsVerbatimArguments = true;
+    }
+    if (is_wsl_default && options.target) {
+      options.target = await convertWslPathToWindows(options.target);
+    }
+    const encodedArguments = ["$ProgressPreference = 'SilentlyContinue';", "Start"];
+    if (options.wait) {
+      encodedArguments.push("-Wait");
+    }
+    if (app) {
+      encodedArguments.push(executePowerShell.escapeArgument(app));
+      if (options.target) {
+        appArguments.push(options.target);
+      }
+    } else if (options.target) {
+      encodedArguments.push(executePowerShell.escapeArgument(options.target));
+    }
+    if (appArguments.length > 0) {
+      appArguments = appArguments.map((argument) => executePowerShell.escapeArgument(argument));
+      encodedArguments.push("-ArgumentList", appArguments.join(","));
+    }
+    options.target = executePowerShell.encodeCommand(encodedArguments.join(" "));
+    if (!options.wait) {
+      childProcessOptions.stdio = "ignore";
+    }
+    if (is_wsl_default) {
+      childProcessOptions.cwd = path2.dirname(command);
+    }
+  } else {
+    if (app) {
+      command = app;
+    } else {
+      const isBundled = !__dirname2 || __dirname2 === "/";
+      let exeLocalXdgOpen = false;
+      try {
+        await fs5.access(localXdgOpenPath, fsConstants2.X_OK);
+        exeLocalXdgOpen = true;
+      } catch {}
+      const useSystemXdgOpen = process9.versions.electron ?? (platform === "android" || isBundled || !exeLocalXdgOpen);
+      command = useSystemXdgOpen ? "xdg-open" : localXdgOpenPath;
+    }
+    if (appArguments.length > 0) {
+      cliArguments.push(...appArguments);
+    }
+    if (!options.wait) {
+      childProcessOptions.stdio = "ignore";
+      childProcessOptions.detached = true;
+    }
+  }
+  if (platform === "darwin" && appArguments.length > 0) {
+    cliArguments.push("--args", ...appArguments);
+  }
+  if (options.target) {
+    cliArguments.push(options.target);
+  }
+  const subprocess = childProcess3.spawn(command, cliArguments, childProcessOptions);
+  if (options.wait) {
+    return new Promise((resolve, reject) => {
+      subprocess.once("error", reject);
+      subprocess.once("close", (exitCode) => {
+        if (!options.allowNonzeroExitCode && exitCode !== 0) {
+          reject(new Error(`Exited with code ${exitCode}`));
+          return;
+        }
+        resolve(subprocess);
+      });
+    });
+  }
+  if (isFallbackAttempt || platform === "win32" || shouldUseWindowsInWsl) {
+    return new Promise((resolve, reject) => {
+      subprocess.once("error", reject);
+      subprocess.once("spawn", () => {
+        subprocess.once("close", (exitCode) => {
+          subprocess.off("error", reject);
+          if (isFallbackAttempt && exitCode !== 0) {
+            reject(new Error(`Exited with code ${exitCode}`));
+            return;
+          }
+          subprocess.unref();
+          resolve(subprocess);
+        });
+      });
+    });
+  }
+  subprocess.unref();
+  return new Promise((resolve, reject) => {
+    subprocess.once("error", reject);
+    subprocess.once("spawn", () => {
+      subprocess.off("error", reject);
+      resolve(subprocess);
+    });
+  });
+};
+var open2 = (target, options) => {
+  if (typeof target !== "string") {
+    throw new TypeError("Expected a `target`");
+  }
+  return baseOpen({
+    ...options,
+    target
+  });
+};
+function detectArchBinary(binary) {
+  if (typeof binary === "string" || Array.isArray(binary)) {
+    return binary;
+  }
+  const { [arch]: archBinary } = binary;
+  if (!archBinary) {
+    throw new Error(`${arch} is not supported`);
+  }
+  return archBinary;
+}
+function detectPlatformBinary({ [platform]: platformBinary }, { wsl } = {}) {
+  if (wsl && is_wsl_default) {
+    return detectArchBinary(wsl);
+  }
+  if (!platformBinary) {
+    throw new Error(`${platform} is not supported`);
+  }
+  return detectArchBinary(platformBinary);
+}
+var apps = {
+  browser: "browser",
+  browserPrivate: "browserPrivate"
+};
+defineLazyProperty(apps, "chrome", () => detectPlatformBinary({
+  darwin: "google chrome",
+  win32: "chrome",
+  linux: ["google-chrome", "google-chrome-stable", "chromium", "chromium-browser"]
+}, {
+  wsl: {
+    ia32: "/mnt/c/Program Files (x86)/Google/Chrome/Application/chrome.exe",
+    x64: ["/mnt/c/Program Files/Google/Chrome/Application/chrome.exe", "/mnt/c/Program Files (x86)/Google/Chrome/Application/chrome.exe"]
+  }
+}));
+defineLazyProperty(apps, "brave", () => detectPlatformBinary({
+  darwin: "brave browser",
+  win32: "brave",
+  linux: ["brave-browser", "brave"]
+}, {
+  wsl: {
+    ia32: "/mnt/c/Program Files (x86)/BraveSoftware/Brave-Browser/Application/brave.exe",
+    x64: ["/mnt/c/Program Files/BraveSoftware/Brave-Browser/Application/brave.exe", "/mnt/c/Program Files (x86)/BraveSoftware/Brave-Browser/Application/brave.exe"]
+  }
+}));
+defineLazyProperty(apps, "firefox", () => detectPlatformBinary({
+  darwin: "firefox",
+  win32: String.raw`C:\Program Files\Mozilla Firefox\firefox.exe`,
+  linux: "firefox"
+}, {
+  wsl: "/mnt/c/Program Files/Mozilla Firefox/firefox.exe"
+}));
+defineLazyProperty(apps, "edge", () => detectPlatformBinary({
+  darwin: "microsoft edge",
+  win32: "msedge",
+  linux: ["microsoft-edge", "microsoft-edge-dev"]
+}, {
+  wsl: "/mnt/c/Program Files (x86)/Microsoft/Edge/Application/msedge.exe"
+}));
+defineLazyProperty(apps, "safari", () => detectPlatformBinary({
+  darwin: "Safari"
+}));
+var open_default = open2;
+
+// packages/agent/src/system/openBrowser.ts
+var openBrowser = (url) => open_default(url).catch(() => {
+  return;
+});
+
+// packages/agent/src/permissions/sanitizeText.ts
+var isControlCode = (code) => code < 32 || code >= 127 && code <= 159;
+var sanitizeText = (text) => [...String(text ?? "")].map((char) => isControlCode(char.charCodeAt(0)) ? " " : char).join("");
+
+// packages/agent/src/permissions/elicitationForm.ts
+var SKIP_LABEL = "Skip";
+var ACCEPT_LABEL = "Accept";
+var DECLINE_LABEL = "Decline";
+var YES_LABEL = "Yes";
+var NO_LABEL = "No";
+var isSchema = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var readList = (value) => Array.isArray(value) ? value : [];
+var toChoice = (entry) => {
+  if (typeof entry === "string")
+    return { value: entry, label: sanitizeText(entry) };
+  if (!isSchema(entry) || typeof entry.const !== "string")
+    return;
+  const label = typeof entry.title === "string" ? entry.title : entry.const;
+  return { value: entry.const, label: sanitizeText(label) };
+};
+var readChoices = (field) => {
+  const source = isSchema(field.items) ? field.items : field;
+  const entries = [...readList(source.oneOf), ...readList(source.anyOf), ...readList(source.enum)];
+  return entries.flatMap((entry) => toChoice(entry) ?? []);
+};
+var readKind = (field, choices) => {
+  if (field.type === "array")
+    return "multi";
+  if (choices.length > 0)
+    return "choice";
+  if (field.type === "boolean")
+    return "boolean";
+  return field.type === "number" || field.type === "integer" ? "number" : "text";
+};
+var readOptions = (kind, choices) => {
+  const labelled = (labels) => labels.map((label) => ({ label, description: "" }));
+  if (kind === "boolean")
+    return labelled([YES_LABEL, NO_LABEL]);
+  return labelled(choices.length > 0 ? choices.map(({ label }) => label) : [SKIP_LABEL]);
+};
+var buildQuestionText = (key, field, message) => {
+  const title = sanitizeText(typeof field.title === "string" ? field.title : key);
+  const description = typeof field.description === "string" ? ` (${sanitizeText(field.description)})` : "";
+  return `${message}${title}${description}`;
+};
+var buildConfirmForm = (header, message) => ({
+  fields: [],
+  questions: [
+    {
+      header,
+      question: message,
+      options: [
+        { label: ACCEPT_LABEL, description: "" },
+        { label: DECLINE_LABEL, description: "" }
+      ]
+    }
+  ]
+});
+function buildElicitationForm(serverName, message, requestedSchema) {
+  const header = sanitizeText(serverName);
+  const properties = isSchema(requestedSchema?.properties) ? requestedSchema.properties : {};
+  const entries = Object.entries(properties).filter((entry) => isSchema(entry[1]));
+  if (entries.length === 0)
+    return buildConfirmForm(header, sanitizeText(message));
+  const fields = [];
+  const questions = [];
+  for (const [key, field] of entries) {
+    const choices = readChoices(field);
+    const kind = readKind(field, choices);
+    const intro = fields.length === 0 ? `${sanitizeText(message)} \u2014 ` : "";
+    const question = buildQuestionText(key, field, intro);
+    fields.push({ key, question, kind, choices });
+    questions.push({
+      header,
+      question,
+      multiSelect: kind === "multi",
+      options: readOptions(kind, choices)
+    });
+  }
+  return { fields, questions };
+}
+var readChoiceValue = (choices, label) => choices.find((choice) => choice.label === label)?.value ?? label;
+var readFieldValue = ({ kind, choices }, answer) => {
+  if (kind === "boolean")
+    return answer === YES_LABEL;
+  if (kind === "number")
+    return Number.isFinite(Number(answer)) ? Number(answer) : undefined;
+  if (kind === "choice")
+    return readChoiceValue(choices, answer);
+  if (kind === "multi")
+    return answer.split(", ").map((label) => readChoiceValue(choices, label));
+  return answer;
+};
+function buildElicitationContent(form, answers) {
+  const content = {};
+  for (const field of form.fields) {
+    const answer = answers[field.question]?.trim();
+    if (!answer || answer === SKIP_LABEL)
+      continue;
+    const value = readFieldValue(field, answer);
+    if (value !== undefined)
+      content[field.key] = value;
+  }
+  return content;
+}
+var isConfirmAccepted = (form, answers) => form.fields.length > 0 || Object.values(answers).includes(ACCEPT_LABEL);
+
+// packages/agent/src/permissions/elicitationGate.ts
+var ELICITATION_PREFIX = "elicitation:";
+var OPEN_BROWSER_LABEL = "Open in browser";
+var DECLINED = { action: "decline" };
+var isWebUrl = (url) => {
+  try {
+    return url !== undefined && /^https?:$/.test(new URL(url).protocol);
+  } catch {
+    return false;
+  }
+};
+var buildUrlQuestion = ({ serverName, message, url }) => ({
+  header: sanitizeText(serverName),
+  question: `${sanitizeText(message)} ${sanitizeText(url)}`,
+  options: [
+    { label: OPEN_BROWSER_LABEL, description: "" },
+    { label: "Decline", description: "" }
+  ]
+});
+
+class ElicitationGate {
+  agentSessionId;
+  openUrl;
+  pending = new Map;
+  emit = () => {};
+  constructor(agentSessionId, openUrl = openBrowser) {
+    this.agentSessionId = agentSessionId;
+    this.openUrl = openUrl;
+  }
+  listen(emit) {
+    this.emit = emit;
+  }
+  handle = async (request, { signal, requestId }) => {
+    if (request.mode === "url") {
+      if (!isWebUrl(request.url))
+        return DECLINED;
+      return this.open(requestId, signal, [buildUrlQuestion(request)], (answers) => this.acceptUrl(request.url, answers));
+    }
+    const form = buildElicitationForm(request.serverName, request.message, request.requestedSchema);
+    return this.open(requestId, signal, form.questions, (answers) => this.acceptForm(form, answers));
+  };
+  answer(toolUseId, answers) {
+    const pending = this.pending.get(toolUseId);
+    if (!pending)
+      return false;
+    this.pending.delete(toolUseId);
+    const answered = Object.keys(answers).length > 0;
+    pending.settle(answered ? pending.accept(answers) : DECLINED);
+    this.emit({ type: "agent.question.resolved", toolUseId, answered });
+    return true;
+  }
+  rejectAll() {
+    for (const id of [...this.pending.keys()])
+      this.answer(id, {});
+  }
+  acceptUrl(url, answers) {
+    if (!Object.values(answers).includes(OPEN_BROWSER_LABEL))
+      return DECLINED;
+    this.openUrl(url);
+    return { action: "accept" };
+  }
+  acceptForm(form, answers) {
+    if (!isConfirmAccepted(form, answers))
+      return DECLINED;
+    return { action: "accept", content: buildElicitationContent(form, answers) };
+  }
+  open(requestId, signal, questions, accept) {
+    const toolUseId = `${ELICITATION_PREFIX}${requestId}`;
+    return new Promise((settle) => {
+      this.pending.set(toolUseId, { settle, accept });
+      signal.addEventListener("abort", () => this.answer(toolUseId, {}), { once: true });
+      this.emit({
+        type: "agent.question.required",
+        agentSessionId: this.agentSessionId,
+        toolUseId,
+        questions
+      });
+    });
+  }
+}
 
 // packages/agent/src/permissions/permissionResults.ts
 var allowTool = (input) => ({
@@ -7800,7 +8777,87 @@ var ADHD_SYSTEM_PROMPT = `For the rest of this session, shape every response for
 
 Break these rules only when: the reader asks you to "explain" or "walk through" (go as long as the topic needs, still no preamble/closer); a destructive action is ahead (confirm first; safety beats brevity); you are in a debug spiral (name the assumption that might be wrong, ask one diagnostic question); or the request is genuinely ambiguous (ask one short clarifying question); or the harness's own system prompt requires something these rules ban (the harness wins; keep the shape).`;
 
-// packages/agent/src/profile/agentProfile.ts
+// packages/agent/src/profile/codeReviewPrompt.ts
+var CODE_REVIEW_DESCRIPTION = "Reviews code changes since a commit, branch, or tag, or the uncommitted work, against the repo's coding standards and the originating spec. Use it to review a branch, a PR, or work in progress.";
+var CODE_REVIEW_PROMPT = `You are CodeReview. You review a diff along two separate axes and report them side by side. You are read-only: never edit files.
+
+- Standards: does the code follow this repo's documented coding standards?
+- Spec: does the code match what the originating issue or spec asked for?
+
+A change can pass one axis and fail the other. Never merge or rerank the two.
+
+## 1. Pin the fixed point
+
+Use the commit, branch, tag, or ref you were given. If none was given, review the uncommitted work with \`git diff HEAD\`.
+Verify the ref with \`git rev-parse <ref>\` and capture the diff once with \`git diff <ref>...HEAD\`, plus \`git log <ref>..HEAD --oneline\`. If the ref is bad or the diff is empty, say so and stop.
+
+## 2. Find the spec
+
+Look in this order:
+1. Issue references in commit messages (#123, Closes #45).
+2. A path you were given.
+3. A spec or issue file under docs/, specs/, or .scratch/ matching the branch name or feature.
+If there is none, skip the Spec axis and say "no spec available".
+
+## 3. Find the standards
+
+Collect every file that documents how code should be written: CLAUDE.md, CODING_STANDARDS.md, CONTRIBUTING.md, and similar. A documented repo standard always wins over the smell baseline.
+
+Smell baseline, always a judgement call, never a hard violation (name it "possible <smell>"). Skip anything tooling already enforces.
+- Mysterious Name: a name that does not reveal what it does or holds.
+- Duplicated Code: the same logic shape in more than one hunk or file.
+- Feature Envy: a method that uses another object's data more than its own.
+- Data Clumps: the same few fields or params always travel together.
+- Primitive Obsession: a primitive standing in for a domain concept.
+- Repeated Switches: the same switch or if-cascade on one type recurs.
+- Shotgun Surgery: one logical change forces scattered edits across many files.
+- Divergent Change: one file is edited for several unrelated reasons.
+- Speculative Generality: abstraction or hooks for needs the spec does not have.
+- Message Chains: long a.b().c().d() navigation callers should not depend on.
+- Middle Man: a class or function that mostly delegates onward.
+- Refused Bequest: a subclass that ignores or overrides most of what it inherits.
+
+## 4. Report
+
+Under \`## Standards\`: every place the diff breaks a documented standard (cite the file and rule), then any baseline smell (name it, quote the hunk). Separate hard violations from judgement calls.
+Under \`## Spec\`: requirements that are missing or partial, behaviour that was not asked for, and requirements that look implemented but wrong. Quote the spec line for each.
+
+Every finding names its file path and line range as <path>:<from>:<to>. Keep each axis under 400 words.
+End with one line: findings per axis and the worst issue within each axis. Do not pick a winner across axes.`;
+
+// packages/agent/src/profile/scoutPrompt.ts
+var SCOUT_DESCRIPTION = "Scans the codebase for specific information and returns concise, useful findings with file paths and line ranges. Use it before reading or searching many files yourself.";
+var SCOUT_PROMPT = `You are Scout. You scan the codebase to answer one exploration request. You are read-only: never edit, write, or run state-changing commands.
+
+1. Use Glob to find files, Grep to find content, Read to confirm. Read only the lines you need.
+2. Answer the request directly. Report only what the request needs.
+3. Every finding names its file path and line range as <path>:<from>:<to>, for example src/auth/login.ts:42:58. A single line is <path>:<line>:<line>.
+4. Keep it concise: one line per finding, the most relevant first, at most 10 findings.
+5. If nothing matches, say so and list what you searched.`;
+
+// packages/agent/src/profile/subagents.ts
+var AGENT_SUBAGENTS = {
+  Scout: {
+    description: SCOUT_DESCRIPTION,
+    prompt: SCOUT_PROMPT,
+    tools: ["Glob", "Grep", "Read"],
+    model: "haiku",
+    effort: "medium"
+  },
+  CodeReview: {
+    description: CODE_REVIEW_DESCRIPTION,
+    prompt: CODE_REVIEW_PROMPT,
+    tools: ["Bash", "Glob", "Grep", "Read"],
+    model: "sonnet",
+    effort: "medium"
+  }
+};
+var SUBAGENT_GUIDANCE = `Prefer subagents over doing the work yourself. Use *Agent* with:
+- Scout: to scan the codebase for specific information. It returns file paths and line ranges (<path>:<from>:<to>). Use it before you search or read many files.
+- CodeReview: to review code changes against the repo's standards and spec.
+Run independent subagents in parallel.`;
+
+// packages/agent/src/profile/agentTools.ts
 var AGENT_TOOLS = [
   "Bash",
   "Read",
@@ -7821,9 +8878,48 @@ var AGENT_TOOLS = [
   "Edit",
   "NotebookEdit"
 ];
+var AGENT_DISALLOWED_TOOLS = [
+  "Agent(Explore)",
+  "Agent(Plan)",
+  "Agent(statusline-setup)"
+];
+
+// packages/agent/src/profile/toolGuidance.ts
+var TOOL_USAGE = {
+  Bash: "run shell commands; never to read, search, or edit files",
+  Read: "read files",
+  Grep: "search file contents",
+  Glob: "scan files by name pattern",
+  WebSearch: "search the web",
+  WebFetch: "fetch a URL",
+  TaskStop: "stop a running background task",
+  Agent: "delegate work to a subagent",
+  TaskCreate: "create a task",
+  TaskGet: "read one task",
+  TaskList: "list tasks",
+  TaskOutput: "read a background task's output",
+  TaskUpdate: "update a task",
+  TodoWrite: "track the steps of multi-step work",
+  AskUserQuestion: "ask the user",
+  Write: "create new files with content",
+  Edit: "update files",
+  NotebookEdit: "update notebook cells"
+};
+var TOOL_GUIDANCE = `Always use the dedicated tool, never a workaround:
+${AGENT_TOOLS.map((tool) => `- Use *${tool}* to ${TOOL_USAGE[tool]}`).join(`
+`)}`;
+
+// packages/agent/src/profile/agentSystemPrompt.ts
+var AGENT_SYSTEM_PROMPT = [ADHD_SYSTEM_PROMPT, TOOL_GUIDANCE, SUBAGENT_GUIDANCE].join(`
+
+`);
+
+// packages/agent/src/profile/agentProfile.ts
 var AGENT_PROFILE_OPTIONS = {
   tools: AGENT_TOOLS,
-  systemPrompt: ADHD_SYSTEM_PROMPT,
+  disallowedTools: AGENT_DISALLOWED_TOOLS,
+  systemPrompt: AGENT_SYSTEM_PROMPT,
+  agents: AGENT_SUBAGENTS,
   enableFileCheckpointing: true,
   extraArgs: { "replay-user-messages": null },
   permissionMode: DEFAULT_PERMISSION_MODE,
@@ -7855,18 +8951,12 @@ var AGENT_PROFILE_OPTIONS = {
   includeHookEvents: true
 };
 
-// packages/agent/src/runtime/buildUserMessage.ts
-var isSlashCommand = (content) => readPromptText(content).trimStart().startsWith("/");
-var buildUserMessage = (content, priority) => ({
-  type: "user",
-  message: { role: "user", content },
-  parent_tool_use_id: null,
-  priority,
-  client_composed: isSlashCommand(content) ? undefined : true
-});
-
-// packages/agent/src/session/pickNextModel.ts
-var pickNextModel = (models, current) => models[(models.findIndex((model) => model.value === current) + 1) % models.length]?.value;
+// packages/agent/src/session/readBackgroundTaskCount.ts
+function readBackgroundTaskCount(message, current) {
+  if (message.type !== "system" || message.subtype !== "background_tasks_changed")
+    return current;
+  return message.tasks.length;
+}
 
 // packages/agent/src/session/agentSession.ts
 function requireRewind(result) {
@@ -7879,18 +8969,22 @@ class AgentSession {
   baseOptions;
   input = pushable({ objectMode: true });
   gate;
+  elicitations;
   query;
   pendingTurns = 0;
+  backgroundTaskCount = 0;
   pumping = false;
   constructor(agentSessionId, baseOptions, runtime) {
     this.baseOptions = baseOptions;
     this.gate = new PermissionGate(agentSessionId);
+    this.elicitations = new ElicitationGate(agentSessionId);
     this.query = runtime.open({
       prompt: this.input,
       options: {
         ...baseOptions,
         ...AGENT_PROFILE_OPTIONS,
-        canUseTool: this.gate.canUseTool
+        canUseTool: this.gate.canUseTool,
+        onElicitation: this.elicitations.handle
       }
     });
   }
@@ -7907,35 +9001,33 @@ class AgentSession {
       return;
     this.pumping = true;
     const sink = pushable({ objectMode: true });
-    this.gate.listen((event) => sink.push(event));
+    this.listenGates((event) => sink.push(event));
     this.pumpMessages(sink);
     try {
       yield* sink;
     } finally {
       this.pumping = false;
-      this.gate.listen(() => {});
+      this.listenGates(() => {});
     }
   }
   answerApproval(toolUseId, decision) {
     this.gate.answerApproval(toolUseId, decision);
   }
   answerQuestion(toolUseId, answers) {
-    this.gate.answerQuestion(toolUseId, answers);
+    if (!this.elicitations.answer(toolUseId, answers))
+      this.gate.answerQuestion(toolUseId, answers);
   }
   async cancel() {
-    this.gate.rejectAll();
+    this.rejectAllPrompts();
     await this.query.interrupt();
   }
+  stopTask(taskId) {
+    return this.query.stopTask(taskId);
+  }
   async setModel(model) {
     await this.query.setModel(model);
     this.baseOptions = { ...this.baseOptions, model };
   }
-  async cycleModel() {
-    const next = pickNextModel(await this.fetchModels(), this.baseOptions.model);
-    if (next)
-      await this.setModel(next);
-    return next;
-  }
   setPermissionMode(mode) {
     return this.query.setPermissionMode(mode);
   }
@@ -7945,6 +9037,27 @@ class AgentSession {
   fetchMcpStatus() {
     return this.query.mcpServerStatus();
   }
+  async startMcpLogin(serverName) {
+    if (typeof this.query.mcpAuthenticate !== "function") {
+      throw new Error("This Claude Agent SDK version does not support MCP login");
+    }
+    const { authUrl } = await this.query.mcpAuthenticate(serverName);
+    if (!authUrl)
+      throw new Error(`MCP server ${serverName} did not offer a login`);
+    if (!/^https?:$/.test(new URL(authUrl).protocol)) {
+      throw new Error(`MCP server ${serverName} offered an unsafe login link`);
+    }
+    return authUrl;
+  }
+  async submitMcpCallback(serverName, callbackUrl) {
+    if (!/^https?:$/.test(new URL(callbackUrl).protocol)) {
+      throw new Error("The callback must be an http(s) link");
+    }
+    await this.query.mcpSubmitOAuthCallbackUrl(serverName, callbackUrl);
+  }
+  awaitMcpLogin(serverName, wait) {
+    return waitForMcpLogin(() => this.fetchMcpStatus(), serverName, wait);
+  }
   fetchModels() {
     return this.query.supportedModels();
   }
@@ -7962,10 +9075,18 @@ class AgentSession {
     });
   }
   close() {
-    this.gate.rejectAll();
+    this.rejectAllPrompts();
     this.input.end();
     this.query.close();
   }
+  listenGates(emit) {
+    this.gate.listen(emit);
+    this.elicitations.listen(emit);
+  }
+  rejectAllPrompts() {
+    this.gate.rejectAll();
+    this.elicitations.rejectAll();
+  }
   async pumpMessages(sink) {
     try {
       while (true) {
@@ -7973,10 +9094,11 @@ class AgentSession {
         if (done)
           break;
         sink.push({ type: "agent.message.received", message: value });
+        this.backgroundTaskCount = readBackgroundTaskCount(value, this.backgroundTaskCount);
         if (value.type !== "result")
           continue;
         this.pendingTurns = Math.max(this.pendingTurns - 1, 0);
-        if (this.pendingTurns === 0)
+        if (this.pendingTurns === 0 && this.backgroundTaskCount === 0)
           break;
       }
       sink.end();
@@ -8038,13 +9160,13 @@ class AgentSessionManager {
 import { homedir } from "os";
 import { join as join2 } from "path";
 var OPTIONS_PATH = join2(homedir(), ".claudin", "options.json");
-async function readOptions(path) {
+async function readOptions2(path) {
   const stored = await Bun.file(path).json().catch(() => ({}));
   const parsed = optionsFileSchema.safeParse(stored);
   return parsed.success ? parsed.data : {};
 }
 async function saveBackground(path, background) {
-  await Bun.write(path, JSON.stringify({ ...await readOptions(path), background }, null, 2));
+  await Bun.write(path, JSON.stringify({ ...await readOptions2(path), background }, null, 2));
 }
 
 // packages/daemon/src/workspace/resolvePath.ts
@@ -8254,6 +9376,9 @@ var agentHandlers = {
     await agents.requireSession(request.agentSessionId).cancel();
     yield { type: "agent.prompt.cancelled", agentSessionId: request.agentSessionId };
   },
+  async* "agent.task.stop.requested"({ agents }, request) {
+    await agents.requireSession(request.agentSessionId).stopTask(request.taskId);
+  },
   async* "agent.tool.approval.answered"({ agents }, request) {
     agents.requireSession(request.agentSessionId).answerApproval(request.toolUseId, request.decision);
   },
@@ -8264,11 +9389,6 @@ var agentHandlers = {
     await agents.requireSession(request.agentSessionId).setModel(request.model);
     yield { type: "agent.model.changed", model: request.model };
   },
-  async* "agent.model.cycle.requested"({ agents }, request) {
-    const model = await agents.requireSession(request.agentSessionId).cycleModel();
-    if (model)
-      yield { type: "agent.model.changed", model };
-  },
   async* "agent.effort.set.requested"({ agents }, request) {
     await agents.requireSession(request.agentSessionId).setEffort(request.effort);
     yield { type: "agent.effort.changed", effort: request.effort };
@@ -8289,6 +9409,22 @@ var agentHandlers = {
     const servers = await agents.requireSession(request.agentSessionId).fetchMcpStatus();
     yield { type: "agent.mcp.status.received", servers };
   },
+  async* "agent.mcp.login.requested"({ agents }, request) {
+    const { serverName } = request;
+    const session = agents.requireSession(request.agentSessionId);
+    const authUrl = await session.startMcpLogin(serverName);
+    yield { type: "agent.mcp.login.started", serverName, authUrl };
+    await openBrowser(authUrl);
+    const servers = await session.awaitMcpLogin(serverName);
+    yield { type: "agent.mcp.status.received", servers };
+  },
+  async* "agent.mcp.callback.submitted"({ agents }, request) {
+    const { serverName, callbackUrl } = request;
+    const session = agents.requireSession(request.agentSessionId);
+    await session.submitMcpCallback(serverName, callbackUrl);
+    const servers = await session.awaitMcpLogin(serverName, { intervalMs: 500, timeoutMs: 1e4 });
+    yield { type: "agent.mcp.status.received", servers };
+  },
   async* "agent.usage.requested"({ agents }, request) {
     const { session } = await agents.requireSession(request.agentSessionId).fetchUsage();
     yield { type: "agent.usage.received", usage: session };
@@ -8319,7 +9455,7 @@ var agentHandlers = {
 // packages/daemon/src/handlers/optionsHandlers.ts
 var optionsHandlers = {
   async* "options.load.requested"({ optionsPath }) {
-    const { background } = await readOptions(optionsPath);
+    const { background } = await readOptions2(optionsPath);
     yield { type: "options.loaded", background };
   },
   async* "options.background.save.requested"({ optionsPath }, request) {
@@ -8360,16 +9496,17 @@ var sessionHandlers = {
 };
 
 // packages/daemon/src/workspace/readFileDiffs.ts
-import { relative } from "path";
+import { relative, resolve as resolve2 } from "path";
 var isTracked = async (cwd, path) => (await Bun.$`git ls-files --error-unmatch -- ${path}`.cwd(cwd).quiet().nothrow()).exitCode === 0;
 async function readPatch(cwd, path) {
   const command = await isTracked(cwd, path) ? Bun.$`git diff --no-color HEAD -- ${path}` : Bun.$`git diff --no-color --no-index -- /dev/null ${path}`;
   return (await command.cwd(cwd).quiet().nothrow()).text();
 }
 async function readFileDiff(cwd, path) {
-  const patch = await readPatch(cwd, path);
+  const absolute = resolve2(cwd, path);
+  const patch = await readPatch(cwd, absolute);
   return {
-    path: relative(cwd, path) || path,
+    path: relative(cwd, absolute) || path,
     patch,
     additions: countPatchLines(patch, "+"),
     deletions: countPatchLines(patch, "-")
@@ -8380,6 +9517,17 @@ async function readFileDiffs(cwd, paths) {
   return diffs.filter(({ patch }) => patch.trim() !== "");
 }
 
+// packages/daemon/src/workspace/readGitChangedPaths.ts
+var readLines = async (cwd, command) => (await command.cwd(cwd).quiet().nothrow()).text().split(`
+`).filter(Boolean);
+async function readGitChangedPaths(cwd) {
+  const [tracked, untracked] = await Promise.all([
+    readLines(cwd, Bun.$`git diff --name-only --relative HEAD`),
+    readLines(cwd, Bun.$`git ls-files --others --exclude-standard`)
+  ]);
+  return [...tracked, ...untracked];
+}
+
 // node_modules/.bun/fuzzysort@4.0.2/node_modules/fuzzysort/fuzzysort.js
 function single(search, target) {
   if (!search || !target)
@@ -10007,7 +11155,9 @@ var workspaceHandlers = {
     yield { type: "workspace.cwd.changed", cwd, ...await readGitInfo(cwd) };
   },
   async* "workspace.diff.requested"({ cwd }, request) {
-    yield { type: "workspace.diff.received", files: await readFileDiffs(cwd, request.paths) };
+    const changed = await readFileDiffs(cwd, await readGitChangedPaths(cwd));
+    const files = changed.length > 0 ? changed : await readFileDiffs(cwd, request.paths);
+    yield { type: "workspace.diff.received", files };
   }
 };
 
@@ -10060,7 +11210,11 @@ async function startDaemon(port = DEFAULT_PORT, context) {
   return server;
 }
 // apps/tui/src/startTui.ts
-import { BoxRenderable as BoxRenderable15, createCliRenderer } from "@opentui/core";
+import {
+  BoxRenderable as BoxRenderable18,
+  createCliRenderer,
+  createHostClipboard
+} from "@opentui/core";
 
 // apps/tui/src/components/backgroundPanel.ts
 import { BoxRenderable, StyledText, TextRenderable } from "@opentui/core";
@@ -17552,7 +18706,7 @@ var detectFiletype = (path) => FILETYPES[path.split(".").pop() ?? ""];
 
 // apps/tui/src/format/diffViewerChunks.ts
 import { bold as bold2, dim as dim2, fg as fg2 } from "@opentui/core";
-var VIEWER_TITLE = "Session diffs";
+var VIEWER_TITLE = "Diffs";
 var VIEWER_HINT = "\u2190/\u2192 file \xB7 \u2191/\u2193 PgUp/PgDn scroll \xB7 Esc close";
 var buildFileChunks = (file, selected) => [
   selected ? bold2(fg2(Theme.fg.primary)(`\u276F ${file.path}`)) : fg2(Theme.fg.secondary)(file.path),
@@ -17802,7 +18956,9 @@ class ListPopover {
 // apps/tui/src/components/promptInput.ts
 import {
   BoxRenderable as BoxRenderable5,
+  decodePasteBytes as decodePasteBytes2,
   SyntaxStyle,
+  stripAnsiSequences,
   TextareaRenderable,
   TextRenderable as TextRenderable5
 } from "@opentui/core";
@@ -17989,6 +19145,10 @@ class PromptInput {
     event.preventDefault();
     this.textarea.insertText(placeholder);
   }
+  insertPasted(content) {
+    const placeholder = planPaste(content, this.attachments);
+    this.textarea.insertText(placeholder ?? stripAnsiSequences(decodePasteBytes2(content.bytes)));
+  }
   clear() {
     this.textarea.setText("");
     this.attachments.reset();
@@ -18823,6 +19983,7 @@ class ApprovalPanel {
     for (const { label, decision, color } of buildButtons()) {
       buttons.add(new TextRenderable9(renderer, {
         content: new StyledText8([bold4(fg9(color)(label))]),
+        selectable: false,
         onMouseDown: () => onDecision(decision)
       }));
     }
@@ -18847,44 +20008,64 @@ import {
 var QUESTION_HINT = "\u2191/\u2193 select \xB7 Space toggle \xB7 Enter confirm \xB7 Esc dismiss";
 var CUSTOM_PLACEHOLDER = "type your own answer";
 var TEXT_CURSOR = "\u258F";
-var buildRowChunks = (draft) => {
-  const current = readCurrentQuestion(draft);
-  if (!current)
-    return [];
-  const rows = [
-    ...current.options,
-    { label: OTHER_LABEL, description: "", custom: true }
+var buildRowChunks = (draft, multiSelect, { label, description, custom }, index) => {
+  const focused = index === draft.cursor;
+  const checked = custom ? draft.custom.trim() !== "" : draft.picks.includes(label);
+  const marker = multiSelect ? checked ? QUESTION_GLYPHS.checked : QUESTION_GLYPHS.unchecked : "";
+  const prefix = [focused ? QUESTION_GLYPHS.cursor : " ", marker].filter(Boolean).join(" ");
+  const head = fg10(focused ? Theme.accent.brand : Theme.fg.primary)(`${prefix} ${label}`);
+  if (!custom)
+    return [head, fg10(Theme.fg.muted)(` ${description}`)];
+  const typed = draft.custom ? [fg10(Theme.fg.primary)(draft.custom)] : focused ? [] : [fg10(Theme.fg.muted)(CUSTOM_PLACEHOLDER)];
+  return [
+    head,
+    fg10(Theme.fg.muted)(": "),
+    ...typed,
+    ...focused ? [fg10(Theme.accent.brand)(TEXT_CURSOR)] : []
   ];
-  return rows.flatMap(({ label, description, custom }, index) => {
-    const focused = index === draft.cursor;
-    const checked = custom ? draft.custom.trim() !== "" : draft.picks.includes(label);
-    const marker = current.multiSelect ? checked ? QUESTION_GLYPHS.checked : QUESTION_GLYPHS.unchecked : "";
-    const prefix = [focused ? QUESTION_GLYPHS.cursor : " ", marker].filter(Boolean).join(" ");
-    const head = fg10(focused ? Theme.accent.brand : Theme.fg.primary)(`
-${prefix} ${label}`);
-    if (!custom)
-      return [head, fg10(Theme.fg.muted)(` ${description}`)];
-    const typed = draft.custom ? fg10(Theme.fg.primary)(draft.custom) : fg10(Theme.fg.muted)(CUSTOM_PLACEHOLDER);
-    return [
-      head,
-      fg10(Theme.fg.muted)(": "),
-      typed,
-      ...focused ? [fg10(Theme.accent.brand)(TEXT_CURSOR)] : []
-    ];
-  });
+};
+var listRows = (draft) => {
+  const current = readCurrentQuestion(draft);
+  return current ? [...current.options, { label: OTHER_LABEL, description: "", custom: true }] : [];
 };
 
 class QuestionPanel {
+  renderer;
+  onSelectRow;
   renderable;
   text;
-  constructor(renderer) {
+  rows;
+  hint;
+  rowViews = [];
+  constructor(renderer, onSelectRow) {
+    this.renderer = renderer;
+    this.onSelectRow = onSelectRow;
     this.renderable = new BoxRenderable9(renderer, {
       flexDirection: "column",
       marginTop: 1,
       flexShrink: 0
     });
     this.text = new TextRenderable10(renderer, { content: "" });
+    this.rows = new BoxRenderable9(renderer, { flexDirection: "column" });
+    this.hint = new TextRenderable10(renderer, {
+      content: new StyledText9([dim4(fg10(Theme.fg.muted)(QUESTION_HINT))])
+    });
     this.renderable.add(this.text);
+    this.renderable.add(this.rows);
+    this.renderable.add(this.hint);
+  }
+  readRowView(index) {
+    const existing = this.rowViews[index];
+    if (existing)
+      return existing;
+    const created = new TextRenderable10(this.renderer, {
+      content: "",
+      selectable: false,
+      onMouseDown: () => this.onSelectRow(index)
+    });
+    this.rowViews.push(created);
+    this.rows.add(created);
+    return created;
   }
   update(draft) {
     const current = readCurrentQuestion(draft);
@@ -18893,11 +20074,17 @@ class QuestionPanel {
     const progress = draft.questions.length > 1 ? ` (${draft.index + 1}/${draft.questions.length})` : "";
     this.text.content = new StyledText9([
       bold5(fg10(Theme.status.warning)(`>>> ${current.header}${progress}: `)),
-      bold5(fg10(Theme.fg.primary)(current.question)),
-      ...buildRowChunks(draft),
-      dim4(fg10(Theme.fg.muted)(`
-${QUESTION_HINT}`))
+      bold5(fg10(Theme.fg.primary)(current.question))
     ]);
+    const rows = listRows(draft);
+    rows.forEach((row, index) => {
+      const view = this.readRowView(index);
+      view.visible = true;
+      view.content = new StyledText9(buildRowChunks(draft, current.multiSelect === true, row, index));
+    });
+    this.rowViews.slice(rows.length).forEach((view) => {
+      view.visible = false;
+    });
   }
 }
 
@@ -18935,15 +20122,25 @@ class ToolCallView {
       onMouseOver: () => this.setHovered(true),
       onMouseOut: () => this.setHovered(false)
     });
-    this.title = new TextRenderable11(renderer, { content: "", wrapMode: "none", flexShrink: 1 });
-    this.duration = new TextRenderable11(renderer, { content: "", flexShrink: 0, marginLeft: 2 });
+    this.title = new TextRenderable11(renderer, {
+      content: "",
+      wrapMode: "none",
+      flexShrink: 1,
+      selectable: false
+    });
+    this.duration = new TextRenderable11(renderer, {
+      content: "",
+      flexShrink: 0,
+      marginLeft: 2,
+      selectable: false
+    });
     header.add(this.title);
     header.add(this.duration);
     this.body = new BoxRenderable10(renderer, { flexDirection: "column", paddingLeft: 2 });
     this.command = new TextRenderable11(renderer, { content: "", fg: Theme.fg.secondary });
     this.output = new TextRenderable11(renderer, { content: "" });
     this.approval = new ApprovalPanel(renderer, (decision) => hooks.onDecision(decision, this.callId));
-    this.question = new QuestionPanel(renderer);
+    this.question = new QuestionPanel(renderer, (index) => hooks.onSelectRow(index));
     this.body.add(this.command);
     this.body.add(this.output);
     this.renderable.add(header);
@@ -18994,7 +20191,7 @@ class ToolCallView {
     const glyph = call.expanded ? COLLAPSE_GLYPHS.expanded : COLLAPSE_GLYPHS.collapsed;
     const accent = this.hovered ? Theme.accent.brand : undefined;
     this.title.content = new StyledText10([
-      fg11(accent ?? toolColor(call.status))(`${glyph} `),
+      fg11(accent ?? toolColor(call.status))(glyph),
       bold6(fg11(accent ?? Theme.fg.primary)(call.name)),
       fg11(Theme.fg.secondary)(` ${summarizeToolCall(call)}`),
       fg11(Theme.fg.muted)(stats)
@@ -19102,7 +20299,6 @@ class UserMessageView {
       return;
     this.entry = entry;
     this.text.content = new StyledText11([
-      bold7(fg12(Theme.accent.brand)("\u276F ")),
       bold7(fg12(Theme.fg.primary)(clipLines(entry.text, USER_LINES)))
     ]);
     this.clock.content = new StyledText11([fg12(Theme.fg.muted)(formatClock(entry.at))]);
@@ -19213,8 +20409,8 @@ var buildWindowChunks = (label, window, now) => {
 };
 function buildRateLimitChunks(limits, now) {
   const windows = [
-    ["\u2784", limits.fiveHour],
-    ["\u277C", limits.sevenDay]
+    ["\uD83E\uDFF5h", limits.fiveHour],
+    ["\uD83E\uDFF7d", limits.sevenDay]
   ];
   return windows.flatMap(([label, window], index) => window ? [
     ...index > 0 ? [fg13(Theme.border.separator)(SEPARATOR)] : [],
@@ -19342,6 +20538,7 @@ class StatusLine {
       content: "",
       wrapMode: "none",
       flexShrink: 0,
+      selectable: false,
       onMouseDown: onStop
     });
     this.renderable.add(this.label);
@@ -19369,6 +20566,161 @@ class StatusLine {
   }
 }
 
+// apps/tui/src/components/taskPanel.ts
+import {
+  BoxRenderable as BoxRenderable16,
+  bold as bold10,
+  dim as dim8,
+  fg as fg17,
+  StyledText as StyledText15,
+  TextRenderable as TextRenderable16
+} from "@opentui/core";
+
+// apps/tui/src/format/taskRows.ts
+var MAX_TASK_ROWS = 5;
+var readDetail = ({ summary, lastToolName, paused }) => {
+  if (paused)
+    return "Paused";
+  return summary ?? lastToolName ?? "Starting...";
+};
+var buildTaskRow = (task, now) => ({
+  taskId: task.id,
+  kind: task.kind,
+  title: task.description,
+  stats: [formatDuration(Math.max(now - task.startedAt, 0)), `\u2193${formatTokenCount(task.tokens)}`].join(SEPARATOR).trim(),
+  detail: readDetail(task)
+});
+var buildTaskRows = (tasks, now) => tasks.slice(0, MAX_TASK_ROWS).map((task) => buildTaskRow(task, now));
+var buildTaskHeader = (tasks) => `Tasks${SEPARATOR}${tasks.length} running`;
+var countHiddenTasks = (tasks) => Math.max(tasks.length - MAX_TASK_ROWS, 0);
+
+// apps/tui/src/components/taskRowView.ts
+import {
+  BoxRenderable as BoxRenderable15,
+  bold as bold9,
+  dim as dim7,
+  fg as fg16,
+  StyledText as StyledText14,
+  TextRenderable as TextRenderable15
+} from "@opentui/core";
+var SPINNER_STEP_MS2 = 100;
+
+class TaskRowView {
+  renderable;
+  title;
+  stop;
+  detail;
+  taskId = "";
+  constructor(renderer, onStop) {
+    this.renderable = new BoxRenderable15(renderer, { flexShrink: 0, visible: false });
+    const line = new BoxRenderable15(renderer, {
+      flexDirection: "row",
+      justifyContent: "space-between"
+    });
+    this.title = new TextRenderable15(renderer, { content: "", wrapMode: "none" });
+    this.stop = new TextRenderable15(renderer, {
+      content: "",
+      wrapMode: "none",
+      flexShrink: 0,
+      selectable: false,
+      onMouseDown: () => onStop(this.taskId)
+    });
+    this.detail = new TextRenderable15(renderer, { content: "", wrapMode: "none" });
+    line.add(this.title);
+    line.add(this.stop);
+    this.renderable.add(line);
+    this.renderable.add(this.detail);
+  }
+  update(row, now) {
+    this.renderable.visible = row !== undefined;
+    if (!row)
+      return;
+    this.taskId = row.taskId;
+    const frame = SPINNER_FRAMES[Math.floor(now / SPINNER_STEP_MS2) % SPINNER_FRAMES.length];
+    this.title.content = new StyledText14([
+      fg16(Theme.status.success)(`${frame} `),
+      bold9(fg16(Theme.fg.primary)(row.kind)),
+      fg16(Theme.fg.secondary)(` ${row.title}`)
+    ]);
+    this.stop.content = new StyledText14([
+      fg16(Theme.fg.muted)(`${row.stats} `),
+      bold9(fg16(Theme.fg.secondary)("[stop]"))
+    ]);
+    this.detail.content = new StyledText14([dim7(fg16(Theme.fg.muted)(`  \u2514 ${row.detail}`))]);
+  }
+}
+
+// apps/tui/src/components/taskPanel.ts
+class TaskPanel {
+  renderable;
+  header;
+  rows;
+  overflow;
+  constructor(renderer, onStop) {
+    this.renderable = new BoxRenderable16(renderer, {
+      flexShrink: 0,
+      paddingLeft: 2,
+      paddingRight: 2,
+      visible: false
+    });
+    this.header = new TextRenderable16(renderer, { content: "", wrapMode: "none" });
+    this.overflow = new TextRenderable16(renderer, { content: "", wrapMode: "none" });
+    this.rows = Array.from({ length: MAX_TASK_ROWS }, () => new TaskRowView(renderer, onStop));
+    this.renderable.add(this.header);
+    for (const row of this.rows)
+      this.renderable.add(row.renderable);
+    this.renderable.add(this.overflow);
+  }
+  update({ tasks, now }) {
+    this.renderable.visible = tasks.length > 0;
+    if (tasks.length === 0)
+      return;
+    const rows = buildTaskRows(tasks, now);
+    this.header.content = new StyledText15([bold10(fg17(Theme.fg.secondary)(buildTaskHeader(tasks)))]);
+    this.rows.forEach((view, index) => view.update(rows[index], now));
+    const hidden = countHiddenTasks(tasks);
+    this.overflow.content = hidden ? new StyledText15([dim8(fg17(Theme.fg.muted)(`  +${hidden} more`))]) : "";
+  }
+}
+
+// apps/tui/src/components/toastView.ts
+import { BoxRenderable as BoxRenderable17, fg as fg18, StyledText as StyledText16, TextRenderable as TextRenderable17 } from "@opentui/core";
+var TOAST_ICON = "\u25CF";
+
+class ToastView {
+  renderable;
+  text;
+  toastId;
+  constructor(renderer) {
+    this.renderable = new BoxRenderable17(renderer, {
+      position: "absolute",
+      top: 1,
+      right: 2,
+      zIndex: 100,
+      paddingLeft: 1,
+      paddingRight: 1,
+      border: true,
+      borderStyle: "rounded",
+      visible: false
+    });
+    this.text = new TextRenderable17(renderer, { content: "", wrapMode: "none", selectable: false });
+    this.renderable.add(this.text);
+  }
+  update({ ui }) {
+    const { toast } = ui;
+    this.renderable.visible = toast !== null;
+    if (!toast || toast.id === this.toastId)
+      return;
+    this.toastId = toast.id;
+    this.renderable.borderColor = Theme.border.focus;
+    this.renderable.backgroundColor = Theme.bg.surface;
+    this.text.content = new StyledText16([
+      fg18(Theme.status.success)(`${TOAST_ICON} `),
+      fg18(Theme.fg.primary)(toast.text)
+    ]);
+  }
+}
+
 // apps/tui/src/input/agentBusy.ts
 var isStatusBusy = (status) => status !== "idle" && status !== "error";
 var isAgentBusy = (store) => isStatusBusy(store.state.status);
@@ -19410,13 +20762,10 @@ var WORKFLOW_COMMANDS = {
         store.emit({ type: "ui.rewind.picker.opened" });
     }
   },
-  "/view-diffs": {
-    description: "Review the diffs of files this session edited",
+  "/diffs": {
+    description: "Review git changes, or this session's edits when there are none",
     run(store) {
-      const paths = listEditedFiles(store.state);
-      if (paths.length === 0)
-        return postNotice(store, "This session has not edited any files");
-      store.request({ type: "workspace.diff.requested", paths });
+      store.request({ type: "workspace.diff.requested", paths: listEditedFiles(store.state) });
     }
   },
   "/export": {
@@ -19436,13 +20785,30 @@ var WORKFLOW_COMMANDS = {
 };
 
 // apps/tui/src/input/localCommands.ts
-function cycleModel(store) {
-  requestAgent(store, { type: "agent.model.cycle.requested" });
+function openModelPicker2(store) {
+  requestAgent(store, { type: "agent.models.requested" });
 }
 var QUIT_COMMAND = {
   description: "Exit the app (also /exit, /q, /leave)",
   run: (store) => store.emit({ type: "ui.exit.requested" })
 };
+var MCP_USAGE = "Usage: /mcp | /mcp login <name> | /mcp callback <name> <url>";
+function runMcpCommand(store, argument) {
+  const [action, serverName, callbackUrl] = argument.trim().split(/\s+/);
+  if (!action)
+    return void requestAgent(store, { type: "agent.mcp.status.requested" });
+  if (action === "login" && serverName) {
+    return void requestAgent(store, { type: "agent.mcp.login.requested", serverName });
+  }
+  if (action === "callback" && serverName && callbackUrl) {
+    return void requestAgent(store, {
+      type: "agent.mcp.callback.submitted",
+      serverName,
+      callbackUrl
+    });
+  }
+  store.emit({ type: "ui.notice.posted", text: MCP_USAGE });
+}
 var SLASH_ALIASES = {
   "/exit": "/quit",
   "/q": "/quit",
@@ -19468,7 +20834,7 @@ var SLASH_COMMANDS = {
     run(store, model) {
       if (model)
         return void requestAgent(store, { type: "agent.model.set.requested", model });
-      requestAgent(store, { type: "agent.models.requested" });
+      openModelPicker2(store);
     }
   },
   "/theme": {
@@ -19522,10 +20888,8 @@ var SLASH_COMMANDS = {
     }
   },
   "/mcp": {
-    description: "List MCP servers",
-    run(store) {
-      requestAgent(store, { type: "agent.mcp.status.requested" });
-    }
+    description: "List MCP servers, sign in with /mcp login <name>, or /mcp callback <name> <url>",
+    run: runMcpCommand
   },
   "/clear": {
     description: "Start a fresh session",
@@ -19719,6 +21083,46 @@ function routeAutocompleteKey(key, store, accept) {
   return true;
 }
 
+// apps/tui/src/prompt/clipboardPaste.ts
+var PREFERRED_TYPES = ["image/png", "text/plain"];
+async function readClipboardPaste(clipboard) {
+  const result = await clipboard.read({ preferredTypes: PREFERRED_TYPES });
+  if (result.status !== "read")
+    return;
+  const { mimeType, bytes } = result.representation;
+  if (bytes.length === 0)
+    return;
+  return { bytes, metadata: { mimeType, kind: mimeType.startsWith("text/") ? "text" : "binary" } };
+}
+
+// apps/tui/src/input/toastActions.ts
+var TOAST_DURATION_MS = 2500;
+function showToast(store, text) {
+  const id = crypto.randomUUID();
+  store.emit({ type: "ui.toast.posted", id, text });
+  setTimeout(() => store.emit({ type: "ui.toast.dismissed", id }), TOAST_DURATION_MS).unref();
+}
+
+// apps/tui/src/input/clipboardActions.ts
+var UNAVAILABLE_NOTICE = "Clipboard unavailable, use your terminal's paste shortcut";
+var COPIED_TOAST = "Copied to clipboard";
+var COPY_FAILED_TOAST = "Could not copy to clipboard";
+async function pasteFromClipboard(store, input, clipboard) {
+  const content = await readClipboardPaste(clipboard);
+  if (content)
+    input.insertPasted(content);
+  else
+    showToast(store, UNAVAILABLE_NOTICE);
+}
+async function copySelection(store, renderer, clipboard, selection) {
+  const text = selection.getSelectedText();
+  if (!text)
+    return;
+  const written = (await clipboard.writeText(text)).status === "written";
+  const copied = written || renderer.copyToClipboardOSC52(text);
+  showToast(store, copied ? COPIED_TOAST : COPY_FAILED_TOAST);
+}
+
 // apps/tui/src/input/slashCommands.ts
 var parseSlashLine = (line) => {
   const [name = "", ...rest] = line.trim().split(/\s+/);
@@ -19771,6 +21175,9 @@ function answerApproval(store, decision, toolUseId) {
   if (target)
     requestAgent(store, { type: "agent.tool.approval.answered", toolUseId: target, decision });
 }
+function stopTask(store, taskId) {
+  requestAgent(store, { type: "agent.task.stop.requested", taskId });
+}
 function cancelTurn(store) {
   requestAgent(store, { type: "agent.prompt.cancel.requested" });
 }
@@ -19898,7 +21305,7 @@ var routeExit = (key, { store, presses, exit }) => {
     return true;
   }
   presses.ctrlCAt = pressedAt;
-  store.emit({ type: "ui.notice.posted", text: EXIT_NOTICE });
+  showToast(store, EXIT_NOTICE);
   return true;
 };
 var routeDoubleEscape = (key, { store, presses }) => {
@@ -19926,10 +21333,11 @@ var QUESTION_ACTIONS = {
   return: confirmQuestion,
   escape: dismissQuestion
 };
+var DELETE_CHARACTER = "\x7F";
 var readTypedText = (key) => {
   if (key.ctrl || key.meta)
     return;
-  return key.sequence.length === 1 && key.sequence >= " " ? key.sequence : undefined;
+  return key.sequence.length === 1 && key.sequence >= " " && key.sequence !== DELETE_CHARACTER ? key.sequence : undefined;
 };
 function typeCustomAnswer(key, store) {
   const { question } = store.state.ui;
@@ -20014,10 +21422,10 @@ var routePicker = (key, { store }) => {
   }
   return true;
 };
-var routeModelCycle = (key, { store }) => {
+var routeModelPicker = (key, { store }) => {
   if (key.name !== "tab" || !key.shift)
     return false;
-  cycleModel(store);
+  openModelPicker2(store);
   return true;
 };
 var routeDelivery = (key, { store, submitInput }) => {
@@ -20027,6 +21435,14 @@ var routeDelivery = (key, { store, submitInput }) => {
   submitInput(delivery);
   return true;
 };
+var routePaste = (key, { store, pasteClipboard }) => {
+  if (key.name !== "v" || !(key.ctrl || key.super))
+    return false;
+  if (store.state.ui.focus !== "input")
+    return false;
+  pasteClipboard();
+  return true;
+};
 var ROUTES = [
   routeExit,
   routeApproval,
@@ -20034,8 +21450,9 @@ var ROUTES = [
   routeDiffViewer,
   routeBackgroundEditor,
   routePicker,
-  routeModelCycle,
+  routeModelPicker,
   routeDelivery,
+  routePaste,
   routeHistorySearch,
   routeCompletion,
   routeDoubleEscape,
@@ -20179,6 +21596,7 @@ class AppStore {
   machine = new EventMachine(createSessionState(""), reduceTimedEvent);
   peerEvents = new WeakSet;
   stopListening;
+  closed = false;
   constructor(client) {
     this.client = client;
     this.stopListening = client.subscribe((event, peer) => this.receive(event, peer));
@@ -20196,7 +21614,8 @@ class AppStore {
     this.client.send(event);
   }
   emit(event) {
-    this.machine.send(event);
+    if (!this.closed)
+      this.machine.send(event);
   }
   subscribe(listener) {
     return this.machine.subscribe(() => listener(this.machine.state));
@@ -20208,6 +21627,7 @@ class AppStore {
     });
   }
   close() {
+    this.closed = true;
     this.stopListening();
     this.client.close();
   }
@@ -20240,6 +21660,7 @@ var readShownBackground = ({ background, ui }) => ui.backgroundEditor?.color ??
 async function startTui(client, options = {}) {
   const activeRenderer = options.renderer ?? await createCliRenderer({ exitOnCtrlC: false, useMouse: true });
   const store = new AppStore(client);
+  const clipboard = options.clipboard ?? createHostClipboard();
   let syntaxStyle = createSyntaxStyle(activeRenderer);
   let appliedTheme = readShownTheme(store.state);
   let appliedBackground = readShownBackground(store.state);
@@ -20247,13 +21668,16 @@ async function startTui(client, options = {}) {
   const infoBar = new SessionInfoBar(activeRenderer);
   const popover = new ListPopover(activeRenderer);
   const backgroundPanel = new BackgroundPanel(activeRenderer);
+  const toastView = new ToastView(activeRenderer);
   const statusLine = new StatusLine(activeRenderer, () => cancelTurn(store));
+  const taskPanel = new TaskPanel(activeRenderer, (taskId) => stopTask(store, taskId));
   const scrollback = new ScrollbackView(activeRenderer, {
     syntaxStyle,
     hooks: {
       syntaxStyle,
       onDecision: (decision, id) => answerApproval(store, decision, id),
-      onToggle: (callId) => store.emit({ type: "ui.tool.toggled", callId })
+      onToggle: (callId) => store.emit({ type: "ui.tool.toggled", callId }),
+      onSelectRow: (cursor) => store.emit({ type: "ui.question.cursor.set", cursor })
     }
   });
   const diffViewer = new DiffViewerPanel(activeRenderer, syntaxStyle);
@@ -20281,7 +21705,7 @@ async function startTui(client, options = {}) {
       saveDraft(text);
     }
   });
-  const root = new BoxRenderable15(activeRenderer, {
+  const root = new BoxRenderable18(activeRenderer, {
     width: "100%",
     height: "100%",
     flexDirection: "column",
@@ -20292,6 +21716,7 @@ async function startTui(client, options = {}) {
     scrollback,
     diffViewer,
     statusLine,
+    taskPanel,
     popover,
     backgroundPanel,
     input,
@@ -20300,7 +21725,11 @@ async function startTui(client, options = {}) {
   for (const part of parts)
     root.add(part.renderable);
   activeRenderer.root.add(root);
-  for (const part of [header, statusLine, popover, backgroundPanel, input, infoBar]) {
+  activeRenderer.root.add(toastView.renderable);
+  activeRenderer.on("selection", (selection) => {
+    copySelection(store, activeRenderer, clipboard, selection);
+  });
+  for (const part of [header, statusLine, taskPanel, popover, backgroundPanel, input, infoBar]) {
     part.renderable.onMouseScroll = ({ scroll }) => {
       if (scroll?.direction === "up")
         scrollback.scrollByLines(-1);
@@ -20332,6 +21761,8 @@ async function startTui(client, options = {}) {
     syncTheme(state);
     header.update(state);
     statusLine.update(state);
+    taskPanel.update(state);
+    toastView.update(state);
     infoBar.update(state);
     scrollback.update(state);
     scrollback.renderable.visible = state.ui.diffViewer === null;
@@ -20356,7 +21787,10 @@ async function startTui(client, options = {}) {
     notifier.notify(event);
     if (event.type === "ui.exit.requested")
       activeRenderer.destroy();
+    if (event.type === "ui.title.set")
+      activeRenderer.setTerminalTitle(event.title);
   });
+  store.emit({ type: "ui.title.set", title: "Claudin" });
   const editor = {
     read: () => input.text,
     replace: (text) => input.replaceText(text, text.length)
@@ -20370,6 +21804,7 @@ async function startTui(client, options = {}) {
       diffViewer,
       editor,
       acceptCompletion: () => acceptAutocomplete(store, input),
+      pasteClipboard: () => void pasteFromClipboard(store, input, clipboard),
       submitInput,
       exit: () => activeRenderer.destroy()
     };
@@ -20377,7 +21812,8 @@ async function startTui(client, options = {}) {
       key.preventDefault();
   });
   const clock = setInterval(() => {
-    if (store.state.status !== "idle")
+    const { status, tasks } = store.state;
+    if (status !== "idle" || tasks.length > 0)
       store.emit({ type: "ui.clock.ticked", now: Date.now() });
   }, CLOCK_INTERVAL_MS);
   let lastRateLimitAt = Date.now();
@@ -20395,6 +21831,7 @@ async function startTui(client, options = {}) {
     clearInterval(rateLimitPoll);
     destroyed = true;
     historySaver.flush();
+    clipboard.dispose();
     options.onExit?.(store.state.sessionId);
     store.close();
   });
@@ -20506,10 +21943,10 @@ function humanReadableArgName(arg) {
 
 // node_modules/.bun/commander@15.0.0/node_modules/commander/lib/command.js
 import { EventEmitter } from "events";
-import childProcess from "child_process";
-import path from "path";
-import fs from "fs";
-import process2 from "process";
+import childProcess4 from "child_process";
+import path3 from "path";
+import fs6 from "fs";
+import process10 from "process";
 import { stripVTControlCharacters as stripVTControlCharacters2 } from "util";
 
 // node_modules/.bun/commander@15.0.0/node_modules/commander/lib/help.js
@@ -21146,13 +22583,13 @@ class Command extends EventEmitter {
     this._showSuggestionAfterError = true;
     this._savedState = null;
     this._outputConfiguration = {
-      writeOut: (str) => process2.stdout.write(str),
-      writeErr: (str) => process2.stderr.write(str),
+      writeOut: (str) => process10.stdout.write(str),
+      writeErr: (str) => process10.stderr.write(str),
       outputError: (str, write) => write(str),
-      getOutHelpWidth: () => process2.stdout.isTTY ? process2.stdout.columns : undefined,
-      getErrHelpWidth: () => process2.stderr.isTTY ? process2.stderr.columns : undefined,
-      getOutHasColors: () => useColor() ?? (process2.stdout.isTTY && process2.stdout.hasColors?.()),
-      getErrHasColors: () => useColor() ?? (process2.stderr.isTTY && process2.stderr.hasColors?.()),
+      getOutHelpWidth: () => process10.stdout.isTTY ? process10.stdout.columns : undefined,
+      getErrHelpWidth: () => process10.stderr.isTTY ? process10.stderr.columns : undefined,
+      getOutHasColors: () => useColor() ?? (process10.stdout.isTTY && process10.stdout.hasColors?.()),
+      getErrHasColors: () => useColor() ?? (process10.stderr.isTTY && process10.stderr.hasColors?.()),
       stripColor: (str) => stripVTControlCharacters2(str)
     };
     this._hidden = false;
@@ -21360,7 +22797,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
     if (this._exitCallback) {
       this._exitCallback(new CommanderError(exitCode, code, message));
     }
-    process2.exit(exitCode);
+    process10.exit(exitCode);
   }
   action(fn) {
     const listener = (args) => {
@@ -21552,16 +22989,16 @@ Expecting one of '${allowedValues.join("', '")}'`);
     }
     parseOptions = parseOptions || {};
     if (argv === undefined && parseOptions.from === undefined) {
-      if (process2.versions?.electron) {
+      if (process10.versions?.electron) {
         parseOptions.from = "electron";
       }
-      const execArgv = process2.execArgv ?? [];
+      const execArgv = process10.execArgv ?? [];
       if (execArgv.includes("-e") || execArgv.includes("--eval") || execArgv.includes("-p") || execArgv.includes("--print")) {
         parseOptions.from = "eval";
       }
     }
     if (argv === undefined) {
-      argv = process2.argv;
+      argv = process10.argv;
     }
     this.rawArgs = argv.slice();
     let userArgs;
@@ -21572,7 +23009,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
         userArgs = argv.slice(2);
         break;
       case "electron":
-        if (process2.defaultApp) {
+        if (process10.defaultApp) {
           this._scriptPath = argv[1];
           userArgs = argv.slice(2);
         } else {
@@ -21638,7 +23075,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
     this.processedArgs = [];
   }
   _checkForMissingExecutable(executableFile, executableDir, subcommandName) {
-    if (fs.existsSync(executableFile))
+    if (fs6.existsSync(executableFile))
       return;
     const executableDirMessage = executableDir ? `searched for local subcommand relative to directory '${executableDir}'` : "no directory for search for local subcommand, use .executableDir() to supply a custom directory";
     const executableMissing = `'${executableFile}' does not exist
@@ -21651,12 +23088,12 @@ Expecting one of '${allowedValues.join("', '")}'`);
     args = args.slice();
     const sourceExt = [".js", ".ts", ".tsx", ".mjs", ".cjs"];
     function findFile(baseDir, baseName) {
-      const localBin = path.resolve(baseDir, baseName);
-      if (fs.existsSync(localBin))
+      const localBin = path3.resolve(baseDir, baseName);
+      if (fs6.existsSync(localBin))
         return localBin;
-      if (sourceExt.includes(path.extname(baseName)))
+      if (sourceExt.includes(path3.extname(baseName)))
         return;
-      const foundExt = sourceExt.find((ext) => fs.existsSync(`${localBin}${ext}`));
+      const foundExt = sourceExt.find((ext) => fs6.existsSync(`${localBin}${ext}`));
       if (foundExt)
         return `${localBin}${foundExt}`;
       return;
@@ -21668,42 +23105,42 @@ Expecting one of '${allowedValues.join("', '")}'`);
     if (this._scriptPath) {
       let resolvedScriptPath;
       try {
-        resolvedScriptPath = fs.realpathSync(this._scriptPath);
+        resolvedScriptPath = fs6.realpathSync(this._scriptPath);
       } catch {
         resolvedScriptPath = this._scriptPath;
       }
-      executableDir = path.resolve(path.dirname(resolvedScriptPath), executableDir);
+      executableDir = path3.resolve(path3.dirname(resolvedScriptPath), executableDir);
     }
     if (executableDir) {
       let localFile = findFile(executableDir, executableFile);
       if (!localFile && !subcommand._executableFile && this._scriptPath) {
-        const legacyName = path.basename(this._scriptPath, path.extname(this._scriptPath));
+        const legacyName = path3.basename(this._scriptPath, path3.extname(this._scriptPath));
         if (legacyName !== this._name) {
           localFile = findFile(executableDir, `${legacyName}-${subcommand._name}`);
         }
       }
       executableFile = localFile || executableFile;
     }
-    const launchWithNode = sourceExt.includes(path.extname(executableFile));
+    const launchWithNode = sourceExt.includes(path3.extname(executableFile));
     let proc;
-    if (process2.platform !== "win32") {
+    if (process10.platform !== "win32") {
       if (launchWithNode) {
         args.unshift(executableFile);
-        args = incrementNodeInspectorPort(process2.execArgv).concat(args);
-        proc = childProcess.spawn(process2.argv[0], args, { stdio: "inherit" });
+        args = incrementNodeInspectorPort(process10.execArgv).concat(args);
+        proc = childProcess4.spawn(process10.argv[0], args, { stdio: "inherit" });
       } else {
-        proc = childProcess.spawn(executableFile, args, { stdio: "inherit" });
+        proc = childProcess4.spawn(executableFile, args, { stdio: "inherit" });
       }
     } else {
       this._checkForMissingExecutable(executableFile, executableDir, subcommand._name);
       args.unshift(executableFile);
-      args = incrementNodeInspectorPort(process2.execArgv).concat(args);
-      proc = childProcess.spawn(process2.execPath, args, { stdio: "inherit" });
+      args = incrementNodeInspectorPort(process10.execArgv).concat(args);
+      proc = childProcess4.spawn(process10.execPath, args, { stdio: "inherit" });
     }
     if (!proc.killed) {
       const signals = ["SIGUSR1", "SIGUSR2", "SIGTERM", "SIGINT", "SIGHUP"];
       signals.forEach((signal) => {
-        process2.on(signal, () => {
+        process10.on(signal, () => {
           if (proc.killed === false && proc.exitCode === null) {
             proc.kill(signal);
           }
@@ -21714,7 +23151,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
     proc.on("close", (code) => {
       code = code ?? 1;
       if (!exitCallback) {
-        process2.exit(code);
+        process10.exit(code);
       } else {
         exitCallback(new CommanderError(code, "commander.executeSubCommandAsync", "(close)"));
       }
@@ -21726,7 +23163,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
         throw new Error(`'${executableFile}' not executable`);
       }
       if (!exitCallback) {
-        process2.exit(1);
+        process10.exit(1);
       } else {
         const wrappedError = new CommanderError(1, "commander.executeSubCommandAsync", "(error)");
         wrappedError.nestedError = err;
@@ -22075,11 +23512,11 @@ Expecting one of '${allowedValues.join("', '")}'`);
   }
   _parseOptionsEnv() {
     this.options.forEach((option) => {
-      if (option.envVar && option.envVar in process2.env) {
+      if (option.envVar && option.envVar in process10.env) {
         const optionKey = option.attributeName();
         if (this.getOptionValue(optionKey) === undefined || ["default", "config", "env"].includes(this.getOptionValueSource(optionKey))) {
           if (option.required || option.optional) {
-            this.emit(`optionEnv:${option.name()}`, process2.env[option.envVar]);
+            this.emit(`optionEnv:${option.name()}`, process10.env[option.envVar]);
           } else {
             this.emit(`optionEnv:${option.name()}`);
           }
@@ -22275,13 +23712,13 @@ Expecting one of '${allowedValues.join("', '")}'`);
       cmd.helpGroup(this._defaultCommandGroup);
   }
   nameFromFilename(filename) {
-    this._name = path.basename(filename, path.extname(filename));
+    this._name = path3.basename(filename, path3.extname(filename));
     return this;
   }
-  executableDir(path2) {
-    if (path2 === undefined)
+  executableDir(path) {
+    if (path === undefined)
       return this._executableDir;
-    this._executableDir = path2;
+    this._executableDir = path;
     return this;
   }
   helpInformation(contextOptions) {
@@ -22378,7 +23815,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
   }
   help(contextOptions) {
     this.outputHelp(contextOptions);
-    let exitCode = Number(process2.exitCode ?? 0);
+    let exitCode = Number(process10.exitCode ?? 0);
     if (exitCode === 0 && contextOptions && typeof contextOptions !== "function" && contextOptions.error) {
       exitCode = 1;
     }
@@ -22444,9 +23881,9 @@ function incrementNodeInspectorPort(args) {
   });
 }
 function useColor() {
-  if (process2.env.NO_COLOR || process2.env.FORCE_COLOR === "0" || process2.env.FORCE_COLOR === "false")
+  if (process10.env.NO_COLOR || process10.env.FORCE_COLOR === "0" || process10.env.FORCE_COLOR === "false")
     return false;
-  if (process2.env.FORCE_COLOR || process2.env.CLICOLOR_FORCE !== undefined)
+  if (process10.env.FORCE_COLOR || process10.env.CLICOLOR_FORCE !== undefined)
     return true;
   return;
 }