dsh-lcx-codex 0.4.0 → 0.4.1

package/lib/dsh-compat.js

@@ -0,0 +1,124 @@
+import { symbols as cordisSymbols } from '@deepseek-ai/cordis'
+
+export function agentSessionId(agent) { return String(agent?.session?.id ?? '') }
+
+export function readAgentRouteState(agent) {
+  return {
+    requestConfig: agent?.session?.requestHeader?.()?.config,
+    options: agent?.options,
+    sessionId: agentSessionId(agent),
+  }
+}
+
+export function sessionsService(ctx) { return ctx?.get?.('sessions') ?? ctx?.sessions }
+export function sessionFor(ctx, sessionId) { return sessionId ? sessionsService(ctx)?.get?.(sessionId) : undefined }
+
+export function readWebSearchProvider(ctx) {
+  try { return Reflect.get(ctx?.web, 'searchProviderId') } catch { return undefined }
+}
+
+export function writeWebSearchProvider(ctx, providerId) {
+  if (!ctx?.web) return false
+  try {
+    if (!Reflect.set(ctx.web, 'searchProviderId', providerId)) return false
+    return Reflect.get(ctx.web, 'searchProviderId') === providerId
+  } catch { return false }
+}
+
+export function contextService(ctx, name) { return ctx?.get?.(name) ?? ctx?.[name] }
+
+export function resolveContextService(ctx, name) {
+  try { return contextService(ctx, name) } catch { return undefined }
+}
+
+export function resolveScopedService(agent, name) { return resolveContextService(agent?.ctx, name) }
+
+export function resolveAgentService(ctx, agent, name) {
+  const agentPresets = resolveContextService(ctx, 'agentPresets')
+  try {
+    const service = agentPresets?.serviceFor?.(agent, name)
+    if (service !== undefined) return service
+  } catch {}
+  return resolveScopedService(agent, name)
+}
+
+export function concreteService(value) {
+  try { return value?.[cordisSymbols.original] ?? value } catch { return value }
+}
+
+export function compactionPatchCandidate(value, records) {
+  const compaction = concreteService(value)
+  if (!compaction || typeof compaction.compactIfNeeded !== 'function' || records.has(compaction)) return undefined
+  return { compaction, original: compaction.compactIfNeeded }
+}
+
+export function installCompactionPatch(records, record) {
+  try { record.compaction.compactIfNeeded = record.wrapper } catch { return false }
+  records.set(record.compaction, record)
+  return true
+}
+
+export function restoreCompactionPatches(records, entries = [...records.values()]) {
+  for (const record of entries) if (record.compaction?.compactIfNeeded === record.wrapper) {
+    try { record.compaction.compactIfNeeded = record.original } catch {}
+  }
+  records.clear()
+}
+
+export function toolResultPrunerState(value) {
+  const pruner = concreteService(value)
+  const original = pruner?.pruneSession
+  return { pruner, original }
+}
+
+export function patchToolResultPruner(state, replacement) {
+  if (!state?.pruner || typeof state.original !== 'function') return undefined
+  state.pruner.pruneSession = replacement
+  return { ...state, replacement }
+}
+
+export function restoreToolResultPruner(record) {
+  if (record?.pruner?.pruneSession === record.replacement) {
+    try { record.pruner.pruneSession = record.original } catch {}
+  }
+}
+
+export function compactionConfigState(service) { return { service, original: service?.config } }
+
+export function patchCompactionConfig(state, createConfig) {
+  if (!state?.original || !state.service || !Object.prototype.hasOwnProperty.call(state.service, 'config')) return undefined
+  try {
+    const installed = createConfig(state.original)
+    state.service.config = installed
+    return { ...state, installed }
+  } catch { return undefined }
+}
+
+export function restoreCompactionConfig(record) {
+  if (record?.service?.config === record.installed) {
+    try { record.service.config = record.original } catch {}
+  }
+}
+
+export function patchVisibleWebSearchTimeout(agent, getTimeoutMs, patchedDefinitions) {
+  const tools = resolveScopedService(agent, 'tools')
+  const definition = tools?.get?.('web_search', agent)
+  if (!definition || typeof definition !== 'object') return
+  if (!patchedDefinitions.has(definition)) patchedDefinitions.set(definition, definition.timeoutMs)
+  const timeoutMs = getTimeoutMs()
+  const target = timeoutMs === undefined ? patchedDefinitions.get(definition) : timeoutMs
+  try { definition.timeoutMs = target } catch {}
+}
+
+export function refreshVisibleWebSearchTimeouts(patchedDefinitions, timeoutMs) {
+  for (const [definition, original] of patchedDefinitions.entries()) {
+    try { definition.timeoutMs = timeoutMs === undefined ? original : timeoutMs } catch {}
+  }
+}
+
+export function restoreVisibleWebSearchTimeouts(patchedDefinitions) {
+  for (const [definition, original] of patchedDefinitions.entries()) {
+    try { if (original === undefined) delete definition.timeoutMs; else definition.timeoutMs = original } catch {}
+  }
+  patchedDefinitions.clear()
+}

