@xortex/xcode 3.0.0

package/utils/fullscreen.ts

@@ -0,0 +1,202 @@
+import { spawnSync } from 'child_process'
+import { getIsInteractive } from '../bootstrap/state.js'
+import { logForDebugging } from './debug.js'
+import { isEnvDefinedFalsy, isEnvTruthy } from './envUtils.js'
+import { execFileNoThrow } from './execFileNoThrow.js'
+
+let loggedTmuxCcDisable = false
+let checkedTmuxMouseHint = false
+
+/**
+ * Cached result from `tmux display-message -p '#{client_control_mode}'`.
+ * undefined = not yet queried (or probe failed) — env heuristic stays authoritative.
+ */
+let tmuxControlModeProbed: boolean | undefined
+
+/**
+ * Env-var heuristic for iTerm2's tmux integration mode (`tmux -CC` / `tmux -2CC`).
+ *
+ * In `-CC` mode, iTerm2 renders tmux panes as native splits — tmux runs
+ * as a server (TMUX is set) but iTerm2 is the actual terminal emulator
+ * for each pane, so TERM_PROGRAM stays `iTerm.app` and TERM is iTerm2's
+ * default (xterm-*). Contrast with regular tmux-inside-iTerm2, where tmux
+ * overwrites TERM_PROGRAM to `tmux` and sets TERM to screen-* or tmux-*.
+ *
+ * This heuristic has known holes (SSH often doesn't propagate TERM_PROGRAM;
+ * .tmux.conf can override TERM) — probeTmuxControlModeSync() is the
+ * authoritative backstop. Kept as a zero-subprocess fast path.
+ */
+function isTmuxControlModeEnvHeuristic(): boolean {
+  if (!process.env.TMUX) return false
+  if (process.env.TERM_PROGRAM !== 'iTerm.app') return false
+  // Belt-and-suspenders: in regular tmux TERM is screen-* or tmux-*;
+  // in -CC mode iTerm2 sets its own TERM (xterm-*).
+  const term = process.env.TERM ?? ''
+  return !term.startsWith('screen') && !term.startsWith('tmux')
+}
+
+/**
+ * Sync one-shot probe: asks tmux directly whether this client is in control
+ * mode via `#{client_control_mode}`. Runs on first isTmuxControlMode() call
+ * when the env heuristic can't decide; result is cached.
+ *
+ * Sync (spawnSync) because the answer gates whether we enter fullscreen — an
+ * async probe raced against React render and lost: coder-tmux (ssh → tmux -CC
+ * on a remote box) doesn't propagate TERM_PROGRAM, so the env heuristic missed,
+ * and by the time the async probe resolved we'd already entered alt-screen with
+ * mouse tracking enabled. Mouse wheel is dead in iTerm2's -CC integration, so
+ * users couldn't scroll at all.
+ *
+ * Cost: one ~5ms subprocess, only when $TMUX is set AND $TERM_PROGRAM is unset
+ * (the SSH-into-tmux case). Local iTerm2 -CC and non-tmux paths skip the spawn.
+ *
+ * The TMUX env check MUST come first — without it, display-message would
+ * query whatever tmux server happens to be running rather than our client.
+ */
+function probeTmuxControlModeSync(): void {
+  // Seed cache with heuristic result so early returns below don't leave it
+  // undefined — isTmuxControlMode() is called 15+ times per render, and an
+  // undefined cache would re-enter this function (re-spawning tmux in the
+  // failure case) on every call.
+  tmuxControlModeProbed = isTmuxControlModeEnvHeuristic()
+  if (tmuxControlModeProbed) return
+  if (!process.env.TMUX) return
+  // Only probe when iTerm might be involved: TERM_PROGRAM is iTerm.app
+  // (covered above) or not set (SSH often doesn't propagate it). When
+  // TERM_PROGRAM is explicitly a non-iTerm terminal, skip — tmux -CC is
+  // an iTerm-only feature, so the subprocess would be wasted.
+  if (process.env.TERM_PROGRAM) return
+  let result
+  try {
+    result = spawnSync(
+      'tmux',
+      ['display-message', '-p', '#{client_control_mode}'],
+      { encoding: 'utf8', timeout: 2000 },
+    )
+  } catch {
+    // spawnSync can throw on some platforms (e.g. ENOENT on Windows if tmux
+    // is absent and the runtime surfaces it as an exception rather than in
+    // result.error). Treat the same as a non-zero exit.
+    return
+  }
+  // Non-zero exit / spawn error: tmux too old (format var added in 2.4) or
+  // unavailable. Keep the heuristic result cached.
+  if (result.status !== 0) return
+  tmuxControlModeProbed = result.stdout.trim() === '1'
+}
+
+/**
+ * True when running under `tmux -CC` (iTerm2 integration mode).
+ *
+ * The alt-screen / mouse-tracking path in fullscreen mode is unrecoverable
+ * in -CC mode (double-click corrupts terminal state; mouse wheel is dead),
+ * so callers auto-disable fullscreen.
+ *
+ * Lazily probes tmux on first call when the env heuristic can't decide.
+ */
+export function isTmuxControlMode(): boolean {
+  if (tmuxControlModeProbed === undefined) probeTmuxControlModeSync()
+  return tmuxControlModeProbed ?? false
+}
+
+export function _resetTmuxControlModeProbeForTesting(): void {
+  tmuxControlModeProbed = undefined
+  loggedTmuxCcDisable = false
+}
+
+/**
+ * Runtime env-var check only. Ants default to on (CLAUDE_CODE_NO_FLICKER=0
+ * to opt out); external users default to off (CLAUDE_CODE_NO_FLICKER=1 to
+ * opt in).
+ */
+export function isFullscreenEnvEnabled(): boolean {
+  // Explicit user opt-out always wins.
+  if (isEnvDefinedFalsy(process.env.CLAUDE_CODE_NO_FLICKER)) return false
+  // Explicit opt-in overrides auto-detection (escape hatch).
+  if (isEnvTruthy(process.env.CLAUDE_CODE_NO_FLICKER)) return true
+  // Auto-disable under tmux -CC: alt-screen + mouse tracking corrupts
+  // terminal state on double-click and mouse wheel is dead.
+  if (isTmuxControlMode()) {
+    if (!loggedTmuxCcDisable) {
+      loggedTmuxCcDisable = true
+      logForDebugging(
+        'fullscreen disabled: tmux -CC (iTerm2 integration mode) detected · set CLAUDE_CODE_NO_FLICKER=1 to override',
+      )
+    }
+    return false
+  }
+  return true
+}
+
+/**
+ * Whether fullscreen mode should enable SGR mouse tracking (DEC 1000/1002/1006).
+ * Set CLAUDE_CODE_DISABLE_MOUSE=1 to keep alt-screen + virtualized scroll
+ * (keyboard PgUp/PgDn/Ctrl+Home/End still work) but skip mouse capture,
+ * so tmux/kitty/terminal-native copy-on-select keeps working.
+ *
+ * Compare with CLAUDE_CODE_NO_FLICKER=0 which is all-or-nothing — it also
+ * disables alt-screen and virtualized scrollback.
+ */
+export function isMouseTrackingEnabled(): boolean {
+  return !isEnvTruthy(process.env.CLAUDE_CODE_DISABLE_MOUSE)
+}
+
+/**
+ * Whether mouse click handling is disabled (clicks/drags ignored, wheel still
+ * works). Set CLAUDE_CODE_DISABLE_MOUSE_CLICKS=1 to prevent accidental clicks
+ * from triggering cursor positioning, text selection, or message expansion.
+ *
+ * Fullscreen-specific — only reachable when CLAUDE_CODE_NO_FLICKER is active.
+ */
+export function isMouseClicksDisabled(): boolean {
+  return isEnvTruthy(process.env.CLAUDE_CODE_DISABLE_MOUSE_CLICKS)
+}
+
+/**
+ * True when the fullscreen alt-screen layout is actually rendering —
+ * requires an interactive REPL session AND the env var not explicitly
+ * set falsy. Headless paths (--print, SDK, in-process teammates) never
+ * enter fullscreen, so features that depend on alt-screen re-rendering
+ * should gate on this.
+ */
+export function isFullscreenActive(): boolean {
+  return getIsInteractive() && isFullscreenEnvEnabled()
+}
+
+/**
+ * One-time hint for tmux users in fullscreen with `mouse off`.
+ *
+ * tmux's `mouse` option is session-scoped by design — there is no
+ * pane-level equivalent. We used to `tmux set mouse on` when entering
+ * alt-screen so wheel scrolling worked, but that changed mouse behavior
+ * for every sibling pane (vim, less, shell) and leaked on kill-pane or
+ * when multiple CC instances raced on restore. Now we leave tmux state
+ * alone — same as vim/less/htop — and just tell the user their options.
+ *
+ * Fire-and-forget from REPL startup. Returns the hint text once per
+ * session if TMUX is set, fullscreen is active, and tmux's current
+ * `mouse` option is off; null otherwise.
+ */
+export async function maybeGetTmuxMouseHint(): Promise<string | null> {
+  if (!process.env.TMUX) return null
+  // tmux -CC auto-disables fullscreen above, but belt-and-suspenders.
+  if (!isFullscreenActive() || isTmuxControlMode()) return null
+  if (checkedTmuxMouseHint) return null
+  checkedTmuxMouseHint = true
+  // -A includes inherited values: `show -v mouse` returns empty when the
+  // option is set globally (`set -g mouse on` in .tmux.conf) but not at
+  // session level — which is the common case. -A gives the effective value.
+  const { stdout, code } = await execFileNoThrow(
+    'tmux',
+    ['show', '-Av', 'mouse'],
+    { useCwd: false, timeout: 2000 },
+  )
+  if (code !== 0 || stdout.trim() === 'on') return null
+  return "tmux detected · scroll with PgUp/PgDn · or add 'set -g mouse on' to ~/.tmux.conf for wheel scroll"
+}
+
+/** Test-only: reset module-level once-per-session flags. */
+export function _resetForTesting(): void {
+  loggedTmuxCcDisable = false
+  checkedTmuxMouseHint = false
+}

