lark-remote 0.1.4 → 0.1.6

package/dist/runner/types.d.ts

@@ -21,6 +21,75 @@ interface SystemCompactEvent {
         preTokens: number;
     };
 }
+export interface ApprovalRequestedEvent {
+    type: 'approval_requested';
+    /** JSON-RPC id of the server request. Wire type is string | integer — keep raw. */
+    requestId: number | string;
+    kind: 'command' | 'file' | 'permissions';
+    threadId: string;
+    turnId: string;
+    itemId: string;
+    view: ApprovalView;
+    timestamp?: string;
+}
+export interface ApprovalResolvedEvent {
+    type: 'approval_resolved';
+    requestId: number | string;
+    outcome: 'resolved' | 'expired';
+    timestamp?: string;
+}
+/** Approval card content update (out-of-order item/started arrives late). */
+export interface ApprovalViewUpdatedEvent {
+    type: 'approval_view_updated';
+    requestId: number | string;
+    view: ApprovalView;
+    timestamp?: string;
+}
+/** Approval expired locally (bridge-side timeout) — card should show expired UI. */
+export interface ApprovalExpiredEvent {
+    type: 'approval_expired';
+    requestId: number | string;
+    timestamp?: string;
+}
+export interface ApprovalView {
+    requestId: number | string;
+    kind: 'command' | 'file' | 'permissions';
+    reason?: string;
+    threadShort: string;
+    turnShort: string;
+    workspace: string;
+    command?: string;
+    commandCwd?: string;
+    fileChanges?: Array<{
+        path: string;
+        kind: 'add' | 'update' | 'delete';
+        diff?: string;
+    }>;
+    network?: {
+        host: string;
+        protocol: string;
+    };
+    permissions?: {
+        networkEnabled?: boolean;
+        fileSystemRead?: string[];
+        fileSystemWrite?: string[];
+        items: Array<{
+            id: string;
+            label: string;
+            target: {
+                kind: 'network';
+            } | {
+                kind: 'fsRead' | 'fsWrite';
+                path: string;
+            };
+            selected: boolean;
+        }>;
+    };
+    availableDecisions: string[];
+    /** Raw payloads for structured decisions (e.g. acceptWithExecpolicyAmendment). */
+    decisionPayloads?: Record<string, unknown>;
+    pendingTotal: number;
+}
 interface ThinkingContent {
     type: 'thinking';
     thinking: string;
@@ -58,7 +127,7 @@ export interface UserEvent {
 }
 export interface ResultEvent {
     type: 'result';
-    subtype: 'success' | 'error';
+    subtype: 'success' | 'error' | 'interrupted';
     session_id: string;
     timestamp?: string;
     usage?: {
@@ -75,6 +144,9 @@ export interface ResultEvent {
         cache_creation_input_tokens?: number;
         /** Agent-declared total; when present the display uses max(total, sum of parts). */
         total_tokens?: number;
+        /** 当前模型 context window 上限（codex app-server tokenUsage.modelContextWindow
+         *  透传）。仅 app-server 提供；缺省时卡片只显示绝对量、不显示百分比。 */
+        context_limit?: number;
     };
     total_cost_usd?: number;
     errorMessage?: string;
@@ -99,7 +171,50 @@ export interface FileChangeEvent {
     operation: 'create' | 'edit' | 'delete' | 'read';
     timestamp?: string;
 }
-export type AgentEvent = SystemInitEvent | SystemCompactEvent | AssistantEvent | UserEvent | ResultEvent | PlanEvent | FileChangeEvent;
+export interface TurnStartedEvent {
+    type: 'turn_started';
+    threadId: string;
+    turnId: string;
+    operationKind: 'turn' | 'compaction';
+    timestamp?: string;
+}
+export interface TurnDiffEvent {
+    type: 'turn_diff';
+    /**
+     * Thread item id this snapshot belongs to (app-server item-scoped stream).
+     * Each content item (reasoning / agentMessage / commandExecution / plan /
+     * fileChange) is tracked independently, so interleaved items keep their
+     * real chronology and update their own block instead of a shared one.
+     */
+    itemId: string;
+    /** Full accumulated assistant text snapshot for this item (replaces previous). */
+    text?: string;
+    /** Full accumulated reasoning snapshot for this item (replaces previous). */
+    reasoning?: string;
+    /** Full accumulated tool output snapshot for this item (replaces previous). */
+    toolOutput?: string;
+    /** Full accumulated plan text snapshot for this item (replaces previous). */
+    plan?: string;
+    /** Current set of file changes for this item (replaces previous). */
+    fileChanges?: Array<{
+        path: string;
+        kind: 'add' | 'update' | 'delete';
+        diff?: string;
+    }>;
+    /**
+     * Authoritative completion snapshot (item/completed or turn/completed).
+     * The reducer finalizes the block in place: thinking/plan active=false,
+     * tool status ok, completedAt stamped. Never reorders blocks.
+     */
+    complete?: boolean;
+    /** Authoritative tool status at completion (commandExecution item). */
+    toolStatus?: 'ok' | 'error';
+    threadId: string;
+    turnId: string;
+    timestamp?: string;
+}
+export type RunnerLifetime = 'turn' | 'workspace';
+export type AgentEvent = SystemInitEvent | SystemCompactEvent | ApprovalRequestedEvent | ApprovalResolvedEvent | ApprovalViewUpdatedEvent | ApprovalExpiredEvent | AssistantEvent | UserEvent | ResultEvent | PlanEvent | FileChangeEvent | TurnStartedEvent | TurnDiffEvent;
 export interface SpawnOptions {
     cwd: string;
     sessionId?: string;
@@ -117,6 +232,8 @@ export interface SpawnOptions {
  */
 export interface Runner {
     readonly isRunning: boolean;
+    readonly lifetime?: RunnerLifetime;
+    dispose?(): Promise<void>;
     run(message: string, opts: SpawnOptions): AsyncGenerator<AgentEvent>;
     /**
      * Stop the running process. SIGTERM → grace → SIGKILL on the per-workspace
@@ -158,6 +275,8 @@ export interface AgentSessionUsage {
     contextLimit?: number;
     /** Claude auto-compact 次数（数 compact_boundary 事件）；codex/opencode 无此概念，留 undefined。 */
     compactCount?: number;
+    /** 压缩前上下文水位（codex compact 后从会话 jsonl 读取，仅会话以压缩收尾时有值）。 */
+    compactPreContextLength?: number;
     /** 从缓存读取的 token 数（节省的费用）。 */
     cacheReadTokens?: number;
     /** 新建缓存的 token 数。 */
@@ -236,6 +355,8 @@ export interface AgentRunner extends Runner {
     readonly sessionReader: AgentSessionReader;
     /** Return current status info for /status display. */
     getStatusInfo(): AgentStatusInfo;
+    /** Whether this runner provides live usage data (vs. file-based). */
+    getUsageAuthority?(): 'live' | 'jsonl';
 }
 /** Agent self-describing status info for /status display. */
 export interface AgentStatusInfo {

package/dist/session/claude/session-index.d.ts

@@ -0,0 +1,93 @@
+import { type ContentBlockMapping } from '../common/content-blocks.js';
+export interface SessionIndexEntry {
+    sessionId: string;
+    path: string;
+    fingerprint: string;
+    mtimeMs: number;
+    summary: string;
+    cwdSet: Set<string>;
+}
+export interface SessionIndexOptions {
+    /** Minimum interval between refresh scans (ms). Default 5000. */
+    refreshIntervalMs?: number;
+}
+/** Claude-specific field-name mapping for content block extraction. */
+export declare const CLAUDE_MAPPING: ContentBlockMapping;
+/**
+ * Detect Claude CLI sub-agent completion notification text.
+ * Claude CLI injects a `type:"user"` record with string content starting
+ * with `<task-notification>` when a sub-agent (Agent tool) finishes.
+ * These must be excluded from displayTitle/summary — they are machine
+ * injections, not real user input. Primary criterion: extracted text
+ * starts with `<task-notification` (works for both string and array
+ * content since `extractText` is called first). Secondary (optional):
+ * `origin.kind === 'task-notification'` (not all CLI versions write it).
+ */
+export declare function isTaskNotificationText(text: string): boolean;
+/**
+ * Extract first text from a user message.
+ * Used by parseSessionJsonl and sessions.ts readSessionContent.
+ */
+export declare function extractText(content: unknown): string | null;
+export interface ParsedSession {
+    cwdSet: Set<string>;
+    summary: string;
+}
+/**
+ * Unified parser: single streaming scan of a JSONL file producing both
+ * the complete set of cwd values AND the first real user message summary.
+ * Replaces the split readCwdFromJsonl (first-cwd) + jsonlContainsCwd (any-cwd).
+ */
+export declare function parseSessionJsonl(filePath: string): ParsedSession;
+/**
+ * Build a fingerprint string from file stat metadata.
+ * Uses `size + mtimeNs + ctimeNs + dev + ino` (bigint stat).
+ * `size`/`mtime` are required; the rest are best-effort.
+ */
+export declare function buildFingerprint(filePath: string): string;
+/**
+ * In-memory session index with three query views:
+ *   byPath:      path → entry
+ *   bySessionId: sessionId → Set<path>
+ *   byCwd:       cwd → Set<path>
+ *
+ * Build once, refresh on demand (throttled). Single-file parse failure
+ * doesn't affect other files; readdir failure preserves old index.
+ */
+export declare class SessionIndex {
+    private readonly projectsDir;
+    private readonly refreshIntervalMs;
+    private readonly byPath;
+    private readonly bySessionId;
+    private readonly byCwd;
+    private lastRefreshAt;
+    private built;
+    /** Test-only: count of parseSessionJsonl calls since creation */
+    parseCount: number;
+    /** Test-only: count of directory scan operations */
+    scanCount: number;
+    constructor(projectsDir: string, opts?: SessionIndexOptions);
+    /** Whether a full scan has ever completed successfully (readdir succeeded). */
+    get isBuilt(): boolean;
+    build(): void;
+    refresh(): void;
+    listByCwd(cwd: string, opts?: {
+        limit?: number;
+        offset?: number;
+    }): SessionIndexEntry[];
+    /**
+     * Find a session entry by sessionId and cwd.
+     * Re-stats the file to verify fingerprint before returning (拍板 3):
+     *   - fingerprint unchanged → trust index cwdSet
+     *   - fingerprint changed → re-parse that one file, update index, re-check
+     * Returns undefined if not found or cwd doesn't match.
+     *
+     * Note: we re-stat ALL paths for the sessionId regardless of the old cwdSet,
+     * because a fingerprint change may have added the target cwd to the set.
+     */
+    findBySessionIdAndCwd(sessionId: string, cwd: string): SessionIndexEntry | undefined;
+    private fullScan;
+    private updateEntry;
+    private removeEntry;
+    private removeCrossRefs;
+}

package/dist/session/claude/session-index.js

@@ -0,0 +1,374 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { scanJsonlLines } from '../common/jsonl.js';
+import { extractContentBlocks } from '../common/content-blocks.js';
+import { truncate } from '../../card/card-shared.js';
+import { getLogger } from '../../logger/index.js';
+// ─── Claude content block mapping (shared with sessions.ts) ─
+/** Claude-specific field-name mapping for content block extraction. */
+export const CLAUDE_MAPPING = {
+    toolUseType: 'tool_use',
+    toolResultType: 'tool_result',
+    toolInputField: 'input',
+    toolErrorField: 'is_error',
+};
+/**
+ * Detect Claude CLI sub-agent completion notification text.
+ * Claude CLI injects a `type:"user"` record with string content starting
+ * with `<task-notification>` when a sub-agent (Agent tool) finishes.
+ * These must be excluded from displayTitle/summary — they are machine
+ * injections, not real user input. Primary criterion: extracted text
+ * starts with `<task-notification` (works for both string and array
+ * content since `extractText` is called first). Secondary (optional):
+ * `origin.kind === 'task-notification'` (not all CLI versions write it).
+ */
+export function isTaskNotificationText(text) {
+    return text.trimStart().startsWith('<task-notification');
+}
+/**
+ * Extract first text from a user message.
+ * Used by parseSessionJsonl and sessions.ts readSessionContent.
+ */
+export function extractText(content) {
+    if (typeof content === 'string' && content.trim()) {
+        return content.trim();
+    }
+    const blocks = extractContentBlocks(content, CLAUDE_MAPPING);
+    const textBlock = blocks.find((b) => b.type === 'text');
+    if (textBlock)
+        return textBlock.content;
+    return null;
+}
+/**
+ * Unified parser: single streaming scan of a JSONL file producing both
+ * the complete set of cwd values AND the first real user message summary.
+ * Replaces the split readCwdFromJsonl (first-cwd) + jsonlContainsCwd (any-cwd).
+ */
+export function parseSessionJsonl(filePath) {
+    const cwdSet = new Set();
+    let summary = '(无摘要)';
+    let foundSummary = false;
+    const ok = scanJsonlLines(filePath, (line) => {
+        let obj;
+        try {
+            obj = JSON.parse(line);
+        }
+        catch {
+            return;
+        }
+        // Collect cwd values
+        if (typeof obj.cwd === 'string' && obj.cwd) {
+            cwdSet.add(obj.cwd);
+        }
+        // Find first real user message for summary (same logic as summarizeSession)
+        if (!foundSummary && obj.type === 'user' && !!obj.message) {
+            const msg = obj.message;
+            if (msg.content) {
+                const text = extractText(msg.content);
+                if (text && !isTaskNotificationText(text)) {
+                    summary = text;
+                    foundSummary = true;
+                }
+            }
+        }
+    });
+    // If file couldn't be opened, return empty result
+    if (!ok) {
+        return { cwdSet: new Set(), summary: '(无摘要)' };
+    }
+    return { cwdSet, summary };
+}
+// ─── buildFingerprint ───────────────────────────────────────
+/**
+ * Build a fingerprint string from file stat metadata.
+ * Uses `size + mtimeNs + ctimeNs + dev + ino` (bigint stat).
+ * `size`/`mtime` are required; the rest are best-effort.
+ */
+export function buildFingerprint(filePath) {
+    let st;
+    try {
+        st = fs.statSync(filePath, { bigint: true });
+    }
+    catch {
+        return '';
+    }
+    const parts = [String(st.size), String(st.mtimeNs)];
+    // ctimeNs, dev, ino: include if available
+    try {
+        parts.push(String(st.ctimeNs));
+    }
+    catch {
+        /* skip */
+    }
+    try {
+        parts.push(String(st.dev));
+    }
+    catch {
+        /* skip */
+    }
+    try {
+        parts.push(String(st.ino));
+    }
+    catch {
+        /* skip */
+    }
+    return parts.join('|');
+}
+// ─── SessionIndex ───────────────────────────────────────────
+/**
+ * In-memory session index with three query views:
+ *   byPath:      path → entry
+ *   bySessionId: sessionId → Set<path>
+ *   byCwd:       cwd → Set<path>
+ *
+ * Build once, refresh on demand (throttled). Single-file parse failure
+ * doesn't affect other files; readdir failure preserves old index.
+ */
+export class SessionIndex {
+    projectsDir;
+    refreshIntervalMs;
+    byPath = new Map();
+    bySessionId = new Map();
+    byCwd = new Map();
+    lastRefreshAt = 0;
+    built = false;
+    /** Test-only: count of parseSessionJsonl calls since creation */
+    parseCount = 0;
+    /** Test-only: count of directory scan operations */
+    scanCount = 0;
+    constructor(projectsDir, opts = {}) {
+        this.projectsDir = projectsDir;
+        this.refreshIntervalMs = opts.refreshIntervalMs ?? 5000;
+    }
+    /** Whether a full scan has ever completed successfully (readdir succeeded). */
+    get isBuilt() {
+        return this.built;
+    }
+    // ── Build (initial full scan) ───────────────────────────
+    build() {
+        this.scanCount++;
+        this.fullScan();
+        this.lastRefreshAt = Date.now();
+    }
+    // ── Refresh (throttled incremental) ─────────────────────
+    refresh() {
+        const now = Date.now();
+        if (now - this.lastRefreshAt < this.refreshIntervalMs) {
+            return; // throttled
+        }
+        this.scanCount++;
+        this.fullScan();
+        this.lastRefreshAt = now;
+    }
+    // ── Query: listByCwd ────────────────────────────────────
+    listByCwd(cwd, opts = {}) {
+        const paths = this.byCwd.get(cwd);
+        if (!paths || paths.size === 0)
+            return [];
+        // Gather entries, deduplicate by sessionId (keep mtime newest)
+        const byId = new Map();
+        for (const p of paths) {
+            const entry = this.byPath.get(p);
+            if (!entry)
+                continue;
+            const existing = byId.get(entry.sessionId);
+            if (!existing || entry.mtimeMs > existing.mtimeMs) {
+                byId.set(entry.sessionId, entry);
+            }
+        }
+        const sorted = [...byId.values()].sort((a, b) => b.mtimeMs - a.mtimeMs || a.sessionId.localeCompare(b.sessionId));
+        const offset = opts.offset ?? 0;
+        const limit = opts.limit;
+        const sliced = limit === undefined ? sorted.slice(offset) : sorted.slice(offset, offset + limit);
+        return sliced;
+    }
+    // ── Query: findBySessionIdAndCwd ────────────────────────
+    /**
+     * Find a session entry by sessionId and cwd.
+     * Re-stats the file to verify fingerprint before returning (拍板 3):
+     *   - fingerprint unchanged → trust index cwdSet
+     *   - fingerprint changed → re-parse that one file, update index, re-check
+     * Returns undefined if not found or cwd doesn't match.
+     *
+     * Note: we re-stat ALL paths for the sessionId regardless of the old cwdSet,
+     * because a fingerprint change may have added the target cwd to the set.
+     */
+    findBySessionIdAndCwd(sessionId, cwd) {
+        const paths = this.bySessionId.get(sessionId);
+        if (!paths || paths.size === 0)
+            return undefined;
+        for (const p of paths) {
+            const entry = this.byPath.get(p);
+            if (!entry)
+                continue;
+            // Re-stat to verify fingerprint (拍板 3)
+            const currentFp = buildFingerprint(p);
+            if (currentFp === '') {
+                // File disappeared — remove from index
+                this.removeEntry(p);
+                continue;
+            }
+            if (currentFp === entry.fingerprint) {
+                // Fingerprint matches → trust index
+                if (entry.cwdSet.has(cwd))
+                    return entry;
+                continue;
+            }
+            // Fingerprint changed → re-parse this single file
+            const parsed = parseSessionJsonl(p);
+            this.parseCount++;
+            try {
+                const st = fs.statSync(p, { bigint: true });
+                const updated = {
+                    sessionId: entry.sessionId,
+                    path: p,
+                    fingerprint: currentFp,
+                    mtimeMs: Number(st.mtimeMs),
+                    summary: truncate(parsed.summary, 60, { normalizeWhitespace: true }),
+                    cwdSet: parsed.cwdSet,
+                };
+                this.updateEntry(p, updated);
+                // Re-check cwd after update
+                if (updated.cwdSet.has(cwd))
+                    return updated;
+            }
+            catch {
+                // File gone
+                this.removeEntry(p);
+            }
+        }
+        return undefined;
+    }
+    // ── Internal: full scan ─────────────────────────────────
+    fullScan() {
+        let entries;
+        try {
+            entries = fs.readdirSync(this.projectsDir);
+        }
+        catch {
+            // readdir failure → preserve old index, degrade to fallback
+            getLogger().warn('[session-index] readdir failed, preserving old index');
+            return;
+        }
+        // readdir succeeded → the snapshot is authoritative for what we could read.
+        this.built = true;
+        const currentPaths = new Set();
+        for (const entry of entries) {
+            const subdir = path.join(this.projectsDir, entry);
+            let st;
+            try {
+                st = fs.statSync(subdir);
+                if (!st.isDirectory())
+                    continue;
+            }
+            catch {
+                continue;
+            }
+            let files;
+            try {
+                files = fs.readdirSync(subdir).filter((f) => f.endsWith('.jsonl'));
+            }
+            catch {
+                continue;
+            }
+            for (const f of files) {
+                const fullPath = path.join(subdir, f);
+                currentPaths.add(fullPath);
+                // Check fingerprint
+                const fp = buildFingerprint(fullPath);
+                if (fp === '')
+                    continue; // can't stat, skip
+                const existing = this.byPath.get(fullPath);
+                if (existing && existing.fingerprint === fp) {
+                    // Unchanged, keep as-is
+                    continue;
+                }
+                // New file or fingerprint changed → parse
+                // Concurrent-write guard: stat before and after parse, compare fingerprints
+                const fpBefore = fp;
+                const parsed = parseSessionJsonl(fullPath);
+                this.parseCount++;
+                const fpAfter = buildFingerprint(fullPath);
+                if (fpBefore !== fpAfter) {
+                    // File was modified during parse → skip this round, retry next refresh
+                    getLogger().info(`[session-index] concurrent write detected for ${f}, skipping`);
+                    continue;
+                }
+                try {
+                    const fileStat = fs.statSync(fullPath, { bigint: true });
+                    const sessionId = f.slice(0, -'.jsonl'.length);
+                    const newEntry = {
+                        sessionId,
+                        path: fullPath,
+                        fingerprint: fpAfter,
+                        mtimeMs: Number(fileStat.mtimeMs),
+                        summary: truncate(parsed.summary, 60, { normalizeWhitespace: true }),
+                        cwdSet: parsed.cwdSet,
+                    };
+                    this.updateEntry(fullPath, newEntry);
+                }
+                catch (err) {
+                    getLogger().warn(`[session-index] skip ${f}: ${err.message}`);
+                }
+            }
+        }
+        // Remove entries for files that no longer exist
+        for (const p of [...this.byPath.keys()]) {
+            if (!currentPaths.has(p)) {
+                this.removeEntry(p);
+            }
+        }
+    }
+    // ── Internal: index mutation ────────────────────────────
+    updateEntry(filePath, entry) {
+        const old = this.byPath.get(filePath);
+        // Remove old entry's cross-references if it exists
+        if (old) {
+            this.removeCrossRefs(filePath, old);
+        }
+        // Set new entry
+        this.byPath.set(filePath, entry);
+        // bySessionId
+        let idPaths = this.bySessionId.get(entry.sessionId);
+        if (!idPaths) {
+            idPaths = new Set();
+            this.bySessionId.set(entry.sessionId, idPaths);
+        }
+        idPaths.add(filePath);
+        // byCwd
+        for (const cwd of entry.cwdSet) {
+            let cwdPaths = this.byCwd.get(cwd);
+            if (!cwdPaths) {
+                cwdPaths = new Set();
+                this.byCwd.set(cwd, cwdPaths);
+            }
+            cwdPaths.add(filePath);
+        }
+    }
+    removeEntry(filePath) {
+        const entry = this.byPath.get(filePath);
+        if (!entry)
+            return;
+        this.removeCrossRefs(filePath, entry);
+        this.byPath.delete(filePath);
+    }
+    removeCrossRefs(filePath, entry) {
+        // bySessionId
+        const idPaths = this.bySessionId.get(entry.sessionId);
+        if (idPaths) {
+            idPaths.delete(filePath);
+            if (idPaths.size === 0)
+                this.bySessionId.delete(entry.sessionId);
+        }
+        // byCwd
+        for (const cwd of entry.cwdSet) {
+            const cwdPaths = this.byCwd.get(cwd);
+            if (cwdPaths) {
+                cwdPaths.delete(filePath);
+                if (cwdPaths.size === 0)
+                    this.byCwd.delete(cwd);
+            }
+        }
+    }
+}
+//# sourceMappingURL=session-index.js.map

package/dist/session/claude/sessions.d.ts

@@ -1,27 +1,9 @@
 import type { AgentSession, AgentSessionContentEvent, AgentSessionUsage } from '../../runner/index.js';
-/**
- * Read the FIRST cwd from a Claude session JSONL. Used for display and
- * diagnostics. Claude CLI writes the absolute (symlink-resolved) cwd on
- * every event that produces one; older versions wrote it once on init.
- * Returns the first non-empty value, or undefined if absent.
- *
- * For cwd GUARD checks (list/read), use `jsonlContainsCwd` which accepts
- * any matching cwd field (required for relocated sessions whose first cwd
- * is the pre-relocate path). The directory name under ~/.claude/projects/
- * is lossy (encodes `/` AND `_` as `-`), so it cannot be decoded back to
- * a real path. See regression 2026-06-21 /resume & /cd 路径错乱.
- */
-export declare function readCwdFromJsonl(filePath: string): string | undefined;
 /**
  * List Claude Code sessions for a given cwd, newest first. Each entry has
  * the sessionId (= jsonl filename stem), a one-line summary extracted from
  * the first user message, and the file mtime. Returns an empty array when
  * the project directory doesn't exist or no jsonl has a matching cwd field.
- *
- * We locate the directory via `projectDirForCwd` (lossy but OK for locating
- * a known cwd) and then **verify** each jsonl's cwd field matches. This
- * prevents collision: `disk_d/foo` and `disk-d/foo` both encode to the same
- * directory name, but only the matching cwd field is kept.
  */
 export declare function listClaudeSessions(cwd: string, opts?: {
     limit?: number;