@ai-devkit/agent-manager 0.27.0 → 0.28.1

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAEvE,OAAO,EAAE,iBAAiB,EAAE,MAAM,iCAAiC,CAAC;AACpE,OAAO,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC1D,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAC9D,OAAO,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAC;AAClE,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAC9D,OAAO,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AAChE,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AACpD,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AACzD,YAAY,EACR,YAAY,EACZ,SAAS,EACT,SAAS,EACT,WAAW,EACX,mBAAmB,EACnB,cAAc,EACd,mBAAmB,EACnB,qBAAqB,GACxB,MAAM,4BAA4B,CAAC;AAEpC,OAAO,EAAE,oBAAoB,EAAE,YAAY,EAAE,MAAM,oCAAoC,CAAC;AACxF,YAAY,EAAE,gBAAgB,EAAE,MAAM,oCAAoC,CAAC;AAC3E,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAEpD,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,EAAE,sBAAsB,EAAE,kBAAkB,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AACtG,YAAY,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAC1D,YAAY,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAE3D,OAAO,EAAE,aAAa,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AACnG,YAAY,EAAE,oBAAoB,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AACpF,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AACxD,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAC3C,YAAY,EAAE,WAAW,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAEzE,YAAY,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAC9D,OAAO,EAAE,mBAAmB,EAAE,sBAAsB,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAE3G,OAAO,EACH,eAAe,EACf,mBAAmB,EACnB,uBAAuB,EACvB,oBAAoB,EACpB,2BAA2B,EAC3B,gBAAgB,GACnB,MAAM,uBAAuB,CAAC;AAC/B,YAAY,EACR,UAAU,EACV,eAAe,EACf,kBAAkB,EAClB,cAAc,EACd,cAAc,EACd,eAAe,EACf,eAAe,GAClB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAC7D,OAAO,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAC;AACnE,YAAY,EACR,qBAAqB,EACrB,sBAAsB,EACtB,gBAAgB,EAChB,kBAAkB,GACrB,MAAM,4BAA4B,CAAC;AACpC,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAC3D,YAAY,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAC;AACvE,OAAO,EAAE,iBAAiB,EAAE,MAAM,8BAA8B,CAAC;AACjE,YAAY,EACR,wBAAwB,EACxB,qBAAqB,EACrB,oBAAoB,GACvB,MAAM,8BAA8B,CAAC;AACtC,OAAO,EAAE,uBAAuB,EAAE,MAAM,oCAAoC,CAAC;AAC7E,YAAY,EACR,8BAA8B,EAC9B,qBAAqB,GACxB,MAAM,oCAAoC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAEvE,OAAO,EAAE,iBAAiB,EAAE,MAAM,iCAAiC,CAAC;AACpE,OAAO,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC1D,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAC9D,OAAO,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAC;AAClE,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAC9D,OAAO,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AAChE,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AACpD,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AACzD,YAAY,EACR,YAAY,EACZ,SAAS,EACT,SAAS,EACT,WAAW,EACX,mBAAmB,EACnB,cAAc,EACd,mBAAmB,EACnB,qBAAqB,GACxB,MAAM,4BAA4B,CAAC;AAEpC,OAAO,EAAE,oBAAoB,EAAE,YAAY,EAAE,MAAM,oCAAoC,CAAC;AACxF,YAAY,EAAE,gBAAgB,EAAE,MAAM,oCAAoC,CAAC;AAC3E,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAEpD,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,EAAE,sBAAsB,EAAE,kBAAkB,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AACtG,YAAY,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAC1D,YAAY,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAE3D,OAAO,EAAE,aAAa,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AACnG,YAAY,EAAE,oBAAoB,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AACpF,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AACxD,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAC3C,YAAY,EAAE,WAAW,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAEzE,YAAY,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAC9D,OAAO,EAAE,mBAAmB,EAAE,sBAAsB,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAE3G,OAAO,EACH,WAAW,EACX,iBAAiB,EACjB,qBAAqB,EACrB,yBAAyB,EACzB,2BAA2B,EAC3B,6BAA6B,EAC7B,gBAAgB,GACnB,MAAM,2BAA2B,CAAC;AACnC,YAAY,EACR,YAAY,EACZ,iBAAiB,EACjB,oBAAoB,EACpB,gBAAgB,EAChB,gBAAgB,EAChB,iBAAiB,EACjB,eAAe,GAClB,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAAE,sBAAsB,EAAE,MAAM,qCAAqC,CAAC;AAC7E,OAAO,EAAE,qBAAqB,EAAE,MAAM,qCAAqC,CAAC;AAC5E,YAAY,EACR,uBAAuB,EACvB,6BAA6B,EAC7B,gBAAgB,EAChB,oBAAoB,GACvB,MAAM,qCAAqC,CAAC;AAC7C,OAAO,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAC7D,YAAY,EAAE,qBAAqB,EAAE,MAAM,6BAA6B,CAAC;AACzE,OAAO,EAAE,iBAAiB,EAAE,MAAM,gCAAgC,CAAC;AACnE,YAAY,EACR,wBAAwB,EACxB,qBAAqB,EACrB,oBAAoB,GACvB,MAAM,gCAAgC,CAAC;AACxC,OAAO,EAAE,uBAAuB,EAAE,MAAM,sCAAsC,CAAC;AAC/E,YAAY,EACR,8BAA8B,EAC9B,qBAAqB,GACxB,MAAM,sCAAsC,CAAC"}