package/utils/generatedFiles.ts

@@ -0,0 +1,136 @@
+import { basename, extname, posix, sep } from 'path'
+
+/**
+ * File patterns that should be excluded from attribution.
+ * Based on GitHub Linguist vendored patterns and common generated file patterns.
+ */
+
+// Exact file name matches (case-insensitive)
+const EXCLUDED_FILENAMES = new Set([
+  'package-lock.json',
+  'yarn.lock',
+  'pnpm-lock.yaml',
+  'bun.lockb',
+  'bun.lock',
+  'composer.lock',
+  'gemfile.lock',
+  'cargo.lock',
+  'poetry.lock',
+  'pipfile.lock',
+  'shrinkwrap.json',
+  'npm-shrinkwrap.json',
+])
+
+// File extension patterns (case-insensitive)
+const EXCLUDED_EXTENSIONS = new Set([
+  '.lock',
+  '.min.js',
+  '.min.css',
+  '.min.html',
+  '.bundle.js',
+  '.bundle.css',
+  '.generated.ts',
+  '.generated.js',
+  '.d.ts', // TypeScript declaration files
+])
+
+// Directory patterns that indicate generated/vendored content
+const EXCLUDED_DIRECTORIES = [
+  '/dist/',
+  '/build/',
+  '/out/',
+  '/output/',
+  '/node_modules/',
+  '/vendor/',
+  '/vendored/',
+  '/third_party/',
+  '/third-party/',
+  '/external/',
+  '/.next/',
+  '/.nuxt/',
+  '/.svelte-kit/',
+  '/coverage/',
+  '/__pycache__/',
+  '/.tox/',
+  '/venv/',
+  '/.venv/',
+  '/target/release/',
+  '/target/debug/',
+]
+
+// Filename patterns using regex for more complex matching
+const EXCLUDED_FILENAME_PATTERNS = [
+  /^.*\.min\.[a-z]+$/i, // *.min.*
+  /^.*-min\.[a-z]+$/i, // *-min.*
+  /^.*\.bundle\.[a-z]+$/i, // *.bundle.*
+  /^.*\.generated\.[a-z]+$/i, // *.generated.*
+  /^.*\.gen\.[a-z]+$/i, // *.gen.*
+  /^.*\.auto\.[a-z]+$/i, // *.auto.*
+  /^.*_generated\.[a-z]+$/i, // *_generated.*
+  /^.*_gen\.[a-z]+$/i, // *_gen.*
+  /^.*\.pb\.(go|js|ts|py|rb)$/i, // Protocol buffer generated files
+  /^.*_pb2?\.py$/i, // Python protobuf files
+  /^.*\.pb\.h$/i, // C++ protobuf headers
+  /^.*\.grpc\.[a-z]+$/i, // gRPC generated files
+  /^.*\.swagger\.[a-z]+$/i, // Swagger generated files
+  /^.*\.openapi\.[a-z]+$/i, // OpenAPI generated files
+]
+
+/**
+ * Check if a file should be excluded from attribution based on Linguist-style rules.
+ *
+ * @param filePath - Relative file path from repository root
+ * @returns true if the file should be excluded from attribution
+ */
+export function isGeneratedFile(filePath: string): boolean {
+  // Normalize path separators for consistent pattern matching (patterns use posix-style /)
+  const normalizedPath =
+    posix.sep + filePath.split(sep).join(posix.sep).replace(/^\/+/, '')
+  const fileName = basename(filePath).toLowerCase()
+  const ext = extname(filePath).toLowerCase()
+
+  // Check exact filename matches
+  if (EXCLUDED_FILENAMES.has(fileName)) {
+    return true
+  }
+
+  // Check extension matches
+  if (EXCLUDED_EXTENSIONS.has(ext)) {
+    return true
+  }
+
+  // Check for compound extensions like .min.js
+  const parts = fileName.split('.')
+  if (parts.length > 2) {
+    const compoundExt = '.' + parts.slice(-2).join('.')
+    if (EXCLUDED_EXTENSIONS.has(compoundExt)) {
+      return true
+    }
+  }
+
+  // Check directory patterns
+  for (const dir of EXCLUDED_DIRECTORIES) {
+    if (normalizedPath.includes(dir)) {
+      return true
+    }
+  }
+
+  // Check filename patterns
+  for (const pattern of EXCLUDED_FILENAME_PATTERNS) {
+    if (pattern.test(fileName)) {
+      return true
+    }
+  }
+
+  return false
+}
+
+/**
+ * Filter a list of files to exclude generated files.
+ *
+ * @param files - Array of file paths
+ * @returns Array of files that are not generated
+ */
+export function filterGeneratedFiles(files: string[]): string[] {
+  return files.filter(file => !isGeneratedFile(file))
+}

