@inixiative/agent-session 0.6.0 → 0.6.3

package/src/harness-session.ts

@@ -10,7 +10,7 @@
 // HarnessSession is stateful: it owns a running process, tracks turns,
 // captures every event for Oracle, and supports fork/interrupt.
 //
-// Implementations: ClaudeCodeSession, CodexMcpSession, CodexAppServerSession,
+// Implementations: ClaudeCodeSession, CodexAppServerSession,
 // ClaudeAgentSdkSession. How a model is reached is the session's transport
 // (see transport.ts); every transport implements this one contract.
 // ---------------------------------------------------------------------------

package/src/index.ts

@@ -17,6 +17,7 @@ export {
   type ClaudeCodeSessionConfig,
 } from './claude-code-session';
 export { type ClaudePrimedConfig, ClaudePrimedSessions } from './claude-primed';
+export { type ClaudeSubagentConfig, ClaudeSubagentSessions } from './claude-subagents';
 export { parseClaudeUsage } from './claude-usage';
 export {
   CODEX_DECISION_DISABLED_FEATURES,
@@ -27,15 +28,12 @@ export {
   codexTokens,
 } from './codex-primed';
 
-// Codex CLI adapter (persistent JSON-RPC session). CodexSession defaults to the
-// mcp-server variant; CodexAppServerSession is the app-server one.
+// Codex CLI adapter: one persistent `codex app-server` JSON-RPC session.
 export {
   type CodexApprovalPolicy,
   CodexAppServerSession,
   type CodexFileChange,
-  CodexMcpSession,
   type CodexSandbox,
-  CodexSession,
   type CodexSessionConfig,
   type CodexSpawn,
   codexPermissions,

package/src/pool.ts

@@ -31,7 +31,7 @@ import {
 import { TRANSPORTS, type TransportKind } from './transport';
 import { createSession } from './transports';
 
-export type PooledTransport = 'claude-cli' | 'codex-mcp' | 'codex-app-server' | 'claude-agent-sdk';
+export type PooledTransport = 'claude-cli' | 'codex-app-server' | 'claude-agent-sdk';
 
 export interface InstanceConfig {
   readonly id: string;

package/src/primed.ts

@@ -46,6 +46,13 @@ export interface DecisionRequest {
   readonly outputSchema?: Readonly<Record<string, unknown>>;
   /** Cancel: refused before dispatch, or the running turn is interrupted and settled. */
   readonly signal?: AbortSignal;
+  /** Decisions of one group share a side session (ClaudeSubagentSessions): a Foundry thread. */
+  readonly group?: string;
+  /**
+   * The group's current context, which precedes `input` (ClaudeSubagentSessions): a member
+   * pre-started with exactly this context receives only `input`; otherwise both are sent.
+   */
+  readonly standby?: string;
 }
 
 export interface DecisionResult {
@@ -121,6 +128,15 @@ export type PrimedEvent =
       readonly cacheRead?: number;
       readonly input?: number;
     }
+  | {
+      /** A pre-started member's standby turn, until its moment (or its end): what pre-starting costs. */
+      readonly type: 'standby';
+      readonly key: string;
+      readonly input: number;
+      readonly output: number;
+      readonly cacheRead: number;
+      readonly cacheWrite: number;
+    }
   | { readonly type: 'limits'; readonly limits: LimitSnapshot }
   | { readonly type: 'violation'; readonly key: string; readonly detail: string }
   | { readonly type: 'hedged'; readonly key: string; readonly afterMs: number }
@@ -142,6 +158,10 @@ export interface PrimedSessions {
   decide(spec: PrimeSpec, request: DecisionRequest): Promise<DecisionResult>;
   /** Drop a key's primed session; the next decision re-primes it. */
   evict(key: string): Promise<void>;
+  /** Keep these roles of a group pre-started, holding this standby context (ClaudeSubagentSessions). */
+  prestart?(group: string, entries: ReadonlyArray<{ spec: PrimeSpec; standby: string }>): void;
+  /** A group is done (its thread closed): stop what it holds (ClaudeSubagentSessions). */
+  releaseGroup?(group: string): Promise<void>;
   limits(): LimitSnapshot | undefined;
   snapshot(): PrimedSnapshot;
   close(): Promise<void>;
@@ -262,7 +282,7 @@ export class Slots {
   }
 }
 
-/** Per-key serialization: a key's decisions run one at a time, in order. */
+/** Per-key serialization: a key's tasks run one at a time, in order. */
 export class KeyedQueue {
   private _tails = new Map<string, Promise<void>>();
   run<T>(key: string, task: () => Promise<T>): Promise<T> {

package/src/transport.ts

@@ -13,21 +13,15 @@
 // is declared absent, with a note.
 // ---------------------------------------------------------------------------
 
-export type TransportKind =
-  | 'claude-cli'
-  | 'codex-mcp'
-  | 'codex-app-server'
-  | 'claude-agent-sdk'
-  | 'acp'
-  | 'api';
+export type TransportKind = 'claude-cli' | 'codex-app-server' | 'claude-agent-sdk' | 'acp' | 'api';
 
 export type TransportRuntime = 'claude' | 'codex' | 'external';
 
 export interface TransportCapabilities {
-  /** Continue a thread by native ID in a new process (`loaded-only`: only while the original process holds it). */
-  readonly resume: 'native' | 'loaded-only' | 'none';
-  /** `native`: a new branch with its own ID; `same-thread`: continues the parent thread (not a real fork). */
-  readonly fork: 'native' | 'same-thread' | 'none';
+  /** Continue a thread by native ID in a new process. */
+  readonly resume: 'native' | 'none';
+  /** `native`: a new branch with its own ID. */
+  readonly fork: 'native' | 'none';
   /** Drop the last N turns of native history. */
   readonly rollback: 'native' | 'none';
   /** `acknowledged`: interruptNative() confirms the stop through the turn's terminal; `local-only`: interrupt() releases the local waiter only. */
@@ -88,29 +82,6 @@ export const TRANSPORTS: Readonly<Record<TransportKind, TransportDescriptor>> =
       'Rollback (`--resume-session-at`) exists natively but is not wired here.',
     ],
   },
-  'codex-mcp': {
-    kind: 'codex-mcp',
-    runtime: 'codex',
-    status: 'implemented',
-    verified: 'live',
-    capabilities: {
-      resume: 'loaded-only',
-      fork: 'same-thread',
-      rollback: 'none',
-      interrupt: 'local-only',
-      push: 'none',
-      approvals: 'mode',
-      usage: true,
-      limits: none,
-      textOnly: false,
-      primed: 'none',
-      billing: 'subscription',
-    },
-    notes: [
-      '`codex mcp-server`; `codex-reply` continues only threads loaded in the same process.',
-      'fork() continues the parent thread; it is not a native fork.',
-    ],
-  },
   'codex-app-server': {
     kind: 'codex-app-server',
     runtime: 'codex',

package/src/transports.ts

@@ -6,7 +6,7 @@ import {
   type ClaudeAgentSdkSessionConfig,
 } from './claude-agent-sdk-session';
 import { ClaudeCodeSession, type ClaudeCodeSessionConfig } from './claude-code-session';
-import { CodexAppServerSession, CodexMcpSession, type CodexSessionConfig } from './codex-session';
+import { CodexAppServerSession, type CodexSessionConfig } from './codex-session';
 import type { HarnessSession } from './harness-session';
 import {
   TRANSPORTS,
@@ -36,7 +36,6 @@ export interface ApiSessionConfig {
 
 export interface TransportConfigs {
   'claude-cli': ClaudeCodeSessionConfig;
-  'codex-mcp': CodexSessionConfig;
   'codex-app-server': CodexSessionConfig;
   'claude-agent-sdk': ClaudeAgentSdkSessionConfig;
   acp: AcpSessionConfig;
@@ -81,8 +80,6 @@ export function createSession<K extends TransportKind>(
   switch (kind) {
     case 'claude-cli':
       return new ClaudeCodeSession(config as ClaudeCodeSessionConfig);
-    case 'codex-mcp':
-      return new CodexMcpSession(config as CodexSessionConfig);
     case 'codex-app-server':
       return new CodexAppServerSession(config as CodexSessionConfig);
     case 'claude-agent-sdk':