sidekick-shared 0.27.6 → 0.28.0

package/dist/toolCategory.js

@@ -0,0 +1,86 @@
+"use strict";
+/**
+ * One vocabulary for what a tool call does, across Claude Code, Codex, and
+ * OpenCode tool names. Browser-safe: no Node imports.
+ *
+ * @module toolCategory
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOOL_CATEGORIES = void 0;
+exports.classifyTool = classifyTool;
+const mcpToolName_1 = require("./parsers/mcpToolName");
+exports.TOOL_CATEGORIES = [
+    'shell',
+    'file_read',
+    'file_edit',
+    'search',
+    'web',
+    'subagent',
+    'planning',
+    'mcp',
+    'other',
+];
+/** Lower-cased tool names of every provider, by category. */
+const CATEGORY_BY_NAME = new Map([
+    [
+        'shell',
+        [
+            'bash',
+            'bashoutput',
+            'killbash',
+            'killshell',
+            'exec_command',
+            'shell',
+            'local_shell',
+            'local_shell_call',
+            'container.exec',
+            'write_stdin',
+        ],
+    ],
+    ['file_read', ['read', 'notebookread', 'ls', 'list', 'view_image']],
+    [
+        'file_edit',
+        ['edit', 'multiedit', 'write', 'notebookedit', 'apply_patch', 'patch', 'patch_applied'],
+    ],
+    ['search', ['grep', 'glob', 'codesearch', 'toolsearch']],
+    ['web', ['webfetch', 'websearch', 'web_search', 'web_search_call', 'fetch']],
+    [
+        'subagent',
+        [
+            'task',
+            'agent',
+            'spawn_agent',
+            'wait_agent',
+            'send_message',
+            'followup_task',
+            'list_agents',
+            'wait',
+        ],
+    ],
+    [
+        'planning',
+        [
+            'todowrite',
+            'todoread',
+            'update_plan',
+            'updateplan',
+            'enterplanmode',
+            'exitplanmode',
+            'taskcreate',
+            'taskupdate',
+            'tasklist',
+            'askuserquestion',
+            'request_user_input',
+        ],
+    ],
+].flatMap(([category, names]) => names.map((name) => [name, category])));
+/**
+ * Classifies a tool name from any supported provider. `mcp__<server>__<tool>`
+ * names and calls with a known `mcpServer` are `mcp`; unknown names are
+ * `other`.
+ */
+function classifyTool(name, options = {}) {
+    if (options.mcpServer || (0, mcpToolName_1.parseMcpToolName)(name))
+        return 'mcp';
+    return CATEGORY_BY_NAME.get(name.trim().toLowerCase()) ?? 'other';
+}

package/dist/types/codex.d.ts

@@ -291,4 +291,8 @@ export interface CodexDbThread {
     source?: string;
     agent_nickname?: string | null;
     agent_role?: string | null;
+    /** 1 once the thread is archived; Codex then moves its rollout to `archived_sessions/`. */
+    archived?: number;
+    /** Unix seconds when the thread was archived. */
+    archived_at?: number | null;
 }

package/dist/usage/usageEvents.d.ts

@@ -50,6 +50,8 @@ export interface UsageEventRecord {
     };
     costUsd: number | null;
     costProvenance: PricingProvenance;
