@iaforged/context-code 1.0.63 → 1.0.67

package/dist/src/utils/fullscreen.js

@@ -1,194 +0,0 @@
-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

@@ -1,122 +0,0 @@
-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

@@ -1,67 +0,0 @@
-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

@@ -1,155 +0,0 @@
-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

@@ -1,56 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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 [];
-    }
-}