@xopcai/xopc 0.0.82 → 0.0.84

package/dist/src/agent/embedded/run-for-session.js.map

@@ -1 +1 @@
-{"version":3,"file":"run-for-session.js","names":[],"sources":["../../../../src/agent/embedded/run-for-session.ts"],"sourcesContent":["import crypto from 'node:crypto';\nimport type { AgentMessage, ThinkingLevel } from '@earendil-works/pi-agent-core';\n\nimport type { Config } from '../../config/schema.js';\nimport type { AgentManager } from '../agent-manager.js';\nimport type { ModelManager } from '../models/index.js';\nimport type { SessionStore } from '../../session/store.js';\nimport { resolveAgentTurnTimeoutMs } from '../orchestration/run-agent-turn-with-timeout.js';\nimport { runXopcEmbeddedTurn } from './run-turn.js';\nimport type { EmbeddedStreamEvent, RunXopcEmbeddedTurnParams, RunXopcEmbeddedTurnResult } from './types.js';\nimport { applyStartupContextToUserMessage } from '../reply/apply-turn-user-enrichment.js';\nimport {\n  mergeTurnTools,\n  resolveEmbeddedMcpToolsForTurn,\n} from '../mcp/resolve-embedded-mcp-tools.js';\nimport { createLogger } from '../../utils/logger.js';\n\nconst log = createLogger('EmbeddedTurnForSession');\n\nexport type RunEmbeddedForSessionParams = {\n  sessionKey: string;\n  runId?: string;\n  userMessage: AgentMessage;\n  sessionStore: SessionStore;\n  agentManager: AgentManager;\n  modelManager: ModelManager;\n  thinkingOverride?: string | null;\n  abortSignal?: AbortSignal;\n  onEvent?: (event: EmbeddedStreamEvent) => void;\n  getConfig?: () => Config | undefined;\n  beforeTurn?: () => void | Promise<void>;\n  afterTurn?: (userPlain: string) => void | Promise<void>;\n  startupAction?: 'new' | 'reset';\n  forceStartupContext?: boolean;\n  applyStartupContext?: boolean;\n  /** When true, dispose session MCP runtime after this turn completes. */\n  cleanupBundleMcpOnRunEnd?: boolean;\n};\n\nexport async function runEmbeddedTurnForSession(\n  params: RunEmbeddedForSessionParams,\n): Promise<RunXopcEmbeddedTurnResult> {\n  const { sessionKey, agentManager, modelManager, sessionStore, userMessage } = params;\n  const runId = params.runId ?? crypto.randomUUID();\n\n  await params.beforeTurn?.();\n\n  const agent = (agentManager as any).getOrCreateAgent(sessionKey) as {\n    state: {\n      tools: RunXopcEmbeddedTurnParams['tools'];\n      systemPrompt?: string;\n      thinkingLevel?: ThinkingLevel;\n    };\n  };\n  const mm = modelManager as any;\n  await mm.applyModelForSession(agent, sessionKey);\n\n  const modelRef = String(mm.getModelForSession(sessionKey));\n  const model = mm.getResolvedModelForSession(sessionKey) as RunXopcEmbeddedTurnParams['model'];\n  const tools = agent.state.tools;\n  const systemPrompt = agent.state.systemPrompt ?? '';\n  const thinkingLevel = (params.thinkingOverride as ThinkingLevel | undefined) ?? agent.state.thinkingLevel;\n  const workspaceDir = agentManager.getResolvedWorkspaceForSession(sessionKey);\n  const config = params.getConfig?.();\n\n  // --- Pre-turn automatic compaction ---\n  await maybeAutoCompactBeforeTurn({\n    sessionKey,\n    sessionStore,\n    agentManager,\n    model,\n    config,\n    onEvent: params.onEvent,\n  });\n\n  let userMessageForTurn = userMessage;\n  if (params.applyStartupContext !== false) {\n    userMessageForTurn = await applyStartupContextToUserMessage({\n      userMessage,\n      sessionKey,\n      workspaceDir,\n      cfg: config,\n      sessionStore,\n      startupAction: params.startupAction,\n      force: params.forceStartupContext,\n    });\n  }\n\n  const result = await (async () => {\n    const mcpResolved = await resolveEmbeddedMcpToolsForTurn({\n      sessionKey,\n      workspaceDir,\n      cfg: config,\n      baseTools: tools,\n      cleanupOnTurnEnd: params.cleanupBundleMcpOnRunEnd === true,\n    });\n    const turnTools = mergeTurnTools(tools, mcpResolved.tools);\n    try {\n      return await runXopcEmbeddedTurn({\n        sessionKey,\n        runId,\n        userMessage: userMessageForTurn,\n        model,\n        modelRef,\n        tools: turnTools,\n        systemPrompt,\n        thinkingLevel,\n        workspaceDir,\n        sessionStore,\n        timeoutMs: resolveAgentTurnTimeoutMs(config),\n        abortSignal: params.abortSignal,\n        onEvent: params.onEvent,\n      });\n    } finally {\n      await mcpResolved.dispose().catch(() => {});\n    }\n  })();\n\n  return result;\n}\n\n// ---------------------------------------------------------------------------\n// Pre-turn automatic compaction\n// ---------------------------------------------------------------------------\n\nasync function maybeAutoCompactBeforeTurn(opts: {\n  sessionKey: string;\n  sessionStore: SessionStore;\n  agentManager: AgentManager;\n  model: RunXopcEmbeddedTurnParams['model'];\n  config: Config | undefined;\n  onEvent?: (event: EmbeddedStreamEvent) => void;\n}): Promise<void> {\n  const { sessionKey, sessionStore, agentManager, model, config, onEvent } = opts;\n\n  // Respect the compaction.enabled flag\n  const compactionConfig = config?.agents?.defaults?.compaction;\n  if (compactionConfig?.enabled === false) {\n    return;\n  }\n\n  const contextWindow = (model as { contextWindow?: number }).contextWindow ?? 128_000;\n  const messages = await sessionStore.load(sessionKey);\n  const prep = sessionStore.prepareCompaction(sessionKey, messages, contextWindow);\n\n  if (!prep.needsCompaction) {\n    return;\n  }\n\n  log.info(\n    { sessionKey, reason: prep.stats?.reason, usagePercent: prep.stats?.usagePercent, contextWindow },\n    'Pre-turn auto-compaction triggered',\n  );\n\n  onEvent?.({\n    type: 'compaction',\n    status: 'started',\n    tokensBefore: prep.stats?.usagePercent != null\n      ? Math.round((prep.stats.usagePercent as number) * contextWindow)\n      : undefined,\n  });\n\n  try {\n    const result = await sessionStore.compact(sessionKey, messages, contextWindow);\n\n    if (result.compacted) {\n      // Evict the cached agent so the next turn reloads from the compacted transcript\n      agentManager.removeAgent(sessionKey);\n\n      log.info(\n        { sessionKey, tokensBefore: result.tokensBefore, tokensAfter: result.tokensAfter },\n        'Pre-turn auto-compaction completed',\n      );\n\n      onEvent?.({\n        type: 'compaction',\n        status: 'completed',\n        tokensBefore: result.tokensBefore,\n        tokensAfter: result.tokensAfter,\n        summary: result.summary.length > 200 ? `${result.summary.slice(0, 200)}…` : result.summary,\n      });\n    } else {\n      onEvent?.({ type: 'compaction', status: 'skipped' });\n    }\n  } catch (err) {\n    const errorMessage = err instanceof Error ? err.message : String(err);\n    log.warn({ err, sessionKey }, `Pre-turn auto-compaction failed: ${errorMessage}`);\n    // Non-fatal: let the turn proceed even if compaction fails\n    onEvent?.({ type: 'compaction', status: 'skipped' });\n  }\n}\n"],"mappings":";;;;;;;;aAeqD;AAErD,MAAM,MAAM,aAAa,yBAAyB;AAsBlD,eAAsB,0BACpB,QACoC;CACpC,MAAM,EAAE,YAAY,cAAc,cAAc,cAAc,gBAAgB;CAC9E,MAAM,QAAQ,OAAO,SAAS,OAAO,YAAY;AAEjD,OAAM,OAAO,cAAc;CAE3B,MAAM,QAAS,aAAqB,iBAAiB,WAAW;CAOhE,MAAM,KAAK;AACX,OAAM,GAAG,qBAAqB,OAAO,WAAW;CAEhD,MAAM,WAAW,OAAO,GAAG,mBAAmB,WAAW,CAAC;CAC1D,MAAM,QAAQ,GAAG,2BAA2B,WAAW;CACvD,MAAM,QAAQ,MAAM,MAAM;CAC1B,MAAM,eAAe,MAAM,MAAM,gBAAgB;CACjD,MAAM,gBAAiB,OAAO,oBAAkD,MAAM,MAAM;CAC5F,MAAM,eAAe,aAAa,+BAA+B,WAAW;CAC5E,MAAM,SAAS,OAAO,aAAa;AAGnC,OAAM,2BAA2B;EAC/B;EACA;EACA;EACA;EACA;EACA,SAAS,OAAO;EACjB,CAAC;CAEF,IAAI,qBAAqB;AACzB,KAAI,OAAO,wBAAwB,MACjC,sBAAqB,MAAM,iCAAiC;EAC1D;EACA;EACA;EACA,KAAK;EACL;EACA,eAAe,OAAO;EACtB,OAAO,OAAO;EACf,CAAC;AAiCJ,QAAO,OA9Be,YAAY;EAChC,MAAM,cAAc,MAAM,+BAA+B;GACvD;GACA;GACA,KAAK;GACL,WAAW;GACX,kBAAkB,OAAO,6BAA6B;GACvD,CAAC;EACF,MAAM,YAAY,eAAe,OAAO,YAAY,MAAM;AAC1D,MAAI;AACF,UAAO,MAAM,oBAAoB;IAC/B;IACA;IACA,aAAa;IACb;IACA;IACA,OAAO;IACP;IACA;IACA;IACA;IACA,WAAW,0BAA0B,OAAO;IAC5C,aAAa,OAAO;IACpB,SAAS,OAAO;IACjB,CAAC;YACM;AACR,SAAM,YAAY,SAAS,CAAC,YAAY,GAAG;;KAE3C;;AASN,eAAe,2BAA2B,MAOxB;CAChB,MAAM,EAAE,YAAY,cAAc,cAAc,OAAO,QAAQ,YAAY;AAI3E,MADyB,QAAQ,QAAQ,UAAU,aAC7B,YAAY,MAChC;CAGF,MAAM,gBAAiB,MAAqC,iBAAiB;CAC7E,MAAM,WAAW,MAAM,aAAa,KAAK,WAAW;CACpD,MAAM,OAAO,aAAa,kBAAkB,YAAY,UAAU,cAAc;AAEhF,KAAI,CAAC,KAAK,gBACR;AAGF,KAAI,KACF;EAAE;EAAY,QAAQ,KAAK,OAAO;EAAQ,cAAc,KAAK,OAAO;EAAc;EAAe,EACjG,qCACD;AAED,WAAU;EACR,MAAM;EACN,QAAQ;EACR,cAAc,KAAK,OAAO,gBAAgB,OACtC,KAAK,MAAO,KAAK,MAAM,eAA0B,cAAc,GAC/D,KAAA;EACL,CAAC;AAEF,KAAI;EACF,MAAM,SAAS,MAAM,aAAa,QAAQ,YAAY,UAAU,cAAc;AAE9E,MAAI,OAAO,WAAW;AAEpB,gBAAa,YAAY,WAAW;AAEpC,OAAI,KACF;IAAE;IAAY,cAAc,OAAO;IAAc,aAAa,OAAO;IAAa,EAClF,qCACD;AAED,aAAU;IACR,MAAM;IACN,QAAQ;IACR,cAAc,OAAO;IACrB,aAAa,OAAO;IACpB,SAAS,OAAO,QAAQ,SAAS,MAAM,GAAG,OAAO,QAAQ,MAAM,GAAG,IAAI,CAAC,KAAK,OAAO;IACpF,CAAC;QAEF,WAAU;GAAE,MAAM;GAAc,QAAQ;GAAW,CAAC;UAE/C,KAAK;EACZ,MAAM,eAAe,eAAe,QAAQ,IAAI,UAAU,OAAO,IAAI;AACrE,MAAI,KAAK;GAAE;GAAK;GAAY,EAAE,oCAAoC,eAAe;AAEjF,YAAU;GAAE,MAAM;GAAc,QAAQ;GAAW,CAAC"}
+{"version":3,"file":"run-for-session.js","names":[],"sources":["../../../../src/agent/embedded/run-for-session.ts"],"sourcesContent":["import crypto from 'node:crypto';\nimport type { AgentMessage, ThinkingLevel } from '@earendil-works/pi-agent-core';\n\nimport type { Config } from '../../config/schema.js';\nimport type { AgentInstanceGateway } from '../agent-instance-gateway.js';\nimport type { ModelManager } from '../models/index.js';\nimport type { SessionStore } from '../../session/store.js';\nimport { resolveAgentTurnTimeoutMs } from '../orchestration/run-agent-turn-with-timeout.js';\nimport { runXopcEmbeddedTurn } from './run-turn.js';\nimport type { EmbeddedStreamEvent, RunXopcEmbeddedTurnParams, RunXopcEmbeddedTurnResult } from './types.js';\nimport { applyStartupContextToUserMessage } from '../reply/apply-turn-user-enrichment.js';\nimport {\n  mergeTurnTools,\n  resolveEmbeddedMcpToolsForTurn,\n} from '../mcp/resolve-embedded-mcp-tools.js';\nimport { createLogger } from '../../utils/logger.js';\n\nconst log = createLogger('EmbeddedTurnForSession');\n\nexport type RunEmbeddedForSessionParams = {\n  sessionKey: string;\n  runId?: string;\n  userMessage: AgentMessage;\n  sessionStore: SessionStore;\n  agentManager: AgentInstanceGateway;\n  modelManager: ModelManager;\n  thinkingOverride?: string | null;\n  abortSignal?: AbortSignal;\n  onEvent?: (event: EmbeddedStreamEvent) => void;\n  getConfig?: () => Config | undefined;\n  beforeTurn?: () => void | Promise<void>;\n  afterTurn?: (userPlain: string) => void | Promise<void>;\n  startupAction?: 'new' | 'reset';\n  forceStartupContext?: boolean;\n  applyStartupContext?: boolean;\n  /** When true, dispose session MCP runtime after this turn completes. */\n  cleanupBundleMcpOnRunEnd?: boolean;\n};\n\nexport async function runEmbeddedTurnForSession(\n  params: RunEmbeddedForSessionParams,\n): Promise<RunXopcEmbeddedTurnResult> {\n  const { sessionKey, agentManager, modelManager, sessionStore, userMessage } = params;\n  const runId = params.runId ?? crypto.randomUUID();\n\n  await params.beforeTurn?.();\n\n  const agent = (agentManager as any).getOrCreateAgent(sessionKey) as {\n    state: {\n      tools: RunXopcEmbeddedTurnParams['tools'];\n      systemPrompt?: string;\n      thinkingLevel?: ThinkingLevel;\n    };\n  };\n  const mm = modelManager as any;\n  await mm.applyModelForSession(agent, sessionKey);\n\n  const modelRef = String(mm.getModelForSession(sessionKey));\n  const model = mm.getResolvedModelForSession(sessionKey) as RunXopcEmbeddedTurnParams['model'];\n  const tools = agent.state.tools;\n  const systemPrompt = agent.state.systemPrompt ?? '';\n  const thinkingLevel = (params.thinkingOverride as ThinkingLevel | undefined) ?? agent.state.thinkingLevel;\n  const workspaceDir = agentManager.getResolvedWorkspaceForSession(sessionKey);\n  const config = params.getConfig?.();\n\n  // --- Pre-turn automatic compaction ---\n  await maybeAutoCompactBeforeTurn({\n    sessionKey,\n    sessionStore,\n    agentManager,\n    model,\n    config,\n    onEvent: params.onEvent,\n  });\n\n  let userMessageForTurn = userMessage;\n  if (params.applyStartupContext !== false) {\n    userMessageForTurn = await applyStartupContextToUserMessage({\n      userMessage,\n      sessionKey,\n      workspaceDir,\n      cfg: config,\n      sessionStore,\n      startupAction: params.startupAction,\n      force: params.forceStartupContext,\n    });\n  }\n\n  const result = await (async () => {\n    const mcpResolved = await resolveEmbeddedMcpToolsForTurn({\n      sessionKey,\n      workspaceDir,\n      cfg: config,\n      baseTools: tools,\n      cleanupOnTurnEnd: params.cleanupBundleMcpOnRunEnd === true,\n    });\n    const turnTools = mergeTurnTools(tools, mcpResolved.tools);\n    try {\n      return await runXopcEmbeddedTurn({\n        sessionKey,\n        runId,\n        userMessage: userMessageForTurn,\n        model,\n        modelRef,\n        tools: turnTools,\n        systemPrompt,\n        thinkingLevel,\n        workspaceDir,\n        sessionStore,\n        timeoutMs: resolveAgentTurnTimeoutMs(config),\n        abortSignal: params.abortSignal,\n        onEvent: params.onEvent,\n      });\n    } finally {\n      await mcpResolved.dispose().catch(() => {});\n    }\n  })();\n\n  return result;\n}\n\n// ---------------------------------------------------------------------------\n// Pre-turn automatic compaction\n// ---------------------------------------------------------------------------\n\nasync function maybeAutoCompactBeforeTurn(opts: {\n  sessionKey: string;\n  sessionStore: SessionStore;\n  agentManager: AgentInstanceGateway;\n  model: RunXopcEmbeddedTurnParams['model'];\n  config: Config | undefined;\n  onEvent?: (event: EmbeddedStreamEvent) => void;\n}): Promise<void> {\n  const { sessionKey, sessionStore, agentManager, model, config, onEvent } = opts;\n\n  // Respect the compaction.enabled flag\n  const compactionConfig = config?.agents?.defaults?.compaction;\n  if (compactionConfig?.enabled === false) {\n    return;\n  }\n\n  const contextWindow = (model as { contextWindow?: number }).contextWindow ?? 128_000;\n  const messages = await sessionStore.load(sessionKey);\n  const prep = sessionStore.prepareCompaction(sessionKey, messages, contextWindow);\n\n  if (!prep.needsCompaction) {\n    return;\n  }\n\n  log.info(\n    { sessionKey, reason: prep.stats?.reason, usagePercent: prep.stats?.usagePercent, contextWindow },\n    'Pre-turn auto-compaction triggered',\n  );\n\n  onEvent?.({\n    type: 'compaction',\n    status: 'started',\n    tokensBefore: prep.stats?.usagePercent != null\n      ? Math.round((prep.stats.usagePercent as number) * contextWindow)\n      : undefined,\n  });\n\n  try {\n    const result = await sessionStore.compact(sessionKey, messages, contextWindow);\n\n    if (result.compacted) {\n      // Evict the cached agent so the next turn reloads from the compacted transcript\n      agentManager.removeAgent(sessionKey);\n\n      log.info(\n        { sessionKey, tokensBefore: result.tokensBefore, tokensAfter: result.tokensAfter },\n        'Pre-turn auto-compaction completed',\n      );\n\n      onEvent?.({\n        type: 'compaction',\n        status: 'completed',\n        tokensBefore: result.tokensBefore,\n        tokensAfter: result.tokensAfter,\n        summary: result.summary.length > 200 ? `${result.summary.slice(0, 200)}…` : result.summary,\n      });\n    } else {\n      onEvent?.({ type: 'compaction', status: 'skipped' });\n    }\n  } catch (err) {\n    const errorMessage = err instanceof Error ? err.message : String(err);\n    log.warn({ err, sessionKey }, `Pre-turn auto-compaction failed: ${errorMessage}`);\n    // Non-fatal: let the turn proceed even if compaction fails\n    onEvent?.({ type: 'compaction', status: 'skipped' });\n  }\n}\n"],"mappings":";;;;;;;;aAeqD;AAErD,MAAM,MAAM,aAAa,yBAAyB;AAsBlD,eAAsB,0BACpB,QACoC;CACpC,MAAM,EAAE,YAAY,cAAc,cAAc,cAAc,gBAAgB;CAC9E,MAAM,QAAQ,OAAO,SAAS,OAAO,YAAY;AAEjD,OAAM,OAAO,cAAc;CAE3B,MAAM,QAAS,aAAqB,iBAAiB,WAAW;CAOhE,MAAM,KAAK;AACX,OAAM,GAAG,qBAAqB,OAAO,WAAW;CAEhD,MAAM,WAAW,OAAO,GAAG,mBAAmB,WAAW,CAAC;CAC1D,MAAM,QAAQ,GAAG,2BAA2B,WAAW;CACvD,MAAM,QAAQ,MAAM,MAAM;CAC1B,MAAM,eAAe,MAAM,MAAM,gBAAgB;CACjD,MAAM,gBAAiB,OAAO,oBAAkD,MAAM,MAAM;CAC5F,MAAM,eAAe,aAAa,+BAA+B,WAAW;CAC5E,MAAM,SAAS,OAAO,aAAa;AAGnC,OAAM,2BAA2B;EAC/B;EACA;EACA;EACA;EACA;EACA,SAAS,OAAO;EACjB,CAAC;CAEF,IAAI,qBAAqB;AACzB,KAAI,OAAO,wBAAwB,MACjC,sBAAqB,MAAM,iCAAiC;EAC1D;EACA;EACA;EACA,KAAK;EACL;EACA,eAAe,OAAO;EACtB,OAAO,OAAO;EACf,CAAC;AAiCJ,QAAO,OA9Be,YAAY;EAChC,MAAM,cAAc,MAAM,+BAA+B;GACvD;GACA;GACA,KAAK;GACL,WAAW;GACX,kBAAkB,OAAO,6BAA6B;GACvD,CAAC;EACF,MAAM,YAAY,eAAe,OAAO,YAAY,MAAM;AAC1D,MAAI;AACF,UAAO,MAAM,oBAAoB;IAC/B;IACA;IACA,aAAa;IACb;IACA;IACA,OAAO;IACP;IACA;IACA;IACA;IACA,WAAW,0BAA0B,OAAO;IAC5C,aAAa,OAAO;IACpB,SAAS,OAAO;IACjB,CAAC;YACM;AACR,SAAM,YAAY,SAAS,CAAC,YAAY,GAAG;;KAE3C;;AASN,eAAe,2BAA2B,MAOxB;CAChB,MAAM,EAAE,YAAY,cAAc,cAAc,OAAO,QAAQ,YAAY;AAI3E,MADyB,QAAQ,QAAQ,UAAU,aAC7B,YAAY,MAChC;CAGF,MAAM,gBAAiB,MAAqC,iBAAiB;CAC7E,MAAM,WAAW,MAAM,aAAa,KAAK,WAAW;CACpD,MAAM,OAAO,aAAa,kBAAkB,YAAY,UAAU,cAAc;AAEhF,KAAI,CAAC,KAAK,gBACR;AAGF,KAAI,KACF;EAAE;EAAY,QAAQ,KAAK,OAAO;EAAQ,cAAc,KAAK,OAAO;EAAc;EAAe,EACjG,qCACD;AAED,WAAU;EACR,MAAM;EACN,QAAQ;EACR,cAAc,KAAK,OAAO,gBAAgB,OACtC,KAAK,MAAO,KAAK,MAAM,eAA0B,cAAc,GAC/D,KAAA;EACL,CAAC;AAEF,KAAI;EACF,MAAM,SAAS,MAAM,aAAa,QAAQ,YAAY,UAAU,cAAc;AAE9E,MAAI,OAAO,WAAW;AAEpB,gBAAa,YAAY,WAAW;AAEpC,OAAI,KACF;IAAE;IAAY,cAAc,OAAO;IAAc,aAAa,OAAO;IAAa,EAClF,qCACD;AAED,aAAU;IACR,MAAM;IACN,QAAQ;IACR,cAAc,OAAO;IACrB,aAAa,OAAO;IACpB,SAAS,OAAO,QAAQ,SAAS,MAAM,GAAG,OAAO,QAAQ,MAAM,GAAG,IAAI,CAAC,KAAK,OAAO;IACpF,CAAC;QAEF,WAAU;GAAE,MAAM;GAAc,QAAQ;GAAW,CAAC;UAE/C,KAAK;EACZ,MAAM,eAAe,eAAe,QAAQ,IAAI,UAAU,OAAO,IAAI;AACrE,MAAI,KAAK;GAAE;GAAK;GAAY,EAAE,oCAAoC,eAAe;AAEjF,YAAU;GAAE,MAAM;GAAc,QAAQ;GAAW,CAAC"}

