@ai-devkit/agent-manager 0.27.0 → 0.28.0

package/README.md

@@ -24,19 +24,27 @@ ai-devkit agent send "run the tests and report back" --id <agent-name> --wait
 npm test 2>&1 | ai-devkit agent send --id <agent-name> --stdin
 ```
 
-Claude Code can also be registered as a durable print-mode agent. Registration
+Claude Code can also be registered as a durable agent. Registration
 does not launch Claude; each send starts one synchronous process and later sends
 resume the same Claude session:
 
 ```bash
-ai-devkit agent start --type claude --mode print --name reviewer --cwd /path/to/project
+ai-devkit agent start --type claude --mode durable --name reviewer --cwd /path/to/project
 ai-devkit agent send "review the current diff" --id reviewer
 ```
 
-Print mode inherits Claude Code's settings, permissions, hooks, MCP servers, and
+Durable mode inherits Claude Code's settings, permissions, hooks, MCP servers, and
 tool side effects for that working directory. AI DevKit adds no permission bypass
 or automatic retry, and prompts are delivered over stdin rather than command-line
-arguments. `--timeout` is not supported for print agents in this first release.
+arguments. `--timeout` is not supported for durable agents in this first release.
+
+Durable durable-agent state is stored in `~/.ai-devkit/agents.db`. This feature was
+not released with JSON persistence, so there is no legacy import or dual-write.
+
+For direct `DurableAgentRepository` consumers, `dbPath` selects the SQLite database. The
+`lockTimeoutMs`, `incompleteLockGraceMs`, and `mutationLockStaleMs` options are
+deprecated, accepted, and ignored because SQLite transactions replace the
+filesystem lock machinery.
 
 Use this package directly only when building custom tooling around AI DevKit's agent detection and control surface.
 

package/dist/__tests__/adapters/CodexAdapter.test.js

@@ -884,6 +884,65 @@ describe('CodexAdapter', ()=>{
             expect(mockedMatchProcessesToSessions).not.toHaveBeenCalled();
             expect(mockedBatchGetSessionFileBirthtimes).not.toHaveBeenCalled();
         });
+        it('uses the hook session mapping instead of a stale registry entry for the same live pid', async ()=>{
+            registerEntry();
+            const sessionsDir = path.join(tmpDir, '.codex', 'sessions');
+            const dateDir = path.join(sessionsDir, '2026', '06', '26');
+            const mappingPath = path.join(tmpDir, '.codex', 'ai-devkit', 'sessions.json');
+            const currentSessionFile = path.join(dateDir, 'sess-current.jsonl');
+            const recentTs = new Date().toISOString();
+            fs.mkdirSync(dateDir, {
+                recursive: true
+            });
+            fs.mkdirSync(path.dirname(mappingPath), {
+                recursive: true
+            });
+            fs.writeFileSync(currentSessionFile, [
+                JSON.stringify({
+                    type: 'session_meta',
+                    payload: {
+                        id: 'sess-current',
+                        timestamp: recentTs,
+                        cwd: '/repo-current'
+                    }
+                }),
+                JSON.stringify({
+                    type: 'event',
+                    timestamp: recentTs,
+                    payload: {
+                        type: 'token_count',
+                        message: 'Hello from current mapping'
+                    }
+                })
+            ].join('\n'));
+            fs.writeFileSync(mappingPath, JSON.stringify({
+                100: currentSessionFile
+            }));
+            cachedAdapter.codexSessionsDir = sessionsDir;
+            cachedAdapter.sessionMappingPath = mappingPath;
+            const processes = [
+                {
+                    pid: 100,
+                    command: 'codex',
+                    cwd: '/repo-current',
+                    tty: 'ttys001',
+                    startTime: new Date()
+                }
+            ];
+            mockedListAgentProcesses.mockReturnValue(processes);
+            mockedEnrichProcesses.mockReturnValue(processes);
+            const agents = await cachedAdapter.detectAgents();
+            expect(agents).toHaveLength(1);
+            expect(agents[0]).toMatchObject({
+                type: 'codex',
+                pid: 100,
+                sessionId: 'sess-current',
+                sessionFilePath: currentSessionFile,
+                summary: 'Hello from current mapping'
+            });
+            expect(mockedMatchProcessesToSessions).not.toHaveBeenCalled();
+            expect(mockedBatchGetSessionFileBirthtimes).not.toHaveBeenCalled();
+        });
         it('falls through when no registry entry exists for the pid', async ()=>{
             const processes = [
                 {
@@ -2152,6 +2211,146 @@ describe('CodexAdapter', ()=>{
             expect(result).toHaveLength(1);
             expect(result[0].firstUserMessage).toBe('first user');
         });
+        it('captures the first current Codex response_item user message as firstUserMessage', async ()=>{
+            const day = path.join(sessionsDir, '2025', '01', '01');
+            writeCodexSession(day, 'response-item-user', [
+                {
+                    type: 'session_meta',
+                    payload: {
+                        id: 'response-item-user',
+                        cwd: '/repo',
+                        timestamp: '2025-01-01T00:00:00Z'
+                    }
+                },
+                {
+                    type: 'response_item',
+                    timestamp: '2025-01-01T00:00:00.500Z',
+                    payload: {
+                        type: 'message',
+                        role: 'user',
+                        content: [
+                            {
+                                type: 'input_text',
+                                text: '<environment_context>\n  <cwd>/repo</cwd>\n</environment_context>'
+                            }
+                        ]
+                    }
+                },
+                {
+                    type: 'response_item',
+                    timestamp: '2025-01-01T00:00:01Z',
+                    payload: {
+                        type: 'message',
+                        role: 'assistant',
+                        content: [
+                            {
+                                type: 'output_text',
+                                text: 'preamble'
+                            }
+                        ]
+                    }
+                },
+                {
+                    type: 'response_item',
+                    timestamp: '2025-01-01T00:00:02Z',
+                    payload: {
+                        type: 'message',
+                        role: 'user',
+                        content: [
+                            {
+                                type: 'input_text',
+                                text: 'first current user'
+                            }
+                        ]
+                    }
+                },
+                {
+                    type: 'response_item',
+                    timestamp: '2025-01-01T00:00:03Z',
+                    payload: {
+                        type: 'message',
+                        role: 'user',
+                        content: [
+                            {
+                                type: 'input_text',
+                                text: 'second current user'
+                            }
+                        ]
+                    }
+                }
+            ]);
+            const result = await adapter.listSessions({
+                cwd: '/repo'
+            });
+            expect(result).toHaveLength(1);
+            expect(result[0].firstUserMessage).toBe('first current user');
+        });
+        it('captures the first current Codex event_msg user message as firstUserMessage', async ()=>{
+            const day = path.join(sessionsDir, '2025', '01', '01');
+            writeCodexSession(day, 'event-msg-user', [
+                {
+                    type: 'session_meta',
+                    payload: {
+                        id: 'event-msg-user',
+                        cwd: '/repo',
+                        timestamp: '2025-01-01T00:00:00Z'
+                    }
+                },
+                {
+                    type: 'event_msg',
+                    timestamp: '2025-01-01T00:00:01Z',
+                    payload: {
+                        type: 'item_completed',
+                        item: {
+                            type: 'AgentMessage',
+                            content: [
+                                {
+                                    type: 'Text',
+                                    text: 'preamble'
+                                }
+                            ]
+                        }
+                    }
+                },
+                {
+                    type: 'event_msg',
+                    timestamp: '2025-01-01T00:00:02Z',
+                    payload: {
+                        type: 'item_completed',
+                        item: {
+                            type: 'UserMessage',
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: 'first event user'
+                                }
+                            ]
+                        }
+                    }
+                },
+                {
+                    type: 'event_msg',
+                    timestamp: '2025-01-01T00:00:03Z',
+                    payload: {
+                        type: 'item_completed',
+                        item: {
+                            type: 'UserMessage',
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: 'second event user'
+                                }
+                            ]
+                        }
+                    }
+                }
+            ]);
+            const result = await adapter.listSessions({
+                cwd: '/repo'
+            });
+            expect(result).toHaveLength(1);
+            expect(result[0].firstUserMessage).toBe('first event user');
+        });
         it('returns empty firstUserMessage when no user_message exists', async ()=>{
             const day = path.join(sessionsDir, '2025', '01', '01');
             writeCodexSession(day, 's', [