package/lib/index.js

@@ -4,8 +4,31 @@ import { randomUUID } from 'node:crypto'
 import { homedir } from 'node:os'
 import { join } from 'node:path'
 import { AsyncLocalStorage } from 'node:async_hooks'
-import { symbols as cordisSymbols } from '@deepseek-ai/cordis'
 import { fetchJsonWithRetry } from './transport.js'
+import {
+  agentSessionId,
+  compactionConfigState,
+  compactionPatchCandidate,
+  contextService,
+  installCompactionPatch,
+  patchCompactionConfig,
+  patchToolResultPruner,
+  patchVisibleWebSearchTimeout,
+  readAgentRouteState,
+  readWebSearchProvider,
+  refreshVisibleWebSearchTimeouts,
+  resolveAgentService,
+  resolveContextService,
+  resolveScopedService,
+  restoreCompactionConfig,
+  restoreCompactionPatches,
+  restoreToolResultPruner,
+  restoreVisibleWebSearchTimeouts,
+  sessionFor,
+  sessionsService,
+  toolResultPrunerState,
+  writeWebSearchProvider,
+} from './dsh-compat.js'
 import {
   authenticatedHeaders,
   currentRoute,
@@ -51,6 +74,9 @@ import {
 } from './web-search-hosted.js'
 import {
   ALPHA_SCHEMA_FINGERPRINT,
+  alphaRefRequiresStore,
+  isAlphaContinuationUrl,
+  isAlphaHttpUrl,
   ALPHA_SEARCH_OUTPUT,
   ALPHA_SEARCH_PARAMETERS,
   buildAlphaSearchBody,
@@ -160,17 +186,22 @@ function webError(message, code, cause) {
 }
 
 function activeAgentRoute(exec, fallback) {
-  const agent = exec?.agent
-  const latest = agent?.session?.requestHeader?.()?.config
+  const route = readAgentRouteState(exec?.agent)
   return {
-    provider: latest?.provider ?? agent?.options?.provider ?? fallback.provider,
-    model: latest?.model ?? agent?.options?.model ?? fallback.model,
-    sessionId: String(agent?.session?.id ?? ''),
+    provider: route.requestConfig?.provider ?? route.options?.provider ?? fallback.provider,
+    model: route.requestConfig?.model ?? route.options?.model ?? fallback.model,
+    sessionId: route.sessionId,
   }
 }
 
-function sessionsService(ctx) { return ctx?.get?.('sessions') ?? ctx?.sessions }
-function sessionFor(ctx, sessionId) { return sessionId ? sessionsService(ctx)?.get?.(sessionId) : undefined }
+function selectedAgentRoute(agent, fallback) {
+  const route = readAgentRouteState(agent)
+  return {
+    provider: route.options?.provider ?? route.requestConfig?.provider ?? fallback.provider,
+    model: route.options?.model ?? route.requestConfig?.model ?? fallback.model,
+    sessionId: route.sessionId,
+  }
+}
 
 function requestImageOptions(routeConfig, imageSupport, signal, imageMap, extra = {}) {
   return {
@@ -182,17 +213,6 @@ function requestImageOptions(routeConfig, imageSupport, signal, imageMap, extra
   }
 }
 
-function readWebSearchProvider(ctx) {
-  try { return Reflect.get(ctx?.web, 'searchProviderId') } catch { return undefined }
-}
-function writeWebSearchProvider(ctx, providerId) {
-  if (!ctx?.web) return false
-  try {
-    if (!Reflect.set(ctx.web, 'searchProviderId', providerId)) return false
-    return Reflect.get(ctx.web, 'searchProviderId') === providerId
-  } catch { return false }
-}
-
 async function executeHostedSearch(ctx, routeConfig, args, signal, sessionId = '') {
   const normalized = normalizeHostedSearchArgs(args)
   const requestId = randomUUID()
@@ -251,12 +271,22 @@ function alphaCapabilityFor(config, store) {
   return { fingerprint, record: store.get(fingerprint) }
 }
 
+function verifiedAlphaCapabilityForRoute(ctx, active, config, store) {
+  const route = resolveResponsesRouteConfig(ctx, active, config)
+  if (!route) return { route: undefined, usable: false }
+  const { fingerprint, record } = alphaCapabilityFor(route, store)
+  return { route, fingerprint, record, usable: alphaCapabilityUsable(record) && record?.schemaFingerprint === ALPHA_SCHEMA_FINGERPRINT }
+}
+
 async function executeAlpha(ctx, routeConfig, capability, refStore, args, exec) {
   const normalized = normalizeAlphaSearchArgs(args)
-  const sessionId = String(exec?.agent?.session?.id ?? '')
+  if (['open', 'find', 'screenshot'].includes(normalized.action) && isAlphaHttpUrl(normalized.refId) && !isAlphaContinuationUrl(normalized.refId)) {
+    throw webError('Alpha Search direct URLs must be public HTTP(S) targets', 'LCX_ALPHA_URL_UNAVAILABLE')
+  }
+  const sessionId = agentSessionId(exec?.agent)
   if (!sessionId) throw webError('Alpha Search requires a DSH session', 'LCX_ALPHA_SESSION_REQUIRED')
   const routeFp = routeFingerprint({ provider: routeConfig.provider, model: routeConfig.model, baseURL: routeConfig.baseURL, sessionId })
-  if (['open','find','click','screenshot'].includes(normalized.action)) refStore.assertUsable(sessionId, routeFp, normalized.refId)
+  if (alphaRefRequiresStore(normalized.action, normalized.refId)) refStore.assertUsable(sessionId, routeFp, normalized.refId)
   const requestId = randomUUID(); const headers = await authenticatedHeaders(ctx, routeConfig, sessionId, requestId)
   let response
   try {
@@ -289,6 +319,41 @@ function createAlphaTool(ctx, state, getConfig, capabilityStore, refStore) {
   }
 }
 
+function syncAlphaToolForAgent(ctx, agent, state, getConfig, capabilityStore, refStore, registrations) {
+  const previous = registrations.get(agent)
+  if (!state.enabled || !state.alphaSearch) {
+    disposeAlphaToolForAgent(agent, registrations)
+    return false
+  }
+  try {
+    const config = getConfig()
+    const active = selectedAgentRoute(agent, config)
+    const capability = verifiedAlphaCapabilityForRoute(ctx, active, config, capabilityStore)
+    if (!capability.usable) {
+      disposeAlphaToolForAgent(agent, registrations)
+      return false
+    }
+    if (previous?.fingerprint === capability.fingerprint) return true
+    disposeAlphaToolForAgent(agent, registrations)
+    const scopedTools = resolveScopedService(agent, 'tools')
+    if (!scopedTools?.register) return false
+    // Alpha is route-bound; global registration would advertise a static record to other routes.
+    registrations.set(agent, { fingerprint: capability.fingerprint, dispose: scopedTools.register(createAlphaTool(ctx, state, getConfig, capabilityStore, refStore)) })
+    return true
+  } catch (error) {
+    disposeAlphaToolForAgent(agent, registrations)
+    ctx.logger?.warn?.(`[lcx-codex] Alpha capability store unavailable: ${error?.message ?? error}`)
+    return false
+  }
+}
+
+function disposeAlphaToolForAgent(agent, registrations) {
+  const registration = registrations.get(agent)
+  if (!registration) return
+  registration.dispose()
+  registrations.delete(agent)
+}
+
 function isDshCompactionDirective(message) {
   if (message?.role !== 'user') return false
   if (message?.source?.kind === 'plugin' && message?.source?.plugin === 'dsh-compaction-basic') return true
@@ -439,9 +504,9 @@ async function* remoteCompactionStream(options, routeConfig, state, ctx, next, r
 }
 
 function routedTargetForAgent(agent, fallback) {
-  const latest = agent?.session?.requestHeader?.()?.config
-  const provider = latest?.provider ?? agent?.options?.provider ?? fallback.provider
-  const model = latest?.model ?? agent?.options?.model ?? fallback.model
+  const route = readAgentRouteState(agent)
+  const provider = route.requestConfig?.provider ?? route.options?.provider ?? fallback.provider
+  const model = route.requestConfig?.model ?? route.options?.model ?? fallback.model
   return provider && model ? { provider, model } : undefined
 }
 
@@ -465,25 +530,6 @@ function adjustedCompactionConfig(config, target, thresholdRatio) {
   return { ...config, thresholdRatio, ...(modelPolicies === undefined ? {} : { modelPolicies }) }
 }
 
-function resolveContextService(ctx, name) {
-  try { return ctx?.get?.(name) ?? ctx?.[name] } catch { return undefined }
-}
-
-function resolveScopedService(agent, name) { return resolveContextService(agent?.ctx, name) }
-
-function resolveAgentService(ctx, agent, name) {
-  const agentPresets = resolveContextService(ctx, 'agentPresets')
-  try {
-    const service = agentPresets?.serviceFor?.(agent, name)
-    if (service !== undefined) return service
-  } catch {}
-  return resolveScopedService(agent, name)
-}
-
-function concreteService(value) {
-  try { return value?.[cordisSymbols.original] ?? value } catch { return value }
-}
-
 function combinedAbortSignal(primary, lifecycle) {
   if (!primary) return lifecycle
   if (!lifecycle) return primary
@@ -492,9 +538,9 @@ function combinedAbortSignal(primary, lifecycle) {
 }
 
 function patchCompactionPressureService(compactionValue, state, getConfig, ctx, records, requestHeaders) {
-  const compaction = concreteService(compactionValue)
-  if (!compaction || typeof compaction.compactIfNeeded !== 'function' || records.has(compaction)) return false
-  const original = compaction.compactIfNeeded
+  const candidate = compactionPatchCandidate(compactionValue, records)
+  if (!candidate) return false
+  const { compaction, original } = candidate
   const record = { compaction, original, wrapper: undefined, mutex: new ServiceMutex(), lifecycle: new AbortController() }
   const wrapper = async function(agentArg, trigger, signal) {
     const activeSignal = combinedAbortSignal(signal, record.lifecycle.signal)
@@ -517,28 +563,22 @@ function patchCompactionPressureService(compactionValue, state, getConfig, ctx,
       const { auto, emergency } = pressurePolicy(state, config)
       const ratioPercent = totalTokens / contextWindow * 100
       if (ratioPercent < auto) return null
-      const pruner = concreteService(resolveAgentService(ctx, agentArg, 'toolResultPruner') ?? resolveContextService(this?.ctx, 'toolResultPruner'))
-      const originalPrune = pruner?.pruneSession
-      const originalConfig = this?.config
+      const prunerState = toolResultPrunerState(resolveAgentService(ctx, agentArg, 'toolResultPruner') ?? resolveContextService(this?.ctx, 'toolResultPruner'))
+      const configState = compactionConfigState(this)
       const nativeFirst = ratioPercent < emergency
       const noOpPrune = () => ({ pruned: [], charsRemoved: 0 })
-      let installedConfig
-      if (nativeFirst && pruner && typeof originalPrune === 'function') pruner.pruneSession = noOpPrune
-      if (originalConfig && this && Object.prototype.hasOwnProperty.call(this, 'config')) {
-        try { installedConfig = adjustedCompactionConfig(originalConfig, target, auto / 100); this.config = installedConfig } catch {}
-      }
+      const prunerPatch = nativeFirst ? patchToolResultPruner(prunerState, noOpPrune) : undefined
+      const configPatch = patchCompactionConfig(configState, originalConfig => adjustedCompactionConfig(originalConfig, target, auto / 100))
       ctx.logger?.info?.(`[lcx-codex] auto pressure ${ratioPercent.toFixed(1)}%: ${nativeFirst ? 'Native V2 first' : 'emergency DSH prune allowed'} (native ${auto}%, emergency ${emergency}%)`)
       try { return await callOriginal() }
       finally {
-        if (installedConfig && this?.config === installedConfig) { try { this.config = originalConfig } catch {} }
-        if (nativeFirst && pruner?.pruneSession === noOpPrune) { try { pruner.pruneSession = originalPrune } catch {} }
+        restoreCompactionConfig(configPatch)
+        restoreToolResultPruner(prunerPatch)
       }
     })
   }
   record.wrapper = wrapper
-  try { compaction.compactIfNeeded = wrapper } catch { return false }
-  records.set(compaction, record)
-  return true
+  return installCompactionPatch(records, record)
 }
 
 function patchCompactionPressureForAgent(agent, state, getConfig, ctx, records, requestHeaders) {
@@ -552,36 +592,20 @@ async function restoreCompactionPressure(records) {
     if (!record.lifecycle.signal.aborted) record.lifecycle.abort(reason)
   }
   await Promise.allSettled(entries.map((record) => record.mutex.close(reason)))
-  for (const record of entries) if (record.compaction?.compactIfNeeded === record.wrapper) { try { record.compaction.compactIfNeeded = record.original } catch {} }
-  records.clear()
+  restoreCompactionPatches(records, entries)
 }
 
-function patchVisibleWebSearchTimeout(agent, state, getConfig, patchedDefinitions) {
-  const tools = resolveScopedService(agent, 'tools')
-  const definition = tools?.get?.('web_search', agent)
-  if (!definition || typeof definition !== 'object') return
-  if (!patchedDefinitions.has(definition)) patchedDefinitions.set(definition, definition.timeoutMs)
+function visibleWebSearchTimeout(state, getConfig) {
   const config = getConfig()
   const timeoutMs = Number.isFinite(state.webSearchTimeoutSeconds) ? Math.min(600_000, Math.max(30_000, Math.round(state.webSearchTimeoutSeconds * 1000))) : config.webSearchTimeoutMs
-  try { definition.timeoutMs = state.enabled && state.webSearch ? timeoutMs : patchedDefinitions.get(definition) } catch {}
-}
-
-function refreshPatchedWebSearchTimeouts(state, getConfig, patchedDefinitions) {
-  const config = getConfig()
-  const timeoutMs = Number.isFinite(state.webSearchTimeoutSeconds) ? Math.min(600_000, Math.max(30_000, Math.round(state.webSearchTimeoutSeconds * 1000))) : config.webSearchTimeoutMs
-  for (const [definition, original] of patchedDefinitions.entries()) { try { definition.timeoutMs = state.enabled && state.webSearch ? timeoutMs : original } catch {} }
-}
-
-function restoreWebSearchTimeouts(patchedDefinitions) {
-  for (const [definition, original] of patchedDefinitions.entries()) { try { if (original === undefined) delete definition.timeoutMs; else definition.timeoutMs = original } catch {} }
-  patchedDefinitions.clear()
+  return state.enabled && state.webSearch ? timeoutMs : undefined
 }
 
 function messagesContainNativeCheckpoint(messages, session) { return Boolean(session && (messages ?? []).some((message) => checkpointStateForMessage(session, message))) }
 function messagesContainLegacyCheckpoint(messages) { return (messages ?? []).some((message) => Boolean(legacyCheckpointId(message))) }
 
 async function* recursiveLlmStream(ctx, options, messages) {
-  const llm = ctx?.get?.('llm') ?? ctx?.llm
+  const llm = contextService(ctx, 'llm')
   if (!llm?.stream) throw Object.assign(new Error('LCX portable replay requires ctx.llm.stream'), { code: 'LCX_CHECKPOINT_REPLAY_UNAVAILABLE' })
   const rewritten = { ...options, messages }
   bypassReplayOptions.add(rewritten)
@@ -613,10 +637,12 @@ function installInjected(ctx, configInput = {}) {
   let warnedWebSelection = false
   const provider = new LcxResponsesSearchProvider(ctx, () => runtimeConfig, () => state.enabled && state.webSearch)
   ctx.web.registerSearchProvider(provider)
-  const tools = ctx?.get?.('tools') ?? ctx?.tools
-  let disposeAdvanced, disposeAlpha
+  const tools = contextService(ctx, 'tools')
+  let disposeAdvanced
   const capabilityStore = new AlphaCapabilityStore(baseConfig.alphaCapabilityPath)
   const refStore = new AlphaRefStore(baseConfig.alphaRefPath)
+  const alphaAgents = new Set()
+  const alphaToolRegistrations = new Map()
   const compactionPatchRecords = new Map()
   const patchedWebSearchDefinitions = new Map()
   const requestHeaders = new Map()
@@ -627,20 +653,22 @@ function installInjected(ctx, configInput = {}) {
   }, { global: true })
   ctx.on('session/disposed', (session) => {
     requestHeaders.delete(String(session?.id ?? ''))
+    for (const agent of alphaAgents) if (agent?.session === session) {
+      disposeAlphaToolForAgent(agent, alphaToolRegistrations)
+      alphaAgents.delete(agent)
+    }
   }, { global: true })
   ctx.on('session/event', (session, event) => {
     updateRequestHeaderCache(requestHeaders, session, event)
+    if (event?.type === 'request/header') for (const agent of alphaAgents) if (agent?.session === session) {
+      syncAlphaToolForAgent(ctx, agent, state, () => runtimeConfig, capabilityStore, refStore, alphaToolRegistrations)
+    }
   }, { global: true })
 
   const refreshTools = () => {
     if (state.enabled && state.webSearch && state.advancedHostedSearch && !disposeAdvanced && tools?.register) disposeAdvanced = tools.register(createAdvancedHostedTool(ctx, state, () => runtimeConfig))
     if ((!state.enabled || !state.webSearch || !state.advancedHostedSearch) && disposeAdvanced) { disposeAdvanced(); disposeAdvanced = undefined }
-    let alphaUsable = false
-    if (state.enabled && state.alphaSearch) {
-      try { const { record } = alphaCapabilityFor(runtimeConfig, capabilityStore); alphaUsable = alphaCapabilityUsable(record) && record?.schemaFingerprint === ALPHA_SCHEMA_FINGERPRINT } catch (error) { ctx.logger?.warn?.(`[lcx-codex] Alpha capability store unavailable: ${error?.message ?? error}`) }
-    }
-    if (alphaUsable && !disposeAlpha && tools?.register) disposeAlpha = tools.register(createAlphaTool(ctx, state, () => runtimeConfig, capabilityStore, refStore))
-    if (!alphaUsable && disposeAlpha) { disposeAlpha(); disposeAlpha = undefined }
+    for (const agent of alphaAgents) syncAlphaToolForAgent(ctx, agent, state, () => runtimeConfig, capabilityStore, refStore, alphaToolRegistrations)
     if (ctx.web) {
       const target = state.enabled && state.webSearch ? runtimeConfig.webSearchProvider : originalSearchProvider
       const selected = writeWebSearchProvider(ctx, target)
@@ -668,7 +696,7 @@ function installInjected(ctx, configInput = {}) {
       state.autoCompactionThresholdPercent = clampPercent(value.autoCompactionThresholdPercent, baseConfig.autoCompactionThresholdPercent, 85, 95)
       state.emergencyPruneThresholdPercent = clampPercent(value.emergencyPruneThresholdPercent, baseConfig.emergencyPruneThresholdPercent, 90, 99)
       runtimeConfig = normalizeConfig({ ...baseConfig, provider: value.provider ?? baseConfig.provider, baseURL: value.baseURL ?? baseConfig.baseURL, apiKeyEnv: value.apiKeyEnv ?? baseConfig.apiKeyEnv, model: value.model ?? baseConfig.model })
-      refreshTools(); refreshPatchedWebSearchTimeouts(state, () => runtimeConfig, patchedWebSearchDefinitions)
+      refreshTools(); refreshVisibleWebSearchTimeouts(patchedWebSearchDefinitions, visibleWebSearchTimeout(state, () => runtimeConfig))
     },
   })
   try {
@@ -689,15 +717,19 @@ function installInjected(ctx, configInput = {}) {
 
   ctx.on('agent/created', ({ agent }) => {
     if (!agent) return
+    alphaAgents.add(agent)
+    syncAlphaToolForAgent(ctx, agent, state, () => runtimeConfig, capabilityStore, refStore, alphaToolRegistrations)
     const installed = patchCompactionPressureForAgent(agent, state, () => runtimeConfig, ctx, compactionPatchRecords, requestHeaders)
     if (installed) ctx.logger?.info?.('[lcx-codex] pressure coordination installed through AgentPresets service resolver')
   }, { global: true })
 
   ctx.on('agent/status', ({ agent, status }) => {
     if (status !== 'running' || !agent) return
+    alphaAgents.add(agent)
+    syncAlphaToolForAgent(ctx, agent, state, () => runtimeConfig, capabilityStore, refStore, alphaToolRegistrations)
     const installed = patchCompactionPressureForAgent(agent, state, () => runtimeConfig, ctx, compactionPatchRecords, requestHeaders)
     if (installed) ctx.logger?.info?.('[lcx-codex] pressure coordination installed through AgentPresets service resolver')
-    patchVisibleWebSearchTimeout(agent, state, () => runtimeConfig, patchedWebSearchDefinitions)
+    patchVisibleWebSearchTimeout(agent, () => visibleWebSearchTimeout(state, () => runtimeConfig), patchedWebSearchDefinitions)
   }, { global: true })
 
   ctx.on('llm/stream', (options, next) => {
@@ -720,16 +752,18 @@ function installInjected(ctx, configInput = {}) {
   })
 
   ctx.effect?.(() => async () => {
-    disposeAdvanced?.(); disposeAlpha?.()
+    disposeAdvanced?.()
+    for (const agent of alphaAgents) disposeAlphaToolForAgent(agent, alphaToolRegistrations)
+    alphaAgents.clear()
     await restoreCompactionPressure(compactionPatchRecords)
-    restoreWebSearchTimeouts(patchedWebSearchDefinitions)
+    restoreVisibleWebSearchTimeouts(patchedWebSearchDefinitions)
     writeWebSearchProvider(ctx, originalSearchProvider)
     requestHeaders.clear()
   }, 'lcx-codex cleanup')
 }
 
 export function apply(ctx, configInput = {}) {
-  return ctx.inject(['llm', 'web', 'sessions'], injectedCtx => installInjected(injectedCtx, configInput))
+  return installInjected(ctx, configInput)
 }
 
 apply.inject = inject