@iaforged/context-code 1.0.63 → 1.0.65

package/dist/src/utils/json.js

@@ -1,295 +0,0 @@
-var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
-    if (value !== null && value !== void 0) {
-        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
-        var dispose, inner;
-        if (async) {
-            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
-            dispose = value[Symbol.asyncDispose];
-        }
-        if (dispose === void 0) {
-            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
-            dispose = value[Symbol.dispose];
-            if (async) inner = dispose;
-        }
-        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
-        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
-        env.stack.push({ value: value, dispose: dispose, async: async });
-    }
-    else if (async) {
-        env.stack.push({ async: true });
-    }
-    return value;
-};
-var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
-    return function (env) {
-        function fail(e) {
-            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
-            env.hasError = true;
-        }
-        var r, s = 0;
-        function next() {
-            while (r = env.stack.pop()) {
-                try {
-                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
-                    if (r.dispose) {
-                        var result = r.dispose.call(r.value);
-                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
-                    }
-                    else s |= 1;
-                }
-                catch (e) {
-                    fail(e);
-                }
-            }
-            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
-            if (env.hasError) throw env.error;
-        }
-        return next();
-    };
-})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-    var e = new Error(message);
-    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-});
-import { open, readFile, stat } from 'fs/promises';
-import { applyEdits, modify, parse as parseJsonc, } from 'jsonc-parser/lib/umd/main.js';
-import { stripBOM } from './jsonRead.js';
-import { logError } from './log.js';
-import { memoizeWithLRU } from './memoize.js';
-import { jsonStringify } from './slowOperations.js';
-// Memoized inner parse. Uses a discriminated-union wrapper because:
-// 1. memoizeWithLRU requires NonNullable<unknown>, but JSON.parse can return
-//    null (e.g. JSON.parse("null")).
-// 2. Invalid JSON must also be cached — otherwise repeated calls with the same
-//    bad string re-parse and re-log every time (behavioral regression vs the
-//    old lodash memoize which wrapped the entire try/catch).
-// Bounded to 50 entries to prevent unbounded memory growth — previously this
-// used lodash memoize which cached every unique JSON string forever (settings,
-// .mcp.json, notebooks, tool results), causing a significant memory leak.
-// Note: shouldLogError is intentionally excluded from the cache key (matching
-// lodash memoize default resolver = first arg only).
-// Skip caching above this size — the LRU stores the full string as the key,
-// so a 200KB config file would pin ~10MB in #keyList across 50 slots. Large
-// inputs like ~/.claude.json also change between reads (numStartups bumps on
-// every CC startup), so the cache never hits anyway.
-const PARSE_CACHE_MAX_KEY_BYTES = 8 * 1024;
-function parseJSONUncached(json, shouldLogError) {
-    try {
-        return { ok: true, value: JSON.parse(stripBOM(json)) };
-    }
-    catch (e) {
-        if (shouldLogError) {
-            logError(e);
-        }
-        return { ok: false };
-    }
-}
-const parseJSONCached = memoizeWithLRU(parseJSONUncached, json => json, 50);
-// Important: memoized for performance (LRU-bounded to 50 entries, small inputs only).
-export const safeParseJSON = Object.assign(function safeParseJSON(json, shouldLogError = true) {
-    if (!json)
-        return null;
-    const result = json.length > PARSE_CACHE_MAX_KEY_BYTES
-        ? parseJSONUncached(json, shouldLogError)
-        : parseJSONCached(json, shouldLogError);
-    return result.ok ? result.value : null;
-}, { cache: parseJSONCached.cache });
-/**
- * Safely parse JSON with comments (jsonc).
- * This is useful for VS Code configuration files like keybindings.json
- * which support comments and other jsonc features.
- */
-export function safeParseJSONC(json) {
-    if (!json) {
-        return null;
-    }
-    try {
-        // Strip BOM before parsing - PowerShell 5.x adds BOM to UTF-8 files
-        return parseJsonc(stripBOM(json));
-    }
-    catch (e) {
-        logError(e);
-        return null;
-    }
-}
-const bunJSONLParse = (() => {
-    if (typeof Bun === 'undefined')
-        return false;
-    const b = Bun;
-    const jsonl = b.JSONL;
-    if (!jsonl?.parseChunk)
-        return false;
-    return jsonl.parseChunk;
-})();
-function parseJSONLBun(data) {
-    const parse = bunJSONLParse;
-    const len = data.length;
-    const result = parse(data);
-    if (!result.error || result.done || result.read >= len) {
-        return result.values;
-    }
-    // Had an error mid-stream — collect what we got and keep going
-    let values = result.values;
-    let offset = result.read;
-    while (offset < len) {
-        const newlineIndex = typeof data === 'string'
-            ? data.indexOf('\n', offset)
-            : data.indexOf(0x0a, offset);
-        if (newlineIndex === -1)
-            break;
-        offset = newlineIndex + 1;
-        const next = parse(data, offset);
-        if (next.values.length > 0) {
-            values = values.concat(next.values);
-        }
-        if (!next.error || next.done || next.read >= len)
-            break;
-        offset = next.read;
-    }
-    return values;
-}
-function parseJSONLBuffer(buf) {
-    const bufLen = buf.length;
-    let start = 0;
-    // Strip UTF-8 BOM (EF BB BF)
-    if (buf[0] === 0xef && buf[1] === 0xbb && buf[2] === 0xbf) {
-        start = 3;
-    }
-    const results = [];
-    while (start < bufLen) {
-        let end = buf.indexOf(0x0a, start);
-        if (end === -1)
-            end = bufLen;
-        const line = buf.toString('utf8', start, end).trim();
-        start = end + 1;
-        if (!line)
-            continue;
-        try {
-            results.push(JSON.parse(line));
-        }
-        catch {
-            // Skip malformed lines
-        }
-    }
-    return results;
-}
-function parseJSONLString(data) {
-    const stripped = stripBOM(data);
-    const len = stripped.length;
-    let start = 0;
-    const results = [];
-    while (start < len) {
-        let end = stripped.indexOf('\n', start);
-        if (end === -1)
-            end = len;
-        const line = stripped.substring(start, end).trim();
-        start = end + 1;
-        if (!line)
-            continue;
-        try {
-            results.push(JSON.parse(line));
-        }
-        catch {
-            // Skip malformed lines
-        }
-    }
-    return results;
-}
-/**
- * Parses JSONL data from a string or Buffer, skipping malformed lines.
- * Uses Bun.JSONL.parseChunk when available for better performance,
- * falls back to indexOf-based scanning otherwise.
- */
-export function parseJSONL(data) {
-    if (bunJSONLParse) {
-        return parseJSONLBun(data);
-    }
-    if (typeof data === 'string') {
-        return parseJSONLString(data);
-    }
-    return parseJSONLBuffer(data);
-}
-const MAX_JSONL_READ_BYTES = 100 * 1024 * 1024;
-/**
- * Reads and parses a JSONL file, reading at most the last 100 MB.
- * For files larger than 100 MB, reads the tail and skips the first partial line.
- *
- * 100 MB is more than sufficient since the longest context window we support
- * is ~2M tokens, which is well under 100 MB of JSONL.
- */
-export async function readJSONLFile(filePath) {
-    const env_1 = { stack: [], error: void 0, hasError: false };
-    try {
-        const { size } = await stat(filePath);
-        if (size <= MAX_JSONL_READ_BYTES) {
-            return parseJSONL(await readFile(filePath));
-        }
-        const fd = __addDisposableResource(env_1, await open(filePath, 'r'), true);
-        const buf = Buffer.allocUnsafe(MAX_JSONL_READ_BYTES);
-        let totalRead = 0;
-        const fileOffset = size - MAX_JSONL_READ_BYTES;
-        while (totalRead < MAX_JSONL_READ_BYTES) {
-            const { bytesRead } = await fd.read(buf, totalRead, MAX_JSONL_READ_BYTES - totalRead, fileOffset + totalRead);
-            if (bytesRead === 0)
-                break;
-            totalRead += bytesRead;
-        }
-        // Skip the first partial line
-        const newlineIndex = buf.indexOf(0x0a);
-        if (newlineIndex !== -1 && newlineIndex < totalRead - 1) {
-            return parseJSONL(buf.subarray(newlineIndex + 1, totalRead));
-        }
-        return parseJSONL(buf.subarray(0, totalRead));
-    }
-    catch (e_1) {
-        env_1.error = e_1;
-        env_1.hasError = true;
-    }
-    finally {
-        const result_1 = __disposeResources(env_1);
-        if (result_1)
-            await result_1;
-    }
-}
-export function addItemToJSONCArray(content, newItem) {
-    try {
-        // If the content is empty or whitespace, create a new JSON file
-        if (!content || content.trim() === '') {
-            return jsonStringify([newItem], null, 4);
-        }
-        // Strip BOM before parsing - PowerShell 5.x adds BOM to UTF-8 files
-        const cleanContent = stripBOM(content);
-        // Parse the content to check if it's valid JSON
-        const parsedContent = parseJsonc(cleanContent);
-        // If the parsed content is a valid array, modify it
-        if (Array.isArray(parsedContent)) {
-            // Get the length of the array
-            const arrayLength = parsedContent.length;
-            // Determine if we are dealing with an empty array
-            const isEmpty = arrayLength === 0;
-            // If it's an empty array we want to add at index 0, otherwise append to the end
-            const insertPath = isEmpty ? [0] : [arrayLength];
-            // Generate edits - we're using isArrayInsertion to add a new item without overwriting existing ones
-            const edits = modify(cleanContent, insertPath, newItem, {
-                formattingOptions: { insertSpaces: true, tabSize: 4 },
-                isArrayInsertion: true,
-            });
-            // If edits could not be generated, fall back to manual JSON string manipulation
-            if (!edits || edits.length === 0) {
-                const copy = [...parsedContent, newItem];
-                return jsonStringify(copy, null, 4);
-            }
-            // Apply the edits to preserve comments (use cleanContent without BOM)
-            return applyEdits(cleanContent, edits);
-        }
-        // If it's not an array at all, create a new array with the item
-        else {
-            // If the content exists but is not an array, we'll replace it completely
-            return jsonStringify([newItem], null, 4);
-        }
-    }
-    catch (e) {
-        // If parsing fails for any reason, log the error and fallback to creating a new JSON array
-        logError(e);
-        return jsonStringify([newItem], null, 4);
-    }
-}

