@ai-devkit/agent-manager 0.24.0 → 0.26.0

package/dist/__tests__/print/ClaudePrintAgentService.test.js

@@ -0,0 +1,108 @@
+import { describe, expect, it, vi } from 'vitest';
+describe('ClaudePrintAgentService', ()=>{
+    it('validates before create and does not run Claude', async ()=>{
+        const api = await import('../../index.js');
+        expect(api).toHaveProperty('ClaudePrintAgentService');
+        const probe = {
+            validate: vi.fn().mockResolvedValue({
+                executable: 'claude',
+                version: '2.1.220'
+            })
+        };
+        const store = {
+            create: vi.fn().mockResolvedValue({
+                id: 'agent-id',
+                name: 'reviewer'
+            })
+        };
+        const runner = {
+            run: vi.fn()
+        };
+        const Service = api.ClaudePrintAgentService;
+        await expect(new Service({
+            store,
+            probe,
+            runner
+        }).create({
+            name: 'reviewer',
+            cwd: '/project'
+        })).resolves.toMatchObject({
+            id: 'agent-id'
+        });
+        expect(probe.validate).toHaveBeenCalledOnce();
+        expect(store.create).toHaveBeenCalledWith({
+            name: 'reviewer',
+            cwd: '/project'
+        });
+        expect(runner.run).not.toHaveBeenCalled();
+    });
+    it('runs first and resumed sends and records provider identity/results', async ()=>{
+        const api = await import('../../index.js');
+        const base = {
+            id: 'id',
+            name: 'reviewer',
+            providerSessionId: 'session',
+            sessionHealth: 'uninitialized'
+        };
+        const store = {
+            resolve: vi.fn().mockResolvedValue(base),
+            acquireRun: vi.fn().mockResolvedValueOnce({
+                agent: base,
+                token: 'one'
+            }).mockResolvedValueOnce({
+                agent: {
+                    ...base,
+                    sessionHealth: 'healthy'
+                },
+                token: 'two'
+            }),
+            recordProviderProcess: vi.fn(),
+            completeRun: vi.fn().mockResolvedValue({})
+        };
+        const runner = {
+            run: vi.fn().mockImplementation(async (request)=>{
+                await request.onSpawn({
+                    pid: 42,
+                    startedAt: 'start'
+                });
+                return {
+                    sessionId: 'session',
+                    result: 'answer',
+                    exitCode: 0
+                };
+            })
+        };
+        const Service = api.ClaudePrintAgentService;
+        const service = new Service({
+            store,
+            probe: {
+                validate: vi.fn()
+            },
+            runner,
+            executable: 'fake-claude'
+        });
+        await service.send('reviewer', 'first');
+        await service.send('id', 'later');
+        expect(runner.run.mock.calls[0][0]).toMatchObject({
+            prompt: 'first',
+            firstRun: true,
+            executable: 'fake-claude'
+        });
+        expect(runner.run.mock.calls[1][0]).toMatchObject({
+            prompt: 'later',
+            firstRun: false,
+            executable: 'fake-claude'
+        });
+        expect(store.recordProviderProcess).toHaveBeenCalledWith('id', 'one', {
+            pid: 42,
+            startedAt: 'start'
+        });
+        expect(store.completeRun).toHaveBeenCalledWith('id', 'one', expect.objectContaining({
+            status: 'succeeded',
+            exitCode: 0,
+            sessionHealth: 'healthy'
+        }));
+    });
+});
+
+//# sourceMappingURL=ClaudePrintAgentService.test.js.map

