@ai-devkit/agent-manager 0.10.0 → 0.12.0

package/src/__tests__/utils/ClaudeSessionParser.test.ts

@@ -0,0 +1,195 @@
+/**
+ * Tests for utils/ClaudeSessionParser.ts — focused on stripping
+ * harness-injected XML tags from conversation content.
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from '@jest/globals';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { ClaudeSessionParser } from '../../utils/ClaudeSessionParser';
+
+interface JsonlEntry {
+    type: 'user' | 'assistant' | 'system';
+    message: { content: string | Array<{ type: string; text?: string; content?: string; name?: string; input?: unknown; is_error?: boolean }> };
+    timestamp?: string;
+}
+
+function writeSession(entries: JsonlEntry[]): string {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'parser-test-'));
+    const filePath = path.join(dir, 'session.jsonl');
+    fs.writeFileSync(filePath, entries.map(e => JSON.stringify(e)).join('\n'));
+    return filePath;
+}
+
+describe('ClaudeSessionParser.getConversation — harness tag stripping', () => {
+    let parser: ClaudeSessionParser;
+    const tempFiles: string[] = [];
+
+    beforeEach(() => {
+        parser = new ClaudeSessionParser();
+    });
+
+    afterEach(() => {
+        for (const f of tempFiles) {
+            try {
+                fs.rmSync(path.dirname(f), { recursive: true, force: true });
+            } catch { /* best effort */ }
+        }
+        tempFiles.length = 0;
+    });
+
+    function makeSession(entries: JsonlEntry[]): string {
+        const f = writeSession(entries);
+        tempFiles.push(f);
+        return f;
+    }
+
+    it('strips <system-reminder> blocks from text content', () => {
+        const file = makeSession([
+            {
+                type: 'assistant',
+                message: {
+                    content: [{
+                        type: 'text',
+                        text: 'Real response here.\n<system-reminder>\nDo not mention this reminder.\n</system-reminder>\nMore response.',
+                    }],
+                },
+            },
+        ]);
+
+        const conv = parser.getConversation(file);
+        expect(conv).toHaveLength(1);
+        expect(conv[0].content).toBe('Real response here.\n\nMore response.');
+    });
+
+    it('strips <local-command-stdout> blocks', () => {
+        const file = makeSession([
+            {
+                type: 'system',
+                message: { content: 'before <local-command-stdout>\nRunning...\nDone\n</local-command-stdout> after' },
+            },
+        ]);
+
+        const conv = parser.getConversation(file);
+        expect(conv[0].content).toBe('before  after');
+    });
+
+    it('strips <user-prompt-submit-hook> blocks', () => {
+        const file = makeSession([
+            {
+                type: 'user',
+                message: { content: '<user-prompt-submit-hook>hook output</user-prompt-submit-hook>\nactual question' },
+            },
+        ]);
+
+        const conv = parser.getConversation(file);
+        expect(conv[0].content).toBe('actual question');
+    });
+
+    it('strips bash and command stdout/stderr blocks', () => {
+        const file = makeSession([
+            {
+                type: 'assistant',
+                message: {
+                    content: [{
+                        type: 'text',
+                        text: 'Output:\n<bash-input>ls</bash-input>\n<bash-stdout>file.txt</bash-stdout>\n<bash-stderr></bash-stderr>\n<command-stdout>x</command-stdout>\n<command-stderr>y</command-stderr>\nEnd.',
+                    }],
+                },
+            },
+        ]);
+
+        const conv = parser.getConversation(file);
+        expect(conv[0].content).toBe('Output:\n\n\n\n\n\nEnd.'.replace(/\n{3,}/g, '\n\n'));
+        expect(conv[0].content).not.toMatch(/<bash-/);
+        expect(conv[0].content).not.toMatch(/<command-stdout>|<command-stderr>/);
+    });
+
+    it('collapses <command-name>/<command-args> into "/name args" shorthand', () => {
+        const file = makeSession([
+            {
+                type: 'user',
+                message: {
+                    content: '<command-message>debug</command-message>\n<command-name>/debug</command-name>\n<command-args>fix the bug</command-args>',
+                },
+            },
+        ]);
+
+        const conv = parser.getConversation(file);
+        expect(conv[0].content).toBe('/debug fix the bug');
+    });
+
+    it('handles <command-name> without <command-args>', () => {
+        const file = makeSession([
+            {
+                type: 'user',
+                message: {
+                    content: '<command-message>clear</command-message>\n<command-name>/clear</command-name>',
+                },
+            },
+        ]);
+
+        const conv = parser.getConversation(file);
+        expect(conv[0].content).toBe('/clear');
+    });
+
+    it('handles multiple harness tags mixed together', () => {
+        const file = makeSession([
+            {
+                type: 'user',
+                message: {
+                    content: [{
+                        type: 'text',
+                        text: '<system-reminder>ignore me</system-reminder>\n<command-message>build</command-message>\n<command-name>/build</command-name>\n<command-args>--watch</command-args>\n<local-command-stdout>build output here</local-command-stdout>',
+                    }],
+                },
+            },
+        ]);
+
+        const conv = parser.getConversation(file);
+        expect(conv[0].content).toBe('/build --watch');
+    });
+
+    it('leaves text without harness tags unchanged', () => {
+        const file = makeSession([
+            {
+                type: 'assistant',
+                message: { content: [{ type: 'text', text: 'Hello, world!' }] },
+            },
+        ]);
+
+        const conv = parser.getConversation(file);
+        expect(conv[0].content).toBe('Hello, world!');
+    });
+
+    it('drops a message that becomes empty after stripping', () => {
+        const file = makeSession([
+            {
+                type: 'system',
+                message: { content: '<system-reminder>only this</system-reminder>' },
+            },
+            {
+                type: 'assistant',
+                message: { content: [{ type: 'text', text: 'kept' }] },
+            },
+        ]);
+
+        const conv = parser.getConversation(file);
+        expect(conv).toHaveLength(1);
+        expect(conv[0].content).toBe('kept');
+    });
+
+    it('strips tags spanning multiple lines', () => {
+        const multilineReminder = '<system-reminder>\nLine 1\nLine 2\nLine 3\n</system-reminder>';
+        const file = makeSession([
+            {
+                type: 'assistant',
+                message: { content: [{ type: 'text', text: `before\n${multilineReminder}\nafter` }] },
+            },
+        ]);
+
+        const conv = parser.getConversation(file);
+        expect(conv[0].content).toBe('before\n\nafter');
+    });
+});