package/utils/generators.ts

@@ -0,0 +1,88 @@
+const NO_VALUE = Symbol('NO_VALUE')
+
+export async function lastX<A>(as: AsyncGenerator<A>): Promise<A> {
+  let lastValue: A | typeof NO_VALUE = NO_VALUE
+  for await (const a of as) {
+    lastValue = a
+  }
+  if (lastValue === NO_VALUE) {
+    throw new Error('No items in generator')
+  }
+  return lastValue
+}
+
+export async function returnValue<A>(
+  as: AsyncGenerator<unknown, A>,
+): Promise<A> {
+  let e
+  do {
+    e = await as.next()
+  } while (!e.done)
+  return e.value
+}
+
+type QueuedGenerator<A> = {
+  done: boolean | void
+  value: A | void
+  generator: AsyncGenerator<A, void>
+  promise: Promise<QueuedGenerator<A>>
+}
+
+// Run all generators concurrently up to a concurrency cap, yielding values as they come in
+export async function* all<A>(
+  generators: AsyncGenerator<A, void>[],
+  concurrencyCap = Infinity,
+): AsyncGenerator<A, void> {
+  const next = (generator: AsyncGenerator<A, void>) => {
+    const promise: Promise<QueuedGenerator<A>> = generator
+      .next()
+      .then(({ done, value }) => ({
+        done,
+        value,
+        generator,
+        promise,
+      }))
+    return promise
+  }
+  const waiting = [...generators]
+  const promises = new Set<Promise<QueuedGenerator<A>>>()
+
+  // Start initial batch up to concurrency cap
+  while (promises.size < concurrencyCap && waiting.length > 0) {
+    const gen = waiting.shift()!
+    promises.add(next(gen))
+  }
+
+  while (promises.size > 0) {
+    const { done, value, generator, promise } = await Promise.race(promises)
+    promises.delete(promise)
+
+    if (!done) {
+      promises.add(next(generator))
+      // TODO: Clean this up
+      if (value !== undefined) {
+        yield value
+      }
+    } else if (waiting.length > 0) {
+      // Start a new generator when one finishes
+      const nextGen = waiting.shift()!
+      promises.add(next(nextGen))
+    }
+  }
+}
+
+export async function toArray<A>(
+  generator: AsyncGenerator<A, void>,
+): Promise<A[]> {
+  const result: A[] = []
+  for await (const a of generator) {
+    result.push(a)
+  }
+  return result
+}
+
+export async function* fromArray<T>(values: T[]): AsyncGenerator<T, void> {
+  for (const value of values) {
+    yield value
+  }
+}