package/dist/__tests__/print/ClaudePrintAgentService.test.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/__tests__/print/ClaudePrintAgentService.test.ts"],"sourcesContent":["import { describe, expect, it, vi } from 'vitest';\n\ndescribe('ClaudePrintAgentService', () => {\n    it('validates before create and does not run Claude', async () => {\n        const api = await import('../../index.js') as Record<string, unknown>;\n        expect(api).toHaveProperty('ClaudePrintAgentService');\n        const probe = { validate: vi.fn().mockResolvedValue({ executable: 'claude', version: '2.1.220' }) };\n        const store = { create: vi.fn().mockResolvedValue({ id: 'agent-id', name: 'reviewer' }) };\n        const runner = { run: vi.fn() };\n        const Service = api.ClaudePrintAgentService as new (options: unknown) => any;\n\n        await expect(new Service({ store, probe, runner }).create({ name: 'reviewer', cwd: '/project' }))\n            .resolves.toMatchObject({ id: 'agent-id' });\n        expect(probe.validate).toHaveBeenCalledOnce();\n        expect(store.create).toHaveBeenCalledWith({ name: 'reviewer', cwd: '/project' });\n        expect(runner.run).not.toHaveBeenCalled();\n    });\n\n    it('runs first and resumed sends and records provider identity/results', async () => {\n        const api = await import('../../index.js') as Record<string, unknown>;\n        const base = { id: 'id', name: 'reviewer', providerSessionId: 'session', sessionHealth: 'uninitialized' };\n        const store = {\n            resolve: vi.fn().mockResolvedValue(base),\n            acquireRun: vi.fn()\n                .mockResolvedValueOnce({ agent: base, token: 'one' })\n                .mockResolvedValueOnce({ agent: { ...base, sessionHealth: 'healthy' }, token: 'two' }),\n            recordProviderProcess: vi.fn(), completeRun: vi.fn().mockResolvedValue({}),\n        };\n        const runner = { run: vi.fn().mockImplementation(async (request) => {\n            await request.onSpawn({ pid: 42, startedAt: 'start' });\n            return { sessionId: 'session', result: 'answer', exitCode: 0 };\n        }) };\n        const Service = api.ClaudePrintAgentService as new (options: unknown) => any;\n        const service = new Service({ store, probe: { validate: vi.fn() }, runner, executable: 'fake-claude' });\n\n        await service.send('reviewer', 'first');\n        await service.send('id', 'later');\n\n        expect(runner.run.mock.calls[0][0]).toMatchObject({ prompt: 'first', firstRun: true, executable: 'fake-claude' });\n        expect(runner.run.mock.calls[1][0]).toMatchObject({ prompt: 'later', firstRun: false, executable: 'fake-claude' });\n        expect(store.recordProviderProcess).toHaveBeenCalledWith('id', 'one', { pid: 42, startedAt: 'start' });\n        expect(store.completeRun).toHaveBeenCalledWith('id', 'one', expect.objectContaining({\n            status: 'succeeded', exitCode: 0, sessionHealth: 'healthy',\n        }));\n    });\n});\n"],"names":["describe","expect","it","vi","api","toHaveProperty","probe","validate","fn","mockResolvedValue","executable","version","store","create","id","name","runner","run","Service","ClaudePrintAgentService","cwd","resolves","toMatchObject","toHaveBeenCalledOnce","toHaveBeenCalledWith","not","toHaveBeenCalled","base","providerSessionId","sessionHealth","resolve","acquireRun","mockResolvedValueOnce","agent","token","recordProviderProcess","completeRun","mockImplementation","request","onSpawn","pid","startedAt","sessionId","result","exitCode","service","send","mock","calls","prompt","firstRun","objectContaining","status"],"mappings":"AAAA,SAASA,QAAQ,EAAEC,MAAM,EAAEC,EAAE,EAAEC,EAAE,QAAQ,SAAS;AAElDH,SAAS,2BAA2B;IAChCE,GAAG,mDAAmD;QAClD,MAAME,MAAM,MAAM,MAAM,CAAC;QACzBH,OAAOG,KAAKC,cAAc,CAAC;QAC3B,MAAMC,QAAQ;YAAEC,UAAUJ,GAAGK,EAAE,GAAGC,iBAAiB,CAAC;gBAAEC,YAAY;gBAAUC,SAAS;YAAU;QAAG;QAClG,MAAMC,QAAQ;YAAEC,QAAQV,GAAGK,EAAE,GAAGC,iBAAiB,CAAC;gBAAEK,IAAI;gBAAYC,MAAM;YAAW;QAAG;QACxF,MAAMC,SAAS;YAAEC,KAAKd,GAAGK,EAAE;QAAG;QAC9B,MAAMU,UAAUd,IAAIe,uBAAuB;QAE3C,MAAMlB,OAAO,IAAIiB,QAAQ;YAAEN;YAAON;YAAOU;QAAO,GAAGH,MAAM,CAAC;YAAEE,MAAM;YAAYK,KAAK;QAAW,IACzFC,QAAQ,CAACC,aAAa,CAAC;YAAER,IAAI;QAAW;QAC7Cb,OAAOK,MAAMC,QAAQ,EAAEgB,oBAAoB;QAC3CtB,OAAOW,MAAMC,MAAM,EAAEW,oBAAoB,CAAC;YAAET,MAAM;YAAYK,KAAK;QAAW;QAC9EnB,OAAOe,OAAOC,GAAG,EAAEQ,GAAG,CAACC,gBAAgB;IAC3C;IAEAxB,GAAG,sEAAsE;QACrE,MAAME,MAAM,MAAM,MAAM,CAAC;QACzB,MAAMuB,OAAO;YAAEb,IAAI;YAAMC,MAAM;YAAYa,mBAAmB;YAAWC,eAAe;QAAgB;QACxG,MAAMjB,QAAQ;YACVkB,SAAS3B,GAAGK,EAAE,GAAGC,iBAAiB,CAACkB;YACnCI,YAAY5B,GAAGK,EAAE,GACZwB,qBAAqB,CAAC;gBAAEC,OAAON;gBAAMO,OAAO;YAAM,GAClDF,qBAAqB,CAAC;gBAAEC,OAAO;oBAAE,GAAGN,IAAI;oBAAEE,eAAe;gBAAU;gBAAGK,OAAO;YAAM;YACxFC,uBAAuBhC,GAAGK,EAAE;YAAI4B,aAAajC,GAAGK,EAAE,GAAGC,iBAAiB,CAAC,CAAC;QAC5E;QACA,MAAMO,SAAS;YAAEC,KAAKd,GAAGK,EAAE,GAAG6B,kBAAkB,CAAC,OAAOC;gBACpD,MAAMA,QAAQC,OAAO,CAAC;oBAAEC,KAAK;oBAAIC,WAAW;gBAAQ;gBACpD,OAAO;oBAAEC,WAAW;oBAAWC,QAAQ;oBAAUC,UAAU;gBAAE;YACjE;QAAG;QACH,MAAM1B,UAAUd,IAAIe,uBAAuB;QAC3C,MAAM0B,UAAU,IAAI3B,QAAQ;YAAEN;YAAON,OAAO;gBAAEC,UAAUJ,GAAGK,EAAE;YAAG;YAAGQ;YAAQN,YAAY;QAAc;QAErG,MAAMmC,QAAQC,IAAI,CAAC,YAAY;QAC/B,MAAMD,QAAQC,IAAI,CAAC,MAAM;QAEzB7C,OAAOe,OAAOC,GAAG,CAAC8B,IAAI,CAACC,KAAK,CAAC,EAAE,CAAC,EAAE,EAAE1B,aAAa,CAAC;YAAE2B,QAAQ;YAASC,UAAU;YAAMxC,YAAY;QAAc;QAC/GT,OAAOe,OAAOC,GAAG,CAAC8B,IAAI,CAACC,KAAK,CAAC,EAAE,CAAC,EAAE,EAAE1B,aAAa,CAAC;YAAE2B,QAAQ;YAASC,UAAU;YAAOxC,YAAY;QAAc;QAChHT,OAAOW,MAAMuB,qBAAqB,EAAEX,oBAAoB,CAAC,MAAM,OAAO;YAAEgB,KAAK;YAAIC,WAAW;QAAQ;QACpGxC,OAAOW,MAAMwB,WAAW,EAAEZ,oBAAoB,CAAC,MAAM,OAAOvB,OAAOkD,gBAAgB,CAAC;YAChFC,QAAQ;YAAaR,UAAU;YAAGf,eAAe;QACrD;IACJ;AACJ"}