package/src/__tests__/utils/session.test.ts

@@ -3,25 +3,31 @@
  */
 
 import { describe, it, expect, jest, beforeEach } from '@jest/globals';
-import { execSync } from 'child_process';
+import * as fs from 'fs';
 import { batchGetSessionFileBirthtimes } from '../../utils/session';
 
-jest.mock('child_process', () => ({
-    execSync: jest.fn(),
+jest.mock('fs', () => ({
+    readdirSync: jest.fn(),
+    statSync: jest.fn(),
 }));
 
-const mockedExecSync = execSync as jest.MockedFunction<typeof execSync>;
+const mockedReaddirSync = fs.readdirSync as jest.MockedFunction<typeof fs.readdirSync>;
+const mockedStatSync = fs.statSync as jest.MockedFunction<typeof fs.statSync>;
 
 describe('batchGetSessionFileBirthtimes', () => {
     beforeEach(() => {
-        mockedExecSync.mockReset();
+        mockedReaddirSync.mockReset();
+        mockedStatSync.mockReset();
     });
 
-    it('should parse stat output correctly', () => {
-        mockedExecSync.mockReturnValue(
-            '1710800324 /home/.claude/projects/my-app/abc123.jsonl\n' +
-            '1710800500 /home/.claude/projects/my-app/def456.jsonl\n',
-        );
+    it('should parse session files correctly', () => {
+        mockedReaddirSync.mockReturnValue([
+            'abc123.jsonl',
+            'def456.jsonl',
+        ] as unknown as ReturnType<typeof fs.readdirSync>);
+        mockedStatSync
+            .mockReturnValueOnce({ birthtimeMs: 1710800324000 } as fs.Stats)
+            .mockReturnValueOnce({ birthtimeMs: 1710800500000 } as fs.Stats);
 
         const results = batchGetSessionFileBirthtimes(['/home/.claude/projects/my-app']);
 
@@ -39,49 +45,57 @@ describe('batchGetSessionFileBirthtimes', () => {
 
     it('should return empty array for empty dirs list', () => {
         expect(batchGetSessionFileBirthtimes([])).toEqual([]);
-        expect(mockedExecSync).not.toHaveBeenCalled();
+        expect(mockedReaddirSync).not.toHaveBeenCalled();
     });
 
-    it('should return empty array on command failure', () => {
-        mockedExecSync.mockImplementation(() => {
-            throw new Error('Command failed');
+    it('should return empty array on readdir failure', () => {
+        mockedReaddirSync.mockImplementation(() => {
+            throw new Error('ENOENT');
         });
 
         expect(batchGetSessionFileBirthtimes(['/some/dir'])).toEqual([]);
     });
 
-    it('should skip lines with invalid epoch (0 or negative)', () => {
-        mockedExecSync.mockReturnValue(
-            '0 /dir/bad.jsonl\n' +
-            '-1 /dir/negative.jsonl\n' +
-            '1710800324 /dir/good.jsonl\n',
-        );
+    it('should skip files with invalid birthtime (0 or negative)', () => {
+        mockedReaddirSync.mockReturnValue([
+            'bad.jsonl',
+            'negative.jsonl',
+            'good.jsonl',
+        ] as unknown as ReturnType<typeof fs.readdirSync>);
+        mockedStatSync
+            .mockReturnValueOnce({ birthtimeMs: 0 } as fs.Stats)
+            .mockReturnValueOnce({ birthtimeMs: -1 } as fs.Stats)
+            .mockReturnValueOnce({ birthtimeMs: 1710800324000 } as fs.Stats);
 
         const results = batchGetSessionFileBirthtimes(['/dir']);
         expect(results).toHaveLength(1);
         expect(results[0].sessionId).toBe('good');
     });
 
-    it('should skip non-jsonl files in output', () => {
-        mockedExecSync.mockReturnValue(
-            '1710800324 /dir/sessions-index.json\n' +
-            '1710800500 /dir/abc123.jsonl\n',
-        );
+    it('should skip non-jsonl files', () => {
+        mockedReaddirSync.mockReturnValue([
+            'sessions-index.json',
+            'abc123.jsonl',
+        ] as unknown as ReturnType<typeof fs.readdirSync>);
+        mockedStatSync
+            .mockReturnValueOnce({ birthtimeMs: 1710800500000 } as fs.Stats);
 
         const results = batchGetSessionFileBirthtimes(['/dir']);
         expect(results).toHaveLength(1);
         expect(results[0].sessionId).toBe('abc123');
     });
 
-    it('should handle empty output', () => {
-        mockedExecSync.mockReturnValue('');
+    it('should handle empty directory', () => {
+        mockedReaddirSync.mockReturnValue([] as unknown as ReturnType<typeof fs.readdirSync>);
         expect(batchGetSessionFileBirthtimes(['/dir'])).toEqual([]);
     });
 
     it('should handle UUID session IDs', () => {
-        mockedExecSync.mockReturnValue(
-            '1710800324 /dir/068e7b1f-cff5-4c94-bf69-b9acd32d765c.jsonl\n',
-        );
+        mockedReaddirSync.mockReturnValue([
+            '068e7b1f-cff5-4c94-bf69-b9acd32d765c.jsonl',
+        ] as unknown as ReturnType<typeof fs.readdirSync>);
+        mockedStatSync
+            .mockReturnValueOnce({ birthtimeMs: 1710800324000 } as fs.Stats);
 
         const results = batchGetSessionFileBirthtimes(['/dir']);
         expect(results).toHaveLength(1);
@@ -89,29 +103,51 @@ describe('batchGetSessionFileBirthtimes', () => {
     });
 
     it('should leave resolvedCwd empty', () => {
-        mockedExecSync.mockReturnValue('1710800324 /dir/abc.jsonl\n');
+        mockedReaddirSync.mockReturnValue([
+            'abc.jsonl',
+        ] as unknown as ReturnType<typeof fs.readdirSync>);
+        mockedStatSync
+            .mockReturnValueOnce({ birthtimeMs: 1710800324000 } as fs.Stats);
 
         const results = batchGetSessionFileBirthtimes(['/dir']);
         expect(results[0].resolvedCwd).toBe('');
     });
 
-    it('should combine multiple directories into a single stat call', () => {
-        mockedExecSync.mockReturnValue(
-            '1710800324 /projects/app-a/sess1.jsonl\n' +
-            '1710800400 /projects/app-b/sess2.jsonl\n' +
-            '1710800500 /projects/app-a/sess3.jsonl\n',
-        );
+    it('should enumerate multiple directories', () => {
+        mockedReaddirSync
+            .mockReturnValueOnce([
+                'sess1.jsonl',
+                'sess3.jsonl',
+            ] as unknown as ReturnType<typeof fs.readdirSync>)
+            .mockReturnValueOnce([
+                'sess2.jsonl',
+            ] as unknown as ReturnType<typeof fs.readdirSync>);
+        mockedStatSync
+            .mockReturnValueOnce({ birthtimeMs: 1710800324000 } as fs.Stats)
+            .mockReturnValueOnce({ birthtimeMs: 1710800500000 } as fs.Stats)
+            .mockReturnValueOnce({ birthtimeMs: 1710800400000 } as fs.Stats);
 
         const results = batchGetSessionFileBirthtimes(['/projects/app-a', '/projects/app-b']);
 
-        expect(mockedExecSync).toHaveBeenCalledTimes(1);
-        const cmd = mockedExecSync.mock.calls[0][0] as string;
-        expect(cmd).toContain('"/projects/app-a"/*.jsonl');
-        expect(cmd).toContain('"/projects/app-b"/*.jsonl');
+        expect(mockedReaddirSync).toHaveBeenCalledTimes(2);
 
         expect(results).toHaveLength(3);
         expect(results[0].projectDir).toBe('/projects/app-a');
-        expect(results[1].projectDir).toBe('/projects/app-b');
-        expect(results[2].projectDir).toBe('/projects/app-a');
+        expect(results[1].projectDir).toBe('/projects/app-a');
+        expect(results[2].projectDir).toBe('/projects/app-b');
+    });
+
+    it('should skip files where statSync fails', () => {
+        mockedReaddirSync.mockReturnValue([
+            'good.jsonl',
+            'gone.jsonl',
+        ] as unknown as ReturnType<typeof fs.readdirSync>);
+        mockedStatSync
+            .mockReturnValueOnce({ birthtimeMs: 1710800324000 } as fs.Stats)
+            .mockImplementationOnce(() => { throw new Error('ENOENT'); });
+
+        const results = batchGetSessionFileBirthtimes(['/dir']);
+        expect(results).toHaveLength(1);
+        expect(results[0].sessionId).toBe('good');
     });
 });

package/src/adapters/AgentAdapter.ts

@@ -81,6 +81,70 @@ export interface ConversationMessage {
     timestamp?: string;
 }
 
+/**
+ * A historical session discovered on disk (running or not).
+ *
+ * Used by `listSessions` to surface enough context for a user to identify
+ * a session and resume it via the originating tool's resume command.
+ */
+export interface SessionSummary {
+    /** Tool that produced this session */
+    type: AgentType;
+
+    /**
+     * ID accepted by the tool's resume command. Adapters MUST pass this
+     * through verbatim — no normalization, no encoding/decoding — so it
+     * round-trips into `claude --resume <id>` (and equivalents).
+     */
+    sessionId: string;
+
+    /** Working directory the session was started in (best-known value) */
+    cwd: string;
+
+    /**
+     * Trimmed first user message; empty string if none. Adapters apply
+     * the same noise-filter their existing parsers use (skip tool_result
+     * blocks, request-interruption notices, system-injected skill
+     * content). The CLI table renderer substitutes a placeholder for
+     * empty values; JSON output keeps the empty string raw.
+     */
+    firstUserMessage: string;
+
+    /** Last activity timestamp (from session content; falls back to file mtime) */
+    lastActive: Date;
+
+    /** Session start time (from session content; falls back to file birthtime/mtime) */
+    startedAt: Date;
+
+    /** Absolute path to the session file on disk (debug/diagnostics) */
+    sessionFilePath: string;
+}
+
+/**
+ * Filters passed by the CLI to {@link AgentAdapter.listSessions}.
+ *
+ * The CLI is the source of truth for filter defaults and semantics
+ * (e.g. cwd defaults to process.cwd(); --all clears it). Adapters apply
+ * the values they receive — they don't invent defaults.
+ */
+export interface ListSessionsOptions {
+    /**
+     * Filter to sessions whose recorded cwd matches this path using strict
+     * equality (no prefix/ancestor matching in v1). Undefined = no cwd
+     * filter.
+     */
+    cwd?: string;
+
+    /**
+     * Filter to a single tool. Enforced by `AgentManager.listSessions`,
+     * which skips adapters whose `type` doesn't match. Adapters MAY
+     * ignore this field — by the time their `listSessions` runs, the
+     * type filter is already satisfied. Undefined = include every
+     * registered adapter.
+     */
+    type?: AgentType;
+}
+
 /**
  * Agent Adapter Interface
  *
@@ -110,4 +174,16 @@ export interface AgentAdapter {
      * @returns Array of conversation messages
      */
     getConversation(sessionFilePath: string, options?: { verbose?: boolean }): ConversationMessage[];
+
+    /**
+     * Enumerate historical sessions for this tool from disk.
+     *
+     * Applies `opts.cwd` as a strict-equality filter when set. Returns
+     * {@link SessionSummary} entries unsorted; sorting and global filters
+     * are handled by `AgentManager` and the CLI.
+     *
+     * @param opts Filter options computed by the CLI
+     * @returns Array of sessions discovered on disk
+     */
+    listSessions(opts?: ListSessionsOptions): Promise<SessionSummary[]>;
 }

package/src/adapters/ClaudeCodeAdapter.ts

@@ -1,9 +1,16 @@
 import * as fs from 'fs';
 import * as path from 'path';
-import type { AgentAdapter, AgentInfo, ProcessInfo, ConversationMessage } from './AgentAdapter';
+import type {
+    AgentAdapter,
+    AgentInfo,
+    ProcessInfo,
+    ConversationMessage,
+    SessionSummary,
+    ListSessionsOptions,
+} from './AgentAdapter';
 import { AgentStatus } from './AgentAdapter';
 import { listAgentProcesses, enrichProcesses } from '../utils/process';
-import { batchGetSessionFileBirthtimes } from '../utils/session';
+import { batchGetSessionFileBirthtimes, isDirectory, listJsonl, safeReaddir, safeStat } from '../utils/session';
 import type { SessionFile } from '../utils/session';
 import { matchProcessesToSessions, generateAgentName } from '../utils/matching';
 import { ClaudeSessionParser } from '../utils/ClaudeSessionParser';
@@ -74,10 +81,17 @@ export class ClaudeCodeAdapter implements AgentAdapter {
             return [];
         }
 
-        // Step 1: try authoritative PID-file matching for every process
-        const { direct, fallback } = this.tryPidFileMatching(processes);
+        // Step 1: extract `--resume <id>` from command line — authoritative for
+        // resumed sessions where the JSONL predates the process and PID-file/
+        // birthtime heuristics can't match it.
+        const { direct: resumeDirect, fallback: noResume } = this.tryResumeMatching(processes);
 
-        // Step 2: run legacy CWD+birthtime matching only for processes without a PID file
+        // Step 2: try authoritative PID-file matching for the rest
+        const { direct: pidDirect, fallback } = this.tryPidFileMatching(noResume);
+
+        const direct = [...resumeDirect, ...pidDirect];
+
+        // Step 3: run legacy CWD+birthtime matching only for processes without a PID file
         const legacySessions = this.discoverSessions(fallback);
         const legacyMatches =
             fallback.length > 0 && legacySessions.length > 0
@@ -91,7 +105,7 @@ export class ClaudeCodeAdapter implements AgentAdapter {
 
         const agents: AgentInfo[] = [];
 
-        // Build agents from direct (PID-file) matches
+        // Build agents from direct (resume + PID-file) matches
         for (const { process: proc, sessionFile } of direct) {
             const sessionData = this.parser.readSession(sessionFile.filePath, sessionFile.resolvedCwd);
             if (sessionData) {
@@ -160,6 +174,55 @@ export class ClaudeCodeAdapter implements AgentAdapter {
         return files;
     }
 
+    /**
+     * Match processes via `claude --resume <uuid>` in their command line.
+     * This works for resumed sessions, where the JSONL was created earlier
+     * (so its birthtime is far from the process startTime and the legacy
+     * matcher can't pair them) and the PID file may also be misaligned.
+     */
+    private tryResumeMatching(processes: ProcessInfo[]): {
+        direct: DirectMatch[];
+        fallback: ProcessInfo[];
+    } {
+        const direct: DirectMatch[] = [];
+        const fallback: ProcessInfo[] = [];
+
+        for (const proc of processes) {
+            const sessionId = this.extractResumeSessionId(proc.command);
+            if (!sessionId || !proc.cwd) {
+                fallback.push(proc);
+                continue;
+            }
+
+            const projectDir = this.getProjectDir(proc.cwd);
+            const jsonlPath = path.join(projectDir, `${sessionId}.jsonl`);
+
+            const stat = safeStat(jsonlPath);
+            if (!stat) {
+                fallback.push(proc);
+                continue;
+            }
+
+            direct.push({
+                process: proc,
+                sessionFile: {
+                    sessionId,
+                    filePath: jsonlPath,
+                    projectDir,
+                    birthtimeMs: stat.birthtimeMs,
+                    resolvedCwd: proc.cwd,
+                },
+            });
+        }
+
+        return { direct, fallback };
+    }
+
+    private extractResumeSessionId(command: string): string | null {
+        const match = command.match(/--resume\s+([0-9a-f-]{36})/i);
+        return match?.[1] ?? null;
+    }
+
     /**
      * Attempt to match each process to its session via ~/.claude/sessions/<pid>.json.
      *
@@ -265,4 +328,71 @@ export class ClaudeCodeAdapter implements AgentAdapter {
     getConversation(sessionFilePath: string, options?: { verbose?: boolean }): ConversationMessage[] {
         return this.parser.getConversation(sessionFilePath, options);
     }
+
+    async listSessions(opts?: ListSessionsOptions): Promise<SessionSummary[]> {
+        const filterCwd = opts?.cwd;
+        const candidates = this.discoverSessionFiles();
+        const summaries: SessionSummary[] = [];
+
+        for (const { filePath, defaultCwd } of candidates) {
+            const session = this.parser.readSession(filePath, defaultCwd);
+            if (!session) continue;
+
+            // Drop sessions whose JSONL had no parseable conversation entries.
+            // readSession is permissive (returns a shell record even when every
+            // line fails to parse); listSessions needs at least one real entry
+            // so we don't surface garbage files.
+            if (!session.lastEntryType) continue;
+
+            const recordedCwd = session.lastCwd || defaultCwd;
+            if (filterCwd !== undefined && recordedCwd !== filterCwd) continue;
+
+            const stat = safeStat(filePath);
+
+            summaries.push({
+                type: 'claude',
+                sessionId: session.sessionId,
+                cwd: recordedCwd,
+                firstUserMessage: session.firstUserMessage || '',
+                lastActive: session.lastActive ?? stat?.mtime ?? new Date(),
+                startedAt: session.sessionStart ?? stat?.birthtime ?? stat?.mtime ?? new Date(),
+                sessionFilePath: filePath,
+            });
+        }
+
+        return summaries;
+    }
+
+    /**
+     * Discover candidate session files for {@link listSessions}.
+     *
+     * Always walks every subdirectory of `projectsDir`. We can't use the
+     * encoded-dir shortcut for the cwd-scoped path because Claude Code
+     * indexes session files by where the *process was launched*, not by
+     * the recorded `cwd` field inside the session — these diverge in
+     * worktrees and similar setups. The cwd filter is applied later
+     * against `session.lastCwd` so callers see exactly the sessions whose
+     * recorded cwd matches.
+     */
+    private discoverSessionFiles(): Array<{ filePath: string; defaultCwd: string }> {
+        const out: Array<{ filePath: string; defaultCwd: string }> = [];
+
+        if (!isDirectory(this.projectsDir)) return out;
+
+        for (const dirName of safeReaddir(this.projectsDir)) {
+            const projectDir = path.join(this.projectsDir, dirName);
+            if (!isDirectory(projectDir)) continue;
+
+            // Best-effort decode for the rare case session content has no
+            // recorded cwd: '-Users-foo-bar' → '/Users/foo/bar'. Lossy for
+            // paths containing '-'; session content's lastCwd overrides
+            // this when available.
+            const decoded = dirName.replace(/-/g, '/');
+            for (const name of listJsonl(projectDir)) {
+                out.push({ filePath: path.join(projectDir, name), defaultCwd: decoded });
+            }
+        }
+
+        return out;
+    }
 }