+    /** Session file the event came from; tells apart two files with one session id. */
+    filePath?: string;
 }
 /** One session that contributed events. */
 export interface UsageSessionRecord {
@@ -71,6 +73,18 @@ export interface CollectUsageEventsOptions {
     until?: Date | string;
     /** Restrict to one workspace's sessions. */
     workspacePath?: string;
+    /**
+     * Restrict to the sessions of several workspaces, listed once each and
+     * counted once even when roots overlap. Takes precedence over
+     * `workspacePath`. Roots that do not resolve are dropped; when none
+     * resolves, no session is read.
+     */
+    workspacePaths?: string[];
+    /**
+     * Also list each root's main checkout and git worktree siblings. Default
+     * true with `workspacePaths`, false with `workspacePath`.
+     */
+    includeWorktrees?: boolean;
     /** Preview-read concurrency (see `listSessionPreviewsAsync`). */
     concurrency?: number;
     /** Cache directory (default `<configDir>/usage-cache`). */
@@ -93,6 +107,8 @@ export interface CollectUsageEventsResult {
     diagnostics: SessionProviderDiagnostic[];
     cacheHits: number;
     cacheMisses: number;
+    /** Realpaths of the roots listed, after worktree expansion, when the call was scoped. */
+    roots?: string[];
 }
 export declare function getUsageCacheDir(): string;
 /** Deletes all but the `keep` most recently used cache files (by mtime). Best-effort. */

package/dist/usage/usageEvents.js

@@ -64,6 +64,7 @@ const paths_1 = require("../paths");
 const sessionPreviews_1 = require("../sessionPreviews");
 const usageNormalization_1 = require("../usageNormalization");
 const atomic_1 = require("../writers/atomic");
+const workspaceRoots_1 = require("../workspaceRoots");
 /**
  * Bump when the cached record shape or the counting rules change; older files
  * are re-read. v2: Claude split lines and duplicate Codex `token_count` events
@@ -162,7 +163,7 @@ function cachedEventFromUsage(usage, timestamp, model) {
     return record;
 }
 /** Price a cached event with the current catalog (or its provider-reported cost). */
-function priceCachedEvent(cached, provider, sessionId, project) {
+function priceCachedEvent(cached, provider, sessionId, project, sessionFile) {
     const usage = {
         uncachedInputTokens: cached.i,
         cacheReadTokens: cached.cr,
@@ -195,6 +196,7 @@ function priceCachedEvent(cached, provider, sessionId, project) {
         },
         costUsd: priced.costUsd,
         costProvenance: priced.source,
+        filePath: sessionFile,
     };
 }
 const CLAUDE_AGENT_FILE = /^agent-.+\.jsonl$/;
@@ -292,12 +294,8 @@ async function collectUsageEvents(options) {
     const useCache = !options.noCache;
     const signal = options.signal;
     signal?.throwIfAborted();
-    const listed = await (0, sessionPreviews_1.listSessionPreviewsAsync)(options.providers, {
-        since: options.since,
-        workspacePath: options.workspacePath,
-        limit: Number.MAX_SAFE_INTEGER,
-        concurrency: options.concurrency,
-    });
+    const scope = usageScope(options);
+    const listed = await listScopedPreviews(options, scope?.listingRoots);
     signal?.throwIfAborted();
     const diagnostics = [...listed.diagnostics];
     for (const diagnostic of listed.diagnostics)
@@ -373,7 +371,7 @@ async function collectUsageEvents(options) {
                 continue;
             if (untilMs !== null && cached.t > untilMs)
                 continue;
-            events.push(priceCachedEvent(cached, preview.provider, preview.sessionId, project));
+            events.push(priceCachedEvent(cached, preview.provider, preview.sessionId, project, preview.filePath));
             first = first === null ? cached.t : Math.min(first, cached.t);
             last = last === null ? cached.t : Math.max(last, cached.t);
             count += 1;
@@ -393,5 +391,51 @@ async function collectUsageEvents(options) {
     if (wroteCache)
         pruneUsageCache(exports.MAX_USAGE_CACHE_FILES, cacheDir);
     events.sort((a, b) => a.timestamp - b.timestamp);
-    return { events, sessions, diagnostics, cacheHits, cacheMisses };
+    return {
+        events,
+        sessions,
+        diagnostics,
+        cacheHits,
+        cacheMisses,
+        ...(scope ? { roots: scope.roots } : {}),
+    };
+}
+/** The roots to list, or undefined for an unscoped (or legacy single-root) call. */
+function usageScope(options) {
+    if (options.workspacePaths) {
+        return (0, workspaceRoots_1.resolveWorkspaceRoots)(options.workspacePaths, {
+            includeWorktrees: options.includeWorktrees !== false,
+        });
+    }
+    if (options.workspacePath && options.includeWorktrees === true) {
+        return (0, workspaceRoots_1.resolveWorkspaceRoots)([options.workspacePath], { includeWorktrees: true });
+    }
+    return undefined;
+}
+/** Lists previews once per root and keeps each session file once. */
+async function listScopedPreviews(options, listingRoots) {
+    const list = (workspacePath) => (0, sessionPreviews_1.listSessionPreviewsAsync)(options.providers, {
+        since: options.since,
+        workspacePath,
+        limit: Number.MAX_SAFE_INTEGER,
+        concurrency: options.concurrency,
+    });
+    if (!listingRoots)
+        return list(options.workspacePath);
+    const byFile = new Map();
+    const diagnostics = new Map();
+    for (const root of listingRoots) {
+        options.signal?.throwIfAborted();
+        const listed = await list(root);
+        // Each root lists every provider again; report each problem once.
+        for (const diagnostic of listed.diagnostics) {
+            diagnostics.set(JSON.stringify(diagnostic), diagnostic);
+        }
+        for (const preview of listed.previews) {
+            if (!byFile.has(preview.filePath))
+                byFile.set(preview.filePath, preview);
+        }
+    }
+    const previews = [...byFile.values()].sort((left, right) => Date.parse(right.modifiedAt) - Date.parse(left.modifiedAt));
+    return { previews, diagnostics: [...diagnostics.values()] };
 }

package/dist/watchers/jsonlTail.d.ts

@@ -3,11 +3,30 @@
  * their own aggregation lifecycle.
  */
 import type { ZodType } from 'zod';
+/** Default bytes read from the file per chunk. */
+export declare const DEFAULT_JSONL_TAIL_READ_BYTES: number;
+/** Default longest line parsed; longer lines are skipped and reported. */
+export declare const DEFAULT_JSONL_TAIL_MAX_LINE_BYTES: number;
 export interface JsonlTailBatch {
     bytesRead: number;
     eventsRead: number;
     offset: number;
 }
+/** Where an event's line sits in the file. */
+export interface JsonlTailLine {
+    /** Byte offset where the line starts. */
+    offset: number;
+    /** Line length in bytes, without the newline. */
+    length: number;
+}
+export type JsonlTailResetReason = 'truncated' | 'rewritten' | 'replaced';
+/** The tail started over from the beginning of the file. */
+export interface JsonlTailReset {
+    /** `truncated`: the file shrank; `rewritten`: its first bytes or the resume point changed; `replaced`: another file now has the path. */
+    reason: JsonlTailResetReason;
+    /** The committed offset before the reset. */
+    previousOffset: number;
+}
 export interface JsonlTailOptions<T> {
     path: string;
     schema?: ZodType<T>;
@@ -15,9 +34,15 @@ export interface JsonlTailOptions<T> {
     startAtEnd?: boolean;
     debounceMs?: number;
     catchupIntervalMs?: number;
-    onEvent: (event: T) => void;
+    onEvent: (event: T, line: JsonlTailLine) => void;
     onBatchComplete?: (batch: JsonlTailBatch) => void;
     onError?: (error: Error, line?: string) => void;
+    /** Called after the tail resets to offset 0; events from the start follow. */
+    onReset?: (reset: JsonlTailReset) => void;
+    /** Bytes read per chunk (default 1 MiB); one poll reads chunk by chunk to the end. */
+    maxReadBytes?: number;
+    /** Longest line parsed (default 16 MiB); a longer line is skipped and reported to `onError`. */
+    maxLineBytes?: number;
 }
 export interface JsonlTail {
     readonly isActive: boolean;

package/dist/watchers/jsonlTail.js

@@ -37,11 +37,17 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_JSONL_TAIL_MAX_LINE_BYTES = exports.DEFAULT_JSONL_TAIL_READ_BYTES = void 0;
 exports.createJsonlTail = createJsonlTail;
 const fs = __importStar(require("fs"));
+const fileHead_1 = require("../fileHead");
 const jsonl_1 = require("../parsers/jsonl");
 const DEFAULT_DEBOUNCE_MS = 100;
 const DEFAULT_CATCHUP_INTERVAL_MS = 30_000;
+/** Default bytes read from the file per chunk. */
+exports.DEFAULT_JSONL_TAIL_READ_BYTES = 1024 * 1024;
+/** Default longest line parsed; longer lines are skipped and reported. */
+exports.DEFAULT_JSONL_TAIL_MAX_LINE_BYTES = 16 * 1024 * 1024;
 /** Skip old complete events while retaining an in-progress final line. */
 function lastCompleteLineOffset(filePath) {
     const fd = fs.openSync(filePath, 'r');
@@ -73,6 +79,15 @@ class JsonlTailReader {
     /** Resume-safe byte position ending immediately after a newline. */
     committedOffset;
     pendingBytes = Buffer.alloc(0);
+    /** Inside a line over `maxLineBytes`: drop bytes until its newline. */
+    skippingLine = false;
+    currentLine = { offset: 0, length: 0 };
+    /** Identity and prefix of the file the offsets refer to, once read. */
+    identity = null;
+    head = null;
+    lastMtimeMs = -1;
+    maxReadBytes;
+    maxLineBytes;
     fsWatcher = null;
     debounceTimer = null;
     catchupTimer = null;
@@ -82,10 +97,12 @@ class JsonlTailReader {
         this.options = options;
         this.readOffset = options.startOffset ?? 0;
         this.committedOffset = this.readOffset;
+        this.maxReadBytes = positiveInteger(options.maxReadBytes, exports.DEFAULT_JSONL_TAIL_READ_BYTES);
+        this.maxLineBytes = positiveInteger(options.maxLineBytes, exports.DEFAULT_JSONL_TAIL_MAX_LINE_BYTES);
         this.parser = new jsonl_1.JsonlParser({
             onEvent: (event) => {
                 this.eventsInCurrentBatch += 1;
-                this.options.onEvent(event);
+                this.options.onEvent(event, this.currentLine);
             },
             onError: (error, line) => this.options.onError?.(error, line),
         }, { schema: options.schema });
@@ -137,36 +154,25 @@ class JsonlTailReader {
     readNow() {
         let fd = null;
         try {
-            const stat = fs.statSync(this.options.path);
-            if (stat.size < this.readOffset) {
-                this.readOffset = 0;
-                this.committedOffset = 0;
-                this.pendingBytes = Buffer.alloc(0);
-                this.parser.reset();
-            }
-            if (stat.size <= this.readOffset)
-                return;
-            const bytesToRead = stat.size - this.readOffset;
-            const buffer = Buffer.alloc(bytesToRead);
             fd = fs.openSync(this.options.path, 'r');
-            const bytesRead = fs.readSync(fd, buffer, 0, bytesToRead, this.readOffset);
-            fs.closeSync(fd);
-            fd = null;
-            if (bytesRead <= 0)
+            const stat = fs.fstatSync(fd);
+            this.checkContinuity(fd, stat);
+            if (stat.size <= this.readOffset)
                 return;
-            this.readOffset += bytesRead;
             this.eventsInCurrentBatch = 0;
-            const combined = Buffer.concat([this.pendingBytes, buffer.subarray(0, bytesRead)]);
-            const lastNewline = combined.lastIndexOf(0x0a);
-            if (lastNewline >= 0) {
-                const completeLines = combined.subarray(0, lastNewline + 1);
-                this.pendingBytes = Buffer.from(combined.subarray(lastNewline + 1));
-                this.parser.processChunk(completeLines.toString('utf8'));
-            }
-            else {
-                this.pendingBytes = combined;
+            let bytesRead = 0;
+            const chunk = Buffer.alloc(Math.min(this.maxReadBytes, stat.size - this.readOffset));
+            while (this.readOffset < stat.size) {
+                const want = Math.min(chunk.length, stat.size - this.readOffset);
+                const count = fs.readSync(fd, chunk, 0, want, this.readOffset);
+                if (count <= 0)
+                    break;
+                this.consume(chunk.subarray(0, count), this.readOffset);
+                this.readOffset += count;
+                bytesRead += count;
             }
-            this.committedOffset = this.readOffset - this.pendingBytes.length;
+            if (bytesRead <= 0)
+                return;
             this.options.onBatchComplete?.({
                 bytesRead,
                 eventsRead: this.eventsInCurrentBatch,
@@ -174,6 +180,9 @@ class JsonlTailReader {
             });
         }
         catch (error) {
+            this.options.onError?.(error instanceof Error ? error : new Error(String(error)));
+        }
+        finally {
             if (fd !== null) {
                 try {
                     fs.closeSync(fd);
@@ -182,9 +191,97 @@ class JsonlTailReader {
                     /* ignore close errors */
                 }
             }
-            this.options.onError?.(error instanceof Error ? error : new Error(String(error)));
         }
     }
+    /**
+     * Starts over when the path now names another file, the file shrank, its
+     * first bytes changed, or the resume point no longer follows a newline.
+     */
+    checkContinuity(fd, stat) {
+        let reason = null;
+        if (this.identity && (stat.dev !== this.identity.dev || stat.ino !== this.identity.ino)) {
+            reason = 'replaced';
+        }
+        else if (stat.size < this.readOffset) {
+            reason = 'truncated';
+        }
+        if (reason === null && this.identity && stat.mtimeMs !== this.lastMtimeMs) {
+            const prefix = readAt(fd, 0, Math.min(fileHead_1.HEAD_BYTES, stat.size));
+            const before = this.committedOffset > 0 ? readAt(fd, this.committedOffset - 1, 1) : null;
+            if ((this.head && !(0, fileHead_1.headMatches)(this.head, prefix)) || (before && before[0] !== 0x0a)) {
+                reason = 'rewritten';
+            }
+        }
+        if (reason !== null)
+            this.reset(reason);
+        this.identity = { dev: stat.dev, ino: stat.ino };
+        this.lastMtimeMs = stat.mtimeMs;
+        if (!this.head || this.head.bytes < Math.min(fileHead_1.HEAD_BYTES, stat.size)) {
+            this.head = (0, fileHead_1.fileHeadOf)(readAt(fd, 0, Math.min(fileHead_1.HEAD_BYTES, stat.size)));
+        }
+    }
+    reset(reason) {
+        const previousOffset = this.committedOffset;
+        this.readOffset = 0;
+        this.committedOffset = 0;
+        this.pendingBytes = Buffer.alloc(0);
+        this.skippingLine = false;
+        this.head = null;
+        this.parser.reset();
+        if (reason === 'replaced' && this.active) {
+            // fs.watch follows the old inode; watch the file now at the path.
+            this.fsWatcher?.close();
+            this.fsWatcher = null;
+            this.watchFile();
+        }
+        this.options.onReset?.({ reason, previousOffset });
+    }
+    /** Parses the complete lines in `bytes`, which start at file offset `position`. */
+    consume(bytes, position) {
+        let start = 0;
+        if (this.skippingLine) {
+            const newline = bytes.indexOf(0x0a);
+            if (newline < 0)
+                return;
+            this.skippingLine = false;
+            start = newline + 1;
+            this.committedOffset = position + start;
+        }
+        let lineStart = this.committedOffset;
+        let cursor = start;
+        for (;;) {
+            const newline = bytes.indexOf(0x0a, cursor);
+            if (newline < 0)
+                break;
+            const piece = bytes.subarray(cursor, newline);
+            const line = this.pendingBytes.length > 0 ? Buffer.concat([this.pendingBytes, piece]) : piece;
+            this.pendingBytes = Buffer.alloc(0);
+            const lineEnd = position + newline + 1;
+            if (line.length > this.maxLineBytes) {
+                this.reportOversized(lineStart, line.length);
+            }
+            else {
+                this.currentLine = { offset: lineStart, length: line.length };
+                this.parser.processChunk(line.toString('utf8') + '\n');
+            }
+            this.committedOffset = lineEnd;
+            lineStart = lineEnd;
+            cursor = newline + 1;
+        }
+        const rest = bytes.subarray(cursor);
+        if (rest.length === 0)
+            return;
+        if (this.pendingBytes.length + rest.length > this.maxLineBytes) {
+            this.reportOversized(lineStart, this.pendingBytes.length + rest.length);
+            this.pendingBytes = Buffer.alloc(0);
+            this.skippingLine = true;
+            return;
+        }
+        this.pendingBytes = Buffer.concat([this.pendingBytes, rest]);
+    }
+    reportOversized(offset, atLeast) {
+        this.options.onError?.(new Error(`JSONL line at byte ${offset} is over ${this.maxLineBytes} bytes (${atLeast} so far); skipped.`));
+    }
     getOffset() {
         return this.committedOffset;
     }
@@ -192,6 +289,7 @@ class JsonlTailReader {
         this.readOffset = Math.max(0, offset);
         this.committedOffset = this.readOffset;
         this.pendingBytes = Buffer.alloc(0);
+        this.skippingLine = false;
         this.parser.reset();
     }
     watchFile() {
@@ -216,3 +314,13 @@ class JsonlTailReader {
         this.debounceTimer = setTimeout(() => this.readNow(), debounceMs);
     }
 }
+function positiveInteger(value, fallback) {
+    return typeof value === 'number' && Number.isFinite(value) && value >= 1
+        ? Math.floor(value)
+        : fallback;
+}
+function readAt(fd, position, length) {
+    const buffer = Buffer.alloc(length);
+    const count = length > 0 ? fs.readSync(fd, buffer, 0, length, position) : 0;
+    return buffer.subarray(0, count);
+}

package/dist/watchers/jsonlWatcher.js

@@ -240,6 +240,13 @@ class JsonlSessionWatcher {
             onEvent: (event) => this.handleRawEvent(event),
             onBatchComplete: () => this.callbacks.onBatchComplete?.(),
             onError: (error) => this.callbacks.onError?.(error),
+            // The file starts over, so per-file state from the old content must go too.
+            onReset: () => {
+                this.codexInPlanMode = false;
+                this.claudeUsageDeduper.reset();
+                this.codexPrevTotal = undefined;
+                this.callbacks.onReset?.();
+            },
         });
         this.tail.start();
     }

package/dist/watchers/providerReaderWatcher.js

@@ -137,6 +137,7 @@ class ProviderReaderSessionWatcher {
         try {
             if (this.reader.wasTruncated()) {
                 this.reader.reset();
+                this.callbacks.onReset?.();
             }
             const events = this.reader.readNew();
             for (const event of events) {

package/dist/watchers/types.d.ts

@@ -54,6 +54,12 @@ export interface SessionWatcherCallbacks {
     /** All events in this read have been delivered; the cursor can now be checkpointed. */
     onBatchComplete?: () => void;
     onError?: (error: Error) => void;
+    /**
+     * The session file was truncated, rewritten, or replaced, and its events
+     * are being delivered again from the beginning: discard anything built
+     * from earlier events.
+     */
+    onReset?: () => void;
 }
 export interface SessionWatcher {
     /** Start watching. If replay=true, emit existing events before streaming. */

package/dist/workspaceRoots.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Workspace-root expansion shared by the session readers: realpath each root
+ * and, optionally, add its git worktree siblings.
+ *
+ * @module workspaceRoots
+ */
+export interface ResolveWorkspaceRootsOptions {
+    /** Add the main checkout and every git worktree of each root. Default true. */
+    includeWorktrees?: boolean;
+}
+export interface ResolvedWorkspaceRoots {
+    /** Realpaths of the roots, after worktree expansion; scope checks use these. */
+    roots: string[];
+    /** The roots plus their unresolved spellings, for listing session files. */
+    listingRoots: string[];
+}
+/** Realpath of an absolute path, or null when it does not resolve. */
+export declare function realpathOrNull(input: string, cache?: Map<string, string | null>): string | null;
+/**
+ * Realpaths each absolute root and, by default, adds its main checkout and
+ * git worktree siblings. Relative and unresolvable roots are dropped.
+ */
+export declare function resolveWorkspaceRoots(workspacePaths: string[], options?: ResolveWorkspaceRootsOptions, realpaths?: Map<string, string | null>): ResolvedWorkspaceRoots;

package/dist/workspaceRoots.js

@@ -0,0 +1,93 @@
+"use strict";
+/**
+ * Workspace-root expansion shared by the session readers: realpath each root
+ * and, optionally, add its git worktree siblings.
+ *
+ * @module workspaceRoots
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.realpathOrNull = realpathOrNull;
+exports.resolveWorkspaceRoots = resolveWorkspaceRoots;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const sessionPathResolver_1 = require("./parsers/sessionPathResolver");
+/** Realpath of an absolute path, or null when it does not resolve. */
+function realpathOrNull(input, cache = new Map()) {
+    const cached = cache.get(input);
+    if (cached !== undefined)
+        return cached;
+    let resolved = null;
+    try {
+        resolved = path.isAbsolute(input) ? fs.realpathSync.native(input) : null;
+    }
+    catch {
+        resolved = null;
+    }
+    cache.set(input, resolved);
+    return resolved;
+}
+/**
+ * Realpaths each absolute root and, by default, adds its main checkout and
+ * git worktree siblings. Relative and unresolvable roots are dropped.
+ */
+function resolveWorkspaceRoots(workspacePaths, options = {}, realpaths = new Map()) {
+    const includeWorktrees = options.includeWorktrees !== false;
+    const roots = new Set();
+    const listingRoots = new Set();
+    const add = (candidate) => {
+        const real = realpathOrNull(candidate, realpaths);
+        if (!real)
+            return;
+        roots.add(real);
+        listingRoots.add(real);
+        listingRoots.add(path.resolve(candidate));
+    };
+    for (const workspacePath of workspacePaths) {
+        if (typeof workspacePath !== 'string' || !path.isAbsolute(workspacePath))
+            continue;
+        add(workspacePath);
+        if (!includeWorktrees)
+            continue;
+        const real = realpathOrNull(workspacePath, realpaths);
+        if (!real)
+            continue;
+        const mainRepo = (0, sessionPathResolver_1.resolveWorktreeMainRepo)(real) ?? real;
+        add(mainRepo);
+        for (const sibling of (0, sessionPathResolver_1.discoverWorktreeSiblings)(mainRepo))
+            add(sibling);
+    }
+    return { roots: [...roots], listingRoots: [...listingRoots] };
+}