package/dist/index.js

@@ -15,11 +15,11 @@ export { AgentRegistry, RenameNotFoundError, RenameConflictError } from './utils
 export { TmuxManager } from './terminal/TmuxManager.js';
 export { AGENTS } from './utils/agents.js';
 export { getAgentRequestPath, readLatestAgentRequest, writeAgentRequest } from './utils/agent-requests.js';
-export { PrintAgentError, PrintAgentBusyError, PrintAgentNotFoundError, PrintAgentStoreError, PrintAgentNameConflictError, ClaudePrintError } from './print/PrintAgent.js';
-export { PrintAgentStore } from './print/PrintAgentStore.js';
-export { LocalProcessInspector } from './print/PrintAgentStore.js';
-export { ClaudeCliProbe } from './print/ClaudeCliProbe.js';
-export { ClaudePrintRunner } from './print/ClaudePrintRunner.js';
-export { ClaudePrintAgentService } from './print/ClaudePrintAgentService.js';
+export { AGENT_MODES, DurableAgentError, DurableAgentBusyError, DurableAgentNotFoundError, DurableAgentRepositoryError, DurableAgentNameConflictError, ClaudePrintError } from './durable/DurableAgent.js';
+export { DurableAgentRepository } from './durable/DurableAgentRepository.js';
+export { LocalProcessInspector } from './durable/DurableAgentRepository.js';
+export { ClaudeCliProbe } from './durable/ClaudeCliProbe.js';
+export { ClaudePrintRunner } from './durable/ClaudePrintRunner.js';
+export { ClaudePrintAgentService } from './durable/ClaudePrintAgentService.js';
 
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/index.ts"],"sourcesContent":["export { AgentManager, AgentNotRunningError } from './AgentManager.js';\n\nexport { ClaudeCodeAdapter } from './adapters/ClaudeCodeAdapter.js';\nexport { CodexAdapter } from './adapters/CodexAdapter.js';\nexport { CopilotAdapter } from './adapters/CopilotAdapter.js';\nexport { GeminiCliAdapter } from './adapters/GeminiCliAdapter.js';\nexport { GrokCliAdapter } from './adapters/GrokCliAdapter.js';\nexport { OpenCodeAdapter } from './adapters/OpenCodeAdapter.js';\nexport { PiAdapter } from './adapters/PiAdapter.js';\nexport { AgentStatus } from './adapters/AgentAdapter.js';\nexport type {\n    AgentAdapter,\n    AgentType,\n    AgentInfo,\n    ProcessInfo,\n    ConversationMessage,\n    SessionSummary,\n    ListSessionsOptions,\n    AgentDetectionContext,\n} from './adapters/AgentAdapter.js';\n\nexport { TerminalFocusManager, TerminalType } from './terminal/TerminalFocusManager.js';\nexport type { TerminalLocation } from './terminal/TerminalFocusManager.js';\nexport { TtyWriter } from './terminal/TtyWriter.js';\n\nexport { getProcessTty } from './utils/process.js';\nexport { captureProcessSnapshot, executableBasename, filterByProcessNames } from './utils/process.js';\nexport type { AgentSortKey } from './utils/sortAgents.js';\nexport type { ListAgentsOptions } from './AgentManager.js';\n\nexport { AgentRegistry, RenameNotFoundError, RenameConflictError } from './utils/AgentRegistry.js';\nexport type { AgentRegistryOptions, RegistryEntry } from './utils/AgentRegistry.js';\nexport { TmuxManager } from './terminal/TmuxManager.js';\nexport { AGENTS } from './utils/agents.js';\nexport type { AgentConfig, StartableAgentType } from './utils/agents.js';\n\nexport type { AgentRequest } from './utils/agent-requests.js';\nexport { getAgentRequestPath, readLatestAgentRequest, writeAgentRequest } from './utils/agent-requests.js';\n\nexport {\n    PrintAgentError,\n    PrintAgentBusyError,\n    PrintAgentNotFoundError,\n    PrintAgentStoreError,\n    PrintAgentNameConflictError,\n    ClaudePrintError,\n} from './print/PrintAgent.js';\nexport type {\n    PrintAgent,\n    PrintAgentState,\n    PrintSessionHealth,\n    PrintRunStatus,\n    PrintActiveRun,\n    PrintLastResult,\n    ProcessIdentity,\n} from './print/PrintAgent.js';\nexport { PrintAgentStore } from './print/PrintAgentStore.js';\nexport { LocalProcessInspector } from './print/PrintAgentStore.js';\nexport type {\n    CreatePrintAgentInput,\n    PrintAgentStoreOptions,\n    ProcessInspector,\n    PrintRunCompletion,\n} from './print/PrintAgentStore.js';\nexport { ClaudeCliProbe } from './print/ClaudeCliProbe.js';\nexport type { ClaudeCliProbeOptions } from './print/ClaudeCliProbe.js';\nexport { ClaudePrintRunner } from './print/ClaudePrintRunner.js';\nexport type {\n    ClaudePrintRunnerOptions,\n    ClaudePrintRunRequest,\n    ClaudePrintRunResult,\n} from './print/ClaudePrintRunner.js';\nexport { ClaudePrintAgentService } from './print/ClaudePrintAgentService.js';\nexport type {\n    ClaudePrintAgentServiceOptions,\n    ClaudePrintSendResult,\n} from './print/ClaudePrintAgentService.js';\n"],"names":["AgentManager","AgentNotRunningError","ClaudeCodeAdapter","CodexAdapter","CopilotAdapter","GeminiCliAdapter","GrokCliAdapter","OpenCodeAdapter","PiAdapter","AgentStatus","TerminalFocusManager","TerminalType","TtyWriter","getProcessTty","captureProcessSnapshot","executableBasename","filterByProcessNames","AgentRegistry","RenameNotFoundError","RenameConflictError","TmuxManager","AGENTS","getAgentRequestPath","readLatestAgentRequest","writeAgentRequest","PrintAgentError","PrintAgentBusyError","PrintAgentNotFoundError","PrintAgentStoreError","PrintAgentNameConflictError","ClaudePrintError","PrintAgentStore","LocalProcessInspector","ClaudeCliProbe","ClaudePrintRunner","ClaudePrintAgentService"],"mappings":"AAAA,SAASA,YAAY,EAAEC,oBAAoB,QAAQ,oBAAoB;AAEvE,SAASC,iBAAiB,QAAQ,kCAAkC;AACpE,SAASC,YAAY,QAAQ,6BAA6B;AAC1D,SAASC,cAAc,QAAQ,+BAA+B;AAC9D,SAASC,gBAAgB,QAAQ,iCAAiC;AAClE,SAASC,cAAc,QAAQ,+BAA+B;AAC9D,SAASC,eAAe,QAAQ,gCAAgC;AAChE,SAASC,SAAS,QAAQ,0BAA0B;AACpD,SAASC,WAAW,QAAQ,6BAA6B;AAYzD,SAASC,oBAAoB,EAAEC,YAAY,QAAQ,qCAAqC;AAExF,SAASC,SAAS,QAAQ,0BAA0B;AAEpD,SAASC,aAAa,QAAQ,qBAAqB;AACnD,SAASC,sBAAsB,EAAEC,kBAAkB,EAAEC,oBAAoB,QAAQ,qBAAqB;AAItG,SAASC,aAAa,EAAEC,mBAAmB,EAAEC,mBAAmB,QAAQ,2BAA2B;AAEnG,SAASC,WAAW,QAAQ,4BAA4B;AACxD,SAASC,MAAM,QAAQ,oBAAoB;AAI3C,SAASC,mBAAmB,EAAEC,sBAAsB,EAAEC,iBAAiB,QAAQ,4BAA4B;AAE3G,SACIC,eAAe,EACfC,mBAAmB,EACnBC,uBAAuB,EACvBC,oBAAoB,EACpBC,2BAA2B,EAC3BC,gBAAgB,QACb,wBAAwB;AAU/B,SAASC,eAAe,QAAQ,6BAA6B;AAC7D,SAASC,qBAAqB,QAAQ,6BAA6B;AAOnE,SAASC,cAAc,QAAQ,4BAA4B;AAE3D,SAASC,iBAAiB,QAAQ,+BAA+B;AAMjE,SAASC,uBAAuB,QAAQ,qCAAqC"}
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["export { AgentManager, AgentNotRunningError } from './AgentManager.js';\n\nexport { ClaudeCodeAdapter } from './adapters/ClaudeCodeAdapter.js';\nexport { CodexAdapter } from './adapters/CodexAdapter.js';\nexport { CopilotAdapter } from './adapters/CopilotAdapter.js';\nexport { GeminiCliAdapter } from './adapters/GeminiCliAdapter.js';\nexport { GrokCliAdapter } from './adapters/GrokCliAdapter.js';\nexport { OpenCodeAdapter } from './adapters/OpenCodeAdapter.js';\nexport { PiAdapter } from './adapters/PiAdapter.js';\nexport { AgentStatus } from './adapters/AgentAdapter.js';\nexport type {\n    AgentAdapter,\n    AgentType,\n    AgentInfo,\n    ProcessInfo,\n    ConversationMessage,\n    SessionSummary,\n    ListSessionsOptions,\n    AgentDetectionContext,\n} from './adapters/AgentAdapter.js';\n\nexport { TerminalFocusManager, TerminalType } from './terminal/TerminalFocusManager.js';\nexport type { TerminalLocation } from './terminal/TerminalFocusManager.js';\nexport { TtyWriter } from './terminal/TtyWriter.js';\n\nexport { getProcessTty } from './utils/process.js';\nexport { captureProcessSnapshot, executableBasename, filterByProcessNames } from './utils/process.js';\nexport type { AgentSortKey } from './utils/sortAgents.js';\nexport type { ListAgentsOptions } from './AgentManager.js';\n\nexport { AgentRegistry, RenameNotFoundError, RenameConflictError } from './utils/AgentRegistry.js';\nexport type { AgentRegistryOptions, RegistryEntry } from './utils/AgentRegistry.js';\nexport { TmuxManager } from './terminal/TmuxManager.js';\nexport { AGENTS } from './utils/agents.js';\nexport type { AgentConfig, StartableAgentType } from './utils/agents.js';\n\nexport type { AgentRequest } from './utils/agent-requests.js';\nexport { getAgentRequestPath, readLatestAgentRequest, writeAgentRequest } from './utils/agent-requests.js';\n\nexport {\n    AGENT_MODES,\n    DurableAgentError,\n    DurableAgentBusyError,\n    DurableAgentNotFoundError,\n    DurableAgentRepositoryError,\n    DurableAgentNameConflictError,\n    ClaudePrintError,\n} from './durable/DurableAgent.js';\nexport type {\n    DurableAgent,\n    DurableAgentState,\n    DurableSessionHealth,\n    DurableRunStatus,\n    DurableActiveRun,\n    DurableLastResult,\n    ProcessIdentity,\n} from './durable/DurableAgent.js';\nexport { DurableAgentRepository } from './durable/DurableAgentRepository.js';\nexport { LocalProcessInspector } from './durable/DurableAgentRepository.js';\nexport type {\n    CreateDurableAgentInput,\n    DurableAgentRepositoryOptions,\n    ProcessInspector,\n    DurableRunCompletion,\n} from './durable/DurableAgentRepository.js';\nexport { ClaudeCliProbe } from './durable/ClaudeCliProbe.js';\nexport type { ClaudeCliProbeOptions } from './durable/ClaudeCliProbe.js';\nexport { ClaudePrintRunner } from './durable/ClaudePrintRunner.js';\nexport type {\n    ClaudePrintRunnerOptions,\n    ClaudePrintRunRequest,\n    ClaudePrintRunResult,\n} from './durable/ClaudePrintRunner.js';\nexport { ClaudePrintAgentService } from './durable/ClaudePrintAgentService.js';\nexport type {\n    ClaudePrintAgentServiceOptions,\n    ClaudePrintSendResult,\n} from './durable/ClaudePrintAgentService.js';\n"],"names":["AgentManager","AgentNotRunningError","ClaudeCodeAdapter","CodexAdapter","CopilotAdapter","GeminiCliAdapter","GrokCliAdapter","OpenCodeAdapter","PiAdapter","AgentStatus","TerminalFocusManager","TerminalType","TtyWriter","getProcessTty","captureProcessSnapshot","executableBasename","filterByProcessNames","AgentRegistry","RenameNotFoundError","RenameConflictError","TmuxManager","AGENTS","getAgentRequestPath","readLatestAgentRequest","writeAgentRequest","AGENT_MODES","DurableAgentError","DurableAgentBusyError","DurableAgentNotFoundError","DurableAgentRepositoryError","DurableAgentNameConflictError","ClaudePrintError","DurableAgentRepository","LocalProcessInspector","ClaudeCliProbe","ClaudePrintRunner","ClaudePrintAgentService"],"mappings":"AAAA,SAASA,YAAY,EAAEC,oBAAoB,QAAQ,oBAAoB;AAEvE,SAASC,iBAAiB,QAAQ,kCAAkC;AACpE,SAASC,YAAY,QAAQ,6BAA6B;AAC1D,SAASC,cAAc,QAAQ,+BAA+B;AAC9D,SAASC,gBAAgB,QAAQ,iCAAiC;AAClE,SAASC,cAAc,QAAQ,+BAA+B;AAC9D,SAASC,eAAe,QAAQ,gCAAgC;AAChE,SAASC,SAAS,QAAQ,0BAA0B;AACpD,SAASC,WAAW,QAAQ,6BAA6B;AAYzD,SAASC,oBAAoB,EAAEC,YAAY,QAAQ,qCAAqC;AAExF,SAASC,SAAS,QAAQ,0BAA0B;AAEpD,SAASC,aAAa,QAAQ,qBAAqB;AACnD,SAASC,sBAAsB,EAAEC,kBAAkB,EAAEC,oBAAoB,QAAQ,qBAAqB;AAItG,SAASC,aAAa,EAAEC,mBAAmB,EAAEC,mBAAmB,QAAQ,2BAA2B;AAEnG,SAASC,WAAW,QAAQ,4BAA4B;AACxD,SAASC,MAAM,QAAQ,oBAAoB;AAI3C,SAASC,mBAAmB,EAAEC,sBAAsB,EAAEC,iBAAiB,QAAQ,4BAA4B;AAE3G,SACIC,WAAW,EACXC,iBAAiB,EACjBC,qBAAqB,EACrBC,yBAAyB,EACzBC,2BAA2B,EAC3BC,6BAA6B,EAC7BC,gBAAgB,QACb,4BAA4B;AAUnC,SAASC,sBAAsB,QAAQ,sCAAsC;AAC7E,SAASC,qBAAqB,QAAQ,sCAAsC;AAO5E,SAASC,cAAc,QAAQ,8BAA8B;AAE7D,SAASC,iBAAiB,QAAQ,iCAAiC;AAMnE,SAASC,uBAAuB,QAAQ,uCAAuC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-devkit/agent-manager",
-  "version": "0.27.0",
+  "version": "0.28.1",
   "type": "module",
   "description": "Standalone agent detection and management utilities for AI DevKit",
   "main": "dist/index.js",