package/dist/src/agent/embedded/runs.d.ts

@@ -6,6 +6,38 @@ export type EmbeddedRunHandle = {
     session: AgentSession;
     abort: () => Promise<void>;
 };
+/**
+ * Tracks in-flight embedded agent turns so we can abort/steer them by sessionKey or runId.
+ *
+ * The previous implementation used two module-level Maps; this class is the supported
+ * single-instance state, while {@link defaultEmbeddedRunRegistry} preserves the previous
+ * free-function API for callers that have not yet been moved to dependency injection.
+ */
+export declare class EmbeddedRunRegistry {
+    private readonly bySessionKey;
+    private readonly byRunId;
+    /**
+     * Register a new in-flight run. If a run is already registered for the same
+     * sessionKey we drop the stale handle (the new run takes ownership). The caller
+     * is responsible for aborting the previous run before re-registering if needed —
+     * we warn loudly so this does not happen silently.
+     */
+    register(handle: EmbeddedRunHandle): void;
+    unregister(handle: EmbeddedRunHandle): void;
+    getBySessionKey(sessionKey: string): EmbeddedRunHandle | undefined;
+    getByRunId(runId: string): EmbeddedRunHandle | undefined;
+    abortBySessionKey(sessionKey: string): Promise<boolean>;
+    steerBySessionKey(sessionKey: string, text: string): Promise<boolean>;
+    /** Test-only helper to drop all registrations without touching live sessions. */
+    resetForTest(): void;
+    size(): number;
+}
+/**
+ * Process-wide default registry. Prefer constructing a dedicated `EmbeddedRunRegistry`
+ * and injecting it; the module-level singleton stays so the existing free functions
+ * keep working until every caller has been migrated.
+ */
+export declare const defaultEmbeddedRunRegistry: EmbeddedRunRegistry;
 export declare function registerEmbeddedRun(handle: EmbeddedRunHandle): void;
 export declare function unregisterEmbeddedRun(handle: EmbeddedRunHandle): void;
 export declare function getEmbeddedRunBySessionKey(sessionKey: string): EmbeddedRunHandle | undefined;

