runcastle 1.5.6 → 1.5.8

package/hook-client.ts

@@ -8,9 +8,6 @@
  * consumes as context). Zero dependencies (plain `fetch`), 3s timeout (5s and
  * retried for `session-start`, see {@link postHook}). On ANY
  * error it prints `{}` and exits 0 — a hook must never break the user's session.
- *
- * One argument is not a route event: `wait-messages`, the background message
- * waiter of the orchestrator and of a feature's lead (see {@link waitMessages}).
  */
 
 const FETCH_TIMEOUT_MS = 3000
@@ -44,70 +41,11 @@ async function readStdin(): Promise<string> {
   })
 }
 
-/** The hook-client argument that runs the orchestrator's message waiter. */
-export const WAIT_MESSAGES_MODE = 'wait-messages'
-
-/** Longer than the server's hold, so a held poll is answered rather than cut off. */
-const WAIT_FETCH_TIMEOUT_MS = 40_000
-/** The pause after a failed poll (server restarting, network blip) before the next. */
-const WAIT_RETRY_MS = 3000
-
-export interface WaitMessagesDeps {
-  fetch?: typeof fetch
-  sleep?: (ms: number) => Promise<void>
-  waiterId?: string
-}
-
-/**
- * `wait-messages` mode (`whole-cuts-plan-themselves` decision 20). Runs as an
- * orchestrate session's `asyncRewake` hook: long-polls
- * `GET /api/hooks/orchestrator-messages` until the server hands it lines, then
- * resolves exit code 2 with them joined by newlines — Claude Code wakes the
- * session with that output as one system reminder. `superseded` (a newer waiter
- * took over) and `ended` (the session is over) resolve 0 with nothing to say. A
- * hold that ran out polls again; a failed poll waits and retries. Never 2
- * without lines.
- */
-export async function waitMessages(
-  serverUrl: string,
-  sessionId: string | undefined,
-  deps: WaitMessagesDeps = {},
-): Promise<{ code: 0 | 2; output: string }> {
-  if (!sessionId) return { code: 0, output: '' }
-  const doFetch = deps.fetch ?? fetch
-  const sleep = deps.sleep ?? ((ms: number) => new Promise<void>((r) => setTimeout(r, ms)))
-  const waiter = deps.waiterId ?? crypto.randomUUID()
-  const url =
-    `${serverUrl}/api/hooks/orchestrator-messages` +
-    `?sessionId=${encodeURIComponent(sessionId)}&waiter=${encodeURIComponent(waiter)}`
-  for (;;) {
-    let answer: { status?: string; lines?: unknown }
-    try {
-      const res = await doFetch(url, { signal: AbortSignal.timeout(WAIT_FETCH_TIMEOUT_MS) })
-      answer = (await res.json()) as typeof answer
-    } catch {
-      await sleep(WAIT_RETRY_MS)
-      continue
-    }
-    if (answer.status === 'superseded' || answer.status === 'ended') return { code: 0, output: '' }
-    const lines = Array.isArray(answer.lines) ? answer.lines.filter((l) => typeof l === 'string') : []
-    if (answer.status === 'lines' && lines.length > 0) return { code: 2, output: lines.join('\n') }
-    // Anything but a hold that ran out answered at once: never spin on it.
-    if (answer.status !== 'empty') await sleep(WAIT_RETRY_MS)
-  }
-}
-
 export async function main(argv: string[] = process.argv.slice(2)): Promise<void> {
   const event = argv[0] ?? ''
   const serverUrl = process.env.RUNCASTLE_SERVER_URL ?? 'http://localhost:4512'
   const sessionId = process.env.RUNCASTLE_SESSION_ID
 
-  if (event === WAIT_MESSAGES_MODE) {
-    const { code, output } = await waitMessages(serverUrl, sessionId)
-    if (output) process.stderr.write(output)
-    process.exit(code)
-  }
-
   const raw = await readStdin()
   let payload: unknown
   try {