@iaforged/context-code 1.0.72 → 1.0.74

package/dist/src/utils/fullscreen.js

@@ -0,0 +1,194 @@
+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;
+/**
+ * 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() {
+    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() {
+    // 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() {
+    if (tmuxControlModeProbed === undefined)
+        probeTmuxControlModeSync();
+    return tmuxControlModeProbed ?? false;
+}
+export function _resetTmuxControlModeProbeForTesting() {
+    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() {
+    // 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 process.env.USER_TYPE === 'ant';
+}
+/**
+ * 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() {
+    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() {
+    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() {
+    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() {
+    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() {
+    loggedTmuxCcDisable = false;
+    checkedTmuxMouseHint = false;
+}

package/dist/src/utils/generatedFiles.js

@@ -0,0 +1,122 @@
+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) {
+    // 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) {
+    return files.filter(file => !isGeneratedFile(file));
+}

package/dist/src/utils/generators.js

@@ -0,0 +1,67 @@
+const NO_VALUE = Symbol('NO_VALUE');
+export async function lastX(as) {
+    let lastValue = 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(as) {
+    let e;
+    do {
+        e = await as.next();
+    } while (!e.done);
+    return e.value;
+}
+// Run all generators concurrently up to a concurrency cap, yielding values as they come in
+export async function* all(generators, concurrencyCap = Infinity) {
+    const next = (generator) => {
+        const promise = generator
+            .next()
+            .then(({ done, value }) => ({
+            done,
+            value,
+            generator,
+            promise,
+        }));
+        return promise;
+    };
+    const waiting = [...generators];
+    const promises = new Set();
+    // 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(generator) {
+    const result = [];
+    for await (const a of generator) {
+        result.push(a);
+    }
+    return result;
+}
+export async function* fromArray(values) {
+    for (const value of values) {
+        yield value;
+    }
+}

package/dist/src/utils/genericProcessUtils.js

@@ -0,0 +1,155 @@
+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) {
+    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, maxDepth = 10) {
+    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) {
+    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, maxDepth = 10) {
+    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) {
+    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/dist/src/utils/getWorktreePaths.js

@@ -0,0 +1,56 @@
+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) {
+    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;
+}

package/dist/src/utils/getWorktreePathsPortable.js

@@ -0,0 +1,23 @@
+import { execFile as execFileCb } from 'child_process';
+import { promisify } from 'util';
+const execFileAsync = promisify(execFileCb);
+/**
+ * Portable worktree detection using only child_process — no analytics,
+ * no bootstrap deps, no execa. Used by listSessionsImpl.ts (SDK) and
+ * anywhere that needs worktree paths without pulling in the CLI
+ * dependency chain (execa → cross-spawn → which).
+ */
+export async function getWorktreePathsPortable(cwd) {
+    try {
+        const { stdout } = await execFileAsync('git', ['worktree', 'list', '--porcelain'], { cwd, timeout: 5000 });
+        if (!stdout)
+            return [];
+        return stdout
+            .split('\n')
+            .filter(line => line.startsWith('worktree '))
+            .map(line => line.slice('worktree '.length).normalize('NFC'));
+    }
+    catch {
+        return [];
+    }
+}