package/dist/src/agent/embedded/runs.js

@@ -1,33 +1,93 @@
+import { createLogger } from "../../utils/logger/index.js";
+import { init_logger } from "../../utils/logger.js";
 //#region src/agent/embedded/runs.ts
-const activeBySessionKey = /* @__PURE__ */ new Map();
-const activeByRunId = /* @__PURE__ */ new Map();
+init_logger();
+const log = createLogger("EmbeddedRunRegistry");
+/**
+* Tracks in-flight embedded agent turns so we can abort/steer them by sessionKey or runId.
+*
+* The previous implementation used two module-level Maps; this class is the supported
+* single-instance state, while {@link defaultEmbeddedRunRegistry} preserves the previous
+* free-function API for callers that have not yet been moved to dependency injection.
+*/
+var EmbeddedRunRegistry = class {
+	bySessionKey = /* @__PURE__ */ new Map();
+	byRunId = /* @__PURE__ */ new Map();
+	/**
+	* Register a new in-flight run. If a run is already registered for the same
+	* sessionKey we drop the stale handle (the new run takes ownership). The caller
+	* is responsible for aborting the previous run before re-registering if needed —
+	* we warn loudly so this does not happen silently.
+	*/
+	register(handle) {
+		const previous = this.bySessionKey.get(handle.sessionKey);
+		if (previous && previous !== handle) {
+			log.warn({
+				sessionKey: handle.sessionKey,
+				previousRunId: previous.runId,
+				newRunId: handle.runId
+			}, "Replacing already-registered embedded run for sessionKey (caller did not unregister first)");
+			this.byRunId.delete(previous.runId);
+		}
+		this.bySessionKey.set(handle.sessionKey, handle);
+		this.byRunId.set(handle.runId, handle);
+	}
+	unregister(handle) {
+		if (this.bySessionKey.get(handle.sessionKey) === handle) this.bySessionKey.delete(handle.sessionKey);
+		this.byRunId.delete(handle.runId);
+	}
+	getBySessionKey(sessionKey) {
+		return this.bySessionKey.get(sessionKey);
+	}
+	getByRunId(runId) {
+		return this.byRunId.get(runId);
+	}
+	async abortBySessionKey(sessionKey) {
+		const handle = this.bySessionKey.get(sessionKey);
+		if (!handle) return false;
+		await handle.abort();
+		return true;
+	}
+	async steerBySessionKey(sessionKey, text) {
+		const handle = this.bySessionKey.get(sessionKey);
+		if (!handle) return false;
+		await handle.session.steer(text);
+		return true;
+	}
+	/** Test-only helper to drop all registrations without touching live sessions. */
+	resetForTest() {
+		this.bySessionKey.clear();
+		this.byRunId.clear();
+	}
+	size() {
+		return this.bySessionKey.size;
+	}
+};
+/**
+* Process-wide default registry. Prefer constructing a dedicated `EmbeddedRunRegistry`
+* and injecting it; the module-level singleton stays so the existing free functions
+* keep working until every caller has been migrated.
+*/
+const defaultEmbeddedRunRegistry = new EmbeddedRunRegistry();
 function registerEmbeddedRun(handle) {
-	activeBySessionKey.set(handle.sessionKey, handle);
-	activeByRunId.set(handle.runId, handle);
+	defaultEmbeddedRunRegistry.register(handle);
 }
 function unregisterEmbeddedRun(handle) {
-	if (activeBySessionKey.get(handle.sessionKey) === handle) activeBySessionKey.delete(handle.sessionKey);
-	activeByRunId.delete(handle.runId);
+	defaultEmbeddedRunRegistry.unregister(handle);
 }
 function getEmbeddedRunBySessionKey(sessionKey) {
-	return activeBySessionKey.get(sessionKey);
+	return defaultEmbeddedRunRegistry.getBySessionKey(sessionKey);
 }
 function getEmbeddedRunByRunId(runId) {
-	return activeByRunId.get(runId);
+	return defaultEmbeddedRunRegistry.getByRunId(runId);
 }