package/dist/__tests__/print/ClaudePrintRunner.test.js

@@ -0,0 +1,187 @@
+import { EventEmitter } from 'node:events';
+import { PassThrough, Writable } from 'node:stream';
+import { describe, expect, it, vi } from 'vitest';
+function agent() {
+    return {
+        id: '11111111-1111-4111-8111-111111111111',
+        name: 'reviewer',
+        provider: 'claude',
+        mode: 'print',
+        cwd: '/project',
+        providerSessionId: '22222222-2222-4222-8222-222222222222',
+        state: 'running',
+        sessionHealth: 'uninitialized',
+        createdAt: '',
+        updatedAt: '',
+        lastActiveAt: null,
+        lastResult: null,
+        activeRun: null
+    };
+}
+function fakeSpawn(events, exitCode = 0) {
+    const calls = [];
+    const promptChunks = [];
+    const child = new EventEmitter();
+    child.pid = 4242;
+    child.stdout = new PassThrough();
+    child.stderr = new PassThrough();
+    child.stdin = new Writable({
+        write (chunk, _encoding, callback) {
+            promptChunks.push(Buffer.from(chunk));
+            callback();
+        },
+        final (callback) {
+            for (const event of events)child.stdout.write(`${JSON.stringify(event)}\n`);
+            child.stdout.end();
+            queueMicrotask(()=>child.emit('close', exitCode, null));
+            callback();
+        }
+    });
+    const spawn = vi.fn((...args)=>{
+        calls.push(args);
+        return child;
+    });
+    return {
+        spawn,
+        calls,
+        promptChunks
+    };
+}
+describe('ClaudePrintRunner', ()=>{
+    it('starts a caller-assigned session and persists provider identity before stdin', async ()=>{
+        const api = await import('../../index.js');
+        expect(api).toHaveProperty('ClaudePrintRunner');
+        const fixture = fakeSpawn([
+            {
+                type: 'system',
+                subtype: 'init',
+                session_id: agent().providerSessionId
+            },
+            {
+                type: 'result',
+                session_id: agent().providerSessionId,
+                result: 'done'
+            }
+        ]);
+        let persisted = false;
+        const Runner = api.ClaudePrintRunner;
+        const runner = new Runner({
+            spawn: fixture.spawn,
+            processInspector: {
+                getIdentity: ()=>({
+                        pid: 4242,
+                        startedAt: 'provider-start'
+                    })
+            }
+        });
+        const result = await runner.run({
+            agent: agent(),
+            prompt: 'secret prompt',
+            executable: 'claude-test',
+            firstRun: true,
+            onSpawn: async ()=>{
+                expect(fixture.promptChunks).toHaveLength(0);
+                persisted = true;
+            }
+        });
+        expect(persisted).toBe(true);
+        expect(fixture.calls[0]).toEqual([
+            'claude-test',
+            [
+                '-p',
+                '--session-id',
+                agent().providerSessionId,
+                '--output-format',
+                'stream-json',
+                '--verbose'
+            ],
+            expect.objectContaining({
+                cwd: '/project',
+                shell: false,
+                stdio: [
+                    'pipe',
+                    'pipe',
+                    'pipe'
+                ]
+            })
+        ]);
+        expect(JSON.stringify(fixture.calls)).not.toContain('secret prompt');
+        expect(Buffer.concat(fixture.promptChunks).toString()).toBe('secret prompt');
+        expect(result).toEqual({
+            sessionId: agent().providerSessionId,
+            result: 'done',
+            exitCode: 0
+        });
+    });
+    it('uses exact resume and rejects a mismatched result session', async ()=>{
+        const api = await import('../../index.js');
+        const fixture = fakeSpawn([
+            {
+                type: 'result',
+                session_id: 'wrong',
+                result: 'nope'
+            }
+        ]);
+        const Runner = api.ClaudePrintRunner;
+        const runner = new Runner({
+            spawn: fixture.spawn,
+            processInspector: {
+                getIdentity: ()=>({
+                        pid: 4242,
+                        startedAt: 'provider-start'
+                    })
+            }
+        });
+        await expect(runner.run({
+            agent: agent(),
+            prompt: 'followup',
+            executable: 'claude',
+            firstRun: false,
+            onSpawn: vi.fn()
+        })).rejects.toMatchObject({
+            code: 'CLAUDE_SESSION_MISMATCH'
+        });
+        expect(fixture.calls[0][1]).toEqual([
+            '-p',
+            '--resume',
+            agent().providerSessionId,
+            '--output-format',
+            'stream-json',
+            '--verbose'
+        ]);
+    });
+    it('does not disclose provider stderr in a failed-run error', async ()=>{
+        const api = await import('../../index.js');
+        const fixture = fakeSpawn([], 1);
+        const Runner = api.ClaudePrintRunner;
+        const runner = new Runner({
+            spawn: fixture.spawn,
+            processInspector: {
+                getIdentity: ()=>({
+                        pid: 4242,
+                        startedAt: 'provider-start'
+                    })
+            }
+        });
+        fixture.spawn.mockImplementationOnce((...args)=>{
+            const child = fakeSpawn([], 1).spawn(...args);
+            child.stdin = new Writable({
+                final (callback) {
+                    child.stderr.write('secret prompt echoed by provider');
+                    child.stderr.end();
+                    queueMicrotask(()=>child.emit('close', 1, null));
+                    callback();
+                }
+            });
+            return child;
+        });
+        await expect(runner.run({
+            agent: agent(),
+            prompt: 'secret prompt',
+            firstRun: true,
+            onSpawn: vi.fn()
+        })).rejects.not.toThrow(/secret prompt/);
+    });
+});
+
+//# sourceMappingURL=ClaudePrintRunner.test.js.map

