typeclaw 0.8.0 → 0.9.1

package/src/run/index.ts

@@ -1,19 +1,28 @@
 import { SessionManager } from '@mariozechner/pi-coding-agent'
 
 import { createSession, createSessionWithDispose } from '@/agent'
+import { LiveSessionRegistry } from '@/agent/live-sessions'
 import { LiveSubagentRegistry } from '@/agent/live-subagents'
 import type { SessionOrigin } from '@/agent/session-origin'
 import {
+  awaitWithSubagentTimeout,
   createSubagentConsumer,
   defaultCreateSessionForSubagent,
   invokeSubagent,
+  isSubagentTimeoutError,
   type Subagent as InternalSubagent,
   type SubagentConsumer,
   type SubagentRegistry,
   type SubagentShared,
 } from '@/agent/subagents'
 import { resolveCapOptionsFromConfig } from '@/bundled-plugins/tool-result-cap'
-import { createChannelManager, createChannelsReloadable, type ChannelManager } from '@/channels'
+import {
+  createChannelManager,
+  createChannelsReloadable,
+  createSubagentCompletionBridge,
+  type ChannelManager,
+  type SubagentCompletionBridge,
+} from '@/channels'
 import { createTunnelBridge, type TunnelBridge } from '@/channels/tunnel-bridge'
 import { createConfigReloadable, getConfig, loadConfigSync, loadPluginConfigsSync } from '@/config'
 import {
@@ -179,6 +188,7 @@ export async function startAgent({
   })
 
   const liveSubagentRegistry = new LiveSubagentRegistry()
+  const liveSessionRegistry = new LiveSessionRegistry()
 
   const channelManager = createChannelManagerFor({
     agentDir: cwd,
@@ -196,6 +206,7 @@ export async function startAgent({
       rehydrateCapOptions: resolveCapOptionsFromConfig(pluginConfigsByName['tool-result-cap']),
       permissions: pluginsLoaded.permissions,
       liveSubagentRegistry,
+      liveSessionRegistry,
       subagentRegistry: pluginRuntime.get().subagents,
       getCreateSessionForSubagent: () => createSessionForSubagent,
       ...containerNameOpt,
@@ -245,8 +256,14 @@ export async function startAgent({
           : {}),
         ...runtimeVersionOpt,
       })
+      liveSessionRegistry.register({ sessionId, session: created.session })
+      const originalDispose = created.dispose
       return {
         ...created,
+        dispose: async () => {
+          liveSessionRegistry.unregister(sessionId)
+          await originalDispose()
+        },
         hooks: snap.hooks,
         sessionId,
         agentDir: cwd,
@@ -360,9 +377,13 @@ export async function startAgent({
         ...containerNameOpt,
         ...runtimeVersionOpt,
       })
+      liveSessionRegistry.register({ sessionId, session })
       return {
         prompt: (text) => session.prompt(text),
-        dispose: () => session.dispose(),
+        dispose: () => {
+          liveSessionRegistry.unregister(sessionId)
+          session.dispose()
+        },
         sessionId,
         agentDir: cwd,
         origin: cronOrigin,
@@ -393,32 +414,91 @@ export async function startAgent({
 
   const tunnelBridge: TunnelBridge = createTunnelBridge({ stream, channelManager })
 
+  // Bridge `subagent.completed` broadcasts into the channel router so a
+  // backgrounded subagent finishing wakes up its parent channel session
+  // with a `<system-reminder>` — symmetric to the TUI bridge in
+  // src/server/index.ts. Must be created BEFORE channelManager.start()
+  // so an initial broadcast can never race past the subscription gap.
+  const subagentCompletionBridge: SubagentCompletionBridge = createSubagentCompletionBridge({
+    stream,
+    router: channelManager.router,
+  })
+
   reloadRegistry.register(createChannelsReloadable({ manager: channelManager }))
   await channelManager.start()
 
   // Captured separately from setSpawnSubagent so both the plugin context and
   // the plugin-command runner can dispatch through the same path. The setter
   // returns void, so without this local binding we couldn't reuse the fn.
+  //
+  // In-flight coalescing for direct ctx.spawnSubagent calls mirrors the
+  // SubagentConsumer's stream-path gate (subagents.ts:441). Two queued
+  // `new-session` messages for the same (name, inFlightKey) drop the second
+  // on the consumer side; without the same gate here, two consecutive
+  // session.prompt fires (cold-start prompt N immediately followed by prompt
+  // N+1 on the same channel session) could both fire memory-retrieval spawns
+  // racing to write `memory/.retrieval-cache/<sessionId>.md`. Awaiting the
+  // spawn in the hook used to mask this; now that the hook is fire-and-forget,
+  // the race is exposed and the gate is mandatory.
+  //
+  // Same key shape as the consumer: `${name}:${inFlightKey(payload)}` when the
+  // subagent declares one, else just `${name}`. Collisions resolve cleanly
+  // (logged + return) instead of rejecting, because callers from
+  // session.prompt are detached and a colliding spawn is a noop, not an error.
+  const directSpawnInFlight = new Set<string>()
   const dispatchSpawnSubagent: CommandSpawnSubagent = async (name, payload, options) => {
-    // Resolve the spawning session's role from its origin so the subagent
-    // inherits it. Callers (hooks like session.idle) pass the parent origin
-    // verbatim; we look up the role rather than letting the caller forge it,
-    // closing the laundering vector the design doc calls out for cron.
-    const spawnedByRole =
-      options?.spawnedByOrigin !== undefined
-        ? pluginsLoaded.permissions.resolveRole(options.spawnedByOrigin)
-        : undefined
-    await invokeSubagent(name, {
-      registry: pluginRuntime.get().subagents,
-      createSessionForSubagent,
-      agentDir: cwd,
-      userPrompt: '',
-      payload,
-      onProviderError: (message) => console.error(`[subagent] ${name}: LLM call failed: ${message}`),
-      ...(options?.parentSessionId !== undefined ? { parentSessionId: options.parentSessionId } : {}),
-      ...(spawnedByRole !== undefined ? { spawnedByRole } : {}),
-      ...(options?.spawnedByOrigin !== undefined ? { spawnedByOrigin: options.spawnedByOrigin } : {}),
-    })
+    const entry = pluginSubagentByName.get(name)
+    const keyFn = entry?.pluginSubagent.inFlightKey
+    let coalesceKey = name
+    if (keyFn !== undefined) {
+      try {
+        coalesceKey = `${name}:${keyFn(payload)}`
+      } catch {
+        coalesceKey = name
+      }
+    }
+    if (directSpawnInFlight.has(coalesceKey)) {
+      console.warn(`[subagent] ${coalesceKey}: previous direct spawn still in progress, skipping`)
+      return
+    }
+    directSpawnInFlight.add(coalesceKey)
+    try {
+      // Resolve the spawning session's role from its origin so the subagent
+      // inherits it. Callers (hooks like session.idle) pass the parent origin
+      // verbatim; we look up the role rather than letting the caller forge it,
+      // closing the laundering vector the design doc calls out for cron.
+      const spawnedByRole =
+        options?.spawnedByOrigin !== undefined
+          ? pluginsLoaded.permissions.resolveRole(options.spawnedByOrigin)
+          : undefined
+      const registry = pluginRuntime.get().subagents
+      try {
+        await awaitWithSubagentTimeout(
+          invokeSubagent(name, {
+            registry,
+            createSessionForSubagent,
+            agentDir: cwd,
+            userPrompt: '',
+            payload,
+            onProviderError: (message) => console.error(`[subagent] ${name}: LLM call failed: ${message}`),
+            ...(options?.parentSessionId !== undefined ? { parentSessionId: options.parentSessionId } : {}),
+            ...(spawnedByRole !== undefined ? { spawnedByRole } : {}),
+            ...(options?.spawnedByOrigin !== undefined ? { spawnedByOrigin: options.spawnedByOrigin } : {}),
+          }),
+          name,
+          coalesceKey,
+          registry[name]?.timeoutMs,
+        )
+      } catch (err) {
+        if (isSubagentTimeoutError(err)) {
+          console.warn(`[subagent] ${coalesceKey} timed out after ${err.timeoutMs}ms; releasing coalesce key`)
+          return
+        }
+        throw err
+      }
+    } finally {
+      directSpawnInFlight.delete(coalesceKey)
+    }
   }
   pluginsLoaded.setSpawnSubagent(dispatchSpawnSubagent)
   pluginsLoaded.markBooted()
@@ -477,6 +557,7 @@ export async function startAgent({
     tunnelManager,
     liveSubagentRegistry,
     createSessionForSubagent,
+    liveSessionRegistry,
     ...containerNameOpt,
     ...runtimeVersionOpt,
     ...tuiTokenOpt,
@@ -500,6 +581,7 @@ export async function startAgent({
     server.stop(true)
     void disposeMaterializedSkills(pluginRuntime)
     tunnelBridge.stop()
+    subagentCompletionBridge.stop()
     await tunnelManager.stop()
     await channelManager.stop()
   }

package/src/secrets/kakao-renewal.ts

@@ -1,7 +1,6 @@
-import { createRequire } from 'node:module'
 import { join } from 'node:path'
 
-import type { KakaoDeviceType } from 'agent-messenger/kakaotalk'
+import { attemptLogin as upstreamAttemptLogin, type KakaoDeviceType } from 'agent-messenger/kakaotalk'
 
 import { decrypt, EncryptionError } from './encryption'
 import { SecretsKakaoCredentialStore } from './kakao-store'
@@ -9,21 +8,6 @@ import { type KeyStore, KeyStoreError } from './keys'
 import { type KakaoChannelBlock } from './schema'
 import { SecretsBackend } from './storage'
 
-// Mirrors KakaoLoginResult from agent-messenger/kakaotalk's types.d.ts. The
-// upstream interface is not re-exported from the package root, so we declare
-// the structural shape locally. If a future version adds new fields, this
-// stays forward-compatible because we only read the ones declared here.
-export type KakaoLoginResult = {
-  authenticated: boolean
-  next_action?: string
-  message?: string
-  warning?: string
-  account_id?: string
-  device_type?: KakaoDeviceType
-  user_id?: string
-  error?: string
-}
-
 export const RENEWAL_THRESHOLD_MS = 5 * 24 * 60 * 60 * 1000
 
 // Hard ~7-day TTL on KakaoTalk sub-device tokens means renewal must happen
@@ -50,21 +34,7 @@ export type RenewalAttempt =
   | { kind: 'reauth_required'; account_id: string; reason: string; message: string }
   | { kind: 'transient_failure'; account_id: string; reason: string }
 
-export type AttemptLoginFn = (
-  email: string,
-  password: string,
-  deviceUuid: string,
-  deviceType: KakaoDeviceType,
-  forced: boolean,
-) => Promise<KakaoLoginResult & { credentials?: LoginCredentials }>
-
-export type LoginCredentials = {
-  access_token: string
-  refresh_token: string
-  user_id: string
-  device_uuid: string
-  device_type: KakaoDeviceType
-}
+export type AttemptLoginFn = typeof upstreamAttemptLogin
 
 export type RenewalContext = {
   containerName: string
@@ -151,7 +121,7 @@ export async function renewCurrentAccount(
     }
   }
 
-  const attemptLogin = ctx.attemptLogin ?? (await resolveAttemptLogin())
+  const attemptLogin = ctx.attemptLogin ?? upstreamAttemptLogin
   const result = await attemptLogin(
     decision.account.email,
     decision.password,
@@ -232,17 +202,3 @@ function classifyDecryptFailure(err: unknown, accountId: string): RenewalDecisio
     message: `Could not decrypt stored KakaoTalk password (${err instanceof Error ? err.message : String(err)}).`,
   }
 }
-
-async function resolveAttemptLogin(): Promise<AttemptLoginFn> {
-  // agent-messenger does not export `attemptLogin` from its public exports
-  // map. Resolve the package's installed location and import the auth
-  // implementation file directly — same pattern as runKakaotalkBootstrap's
-  // loginFlow resolution in src/init/kakaotalk-auth.ts.
-  const require = createRequire(import.meta.url)
-  const pkgJson = require.resolve('agent-messenger/package.json')
-  const pkgDir = pkgJson.replace(/\/package\.json$/, '')
-  const mod = (await import(`${pkgDir}/dist/src/platforms/kakaotalk/auth/kakao-login.js`)) as {
-    attemptLogin: AttemptLoginFn
-  }
-  return mod.attemptLogin
-}