-async function abortEmbeddedRun(sessionKey) {
-	const handle = activeBySessionKey.get(sessionKey);
-	if (!handle) return false;
-	await handle.abort();
-	return true;
+function abortEmbeddedRun(sessionKey) {
+	return defaultEmbeddedRunRegistry.abortBySessionKey(sessionKey);
 }
-async function queueEmbeddedSteer(sessionKey, text) {
-	const handle = activeBySessionKey.get(sessionKey);
-	if (!handle) return false;
-	await handle.session.steer(text);
-	return true;
+function queueEmbeddedSteer(sessionKey, text) {
+	return defaultEmbeddedRunRegistry.steerBySessionKey(sessionKey, text);
 }
 //#endregion
-export { abortEmbeddedRun, getEmbeddedRunByRunId, getEmbeddedRunBySessionKey, queueEmbeddedSteer, registerEmbeddedRun, unregisterEmbeddedRun };
+export { EmbeddedRunRegistry, abortEmbeddedRun, defaultEmbeddedRunRegistry, getEmbeddedRunByRunId, getEmbeddedRunBySessionKey, queueEmbeddedSteer, registerEmbeddedRun, unregisterEmbeddedRun };
 
 //# sourceMappingURL=runs.js.map

package/dist/src/agent/embedded/runs.js.map

@@ -1 +1 @@
-{"version":3,"file":"runs.js","names":[],"sources":["../../../../src/agent/embedded/runs.ts"],"sourcesContent":["import type { AgentSession } from '@earendil-works/pi-coding-agent';\n\nexport type EmbeddedRunHandle = {\n  sessionKey: string;\n  sessionId: string;\n  runId: string;\n  session: AgentSession;\n  abort: () => Promise<void>;\n};\n\nconst activeBySessionKey = new Map<string, EmbeddedRunHandle>();\nconst activeByRunId = new Map<string, EmbeddedRunHandle>();\n\nexport function registerEmbeddedRun(handle: EmbeddedRunHandle): void {\n  activeBySessionKey.set(handle.sessionKey, handle);\n  activeByRunId.set(handle.runId, handle);\n}\n\nexport function unregisterEmbeddedRun(handle: EmbeddedRunHandle): void {\n  const cur = activeBySessionKey.get(handle.sessionKey);\n  if (cur === handle) {\n    activeBySessionKey.delete(handle.sessionKey);\n  }\n  activeByRunId.delete(handle.runId);\n}\n\nexport function getEmbeddedRunBySessionKey(sessionKey: string): EmbeddedRunHandle | undefined {\n  return activeBySessionKey.get(sessionKey);\n}\n\nexport function getEmbeddedRunByRunId(runId: string): EmbeddedRunHandle | undefined {\n  return activeByRunId.get(runId);\n}\n\nexport async function abortEmbeddedRun(sessionKey: string): Promise<boolean> {\n  const handle = activeBySessionKey.get(sessionKey);\n  if (!handle) {\n    return false;\n  }\n  await handle.abort();\n  return true;\n}\n\nexport async function queueEmbeddedSteer(sessionKey: string, text: string): Promise<boolean> {\n  const handle = activeBySessionKey.get(sessionKey);\n  if (!handle) {\n    return false;\n  }\n  await handle.session.steer(text);\n  return true;\n}\n"],"mappings":";AAUA,MAAM,qCAAqB,IAAI,KAAgC;AAC/D,MAAM,gCAAgB,IAAI,KAAgC;AAE1D,SAAgB,oBAAoB,QAAiC;AACnE,oBAAmB,IAAI,OAAO,YAAY,OAAO;AACjD,eAAc,IAAI,OAAO,OAAO,OAAO;;AAGzC,SAAgB,sBAAsB,QAAiC;AAErE,KADY,mBAAmB,IAAI,OAAO,WACnC,KAAK,OACV,oBAAmB,OAAO,OAAO,WAAW;AAE9C,eAAc,OAAO,OAAO,MAAM;;AAGpC,SAAgB,2BAA2B,YAAmD;AAC5F,QAAO,mBAAmB,IAAI,WAAW;;AAG3C,SAAgB,sBAAsB,OAA8C;AAClF,QAAO,cAAc,IAAI,MAAM;;AAGjC,eAAsB,iBAAiB,YAAsC;CAC3E,MAAM,SAAS,mBAAmB,IAAI,WAAW;AACjD,KAAI,CAAC,OACH,QAAO;AAET,OAAM,OAAO,OAAO;AACpB,QAAO;;AAGT,eAAsB,mBAAmB,YAAoB,MAAgC;CAC3F,MAAM,SAAS,mBAAmB,IAAI,WAAW;AACjD,KAAI,CAAC,OACH,QAAO;AAET,OAAM,OAAO,QAAQ,MAAM,KAAK;AAChC,QAAO"}
+{"version":3,"file":"runs.js","names":[],"sources":["../../../../src/agent/embedded/runs.ts"],"sourcesContent":["import type { AgentSession } from '@earendil-works/pi-coding-agent';\n\nimport { createLogger } from '../../utils/logger.js';\n\nconst log = createLogger('EmbeddedRunRegistry');\n\nexport type EmbeddedRunHandle = {\n  sessionKey: string;\n  sessionId: string;\n  runId: string;\n  session: AgentSession;\n  abort: () => Promise<void>;\n};\n\n/**\n * Tracks in-flight embedded agent turns so we can abort/steer them by sessionKey or runId.\n *\n * The previous implementation used two module-level Maps; this class is the supported\n * single-instance state, while {@link defaultEmbeddedRunRegistry} preserves the previous\n * free-function API for callers that have not yet been moved to dependency injection.\n */\nexport class EmbeddedRunRegistry {\n  private readonly bySessionKey = new Map<string, EmbeddedRunHandle>();\n  private readonly byRunId = new Map<string, EmbeddedRunHandle>();\n\n  /**\n   * Register a new in-flight run. If a run is already registered for the same\n   * sessionKey we drop the stale handle (the new run takes ownership). The caller\n   * is responsible for aborting the previous run before re-registering if needed —\n   * we warn loudly so this does not happen silently.\n   */\n  register(handle: EmbeddedRunHandle): void {\n    const previous = this.bySessionKey.get(handle.sessionKey);\n    if (previous && previous !== handle) {\n      log.warn(\n        {\n          sessionKey: handle.sessionKey,\n          previousRunId: previous.runId,\n          newRunId: handle.runId,\n        },\n        'Replacing already-registered embedded run for sessionKey (caller did not unregister first)',\n      );\n      this.byRunId.delete(previous.runId);\n    }\n    this.bySessionKey.set(handle.sessionKey, handle);\n    this.byRunId.set(handle.runId, handle);\n  }\n\n  unregister(handle: EmbeddedRunHandle): void {\n    const current = this.bySessionKey.get(handle.sessionKey);\n    if (current === handle) {\n      this.bySessionKey.delete(handle.sessionKey);\n    }\n    this.byRunId.delete(handle.runId);\n  }\n\n  getBySessionKey(sessionKey: string): EmbeddedRunHandle | undefined {\n    return this.bySessionKey.get(sessionKey);\n  }\n\n  getByRunId(runId: string): EmbeddedRunHandle | undefined {\n    return this.byRunId.get(runId);\n  }\n\n  async abortBySessionKey(sessionKey: string): Promise<boolean> {\n    const handle = this.bySessionKey.get(sessionKey);\n    if (!handle) {\n      return false;\n    }\n    await handle.abort();\n    return true;\n  }\n\n  async steerBySessionKey(sessionKey: string, text: string): Promise<boolean> {\n    const handle = this.bySessionKey.get(sessionKey);\n    if (!handle) {\n      return false;\n    }\n    await handle.session.steer(text);\n    return true;\n  }\n\n  /** Test-only helper to drop all registrations without touching live sessions. */\n  resetForTest(): void {\n    this.bySessionKey.clear();\n    this.byRunId.clear();\n  }\n\n  size(): number {\n    return this.bySessionKey.size;\n  }\n}\n\n/**\n * Process-wide default registry. Prefer constructing a dedicated `EmbeddedRunRegistry`\n * and injecting it; the module-level singleton stays so the existing free functions\n * keep working until every caller has been migrated.\n */\nexport const defaultEmbeddedRunRegistry = new EmbeddedRunRegistry();\n\nexport function registerEmbeddedRun(handle: EmbeddedRunHandle): void {\n  defaultEmbeddedRunRegistry.register(handle);\n}\n\nexport function unregisterEmbeddedRun(handle: EmbeddedRunHandle): void {\n  defaultEmbeddedRunRegistry.unregister(handle);\n}\n\nexport function getEmbeddedRunBySessionKey(sessionKey: string): EmbeddedRunHandle | undefined {\n  return defaultEmbeddedRunRegistry.getBySessionKey(sessionKey);\n}\n\nexport function getEmbeddedRunByRunId(runId: string): EmbeddedRunHandle | undefined {\n  return defaultEmbeddedRunRegistry.getByRunId(runId);\n}\n\nexport function abortEmbeddedRun(sessionKey: string): Promise<boolean> {\n  return defaultEmbeddedRunRegistry.abortBySessionKey(sessionKey);\n}\n\nexport function queueEmbeddedSteer(sessionKey: string, text: string): Promise<boolean> {\n  return defaultEmbeddedRunRegistry.steerBySessionKey(sessionKey, text);\n}\n"],"mappings":";;;aAEqD;AAErD,MAAM,MAAM,aAAa,sBAAsB;;;;;;;;AAiB/C,IAAa,sBAAb,MAAiC;CAC/B,+BAAgC,IAAI,KAAgC;CACpE,0BAA2B,IAAI,KAAgC;;;;;;;CAQ/D,SAAS,QAAiC;EACxC,MAAM,WAAW,KAAK,aAAa,IAAI,OAAO,WAAW;AACzD,MAAI,YAAY,aAAa,QAAQ;AACnC,OAAI,KACF;IACE,YAAY,OAAO;IACnB,eAAe,SAAS;IACxB,UAAU,OAAO;IAClB,EACD,6FACD;AACD,QAAK,QAAQ,OAAO,SAAS,MAAM;;AAErC,OAAK,aAAa,IAAI,OAAO,YAAY,OAAO;AAChD,OAAK,QAAQ,IAAI,OAAO,OAAO,OAAO;;CAGxC,WAAW,QAAiC;AAE1C,MADgB,KAAK,aAAa,IAAI,OAAO,WAClC,KAAK,OACd,MAAK,aAAa,OAAO,OAAO,WAAW;AAE7C,OAAK,QAAQ,OAAO,OAAO,MAAM;;CAGnC,gBAAgB,YAAmD;AACjE,SAAO,KAAK,aAAa,IAAI,WAAW;;CAG1C,WAAW,OAA8C;AACvD,SAAO,KAAK,QAAQ,IAAI,MAAM;;CAGhC,MAAM,kBAAkB,YAAsC;EAC5D,MAAM,SAAS,KAAK,aAAa,IAAI,WAAW;AAChD,MAAI,CAAC,OACH,QAAO;AAET,QAAM,OAAO,OAAO;AACpB,SAAO;;CAGT,MAAM,kBAAkB,YAAoB,MAAgC;EAC1E,MAAM,SAAS,KAAK,aAAa,IAAI,WAAW;AAChD,MAAI,CAAC,OACH,QAAO;AAET,QAAM,OAAO,QAAQ,MAAM,KAAK;AAChC,SAAO;;;CAIT,eAAqB;AACnB,OAAK,aAAa,OAAO;AACzB,OAAK,QAAQ,OAAO;;CAGtB,OAAe;AACb,SAAO,KAAK,aAAa;;;;;;;;AAS7B,MAAa,6BAA6B,IAAI,qBAAqB;AAEnE,SAAgB,oBAAoB,QAAiC;AACnE,4BAA2B,SAAS,OAAO;;AAG7C,SAAgB,sBAAsB,QAAiC;AACrE,4BAA2B,WAAW,OAAO;;AAG/C,SAAgB,2BAA2B,YAAmD;AAC5F,QAAO,2BAA2B,gBAAgB,WAAW;;AAG/D,SAAgB,sBAAsB,OAA8C;AAClF,QAAO,2BAA2B,WAAW,MAAM;;AAGrD,SAAgB,iBAAiB,YAAsC;AACrE,QAAO,2BAA2B,kBAAkB,WAAW;;AAGjE,SAAgB,mBAAmB,YAAoB,MAAgC;AACrF,QAAO,2BAA2B,kBAAkB,YAAY,KAAK"}

package/dist/src/agent/embedded/session-manager-cache.d.ts

@@ -1,3 +1,17 @@
+/**
+ * Tracks which session JSONL files we have already confirmed exist on disk so
+ * subsequent acquires can skip the open/close probe. The class is owned by the
+ * session runner pool; {@link defaultSessionManagerCache} keeps the free-function
+ * API working until every caller has been wired through dependency injection.
+ */
+export declare class SessionManagerCache {
+    private readonly seen;
+    prewarm(sessionFile: string): Promise<void>;
+    trackAccess(sessionFile: string): void;
+    has(sessionFile: string): boolean;
+    resetForTest(): void;
+}
+export declare const defaultSessionManagerCache: SessionManagerCache;
 export declare function prewarmSessionFile(sessionFile: string): Promise<void>;
 export declare function trackSessionManagerAccess(sessionFile: string): void;
 export declare function isSessionManagerCached(sessionFile: string): boolean;

package/dist/src/agent/embedded/session-manager-cache.js

@@ -1,27 +1,48 @@
 import fs from "node:fs/promises";
 //#region src/agent/embedded/session-manager-cache.ts
 const DEFAULT_TTL_MS = 3e4;
-const cache = /* @__PURE__ */ new Map();
-async function prewarmSessionFile(sessionFile) {
-	if (cache.get(sessionFile) === true) return;
-	try {
-		await (await fs.open(sessionFile, "r")).close();
-		cache.set(sessionFile, true);
-	} catch {}
+/**
+* Tracks which session JSONL files we have already confirmed exist on disk so
+* subsequent acquires can skip the open/close probe. The class is owned by the
+* session runner pool; {@link defaultSessionManagerCache} keeps the free-function
+* API working until every caller has been wired through dependency injection.
+*/
+var SessionManagerCache = class {
+	seen = /* @__PURE__ */ new Map();
+	async prewarm(sessionFile) {
+		if (this.seen.get(sessionFile) === true) return;
+		try {
+			await (await fs.open(sessionFile, "r")).close();
+			this.seen.set(sessionFile, true);
+		} catch {}
+	}
+	trackAccess(sessionFile) {
+		this.seen.set(sessionFile, true);
+	}
+	has(sessionFile) {
+		return this.seen.get(sessionFile) === true;
+	}
+	resetForTest() {
+		this.seen.clear();
+	}
+};
+const defaultSessionManagerCache = new SessionManagerCache();
+function prewarmSessionFile(sessionFile) {
+	return defaultSessionManagerCache.prewarm(sessionFile);
 }
 function trackSessionManagerAccess(sessionFile) {
-	cache.set(sessionFile, true);
+	defaultSessionManagerCache.trackAccess(sessionFile);
 }
 function isSessionManagerCached(sessionFile) {
-	return cache.get(sessionFile) === true;
+	return defaultSessionManagerCache.has(sessionFile);
 }
 function resetSessionManagerCacheForTest() {
-	cache.clear();
+	defaultSessionManagerCache.resetForTest();
 }
 function getSessionManagerCacheTtlMs() {
 	return DEFAULT_TTL_MS;
 }
 //#endregion
-export { getSessionManagerCacheTtlMs, isSessionManagerCached, prewarmSessionFile, resetSessionManagerCacheForTest, trackSessionManagerAccess };
+export { SessionManagerCache, defaultSessionManagerCache, getSessionManagerCacheTtlMs, isSessionManagerCached, prewarmSessionFile, resetSessionManagerCacheForTest, trackSessionManagerAccess };
 
 //# sourceMappingURL=session-manager-cache.js.map

package/dist/src/agent/embedded/session-manager-cache.js.map

@@ -1 +1 @@
-{"version":3,"file":"session-manager-cache.js","names":[],"sources":["../../../../src/agent/embedded/session-manager-cache.ts"],"sourcesContent":["import fs from 'node:fs/promises';\n\nconst DEFAULT_TTL_MS = 30_000;\n\nconst cache = new Map<string, boolean>();\n\nexport async function prewarmSessionFile(sessionFile: string): Promise<void> {\n  if (cache.get(sessionFile) === true) {\n    return;\n  }\n  try {\n    const handle = await fs.open(sessionFile, 'r');\n    await handle.close();\n    cache.set(sessionFile, true);\n  } catch {\n    // File doesn't exist yet; SessionManager will create it\n  }\n}\n\nexport function trackSessionManagerAccess(sessionFile: string): void {\n  cache.set(sessionFile, true);\n}\n\nexport function isSessionManagerCached(sessionFile: string): boolean {\n  return cache.get(sessionFile) === true;\n}\n\nexport function resetSessionManagerCacheForTest(): void {\n  cache.clear();\n}\n\nexport function getSessionManagerCacheTtlMs(): number {\n  return DEFAULT_TTL_MS;\n}\n"],"mappings":";;AAEA,MAAM,iBAAiB;AAEvB,MAAM,wBAAQ,IAAI,KAAsB;AAExC,eAAsB,mBAAmB,aAAoC;AAC3E,KAAI,MAAM,IAAI,YAAY,KAAK,KAC7B;AAEF,KAAI;AAEF,SAAM,MADe,GAAG,KAAK,aAAa,IAAI,EACjC,OAAO;AACpB,QAAM,IAAI,aAAa,KAAK;SACtB;;AAKV,SAAgB,0BAA0B,aAA2B;AACnE,OAAM,IAAI,aAAa,KAAK;;AAG9B,SAAgB,uBAAuB,aAA8B;AACnE,QAAO,MAAM,IAAI,YAAY,KAAK;;AAGpC,SAAgB,kCAAwC;AACtD,OAAM,OAAO;;AAGf,SAAgB,8BAAsC;AACpD,QAAO"}
+{"version":3,"file":"session-manager-cache.js","names":[],"sources":["../../../../src/agent/embedded/session-manager-cache.ts"],"sourcesContent":["import fs from 'node:fs/promises';\n\nconst DEFAULT_TTL_MS = 30_000;\n\n/**\n * Tracks which session JSONL files we have already confirmed exist on disk so\n * subsequent acquires can skip the open/close probe. The class is owned by the\n * session runner pool; {@link defaultSessionManagerCache} keeps the free-function\n * API working until every caller has been wired through dependency injection.\n */\nexport class SessionManagerCache {\n  private readonly seen = new Map<string, boolean>();\n\n  async prewarm(sessionFile: string): Promise<void> {\n    if (this.seen.get(sessionFile) === true) {\n      return;\n    }\n    try {\n      const handle = await fs.open(sessionFile, 'r');\n      await handle.close();\n      this.seen.set(sessionFile, true);\n    } catch {\n      // File doesn't exist yet; SessionManager will create it\n    }\n  }\n\n  trackAccess(sessionFile: string): void {\n    this.seen.set(sessionFile, true);\n  }\n\n  has(sessionFile: string): boolean {\n    return this.seen.get(sessionFile) === true;\n  }\n\n  resetForTest(): void {\n    this.seen.clear();\n  }\n}\n\nexport const defaultSessionManagerCache = new SessionManagerCache();\n\nexport function prewarmSessionFile(sessionFile: string): Promise<void> {\n  return defaultSessionManagerCache.prewarm(sessionFile);\n}\n\nexport function trackSessionManagerAccess(sessionFile: string): void {\n  defaultSessionManagerCache.trackAccess(sessionFile);\n}\n\nexport function isSessionManagerCached(sessionFile: string): boolean {\n  return defaultSessionManagerCache.has(sessionFile);\n}\n\nexport function resetSessionManagerCacheForTest(): void {\n  defaultSessionManagerCache.resetForTest();\n}\n\nexport function getSessionManagerCacheTtlMs(): number {\n  return DEFAULT_TTL_MS;\n}\n"],"mappings":";;AAEA,MAAM,iBAAiB;;;;;;;AAQvB,IAAa,sBAAb,MAAiC;CAC/B,uBAAwB,IAAI,KAAsB;CAElD,MAAM,QAAQ,aAAoC;AAChD,MAAI,KAAK,KAAK,IAAI,YAAY,KAAK,KACjC;AAEF,MAAI;AAEF,UAAM,MADe,GAAG,KAAK,aAAa,IAAI,EACjC,OAAO;AACpB,QAAK,KAAK,IAAI,aAAa,KAAK;UAC1B;;CAKV,YAAY,aAA2B;AACrC,OAAK,KAAK,IAAI,aAAa,KAAK;;CAGlC,IAAI,aAA8B;AAChC,SAAO,KAAK,KAAK,IAAI,YAAY,KAAK;;CAGxC,eAAqB;AACnB,OAAK,KAAK,OAAO;;;AAIrB,MAAa,6BAA6B,IAAI,qBAAqB;AAEnE,SAAgB,mBAAmB,aAAoC;AACrE,QAAO,2BAA2B,QAAQ,YAAY;;AAGxD,SAAgB,0BAA0B,aAA2B;AACnE,4BAA2B,YAAY,YAAY;;AAGrD,SAAgB,uBAAuB,aAA8B;AACnE,QAAO,2BAA2B,IAAI,YAAY;;AAGpD,SAAgB,kCAAwC;AACtD,4BAA2B,cAAc;;AAG3C,SAAgB,8BAAsC;AACpD,QAAO"}

package/dist/src/agent/embedded/session-runner.d.ts

@@ -2,7 +2,8 @@ import type { AgentTool } from '@earendil-works/pi-agent-core';
 import type { ThinkingLevel } from '@earendil-works/pi-agent-core';
 import { type AgentSession } from '@earendil-works/pi-coding-agent';
 import type { Model, Api } from '@earendil-works/pi-ai';
-import { type GuardedPiTranscriptManager } from './session-tool-result-guard-wrapper.js';
+import { type GuardedPiTranscriptManager } from './session-tool-result-guard.js';
+import { type SessionManagerCache } from './session-manager-cache.js';
 export type EmbeddedRunnerFingerprintInput = {
     sessionFile: string;
     workspaceDir: string;
@@ -31,17 +32,47 @@ export type AcquiredEmbeddedSessionRunner = {
     reused: boolean;
     release: () => void;
 };
-declare let stats: {
+export interface EmbeddedSessionRunnerPoolStats {
     acquires: number;
     reuses: number;
     creates: number;
     evictions: number;
-};
+    pooled: number;
+}
 export declare function isEmbeddedSessionRunnerEnabled(): boolean;
 export declare function getEmbeddedSessionRunnerIdleTtlMs(): number;
-export declare function getEmbeddedSessionRunnerStats(): Readonly<typeof stats> & {
-    pooled: number;
-};
+export interface EmbeddedSessionRunnerPoolOptions {
+    /** File-exists cache shared with prewarmSessionFile callers. */
+    sessionManagerCache?: SessionManagerCache;
+    /** Override for the env-driven enable flag (testing). */
+    isEnabled?: () => boolean;
+    /** Override for the env-driven idle TTL (testing). */
+    getIdleTtlMs?: () => number;
+}
+/**
+ * Owns the per-session pool of pi `AgentSession` runners. The class is the supported,
+ * injectable owner; {@link defaultEmbeddedSessionRunnerPool} keeps the historic
+ * module-level free functions working until every caller is migrated to DI.
+ */
+export declare class EmbeddedSessionRunnerPool {
+    private readonly pool;
+    private readonly cache;
+    private readonly isEnabledFn;
+    private readonly getIdleTtlMsFn;
+    private stats;
+    constructor(opts?: EmbeddedSessionRunnerPoolOptions);
+    getStats(): Readonly<EmbeddedSessionRunnerPoolStats>;
+    resetForTest(): void;
+    evict(sessionKey: string, reason?: string): void;
+    evictAll(reason?: string): void;
+    acquire(params: AcquireEmbeddedSessionRunnerParams): Promise<AcquiredEmbeddedSessionRunner>;
+    private clearIdleTimer;
+    private scheduleIdleEviction;
+    private disposePooledRunner;
+    private createPooledRunner;
+}
+export declare const defaultEmbeddedSessionRunnerPool: EmbeddedSessionRunnerPool;
+export declare function getEmbeddedSessionRunnerStats(): Readonly<EmbeddedSessionRunnerPoolStats>;
 export declare function resetEmbeddedSessionRunnerForTest(): void;
 export declare function evictEmbeddedSessionRunner(sessionKey: string, reason?: string): void;
 export declare function evictAllEmbeddedSessionRunners(reason?: string): void;
@@ -53,4 +84,3 @@ export declare function resolveEmbeddedTranscriptInputs(sessionStore: import('..
     sessionsDir: string;
     hadSessionFile: boolean;
 }>;
-export {};