package/dist/__tests__/print/ClaudePrintRunner.test.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/__tests__/print/ClaudePrintRunner.test.ts"],"sourcesContent":["import { EventEmitter } from 'node:events';\nimport { PassThrough, Writable } from 'node:stream';\nimport { describe, expect, it, vi } from 'vitest';\nimport type { PrintAgent } from '../../index.js';\n\nfunction agent(): PrintAgent {\n    return {\n        id: '11111111-1111-4111-8111-111111111111', name: 'reviewer', provider: 'claude', mode: 'print',\n        cwd: '/project', providerSessionId: '22222222-2222-4222-8222-222222222222', state: 'running',\n        sessionHealth: 'uninitialized', createdAt: '', updatedAt: '', lastActiveAt: null, lastResult: null,\n        activeRun: null,\n    };\n}\n\nfunction fakeSpawn(events: object[], exitCode = 0) {\n    const calls: unknown[][] = [];\n    const promptChunks: Buffer[] = [];\n    const child = new EventEmitter() as any;\n    child.pid = 4242;\n    child.stdout = new PassThrough();\n    child.stderr = new PassThrough();\n    child.stdin = new Writable({\n        write(chunk, _encoding, callback) { promptChunks.push(Buffer.from(chunk)); callback(); },\n        final(callback) {\n            for (const event of events) child.stdout.write(`${JSON.stringify(event)}\\n`);\n            child.stdout.end();\n            queueMicrotask(() => child.emit('close', exitCode, null));\n            callback();\n        },\n    });\n    const spawn = vi.fn((...args: unknown[]) => { calls.push(args); return child; });\n    return { spawn, calls, promptChunks };\n}\n\ndescribe('ClaudePrintRunner', () => {\n    it('starts a caller-assigned session and persists provider identity before stdin', async () => {\n        const api = await import('../../index.js') as Record<string, unknown>;\n        expect(api).toHaveProperty('ClaudePrintRunner');\n        const fixture = fakeSpawn([\n            { type: 'system', subtype: 'init', session_id: agent().providerSessionId },\n            { type: 'result', session_id: agent().providerSessionId, result: 'done' },\n        ]);\n        let persisted = false;\n        const Runner = api.ClaudePrintRunner as new (options: unknown) => any;\n        const runner = new Runner({ spawn: fixture.spawn, processInspector: {\n            getIdentity: () => ({ pid: 4242, startedAt: 'provider-start' }),\n        } });\n\n        const result = await runner.run({\n            agent: agent(), prompt: 'secret prompt', executable: 'claude-test', firstRun: true,\n            onSpawn: async () => { expect(fixture.promptChunks).toHaveLength(0); persisted = true; },\n        });\n\n        expect(persisted).toBe(true);\n        expect(fixture.calls[0]).toEqual([\n            'claude-test',\n            ['-p', '--session-id', agent().providerSessionId, '--output-format', 'stream-json', '--verbose'],\n            expect.objectContaining({ cwd: '/project', shell: false, stdio: ['pipe', 'pipe', 'pipe'] }),\n        ]);\n        expect(JSON.stringify(fixture.calls)).not.toContain('secret prompt');\n        expect(Buffer.concat(fixture.promptChunks).toString()).toBe('secret prompt');\n        expect(result).toEqual({ sessionId: agent().providerSessionId, result: 'done', exitCode: 0 });\n    });\n\n    it('uses exact resume and rejects a mismatched result session', async () => {\n        const api = await import('../../index.js') as Record<string, unknown>;\n        const fixture = fakeSpawn([{ type: 'result', session_id: 'wrong', result: 'nope' }]);\n        const Runner = api.ClaudePrintRunner as new (options: unknown) => any;\n        const runner = new Runner({ spawn: fixture.spawn, processInspector: {\n            getIdentity: () => ({ pid: 4242, startedAt: 'provider-start' }),\n        } });\n\n        await expect(runner.run({\n            agent: agent(), prompt: 'followup', executable: 'claude', firstRun: false, onSpawn: vi.fn(),\n        })).rejects.toMatchObject({ code: 'CLAUDE_SESSION_MISMATCH' });\n        expect(fixture.calls[0]![1]).toEqual([\n            '-p', '--resume', agent().providerSessionId, '--output-format', 'stream-json', '--verbose',\n        ]);\n    });\n\n    it('does not disclose provider stderr in a failed-run error', async () => {\n        const api = await import('../../index.js') as Record<string, unknown>;\n        const fixture = fakeSpawn([], 1);\n        const Runner = api.ClaudePrintRunner as new (options: unknown) => any;\n        const runner = new Runner({ spawn: fixture.spawn, processInspector: {\n            getIdentity: () => ({ pid: 4242, startedAt: 'provider-start' }),\n        } });\n        fixture.spawn.mockImplementationOnce((...args: unknown[]) => {\n            const child = (fakeSpawn([], 1).spawn as any)(...args);\n            child.stdin = new Writable({\n                final(callback) {\n                    child.stderr.write('secret prompt echoed by provider');\n                    child.stderr.end();\n                    queueMicrotask(() => child.emit('close', 1, null));\n                    callback();\n                },\n            });\n            return child;\n        });\n\n        await expect(runner.run({\n            agent: agent(), prompt: 'secret prompt', firstRun: true, onSpawn: vi.fn(),\n        })).rejects.not.toThrow(/secret prompt/);\n    });\n});\n"],"names":["EventEmitter","PassThrough","Writable","describe","expect","it","vi","agent","id","name","provider","mode","cwd","providerSessionId","state","sessionHealth","createdAt","updatedAt","lastActiveAt","lastResult","activeRun","fakeSpawn","events","exitCode","calls","promptChunks","child","pid","stdout","stderr","stdin","write","chunk","_encoding","callback","push","Buffer","from","final","event","JSON","stringify","end","queueMicrotask","emit","spawn","fn","args","api","toHaveProperty","fixture","type","subtype","session_id","result","persisted","Runner","ClaudePrintRunner","runner","processInspector","getIdentity","startedAt","run","prompt","executable","firstRun","onSpawn","toHaveLength","toBe","toEqual","objectContaining","shell","stdio","not","toContain","concat","toString","sessionId","rejects","toMatchObject","code","mockImplementationOnce","toThrow"],"mappings":"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"}