package/dist/src/utils/jsonRead.js

@@ -1,14 +0,0 @@
-/**
- * Leaf stripBOM — extracted from json.ts to break settings → json → log →
- * types/logs → … → settings. json.ts imports this for its memoized+logging
- * safeParseJSON; leaf callers that can't import json.ts use stripBOM +
- * jsonParse inline (syncCacheState does this).
- *
- * UTF-8 BOM (U+FEFF): PowerShell 5.x writes UTF-8 with BOM by default
- * (Out-File, Set-Content). We can't control user environments, so strip on
- * read. Without this, JSON.parse fails with "Unexpected token".
- */
-const UTF8_BOM = '\uFEFF';
-export function stripBOM(content) {
-    return content.startsWith(UTF8_BOM) ? content.slice(1) : content;
-}

package/dist/src/utils/keyboardShortcuts.js

@@ -1,11 +0,0 @@
-// Special characters that macOS Option+key produces, mapped to their
-// keybinding equivalents. Used to detect Option+key shortcuts on macOS
-// terminals that don't have "Option as Meta" enabled.
-export const MACOS_OPTION_SPECIAL_CHARS = {
-    '†': 'alt+t', // Option+T -> thinking toggle
-    π: 'alt+p', // Option+P -> model picker
-    ø: 'alt+o', // Option+O -> fast mode
-};
-export function isMacosOptionChar(char) {
-    return char in MACOS_OPTION_SPECIAL_CHARS;
-}