package/utils/genericProcessUtils.ts

@@ -0,0 +1,184 @@
+import {
+  execFileNoThrowWithCwd,
+  execSyncWithDefaults_DEPRECATED,
+} from './execFileNoThrow.js'
+
+// This file contains platform-agnostic implementations of common `ps` type commands.
+// When adding new code to this file, make sure to handle:
+// - Win32, as `ps` within cygwin and WSL may not behave as expected, particularly when attempting to access processes on the host.
+// - Unix vs BSD-style `ps` have different options.
+
+/**
+ * Check if a process with the given PID is running (signal 0 probe).
+ *
+ * PID ≤ 1 returns false (0 is current process group, 1 is init).
+ *
+ * Note: `process.kill(pid, 0)` throws EPERM when the process exists but is
+ * owned by another user. This reports such processes as NOT running, which
+ * is conservative for lock recovery (we won't steal a live lock).
+ */
+export function isProcessRunning(pid: number): boolean {
+  if (pid <= 1) return false
+  try {
+    process.kill(pid, 0)
+    return true
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Gets the ancestor process chain for a given process (up to maxDepth levels)
+ * @param pid - The starting process ID
+ * @param maxDepth - Maximum number of ancestors to fetch (default: 10)
+ * @returns Array of ancestor PIDs from immediate parent to furthest ancestor
+ */
+export async function getAncestorPidsAsync(
+  pid: string | number,
+  maxDepth = 10,
+): Promise<number[]> {
+  if (process.platform === 'win32') {
+    // For Windows, use a PowerShell script that walks the process tree
+    const script = `
+      $pid = ${String(pid)}
+      $ancestors = @()
+      for ($i = 0; $i -lt ${maxDepth}; $i++) {
+        $proc = Get-CimInstance Win32_Process -Filter "ProcessId=$pid" -ErrorAction SilentlyContinue
+        if (-not $proc -or -not $proc.ParentProcessId -or $proc.ParentProcessId -eq 0) { break }
+        $pid = $proc.ParentProcessId
+        $ancestors += $pid
+      }
+      $ancestors -join ','
+    `.trim()
+
+    const result = await execFileNoThrowWithCwd(
+      'powershell.exe',
+      ['-NoProfile', '-Command', script],
+      { timeout: 3000 },
+    )
+    if (result.code !== 0 || !result.stdout?.trim()) {
+      return []
+    }
+    return result.stdout
+      .trim()
+      .split(',')
+      .filter(Boolean)
+      .map(p => parseInt(p, 10))
+      .filter(p => !isNaN(p))
+  }
+
+  // For Unix, use a shell command that walks up the process tree
+  // This uses a single process invocation instead of multiple sequential calls
+  const script = `pid=${String(pid)}; for i in $(seq 1 ${maxDepth}); do ppid=$(ps -o ppid= -p $pid 2>/dev/null | tr -d ' '); if [ -z "$ppid" ] || [ "$ppid" = "0" ] || [ "$ppid" = "1" ]; then break; fi; echo $ppid; pid=$ppid; done`
+
+  const result = await execFileNoThrowWithCwd('sh', ['-c', script], {
+    timeout: 3000,
+  })
+  if (result.code !== 0 || !result.stdout?.trim()) {
+    return []
+  }
+  return result.stdout
+    .trim()
+    .split('\n')
+    .filter(Boolean)
+    .map(p => parseInt(p, 10))
+    .filter(p => !isNaN(p))
+}
+
+/**
+ * Gets the command line for a given process
+ * @param pid - The process ID to get the command for
+ * @returns The command line string, or null if not found
+ * @deprecated Use getAncestorCommandsAsync instead
+ */
+export function getProcessCommand(pid: string | number): string | null {
+  try {
+    const pidStr = String(pid)
+    const command =
+      process.platform === 'win32'
+        ? `powershell.exe -NoProfile -Command "(Get-CimInstance Win32_Process -Filter \\"ProcessId=${pidStr}\\").CommandLine"`
+        : `ps -o command= -p ${pidStr}`
+
+    const result = execSyncWithDefaults_DEPRECATED(command, { timeout: 1000 })
+    return result ? result.trim() : null
+  } catch {
+    return null
+  }
+}
+
+/**
+ * Gets the command lines for a process and its ancestors in a single call
+ * @param pid - The starting process ID
+ * @param maxDepth - Maximum depth to traverse (default: 10)
+ * @returns Array of command strings for the process chain
+ */
+export async function getAncestorCommandsAsync(
+  pid: string | number,
+  maxDepth = 10,
+): Promise<string[]> {
+  if (process.platform === 'win32') {
+    // For Windows, use a PowerShell script that walks the process tree and collects commands
+    const script = `
+      $currentPid = ${String(pid)}
+      $commands = @()
+      for ($i = 0; $i -lt ${maxDepth}; $i++) {
+        $proc = Get-CimInstance Win32_Process -Filter "ProcessId=$currentPid" -ErrorAction SilentlyContinue
+        if (-not $proc) { break }
+        if ($proc.CommandLine) { $commands += $proc.CommandLine }
+        if (-not $proc.ParentProcessId -or $proc.ParentProcessId -eq 0) { break }
+        $currentPid = $proc.ParentProcessId
+      }
+      $commands -join [char]0
+    `.trim()
+
+    const result = await execFileNoThrowWithCwd(
+      'powershell.exe',
+      ['-NoProfile', '-Command', script],
+      { timeout: 3000 },
+    )
+    if (result.code !== 0 || !result.stdout?.trim()) {
+      return []
+    }
+    return result.stdout.split('\0').filter(Boolean)
+  }
+
+  // For Unix, use a shell command that walks up the process tree and collects commands
+  // Using null byte as separator to handle commands with newlines
+  const script = `currentpid=${String(pid)}; for i in $(seq 1 ${maxDepth}); do cmd=$(ps -o command= -p $currentpid 2>/dev/null); if [ -n "$cmd" ]; then printf '%s\\0' "$cmd"; fi; ppid=$(ps -o ppid= -p $currentpid 2>/dev/null | tr -d ' '); if [ -z "$ppid" ] || [ "$ppid" = "0" ] || [ "$ppid" = "1" ]; then break; fi; currentpid=$ppid; done`
+
+  const result = await execFileNoThrowWithCwd('sh', ['-c', script], {
+    timeout: 3000,
+  })
+  if (result.code !== 0 || !result.stdout?.trim()) {
+    return []
+  }
+  return result.stdout.split('\0').filter(Boolean)
+}
+
+/**
+ * Gets the child process IDs for a given process
+ * @param pid - The parent process ID
+ * @returns Array of child process IDs as numbers
+ */
+export function getChildPids(pid: string | number): number[] {
+  try {
+    const pidStr = String(pid)
+    const command =
+      process.platform === 'win32'
+        ? `powershell.exe -NoProfile -Command "(Get-CimInstance Win32_Process -Filter \\"ParentProcessId=${pidStr}\\").ProcessId"`
+        : `pgrep -P ${pidStr}`
+
+    const result = execSyncWithDefaults_DEPRECATED(command, { timeout: 1000 })
+    if (!result) {
+      return []
+    }
+    return result
+      .trim()
+      .split('\n')
+      .filter(Boolean)
+      .map(p => parseInt(p, 10))
+      .filter(p => !isNaN(p))
+  } catch {
+    return []
+  }
+}

package/utils/getWorktreePaths.ts

@@ -0,0 +1,70 @@
+import { sep } from 'path'
+import { logEvent } from '../services/analytics/index.js'
+import { execFileNoThrowWithCwd } from './execFileNoThrow.js'
+import { gitExe } from './git.js'
+
+/**
+ * Returns the paths of all worktrees for the current git repository.
+ * If git is not available, not in a git repo, or only has one worktree,
+ * returns an empty array.
+ *
+ * This version includes analytics tracking and uses the CLI's gitExe()
+ * resolver. For a portable version without CLI deps, use
+ * getWorktreePathsPortable().
+ *
+ * @param cwd Directory to run the command from
+ * @returns Array of absolute worktree paths
+ */
+export async function getWorktreePaths(cwd: string): Promise<string[]> {
+  const startTime = Date.now()
+
+  const { stdout, code } = await execFileNoThrowWithCwd(
+    gitExe(),
+    ['worktree', 'list', '--porcelain'],
+    {
+      cwd,
+      preserveOutputOnError: false,
+    },
+  )
+
+  const durationMs = Date.now() - startTime
+
+  if (code !== 0) {
+    logEvent('tengu_worktree_detection', {
+      duration_ms: durationMs,
+      worktree_count: 0,
+      success: false,
+    })
+    return []
+  }
+
+  // Parse porcelain output - lines starting with "worktree " contain paths
+  // Example:
+  // worktree /Users/foo/repo
+  // HEAD abc123
+  // branch refs/heads/main
+  //
+  // worktree /Users/foo/repo-wt1
+  // HEAD def456
+  // branch refs/heads/feature
+  const worktreePaths = stdout
+    .split('\n')
+    .filter(line => line.startsWith('worktree '))
+    .map(line => line.slice('worktree '.length).normalize('NFC'))
+
+  logEvent('tengu_worktree_detection', {
+    duration_ms: durationMs,
+    worktree_count: worktreePaths.length,
+    success: true,
+  })
+
+  // Sort worktrees: current worktree first, then alphabetically
+  const currentWorktree = worktreePaths.find(
+    path => cwd === path || cwd.startsWith(path + sep),
+  )
+  const otherWorktrees = worktreePaths
+    .filter(path => path !== currentWorktree)
+    .sort((a, b) => a.localeCompare(b))
+
+  return currentWorktree ? [currentWorktree, ...otherWorktrees] : otherWorktrees
+}