package/dist/__tests__/print/PrintAgent.test.js

@@ -0,0 +1,17 @@
+import { describe, expect, it } from 'vitest';
+describe('print-agent public domain', ()=>{
+    it('exports a classified busy error without exposing prompt data', async ()=>{
+        const api = await import('../../index.js');
+        expect(api).toHaveProperty('PrintAgentBusyError');
+        const ErrorType = api.PrintAgentBusyError;
+        const error = new ErrorType('agent-id', 'reviewer');
+        expect(error).toMatchObject({
+            name: 'PrintAgentBusyError',
+            code: 'PRINT_AGENT_BUSY',
+            agentId: 'agent-id',
+            message: 'Print agent "reviewer" is busy.'
+        });
+    });
+});
+
+//# sourceMappingURL=PrintAgent.test.js.map

package/dist/__tests__/print/PrintAgent.test.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/__tests__/print/PrintAgent.test.ts"],"sourcesContent":["import { describe, expect, it } from 'vitest';\n\ndescribe('print-agent public domain', () => {\n    it('exports a classified busy error without exposing prompt data', async () => {\n        const api = await import('../../index.js') as Record<string, unknown>;\n\n        expect(api).toHaveProperty('PrintAgentBusyError');\n        const ErrorType = api.PrintAgentBusyError as new (agentId: string, name: string) => Error & {\n            code: string;\n            agentId: string;\n        };\n        const error = new ErrorType('agent-id', 'reviewer');\n\n        expect(error).toMatchObject({\n            name: 'PrintAgentBusyError',\n            code: 'PRINT_AGENT_BUSY',\n            agentId: 'agent-id',\n            message: 'Print agent \"reviewer\" is busy.',\n        });\n    });\n});\n"],"names":["describe","expect","it","api","toHaveProperty","ErrorType","PrintAgentBusyError","error","toMatchObject","name","code","agentId","message"],"mappings":"AAAA,SAASA,QAAQ,EAAEC,MAAM,EAAEC,EAAE,QAAQ,SAAS;AAE9CF,SAAS,6BAA6B;IAClCE,GAAG,gEAAgE;QAC/D,MAAMC,MAAM,MAAM,MAAM,CAAC;QAEzBF,OAAOE,KAAKC,cAAc,CAAC;QAC3B,MAAMC,YAAYF,IAAIG,mBAAmB;QAIzC,MAAMC,QAAQ,IAAIF,UAAU,YAAY;QAExCJ,OAAOM,OAAOC,aAAa,CAAC;YACxBC,MAAM;YACNC,MAAM;YACNC,SAAS;YACTC,SAAS;QACb;IACJ;AACJ"}