package/dist/src/utils/lazySchema.js

@@ -1,8 +0,0 @@
-/**
- * Returns a memoized factory function that constructs the value on first call.
- * Used to defer Zod schema construction from module init time to first access.
- */
-export function lazySchema(factory) {
-    let cached;
-    return () => (cached ??= factory());
-}

package/dist/src/utils/listSessionsImpl.js

@@ -1,332 +0,0 @@
-/**
- * Standalone implementation of listSessions for the Agent SDK.
- *
- * Dependencies are kept minimal and portable — no bootstrap/state.ts,
- * no analytics, no bun:bundle, no module-scope mutable state. This module
- * can be imported safely from the SDK entrypoint without triggering CLI
- * initialization or pulling in expensive dependency chains.
- */
-import { readdir, stat } from 'fs/promises';
-import { basename, join } from 'path';
-import { getWorktreePathsPortable } from './getWorktreePathsPortable.js';
-import { canonicalizePath, extractFirstPromptFromHead, extractJsonStringField, extractLastJsonStringField, findProjectDir, getProjectsDir, MAX_SANITIZED_LENGTH, readSessionLite, sanitizePath, validateUuid, } from './sessionStoragePortable.js';
-// ---------------------------------------------------------------------------
-// Field extraction — shared by listSessionsImpl and getSessionInfoImpl
-// ---------------------------------------------------------------------------
-/**
- * Parses SessionInfo fields from a lite session read (head/tail/stat).
- * Returns null for sidechain sessions or metadata-only sessions with no
- * extractable summary.
- *
- * Exported for reuse by getSessionInfoImpl.
- */
-export function parseSessionInfoFromLite(sessionId, lite, projectPath) {
-    const { head, tail, mtime, size } = lite;
-    // Check first line for sidechain sessions
-    const firstNewline = head.indexOf('\n');
-    const firstLine = firstNewline >= 0 ? head.slice(0, firstNewline) : head;
-    if (firstLine.includes('"isSidechain":true') ||
-        firstLine.includes('"isSidechain": true')) {
-        return null;
-    }
-    // User title (customTitle) wins over AI title (aiTitle); distinct
-    // field names mean extractLastJsonStringField naturally disambiguates.
-    const customTitle = extractLastJsonStringField(tail, 'customTitle') ||
-        extractLastJsonStringField(head, 'customTitle') ||
-        extractLastJsonStringField(tail, 'aiTitle') ||
-        extractLastJsonStringField(head, 'aiTitle') ||
-        undefined;
-    const firstPrompt = extractFirstPromptFromHead(head) || undefined;
-    // First entry's ISO timestamp → epoch ms. More reliable than
-    // stat().birthtime which is unsupported on some filesystems.
-    const firstTimestamp = extractJsonStringField(head, 'timestamp');
-    let createdAt;
-    if (firstTimestamp) {
-        const parsed = Date.parse(firstTimestamp);
-        if (!Number.isNaN(parsed))
-            createdAt = parsed;
-    }
-    // last-prompt tail entry (captured by extractFirstPrompt at write
-    // time, filtered) shows what the user was most recently doing.
-    // Head scan is fallback for sessions without a last-prompt entry.
-    const summary = customTitle ||
-        extractLastJsonStringField(tail, 'lastPrompt') ||
-        extractLastJsonStringField(tail, 'summary') ||
-        firstPrompt;
-    // Skip metadata-only sessions (no title, no summary, no prompt)
-    if (!summary)
-        return null;
-    const gitBranch = extractLastJsonStringField(tail, 'gitBranch') ||
-        extractJsonStringField(head, 'gitBranch') ||
-        undefined;
-    const sessionCwd = extractJsonStringField(head, 'cwd') || projectPath || undefined;
-    // Type-scope tag extraction to the {"type":"tag"} JSONL line to avoid
-    // collision with tool_use inputs containing a `tag` parameter (git tag,
-    // Docker tags, cloud resource tags). Mirrors sessionStorage.ts:608.
-    const tagLine = tail.split('\n').findLast(l => l.startsWith('{"type":"tag"'));
-    const tag = tagLine
-        ? extractLastJsonStringField(tagLine, 'tag') || undefined
-        : undefined;
-    return {
-        sessionId,
-        summary,
-        lastModified: mtime,
-        fileSize: size,
-        customTitle,
-        firstPrompt,
-        gitBranch,
-        cwd: sessionCwd,
-        tag,
-        createdAt,
-    };
-}
-/**
- * Lists candidate session files in a directory via readdir, optionally
- * stat'ing each for mtime. When `doStat` is false, mtime is set to 0
- * (caller must sort/dedup after reading file contents instead).
- */
-export async function listCandidates(projectDir, doStat, projectPath) {
-    let names;
-    try {
-        names = await readdir(projectDir);
-    }
-    catch {
-        return [];
-    }
-    const results = await Promise.all(names.map(async (name) => {
-        if (!name.endsWith('.jsonl'))
-            return null;
-        const sessionId = validateUuid(name.slice(0, -6));
-        if (!sessionId)
-            return null;
-        const filePath = join(projectDir, name);
-        if (!doStat)
-            return { sessionId, filePath, mtime: 0, projectPath };
-        try {
-            const s = await stat(filePath);
-            return { sessionId, filePath, mtime: s.mtime.getTime(), projectPath };
-        }
-        catch {
-            return null;
-        }
-    }));
-    return results.filter((c) => c !== null);
-}
-/**
- * Reads a candidate's file contents and extracts full SessionInfo.
- * Returns null if the session should be filtered out (sidechain, no summary).
- */
-async function readCandidate(c) {
-    const lite = await readSessionLite(c.filePath);
-    if (!lite)
-        return null;
-    const info = parseSessionInfoFromLite(c.sessionId, lite, c.projectPath);
-    if (!info)
-        return null;
-    // Prefer stat-pass mtime for sort-key consistency; fall back to
-    // lite.mtime when doStat=false (c.mtime is 0 placeholder).
-    if (c.mtime)
-        info.lastModified = c.mtime;
-    return info;
-}
-// ---------------------------------------------------------------------------
-// Sort + limit — batch-read candidates in sorted order until `limit`
-// survivors are collected (some candidates filter out on full read).
-// ---------------------------------------------------------------------------
-/** Batch size for concurrent reads when walking the sorted candidate list. */
-const READ_BATCH_SIZE = 32;
-/**
- * Sort comparator: lastModified desc, then sessionId desc for stable
- * ordering across mtime ties.
- */
-function compareDesc(a, b) {
-    if (b.mtime !== a.mtime)
-        return b.mtime - a.mtime;
-    return b.sessionId < a.sessionId ? -1 : b.sessionId > a.sessionId ? 1 : 0;
-}
-async function applySortAndLimit(candidates, limit, offset) {
-    candidates.sort(compareDesc);
-    const sessions = [];
-    // limit: 0 means "no limit" (matches getSessionMessages semantics)
-    const want = limit && limit > 0 ? limit : Infinity;
-    let skipped = 0;
-    // Dedup post-filter: since candidates are sorted mtime-desc, the first
-    // non-null read per sessionId is naturally the newest valid copy.
-    // Pre-filter dedup would drop a session entirely if its newest-mtime
-    // copy is unreadable/empty, diverging from the no-stat readAllAndSort path.
-    const seen = new Set();
-    for (let i = 0; i < candidates.length && sessions.length < want;) {
-        const batchEnd = Math.min(i + READ_BATCH_SIZE, candidates.length);
-        const batch = candidates.slice(i, batchEnd);
-        const results = await Promise.all(batch.map(readCandidate));
-        for (let j = 0; j < results.length && sessions.length < want; j++) {
-            i++;
-            const r = results[j];
-            if (!r)
-                continue;
-            if (seen.has(r.sessionId))
-                continue;
-            seen.add(r.sessionId);
-            if (skipped < offset) {
-                skipped++;
-                continue;
-            }
-            sessions.push(r);
-        }
-    }
-    return sessions;
-}
-/**
- * Read-all path for when no limit/offset is set. Skips the stat pass
- * entirely — reads every candidate, then sorts/dedups on real mtimes
- * from readSessionLite. Matches pre-refactor I/O cost (no extra stats).
- */
-async function readAllAndSort(candidates) {
-    const all = await Promise.all(candidates.map(readCandidate));
-    const byId = new Map();
-    for (const s of all) {
-        if (!s)
-            continue;
-        const existing = byId.get(s.sessionId);
-        if (!existing || s.lastModified > existing.lastModified) {
-            byId.set(s.sessionId, s);
-        }
-    }
-    const sessions = [...byId.values()];
-    sessions.sort((a, b) => b.lastModified !== a.lastModified
-        ? b.lastModified - a.lastModified
-        : b.sessionId < a.sessionId
-            ? -1
-            : b.sessionId > a.sessionId
-                ? 1
-                : 0);
-    return sessions;
-}
-// ---------------------------------------------------------------------------
-// Project directory enumeration (single-project vs all-projects)
-// ---------------------------------------------------------------------------
-/**
- * Gathers candidate session files for a specific project directory
- * (and optionally its git worktrees).
- */
-async function gatherProjectCandidates(dir, includeWorktrees, doStat) {
-    const canonicalDir = await canonicalizePath(dir);
-    let worktreePaths;
-    if (includeWorktrees) {
-        try {
-            worktreePaths = await getWorktreePathsPortable(canonicalDir);
-        }
-        catch {
-            worktreePaths = [];
-        }
-    }
-    else {
-        worktreePaths = [];
-    }
-    // No worktrees (or git not available / scanning disabled) — just scan the single project dir
-    if (worktreePaths.length <= 1) {
-        const projectDir = await findProjectDir(canonicalDir);
-        if (!projectDir)
-            return [];
-        return listCandidates(projectDir, doStat, canonicalDir);
-    }
-    // Worktree-aware scanning: find all project dirs matching any worktree
-    const projectsDir = getProjectsDir();
-    const caseInsensitive = process.platform === 'win32';
-    // Sort worktree paths by sanitized prefix length (longest first) so
-    // more specific matches take priority over shorter ones
-    const indexed = worktreePaths.map(wt => {
-        const sanitized = sanitizePath(wt);
-        return {
-            path: wt,
-            prefix: caseInsensitive ? sanitized.toLowerCase() : sanitized,
-        };
-    });
-    indexed.sort((a, b) => b.prefix.length - a.prefix.length);
-    let allDirents;
-    try {
-        allDirents = await readdir(projectsDir, { withFileTypes: true });
-    }
-    catch {
-        // Fall back to single project dir
-        const projectDir = await findProjectDir(canonicalDir);
-        if (!projectDir)
-            return [];
-        return listCandidates(projectDir, doStat, canonicalDir);
-    }
-    const all = [];
-    const seenDirs = new Set();
-    // Always include the user's actual directory (handles subdirectories
-    // like /repo/packages/my-app that won't match worktree root prefixes)
-    const canonicalProjectDir = await findProjectDir(canonicalDir);
-    if (canonicalProjectDir) {
-        const dirBase = basename(canonicalProjectDir);
-        seenDirs.add(caseInsensitive ? dirBase.toLowerCase() : dirBase);
-        all.push(...(await listCandidates(canonicalProjectDir, doStat, canonicalDir)));
-    }
-    for (const dirent of allDirents) {
-        if (!dirent.isDirectory())
-            continue;
-        const dirName = caseInsensitive ? dirent.name.toLowerCase() : dirent.name;
-        if (seenDirs.has(dirName))
-            continue;
-        for (const { path: wtPath, prefix } of indexed) {
-            // Only use startsWith for truncated paths (>MAX_SANITIZED_LENGTH) where
-            // a hash suffix follows. For short paths, require exact match to avoid
-            // /root/project matching /root/project-foo.
-            const isMatch = dirName === prefix ||
-                (prefix.length >= MAX_SANITIZED_LENGTH &&
-                    dirName.startsWith(prefix + '-'));
-            if (isMatch) {
-                seenDirs.add(dirName);
-                all.push(...(await listCandidates(join(projectsDir, dirent.name), doStat, wtPath)));
-                break;
-            }
-        }
-    }
-    return all;
-}
-/**
- * Gathers candidate session files across all project directories.
- */
-async function gatherAllCandidates(doStat) {
-    const projectsDir = getProjectsDir();
-    let dirents;
-    try {
-        dirents = await readdir(projectsDir, { withFileTypes: true });
-    }
-    catch {
-        return [];
-    }
-    const perProject = await Promise.all(dirents
-        .filter(d => d.isDirectory())
-        .map(d => listCandidates(join(projectsDir, d.name), doStat)));
-    return perProject.flat();
-}
-/**
- * Lists sessions with metadata extracted from stat + head/tail reads.
- *
- * When `dir` is provided, returns sessions for that project directory
- * and its git worktrees. When omitted, returns sessions across all
- * projects.
- *
- * Pagination via `limit`/`offset` operates on the filtered, sorted result
- * set. When either is set, a cheap stat-only pass sorts candidates before
- * expensive head/tail reads — so `limit: 20` on a directory with 1000
- * sessions does ~1000 stats + ~20 content reads, not 1000 content reads.
- * When neither is set, stat is skipped (read-all-then-sort, same I/O cost
- * as the original implementation).
- */
-export async function listSessionsImpl(options) {
-    const { dir, limit, offset, includeWorktrees } = options ?? {};
-    const off = offset ?? 0;
-    // Only stat when we need to sort before reading (won't read all anyway).
-    // limit: 0 means "no limit" (see applySortAndLimit), so treat it as unset.
-    const doStat = (limit !== undefined && limit > 0) || off > 0;
-    const candidates = dir
-        ? await gatherProjectCandidates(dir, includeWorktrees ?? true, doStat)
-        : await gatherAllCandidates(doStat);
-    if (!doStat)
-        return readAllAndSort(candidates);
-    return applySortAndLimit(candidates, limit, off);
-}