package/src/__tests__/adapters/CodexAdapter.test.ts

@@ -750,6 +750,45 @@ describe('CodexAdapter', () => {
             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 as any).codexSessionsDir = sessionsDir;
+            (cachedAdapter as any).sessionMappingPath = mappingPath;
+
+            const processes: ProcessInfo[] = [
+                { 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: ProcessInfo[] = [
                 { pid: 100, command: 'codex', cwd: '/repo-a', tty: 'ttys001', startTime: new Date() },
@@ -1566,6 +1605,99 @@ describe('CodexAdapter', () => {
             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', [

package/src/__tests__/database/DurableAgentsDatabase.test.ts

@@ -0,0 +1,77 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import Database from 'better-sqlite3';
+import { afterEach, describe, expect, it } from 'vitest';
+import { DatabaseConnection } from '../../database/connection.js';
+import { getSchemaVersion } from '../../database/schema.js';
+
+const roots: string[] = [];
+
+afterEach(() => {
+    for (const root of roots.splice(0)) fs.rmSync(root, { recursive: true, force: true });
+});
+
+function dbPath(): string {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), 'durable-agent-db-'));
+    roots.push(root);
+    return path.join(root, 'state', 'agents.db');
+}
+
+describe('durable agents schema', () => {
+    it('migrates to version 3 with durable constraints and indexes', () => {
+        const connection = new DatabaseConnection({ dbPath: dbPath() });
+        expect(getSchemaVersion(connection)).toBe(3);
+        const table = connection.queryOne<{ sql: string }>(
+            "SELECT sql FROM sqlite_master WHERE type = 'table' AND name = 'durable_agents'",
+        );
+        expect(table?.sql).toContain("DEFAULT 'durable'");
+        expect(table?.sql).toContain("state IN ('ready','running','degraded')");
+        expect(connection.query<{ name: string }>(
+            "SELECT name FROM sqlite_master WHERE type = 'index' AND tbl_name = 'durable_agents'",
+        ).map(({ name }) => name)).toEqual(expect.arrayContaining([
+            'idx_durable_agents_state', 'idx_durable_agents_list',
+        ]));
+        connection.close();
+    });
+
+    it('enforces case-insensitive names and active-run consistency but permits new providers', () => {
+        const connection = new DatabaseConnection({ dbPath: dbPath() });
+        const insert = (name: string, provider: string, state = 'ready') => connection.execute(`
+            INSERT INTO durable_agents (
+                id, name, provider, mode, cwd, provider_session_id, state, session_health,
+                created_at, updated_at
+            ) VALUES (?, ?, ?, 'durable', '/tmp', ?, ?, 'uninitialized', ?, ?)
+        `, [crypto.randomUUID(), name, provider, crypto.randomUUID(), state, new Date().toISOString(), new Date().toISOString()]);
+        expect(() => insert('Alpha', 'future-provider')).not.toThrow();
+        expect(() => insert('alpha', 'claude')).toThrow(/UNIQUE/i);
+        expect(() => insert('Broken', 'claude', 'running')).toThrow(/CHECK/i);
+        connection.close();
+    });
+});
+
+describe('readonly DatabaseConnection', () => {
+    it('opens an already migrated database without changing it', () => {
+        const file = dbPath();
+        const writable = new DatabaseConnection({ dbPath: file });
+        writable.close();
+        const before = fs.statSync(file).mtimeMs;
+        const readonly = new DatabaseConnection({ dbPath: file, readonly: true });
+        expect(readonly.queryOne<{ user_version: number }>('PRAGMA user_version')?.user_version).toBe(3);
+        readonly.close();
+        expect(fs.statSync(file).mtimeMs).toBe(before);
+    });
+
+    it('does not create a missing database or migrate an old one', () => {
+        const missing = dbPath();
+        expect(() => new DatabaseConnection({ dbPath: missing, readonly: true })).toThrow(/readonly.*exist/i);
+        expect(fs.existsSync(missing)).toBe(false);
+
+        fs.mkdirSync(path.dirname(missing), { recursive: true });
+        const raw = new Database(missing);
+        raw.pragma('user_version = 2');
+        raw.close();
+        expect(() => new DatabaseConnection({ dbPath: missing, readonly: true })).toThrow(/schema version 3/i);
+        expect(new Database(missing, { readonly: true }).pragma('user_version', { simple: true })).toBe(2);
+    });
+});

package/src/__tests__/print/ClaudePrintAgent.integration.test.ts

@@ -7,7 +7,7 @@ import {
     ClaudeCliProbe,
     ClaudePrintAgentService,
     ClaudePrintRunner,
-    PrintAgentStore,
+    DurableAgentRepository,
 } from '../../index.js';
 
 const roots: string[] = [];
@@ -19,18 +19,18 @@ afterEach(() => {
     for (const root of roots.splice(0)) fs.rmSync(root, { recursive: true, force: true });
 });
 
-describe('Claude print-agent fake-provider journey', () => {
+describe('Claude durable-agent fake-provider journey', () => {
     it('creates without invocation, then starts and resumes the same session through stdin', async () => {
-        const root = fs.mkdtempSync(path.join(os.tmpdir(), 'print-agent-integration-'));
+        const root = fs.mkdtempSync(path.join(os.tmpdir(), 'durable-agent-integration-'));
         roots.push(root);
         const cwd = path.join(root, 'project');
         fs.mkdirSync(cwd);
         const capture = path.join(root, 'capture.jsonl');
         process.env.AI_DEVKIT_FAKE_CLAUDE_CAPTURE = capture;
         const executable = fileURLToPath(new URL('../fixtures/fake-claude.cjs', import.meta.url));
-        const store = new PrintAgentStore({ filePath: path.join(root, 'state', 'print-agents.json') });
+        const repository = new DurableAgentRepository({ dbPath: path.join(root, 'state', 'agents.db') });
         const service = new ClaudePrintAgentService({
-            store,
+            repository,
             probe: new ClaudeCliProbe({ executable }),
             runner: new ClaudePrintRunner(),
             executable,
@@ -50,7 +50,7 @@ describe('Claude print-agent fake-provider journey', () => {
         expect(invocations[1].args).toContain('--resume');
         expect(invocations[1].args[invocations[1].args.indexOf('--resume') + 1]).toBe(created.providerSessionId);
 
-        const persisted = await store.getById(created.id);
+        const persisted = await repository.getById(created.id);
         expect(persisted).toMatchObject({ state: 'ready', sessionHealth: 'healthy' });
     });
 });

package/src/__tests__/print/ClaudePrintAgentService.test.ts

@@ -5,21 +5,21 @@ describe('ClaudePrintAgentService', () => {
         const api = await import('../../index.js') as Record<string, unknown>;
         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 repository = { create: vi.fn().mockResolvedValue({ id: 'agent-id', name: 'reviewer' }) };
         const runner = { run: vi.fn() };
         const Service = api.ClaudePrintAgentService as new (options: unknown) => any;
 
-        await expect(new Service({ store, probe, runner }).create({ name: 'reviewer', cwd: '/project' }))
+        await expect(new Service({ repository, 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(repository.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') as Record<string, unknown>;
         const base = { id: 'id', name: 'reviewer', providerSessionId: 'session', sessionHealth: 'uninitialized' };
-        const store = {
+        const repository = {
             resolve: vi.fn().mockResolvedValue(base),
             acquireRun: vi.fn()
                 .mockResolvedValueOnce({ agent: base, token: 'one' })
@@ -31,15 +31,15 @@ describe('ClaudePrintAgentService', () => {
             return { sessionId: 'session', result: 'answer', exitCode: 0 };
         }) };
         const Service = api.ClaudePrintAgentService as new (options: unknown) => any;
-        const service = new Service({ store, probe: { validate: vi.fn() }, runner, executable: 'fake-claude' });
+        const service = new Service({ repository, 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({
+        expect(repository.recordProviderProcess).toHaveBeenCalledWith('id', 'one', { pid: 42, startedAt: 'start' });
+        expect(repository.completeRun).toHaveBeenCalledWith('id', 'one', expect.objectContaining({
             status: 'succeeded', exitCode: 0, sessionHealth: 'healthy',
         }));
     });

package/src/__tests__/print/ClaudePrintRunner.test.ts

@@ -1,11 +1,11 @@
 import { EventEmitter } from 'node:events';
 import { PassThrough, Writable } from 'node:stream';
 import { describe, expect, it, vi } from 'vitest';
-import type { PrintAgent } from '../../index.js';
+import type { DurableAgent } from '../../index.js';
 
-function agent(): PrintAgent {
+function agent(): DurableAgent {
     return {
-        id: '11111111-1111-4111-8111-111111111111', name: 'reviewer', provider: 'claude', mode: 'print',
+        id: '11111111-1111-4111-8111-111111111111', name: 'reviewer', provider: 'claude', mode: 'durable',
         cwd: '/project', providerSessionId: '22222222-2222-4222-8222-222222222222', state: 'running',
         sessionHealth: 'uninitialized', createdAt: '', updatedAt: '', lastActiveAt: null, lastResult: null,
         activeRun: null,

package/src/__tests__/print/{PrintAgent.test.ts → DurableAgent.test.ts}

@@ -1,21 +1,21 @@
 import { describe, expect, it } from 'vitest';
 
-describe('print-agent public domain', () => {
+describe('durable-agent public domain', () => {
     it('exports a classified busy error without exposing prompt data', async () => {
         const api = await import('../../index.js') as Record<string, unknown>;
 
-        expect(api).toHaveProperty('PrintAgentBusyError');
-        const ErrorType = api.PrintAgentBusyError as new (agentId: string, name: string) => Error & {
+        expect(api).toHaveProperty('DurableAgentBusyError');
+        const ErrorType = api.DurableAgentBusyError as new (agentId: string, name: string) => Error & {
             code: string;
             agentId: string;
         };
         const error = new ErrorType('agent-id', 'reviewer');
 
         expect(error).toMatchObject({
-            name: 'PrintAgentBusyError',
-            code: 'PRINT_AGENT_BUSY',
+            name: 'DurableAgentBusyError',
+            code: 'DURABLE_AGENT_BUSY',
             agentId: 'agent-id',
-            message: 'Print agent "reviewer" is busy.',
+            message: 'Durable agent "reviewer" is busy.',
         });
     });
 });

package/src/__tests__/print/DurableAgentRepository.sqlite.test.ts

@@ -0,0 +1,105 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import Database from 'better-sqlite3';
+import { afterEach, describe, expect, it } from 'vitest';
+import { DurableAgentRepository } from '../../durable/DurableAgentRepository.js';
+
+const roots: string[] = [];
+afterEach(() => {
+    for (const root of roots.splice(0)) fs.rmSync(root, { recursive: true, force: true });
+});
+
+function fixture() {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), 'durable-agent-sqlite-'));
+    roots.push(root);
+    const cwd = path.join(root, 'project');
+    fs.mkdirSync(cwd);
+    return { root, cwd, dbPath: path.join(root, 'state', 'agents.db') };
+}
+
+describe('DurableAgentRepository SQLite concurrency', () => {
+    it('allows exactly one acquisition across two connections', async () => {
+        const { cwd, dbPath } = fixture();
+        const identity = { pid: process.pid, startedAt: 'owner-start' };
+        const processInspector = { getIdentity: (pid: number) => pid === process.pid ? identity : null };
+        const first = new DurableAgentRepository({ dbPath, processInspector });
+        const second = new DurableAgentRepository({ dbPath, processInspector });
+        const agent = await first.create({ name: 'race', cwd });
+        const results = await Promise.allSettled([first.acquireRun(agent.id), second.acquireRun(agent.id)]);
+        expect(results.filter(({ status }) => status === 'fulfilled')).toHaveLength(1);
+        const rejected = results.find(({ status }) => status === 'rejected');
+        expect(rejected).toMatchObject({ reason: { code: 'DURABLE_AGENT_BUSY' } });
+    });
+
+    it('accepts deprecated lock options without creating lock artifacts', async () => {
+        const { root, cwd, dbPath } = fixture();
+        const repository = new DurableAgentRepository({
+            dbPath, lockTimeoutMs: 1, incompleteLockGraceMs: 1, mutationLockStaleMs: 1,
+        });
+        await repository.create({ name: 'lockless', cwd });
+        expect(fs.existsSync(`${dbPath}.lock`)).toBe(false);
+        expect(fs.existsSync(path.join(root, 'state', 'durable-agent-locks'))).toBe(false);
+    });
+
+    it('keeps readonly listing pure', async () => {
+        const { cwd, dbPath } = fixture();
+        const live = new Map([[process.pid, 'owner-start']]);
+        const processInspector = { getIdentity: (pid: number) => {
+            const startedAt = live.get(pid);
+            return startedAt ? { pid, startedAt } : null;
+        } };
+        const writable = new DurableAgentRepository({ dbPath, processInspector });
+        const agent = await writable.create({ name: 'readonly', cwd });
+        await writable.acquireRun(agent.id);
+        live.clear();
+        const readonly = new DurableAgentRepository({ dbPath, readonly: true, processInspector });
+        expect((await readonly.list())[0]?.state).toBe('running');
+    });
+
+    it('rejects stale tokens and caps the persisted completion summary', async () => {
+        const { cwd, dbPath } = fixture();
+        const processInspector = { getIdentity: (pid: number) => ({ pid, startedAt: 'owner-start' }) };
+        const repository = new DurableAgentRepository({ dbPath, processInspector });
+        const agent = await repository.create({ name: 'token', cwd });
+        const run = await repository.acquireRun(agent.id);
+        await expect(repository.recordProviderProcess(agent.id, 'stale', { pid: 42, startedAt: 'provider' }))
+            .rejects.toMatchObject({ code: 'DURABLE_AGENT_REPOSITORY' });
+        const completed = await repository.completeRun(agent.id, run.token, {
+            status: 'succeeded', exitCode: 0, summary: 'x'.repeat(5000), sessionHealth: 'healthy',
+        });
+        expect(completed.lastResult?.summary).toHaveLength(4096);
+    });
+
+    it('does not reconcile over ownership changed after process inspection', async () => {
+        const { cwd, dbPath } = fixture();
+        let inspect: (() => void) | undefined;
+        const processInspector = { getIdentity: (pid: number) => {
+            if (inspect) inspect();
+            return inspect ? null : { pid, startedAt: 'owner-start' };
+        } };
+        const repository = new DurableAgentRepository({ dbPath, processInspector });
+        const agent = await repository.create({ name: 'cas', cwd });
+        await repository.acquireRun(agent.id);
+        const other = new Database(dbPath);
+        inspect = () => {
+            inspect = undefined;
+            other.prepare(`UPDATE durable_agents SET
+                active_run_token = 'replacement-token', active_owner_started_at = 'replacement-owner'
+                WHERE id = ?`).run(agent.id);
+        };
+
+        await repository.reconcile();
+
+        expect(other.prepare('SELECT state, active_run_token FROM durable_agents WHERE id = ?').get(agent.id))
+            .toEqual({ state: 'running', active_run_token: 'replacement-token' });
+        other.close();
+    });
+
+    it('maps a corrupt database to a store error', () => {
+        const { dbPath } = fixture();
+        fs.mkdirSync(path.dirname(dbPath), { recursive: true });
+        fs.writeFileSync(dbPath, 'not sqlite');
+        expect(() => new DurableAgentRepository({ dbPath })).toThrow(/Cannot open durable-agent database/);
+    });
+});