package/dist/__tests__/print/PrintAgentStore.test.js

@@ -0,0 +1,307 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { afterEach, describe, expect, it } from 'vitest';
+const tempDirs = [];
+afterEach(()=>{
+    for (const dir of tempDirs.splice(0))fs.rmSync(dir, {
+        recursive: true,
+        force: true
+    });
+});
+async function loadStore() {
+    const api = await import('../../index.js');
+    expect(api).toHaveProperty('PrintAgentStore');
+    return api.PrintAgentStore;
+}
+function fixture() {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), 'print-agent-store-'));
+    tempDirs.push(root);
+    const cwd = path.join(root, 'project');
+    fs.mkdirSync(cwd);
+    return {
+        root,
+        cwd,
+        filePath: path.join(root, 'state', 'print-agents.json')
+    };
+}
+describe('PrintAgentStore create/list/resolve', ()=>{
+    it('creates distinct durable identities with a canonical cwd and lists them', async ()=>{
+        const PrintAgentStore = await loadStore();
+        const { cwd, filePath } = fixture();
+        const store = new PrintAgentStore({
+            filePath,
+            now: ()=>new Date('2026-08-07T09:00:00Z')
+        });
+        const agent = await store.create({
+            name: 'reviewer',
+            cwd
+        });
+        expect(agent).toMatchObject({
+            name: 'reviewer',
+            provider: 'claude',
+            mode: 'print',
+            cwd: fs.realpathSync(cwd),
+            state: 'ready',
+            sessionHealth: 'uninitialized',
+            activeRun: null
+        });
+        expect(agent.id).toMatch(/^[0-9a-f-]{36}$/);
+        expect(agent.providerSessionId).toMatch(/^[0-9a-f-]{36}$/);
+        expect(agent.id).not.toBe(agent.providerSessionId);
+        expect(await store.list()).toEqual([
+            agent
+        ]);
+        expect(fs.statSync(filePath).mode & 0o777).toBe(0o600);
+    });
+    it('resolves exact ids and names and rejects duplicate names', async ()=>{
+        const PrintAgentStore = await loadStore();
+        const { cwd, filePath } = fixture();
+        const store = new PrintAgentStore({
+            filePath
+        });
+        const agent = await store.create({
+            name: 'Reviewer',
+            cwd
+        });
+        expect(await store.resolve(agent.id)).toMatchObject({
+            id: agent.id
+        });
+        expect(await store.resolve('reviewer')).toMatchObject({
+            id: agent.id
+        });
+        expect(await store.resolve('view')).toBeNull();
+        await expect(store.create({
+            name: 'reviewer',
+            cwd
+        })).rejects.toMatchObject({
+            code: 'PRINT_AGENT_NAME_CONFLICT'
+        });
+    });
+    it('rejects missing cwd, malformed storage, and symlinked store targets', async ()=>{
+        const PrintAgentStore = await loadStore();
+        const { root, cwd, filePath } = fixture();
+        const store = new PrintAgentStore({
+            filePath
+        });
+        await expect(store.create({
+            name: 'missing',
+            cwd: path.join(root, 'missing')
+        })).rejects.toMatchObject({
+            code: 'PRINT_AGENT_STORE'
+        });
+        fs.mkdirSync(path.dirname(filePath), {
+            recursive: true
+        });
+        fs.writeFileSync(filePath, '{bad json', {
+            mode: 0o600
+        });
+        await expect(store.list()).rejects.toMatchObject({
+            code: 'PRINT_AGENT_STORE'
+        });
+        fs.rmSync(filePath);
+        const target = path.join(root, 'target.json');
+        fs.writeFileSync(target, JSON.stringify({
+            version: 1,
+            agents: []
+        }));
+        fs.symlinkSync(target, filePath);
+        await expect(store.create({
+            name: 'unsafe',
+            cwd
+        })).rejects.toMatchObject({
+            code: 'PRINT_AGENT_STORE'
+        });
+    });
+    it('recovers an abandoned old mutation lock after a crash', async ()=>{
+        const PrintAgentStore = await loadStore();
+        const { cwd, filePath } = fixture();
+        fs.mkdirSync(path.dirname(filePath), {
+            recursive: true
+        });
+        const lockPath = `${filePath}.lock`;
+        fs.mkdirSync(lockPath);
+        const old = new Date(Date.now() - 60_000);
+        fs.utimesSync(lockPath, old, old);
+        const store = new PrintAgentStore({
+            filePath,
+            mutationLockStaleMs: 10
+        });
+        await expect(store.create({
+            name: 'recovered',
+            cwd
+        })).resolves.toMatchObject({
+            name: 'recovered'
+        });
+    });
+});
+describe('PrintAgentStore run ownership', ()=>{
+    it('fails fast when another exact owner is live and completes only for its token', async ()=>{
+        const PrintAgentStore = await loadStore();
+        const { cwd, filePath } = fixture();
+        const live = new Map([
+            [
+                process.pid,
+                'owner-start'
+            ]
+        ]);
+        const processInspector = {
+            getIdentity: (pid)=>{
+                const startedAt = live.get(pid);
+                return startedAt ? {
+                    pid,
+                    startedAt
+                } : null;
+            }
+        };
+        const store = new PrintAgentStore({
+            filePath,
+            processInspector
+        });
+        const agent = await store.create({
+            name: 'runner',
+            cwd
+        });
+        const acquired = await store.acquireRun(agent.id);
+        await expect(store.acquireRun(agent.id)).rejects.toMatchObject({
+            code: 'PRINT_AGENT_BUSY'
+        });
+        await expect(store.completeRun(agent.id, 'wrong-token', {
+            status: 'succeeded',
+            exitCode: 0,
+            summary: 'done',
+            sessionHealth: 'healthy'
+        })).rejects.toMatchObject({
+            code: 'PRINT_AGENT_STORE'
+        });
+        const completed = await store.completeRun(agent.id, acquired.token, {
+            status: 'succeeded',
+            exitCode: 0,
+            summary: 'done',
+            sessionHealth: 'healthy'
+        });
+        expect(completed).toMatchObject({
+            state: 'ready',
+            sessionHealth: 'healthy',
+            activeRun: null
+        });
+    });
+    it('retains busy for a live provider then recovers a dead run without signaling it', async ()=>{
+        const PrintAgentStore = await loadStore();
+        const { cwd, filePath } = fixture();
+        const live = new Map([
+            [
+                process.pid,
+                'owner-start'
+            ],
+            [
+                4242,
+                'provider-start'
+            ]
+        ]);
+        const processInspector = {
+            getIdentity: (pid)=>{
+                const startedAt = live.get(pid);
+                return startedAt ? {
+                    pid,
+                    startedAt
+                } : null;
+            }
+        };
+        const first = new PrintAgentStore({
+            filePath,
+            processInspector
+        });
+        const agent = await first.create({
+            name: 'recoverable',
+            cwd
+        });
+        const run = await first.acquireRun(agent.id);
+        await first.recordProviderProcess(agent.id, run.token, {
+            pid: 4242,
+            startedAt: 'provider-start'
+        });
+        live.delete(process.pid);
+        await expect(first.acquireRun(agent.id)).rejects.toMatchObject({
+            code: 'PRINT_AGENT_BUSY'
+        });
+        live.delete(4242);
+        live.set(process.pid, 'replacement-owner-start');
+        const recovered = await first.acquireRun(agent.id);
+        expect(recovered.agent).toMatchObject({
+            state: 'running',
+            lastResult: {
+                status: 'interrupted'
+            }
+        });
+        await first.completeRun(agent.id, recovered.token, {
+            status: 'failed',
+            exitCode: 1,
+            summary: 'failed',
+            sessionHealth: 'unknown'
+        });
+    });
+    it('reconciles an old incomplete lock to degraded during list', async ()=>{
+        const PrintAgentStore = await loadStore();
+        const { root, cwd, filePath } = fixture();
+        const live = new Map([
+            [
+                process.pid,
+                'owner-start'
+            ]
+        ]);
+        const store = new PrintAgentStore({
+            filePath,
+            incompleteLockGraceMs: 10,
+            processInspector: {
+                getIdentity: (pid)=>{
+                    const startedAt = live.get(pid);
+                    return startedAt ? {
+                        pid,
+                        startedAt
+                    } : null;
+                }
+            }
+        });
+        const agent = await store.create({
+            name: 'crashed',
+            cwd
+        });
+        await store.acquireRun(agent.id);
+        const lockPath = path.join(root, 'state', 'print-agent-locks', `${agent.id}.lock`);
+        fs.unlinkSync(path.join(lockPath, 'owner.json'));
+        const old = new Date(Date.now() - 1000);
+        fs.utimesSync(lockPath, old, old);
+        live.clear();
+        const listed = await store.list();
+        expect(listed[0]).toMatchObject({
+            state: 'degraded',
+            sessionHealth: 'unknown',
+            activeRun: null,
+            lastResult: {
+                status: 'interrupted'
+            }
+        });
+    });
+    it('rejects send acquisition when the bound cwd is replaced by a symlink', async ()=>{
+        const PrintAgentStore = await loadStore();
+        const { root, cwd, filePath } = fixture();
+        const store = new PrintAgentStore({
+            filePath
+        });
+        const agent = await store.create({
+            name: 'bound',
+            cwd
+        });
+        const moved = path.join(root, 'moved-project');
+        const other = path.join(root, 'other-project');
+        fs.renameSync(cwd, moved);
+        fs.mkdirSync(other);
+        fs.symlinkSync(other, cwd);
+        await expect(store.acquireRun(agent.id)).rejects.toMatchObject({
+            code: 'PRINT_AGENT_STORE'
+        });
+    });
+});
+
+//# sourceMappingURL=PrintAgentStore.test.js.map