@xingular/harness 0.1.6 → 1.0.0

package/src/terminal/controller.ts

@@ -1,227 +0,0 @@
-// One `pi` command running in a terminal, as the harness sees it. The terminal itself belongs
-// to whoever embeds the harness; this follows the native process through its extension's
-// telemetry (never by reading the screen), turns each native turn into a run, and answers the
-// extension's questions about policy, approvals, and what to do next.
-import { createHash, randomUUID } from 'node:crypto'
-
-import { HarnessError } from '../core/errors'
-import type { ActiveRun, ApprovalDecision, QuestionAnswer } from '../sessions/registry'
-
-export interface PolicyReply {
-  allowed: boolean
-  reason?: string | null
-  requiresApproval?: boolean
-}
-
-export interface ControllerHooks {
-  sessionId: string
-  nativeSessionId: string | null
-  /** Reserves or creates the run for a native turn and starts tracking it. */
-  begin(input: { reservedRunId: string | null; nativeTurnId: string; text: string }): ActiveRun
-  /** Whether a native tool call may run. */
-  policy(run: ActiveRun, tool: string, args: unknown): Promise<PolicyReply>
-  /** The native conversation identity changed. */
-  native(nativeSessionId: string): void
-  telemetry(event: string): void
-}
-
-interface Delivery {
-  runId: string
-  text: string
-  resolve: () => void
-  reject: (error: Error) => void
-}
-
-type Command = { type: 'interrupt' } | { type: 'send'; text: string }
-
-const READY_TIMEOUT_MS = 90_000
-const ACK_TIMEOUT_MS = 25_000
-
-export class TerminalController {
-  private run: ActiveRun | null = null
-  private ready = false
-  private disposed = false
-  private dirty = false
-  private multilineDraft = false
-  private startupError: string | null = null
-  private startupPhase = 'Waiting for the native extension'
-  private delivery: Delivery | null = null
-  private nativeId: string | null
-  private readonly seen = new Map<string, Promise<unknown>>()
-  private readonly commands: Command[] = []
-
-  constructor(private readonly hooks: ControllerHooks) {
-    this.nativeId = hooks.nativeSessionId
-  }
-
-  get nativeSessionId(): string | null {
-    return this.nativeId
-  }
-
-  get activeRun(): ActiveRun | null {
-    return this.run && !this.run.finished ? this.run : null
-  }
-
-  state(): { ready: boolean; dirty: boolean; active: boolean } {
-    return { ready: this.ready, dirty: this.dirty, active: !!this.activeRun || !!this.delivery }
-  }
-
-  private requestId(nativeId: string): string {
-    return createHash('sha256').update(`${this.hooks.sessionId}:${this.run?.runId}:${nativeId}`).digest('hex')
-  }
-
-  private begin(nativeTurnId: string, text: string): ActiveRun {
-    if (this.startupError) throw new Error(this.startupError)
-    this.dirty = false
-    this.multilineDraft = false
-    if (this.run && !this.run.finished) return this.run
-    const delivery = this.delivery
-    if (delivery && text && delivery.text !== text) throw new Error('The native prompt did not match the reserved delivery. Inspect the terminal before continuing.')
-    const run = this.hooks.begin({ reservedRunId: delivery?.runId ?? null, nativeTurnId, text })
-    this.run = run
-    run.onInterrupt(() => void this.commands.push({ type: 'interrupt' }))
-    if (text) run.emit('message.completed', { messageId: nativeTurnId, role: 'user', text })
-    delivery?.resolve()
-    this.delivery = null
-    return run
-  }
-
-  private finish(outcome: 'completed' | 'failed' | 'interrupted', message?: string): void {
-    this.run?.finish(outcome, message ? { code: 'terminal_attention', message } : undefined)
-    this.run = null
-    this.seen.clear()
-  }
-
-  /** Hands the native process an instruction and waits until it acknowledges the prompt. */
-  async send(runId: string, text: string): Promise<void> {
-    if (this.disposed) throw new HarnessError('terminal_not_ready', 'Reopen the terminal before sending instructions.')
-    if (this.activeRun || this.delivery) throw new HarnessError('session_busy', 'This terminal has an active task or delivery.')
-    const deadline = Date.now() + READY_TIMEOUT_MS
-    while (!this.ready && !this.startupError && !this.disposed && Date.now() < deadline) await new Promise((resolve) => setTimeout(resolve, 50))
-    if (this.disposed) throw new HarnessError('terminal_not_ready', 'The terminal stopped during initialization.')
-    if (this.startupError) throw new HarnessError('terminal_not_ready', this.startupError)
-    if (!this.ready) throw new HarnessError('terminal_not_ready', `The native telemetry handshake is missing (${this.startupPhase}). Inspect the terminal sign-in or trust screen.`)
-    if (this.dirty) throw new HarnessError('terminal_has_draft', 'The terminal contains user input. Submit or clear it before handing back control.')
-    let timer: ReturnType<typeof setTimeout>
-    const ack = new Promise<void>((resolve, reject) => {
-      timer = setTimeout(() => reject(new HarnessError('delivery_uncertain', 'The native prompt acknowledgement was not received. Inspect the terminal; this instruction will not be resent.')), ACK_TIMEOUT_MS)
-      this.delivery = { runId, text, resolve, reject }
-    })
-    // Delivery can fail while the native process is still starting the turn. Observe it immediately.
-    void ack.catch(() => {})
-    try {
-      this.commands.push({ type: 'send', text })
-      await ack
-    } catch (error) {
-      this.ready = false
-      this.startupError = error instanceof Error ? error.message : String(error)
-      this.delivery = null
-      this.commands.length = 0
-      this.commands.push({ type: 'interrupt' })
-      this.finish('failed', this.startupError)
-      throw error
-    } finally {
-      clearTimeout(timer!)
-    }
-  }
-
-  /** What the person typed into the terminal, so an instruction is never sent over their draft. */
-  onInput(data: string): void {
-    if (!this.ready || this.activeRun || data === '\u0003') return
-    if (data.includes('\n') || data.includes('\r')) this.multilineDraft = true
-    this.dirty = data !== '\u0015' || this.multilineDraft
-  }
-
-  /** The native process hung up while it was waiting for a decision. */
-  disconnected(): void {
-    if (this.disposed) return
-    this.ready = false
-    this.commands.push({ type: 'interrupt' })
-    this.finish('failed', 'The native decision callback disconnected. Inspect the terminal before continuing.')
-  }
-
-  async accept(event: string, data: Record<string, any>): Promise<unknown> {
-    if (this.disposed) throw new Error('This terminal controller was disposed.')
-    if (event !== 'poll') this.hooks.telemetry(event)
-    if (event === 'startup') {
-      this.startupPhase = String(data.phase)
-      return {}
-    }
-    if (event === 'startupFailed') {
-      this.startupError = String(data.reason ?? 'The native extension could not initialize.')
-      this.ready = false
-      this.finish('failed', this.startupError)
-      return {}
-    }
-    if (event === 'poll') return { command: this.commands.shift() ?? null }
-    if (event === 'ready') {
-      if (!this.ready) {
-        this.dirty = false
-        this.multilineDraft = false
-      }
-      this.ready = true
-      if (typeof data.nativeSessionId === 'string' && data.nativeSessionId) {
-        this.nativeId = data.nativeSessionId
-        this.hooks.native(data.nativeSessionId)
-      }
-      return {}
-    }
-    if (event === 'begin') {
-      this.begin(String(data.turnId ?? randomUUID()), String(data.text ?? ''))
-      return {}
-    }
-    if (event === 'shutdown') {
-      this.ready = false
-      this.finish('interrupted')
-      return {}
-    }
-    if (event === 'settled') {
-      this.finish(data.error ? 'failed' : 'completed', data.error ? String(data.error) : undefined)
-      return {}
-    }
-    const run = this.run
-    if (!run) throw new Error('Native telemetry arrived without an active turn.')
-    if (event === 'policy') return this.hooks.policy(run, String(data.tool), data.args ?? {})
-    if (event === 'approval' || event === 'question') {
-      const key = this.requestId(String(data.requestId ?? JSON.stringify(data)))
-      const existing = this.seen.get(key)
-      if (existing) return event === 'approval' ? { decision: await existing } : existing
-      if (event === 'question') {
-        const response: Promise<QuestionAnswer> = run.requestAnswer({ requestId: key, question: String(data.question ?? ''), options: data.options ?? [], multiSelect: !!data.multiSelect, allowText: true })
-        this.seen.set(key, response)
-        return response
-      }
-      const response: Promise<ApprovalDecision> = run.requestApproval({
-        requestId: key,
-        target: String(data.target ?? 'Native action'),
-        action: String(data.action ?? '{}'),
-        operation: { tool: String(data.tool ?? data.target), args: data.args ?? {} },
-        rememberable: false
-      })
-      this.seen.set(key, response)
-      return { decision: await response }
-    }
-    if (event === 'usage') run.emit('usage.updated', data)
-    else if (event === 'file') run.emit('file.changed', data)
-    else if (event === 'message') run.emit('message.completed', { messageId: data.id ?? randomUUID(), role: data.role ?? 'assistant', text: String(data.text) })
-    else if (event === 'tool') {
-      run.emit(data.phase === 'start' ? 'tool.started' : 'tool.completed', {
-        toolCallId: String(data.id),
-        name: String(data.name),
-        ...(data.phase === 'start'
-          ? { summary: String(data.summary ?? '') }
-          : { ok: data.ok !== false, ...(typeof data.durationMs === 'number' ? { durationMs: data.durationMs } : {}), ...(typeof data.resultChars === 'number' ? { resultChars: data.resultChars } : {}) })
-      })
-    }
-    return {}
-  }
-
-  dispose(): void {
-    if (this.disposed) return
-    this.disposed = true
-    this.ready = false
-    this.delivery?.reject(new Error('The terminal stopped before prompt acknowledgement.'))
-    this.delivery = null
-    this.finish('interrupted')
-  }
-}

package/src/terminal/launch.test.ts

@@ -1,34 +0,0 @@
-import { spawnSync } from 'node:child_process'
-import { describe, expect, it } from 'vitest'
-
-import { bundledPiCli, resolvePiCommand, terminalCommandFiles } from './launch'
-
-describe('terminal launch commands', () => {
-  it('runs the pinned Pi CLI with the active Node runtime on Windows', () => {
-    const launch = resolvePiCommand({ platform: 'win32', node: 'C:\\Program Files\\nodejs\\node.exe' })
-
-    expect(launch.program).toBe('C:\\Program Files\\nodejs\\node.exe')
-    expect(launch.argsPrefix[0]).toMatch(/[\\/]node_modules[\\/]@earendil-works[\\/]pi-coding-agent[\\/]dist[\\/]bundle[\\/]cli\.js$/)
-  })
-
-  it('runs the package CLI through Node for a no-model help smoke', () => {
-    const result = spawnSync(process.execPath, [bundledPiCli(), '--help'], { encoding: 'utf8', timeout: 20_000 })
-
-    expect(result.error).toBeUndefined()
-    expect(result.status).toBe(0)
-    expect(`${result.stdout}${result.stderr}`).toMatch(/usage|options|pi/i)
-  })
-
-  it('keeps an explicitly configured executable even on Windows', () => {
-    expect(resolvePiCommand({ platform: 'win32', node: 'node.exe', programOverride: () => 'C:\\Tools\\pi.exe' }))
-      .toEqual({ program: 'C:\\Tools\\pi.exe', argsPrefix: [] })
-  })
-
-  it('provides Git Bash and native Windows launchers for each Harness command', () => {
-    expect(terminalCommandFiles('win32', 'C:\\Program Files\\nodejs\\node.exe', 'C:\\Harness\\cli.js', 'xagent-wiki', 'wiki'))
-      .toEqual([
-        { name: 'xagent-wiki', content: "#!/bin/sh\nexec '/c/Program Files/nodejs/node.exe' '/c/Harness/cli.js' wiki \"$@\"\n" },
-        { name: 'xagent-wiki.cmd', content: '@echo off\r\n"%XINGULAR_HARNESS_NODE%" "%XINGULAR_HARNESS_CLI%" wiki %*\r\nexit /b %ERRORLEVEL%\r\n' }
-      ])
-  })
-})

package/src/terminal/launch.ts

@@ -1,88 +0,0 @@
-import { existsSync, readFileSync } from 'node:fs'
-import { createRequire } from 'node:module'
-import { join, resolve } from 'node:path'
-
-import { HarnessError } from '../core/errors'
-import { findBinary } from '../core/path'
-
-const PI_PACKAGE = '@earendil-works/pi-coding-agent'
-
-export interface PiCommand {
-  program: string
-  argsPrefix: string[]
-}
-
-/** Resolve the Pi package's declared command instead of depending on its POSIX npm shim. */
-export function bundledPiCli(): string {
-  const require = createRequire(import.meta.url)
-  for (const nodeModules of require.resolve.paths(PI_PACKAGE) ?? []) {
-    const directory = join(nodeModules, ...PI_PACKAGE.split('/'))
-    const manifestPath = join(directory, 'package.json')
-    if (!existsSync(manifestPath)) continue
-    try {
-      const manifest = JSON.parse(readFileSync(manifestPath, 'utf8')) as {
-        name?: unknown
-        bin?: unknown
-      }
-      if (manifest.name === PI_PACKAGE) {
-        const executable = typeof manifest.bin === 'string'
-          ? manifest.bin
-          : manifest.bin && typeof manifest.bin === 'object' && typeof (manifest.bin as Record<string, unknown>).pi === 'string'
-            ? (manifest.bin as Record<string, string>).pi
-            : null
-        if (!executable) throw new Error('the package does not declare its pi command')
-        const cli = resolve(directory, executable)
-        if (!existsSync(cli)) throw new Error(`the declared command does not exist at ${cli}`)
-        return cli
-      }
-    } catch {
-      continue
-    }
-  }
-
-  throw new HarnessError('harness_unavailable', `The bundled ${PI_PACKAGE} package does not expose a usable pi command. Reinstall the Harness package and try again.`)
-}
-
-export function resolvePiCommand(options: {
-  platform: NodeJS.Platform
-  node: string
-  programOverride?: () => string | null
-}): PiCommand {
-  if (options.programOverride) {
-    const program = options.programOverride()
-    if (!program) throw new HarnessError('harness_unavailable', 'The Pi CLI was not found on PATH.')
-    return { program, argsPrefix: [] }
-  }
-  if (options.platform === 'win32') return { program: options.node, argsPrefix: [bundledPiCli()] }
-  const program = findBinary('pi')
-  if (!program) throw new HarnessError('harness_unavailable', 'The Pi CLI was not found on PATH.')
-  return { program, argsPrefix: [] }
-}
-
-function bashPath(path: string): string {
-  const drive = /^([a-z]):[\\/](.*)$/i.exec(path)
-  if (drive) return `/${drive[1].toLowerCase()}/${drive[2].replaceAll('\\', '/')}`
-  if (path.startsWith('\\\\')) return `//${path.slice(2).replaceAll('\\', '/')}`
-  return path
-}
-
-function shellQuote(value: string): string {
-  return `'${value.replaceAll("'", "'\\''")}'`
-}
-
-/** Files Pi's Git Bash shell and native Windows shells use to call Harness subcommands. */
-export function terminalCommandFiles(platform: NodeJS.Platform, node: string, cli: string, name: string, mode: string): Array<{ name: string; content: string }> {
-  const shellNode = platform === 'win32' ? bashPath(node) : node
-  const shellCli = platform === 'win32' ? bashPath(cli) : cli
-  const files = [{
-    name,
-    content: `#!/bin/sh\nexec ${shellQuote(shellNode)} ${shellQuote(shellCli)} ${mode} "$@"\n`
-  }]
-  if (platform === 'win32') {
-    files.push({
-      name: `${name}.cmd`,
-      content: `@echo off\r\n"%XINGULAR_HARNESS_NODE%" "%XINGULAR_HARNESS_CLI%" ${mode} %*\r\nexit /b %ERRORLEVEL%\r\n`
-    })
-  }
-  return files
-}

package/src/terminal/piExtension.ts

@@ -1,210 +0,0 @@
-// Loaded by the `pi` command in a terminal session (`--extension`). It reports what the native
-// session does to the harness, asks before each tool call, takes instructions the harness
-// queues for it, and gives the session the harness's own tools. It runs in the `pi` process,
-// so everything it knows about the harness comes through the session socket.
-import type { ExtensionAPI, ExtensionContext } from '@earendil-works/pi-coding-agent'
-import { Type } from 'typebox'
-
-import { connectionFromEnv, socketCall, terminalCall } from './client'
-import { runPluginsMenu } from './pluginMenu'
-
-interface SocketTool {
-  name: string
-  label: string
-  description: string
-  parameters: Record<string, unknown>
-}
-
-/** How much text a tool handed back to the model. */
-function resultSize(result: unknown): number | null {
-  const content = (result as { content?: unknown } | null | undefined)?.content
-  if (!Array.isArray(content)) return typeof result === 'string' ? result.length : null
-  return content.reduce((total: number, part: { type?: string; text?: unknown }) => total + (part?.type === 'text' && typeof part.text === 'string' ? part.text.length : 0), 0)
-}
-
-export default async function (pi: ExtensionAPI) {
-  await terminalCall('startup', { phase: 'Pi extension loaded' })
-  let context: ExtensionContext | null = null
-  let timer: ReturnType<typeof setInterval> | null = null
-  let polling = false
-  let failure: string | undefined
-  const emptyUsage = () => ({ inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0, requests: 0, costUsd: 0 })
-  let usage = emptyUsage()
-  let reasoningTokens: number | undefined
-  let costReported = false
-  let requestStartedAt: number | null = null
-  const toolStartedAt = new Map<string, number>()
-  const fileTools = new Map<string, string>()
-
-  // The harness's own tools for this session (connected apps and what the application offers).
-  let stage = 'Tool discovery'
-  try {
-    await terminalCall('startup', { phase: stage })
-    const connection = connectionFromEnv()
-    // Claimed here, before the model has run anything, and kept in this process's memory: a
-    // command the model runs can read the session token from its environment, never this key.
-    const control = await socketCall<{ key: string }>(connection, 'control.claim', {}, 15_000).then((claimed) => claimed.key).catch(() => null)
-    pi.registerCommand('plugins', {
-      description: 'See what this session loads, and switch a plugin on or off or trust its code',
-      handler: async (_args, ctx) => {
-        if (!control) return ctx.ui.notify('This session cannot change plugins.', 'warning')
-        const { projectId } = await socketCall<{ projectId: string | null }>(connection, 'plugins.session', {}, 15_000, control).catch(() => ({ projectId: null }))
-        await runPluginsMenu(
-          { select: (title, options) => ctx.ui.select(title, options), confirm: (title, message) => ctx.ui.confirm(title, message), notify: (message, level) => ctx.ui.notify(message, level) },
-          (method, params) => socketCall(connection, method, params ?? {}, 60_000, control),
-          projectId
-        )
-      }
-    })
-    const { tools } = await socketCall<{ tools: SocketTool[] }>(connection, 'tools.list', {}, 15_000)
-    stage = 'Tool registration'
-    for (const tool of tools) {
-      pi.registerTool({
-        name: tool.name,
-        label: tool.label,
-        description: tool.description,
-        parameters: Type.Unsafe(tool.parameters),
-        async execute(_id, input) {
-          const result = await socketCall<{ text: string }>(connection, 'tools.call', { name: tool.name, input: input as Record<string, unknown> }, 1_230_000)
-          return { content: [{ type: 'text', text: result.text }], details: undefined }
-        }
-      })
-    }
-  } catch (error) {
-    await terminalCall('startupFailed', { reason: `${stage} failed: ${error instanceof Error ? error.message : 'Unavailable'}` }).catch(() => {})
-    throw error
-  }
-
-  pi.on('session_start', async (_event, ctx) => {
-    context = ctx
-    await terminalCall('ready', { nativeSessionId: ctx.sessionManager.getSessionFile() })
-    timer = setInterval(() => {
-      if (polling || !context) return
-      polling = true
-      void terminalCall<{ command: { type: string; text?: string } | null }>('poll', {}, 5_000)
-        .then(({ command }) => {
-          if (command?.type === 'interrupt') context?.abort()
-          else if (command?.type === 'send') {
-            if (context?.ui.getEditorText().trim()) throw new Error('The terminal contains a user draft.')
-            // Pi 1.2 needs deliverAs while a run is busy; a message sent then waits for that run to finish.
-            pi.sendUserMessage(command.text!, context?.isIdle() === false ? { deliverAs: 'followUp' } : undefined)
-          }
-        })
-        .catch(() => {
-          context?.abort()
-          if (timer) clearInterval(timer)
-        })
-        .finally(() => {
-          polling = false
-        })
-    }, 100)
-  })
-  pi.on('before_agent_start', async (event, ctx) => {
-    context = ctx
-    failure = undefined
-    usage = emptyUsage()
-    reasoningTokens = undefined
-    costReported = false
-    // A run a plugin starts with a custom message has no user prompt to record; it still begins a turn.
-    await terminalCall('begin', { text: event.messageType === 'user' ? event.prompt : '' })
-  })
-  pi.on('message_end', async (event) => {
-    if (event.message.role !== 'assistant') return
-    if (event.message.stopReason === 'error' || event.message.stopReason === 'aborted') failure = event.message.errorMessage ?? `Pi stopped: ${event.message.stopReason}`
-    const text = event.message.content.filter((part) => part.type === 'text').map((part) => part.text).join('\n')
-    if (text) await terminalCall('message', { text })
-    if (event.message.usage) {
-      const reported = event.message.usage
-      usage.inputTokens += reported.input ?? 0
-      usage.outputTokens += reported.output ?? 0
-      usage.cacheReadTokens += reported.cacheRead ?? 0
-      usage.cacheWriteTokens += reported.cacheWrite ?? 0
-      usage.requests += 1
-      if (typeof reported.reasoning === 'number') reasoningTokens = (reasoningTokens ?? 0) + reported.reasoning
-      const cost = reported.cost?.total
-      if (typeof cost === 'number') {
-        usage.costUsd += cost
-        costReported = true
-      }
-      const identity = { model: event.message.model, provider: event.message.provider }
-      const { costUsd, ...tokens } = usage
-      await terminalCall('usage', {
-        ...tokens,
-        ...(costReported ? { costUsd, costSource: 'harness' } : {}),
-        ...(reasoningTokens === undefined ? {} : { reasoningTokens }),
-        contextTokens: (reported.input ?? 0) + (reported.cacheRead ?? 0) + (reported.cacheWrite ?? 0),
-        ...(context?.model?.contextWindow ? { contextWindow: context.model.contextWindow } : {}),
-        ...identity,
-        request: {
-          index: usage.requests,
-          ...identity,
-          responseId: event.message.responseId,
-          inputTokens: reported.input ?? 0,
-          cacheReadTokens: reported.cacheRead ?? 0,
-          cacheWriteTokens: reported.cacheWrite ?? 0,
-          outputTokens: reported.output ?? 0,
-          ...(typeof reported.reasoning === 'number' ? { reasoningTokens: reported.reasoning } : {}),
-          ...(typeof cost === 'number' ? { costUsd: cost, costSource: 'harness' } : {}),
-          ...(requestStartedAt === null ? {} : { durationMs: Date.now() - requestStartedAt }),
-          stopReason: event.message.stopReason
-        }
-      })
-      requestStartedAt = null
-    }
-  })
-  pi.on('turn_start', async () => {
-    requestStartedAt = Date.now()
-  })
-  pi.on('tool_call', async (event) => {
-    try {
-      const policy = await terminalCall<{ allowed: boolean; reason?: string; requiresApproval?: boolean }>('policy', { tool: event.toolName, args: event.input })
-      if (policy.requiresApproval) {
-        const approval = await terminalCall<{ decision: string }>('approval', { requestId: event.toolCallId, target: event.toolName, action: JSON.stringify(event.input), tool: event.toolName, args: event.input })
-        if (approval.decision === 'approved') return
-        return { block: true, reason: 'The user denied this action. Ask how they would like to proceed.' }
-      }
-      if (!policy.allowed) return { block: true, reason: policy.reason ?? 'Outside what this session may do.' }
-    } catch {
-      return { block: true, reason: 'The terminal controller is unavailable.' }
-    }
-  })
-  pi.on('tool_execution_start', async (event) => {
-    if (['edit', 'write'].includes(event.toolName) && typeof event.args.path === 'string') fileTools.set(event.toolCallId, event.args.path)
-    toolStartedAt.set(event.toolCallId, Date.now())
-    await terminalCall('tool', { phase: 'start', id: event.toolCallId, name: event.toolName, summary: JSON.stringify(event.args).slice(0, 200) })
-  })
-  pi.on('tool_execution_end', async (event) => {
-    const started = toolStartedAt.get(event.toolCallId)
-    toolStartedAt.delete(event.toolCallId)
-    const resultChars = resultSize(event.result)
-    await terminalCall('tool', { phase: 'end', id: event.toolCallId, name: event.toolName, ok: !event.isError, ...(started === undefined ? {} : { durationMs: Date.now() - started }), ...(resultChars === null ? {} : { resultChars }) })
-    const path = fileTools.get(event.toolCallId)
-    fileTools.delete(event.toolCallId)
-    if (!event.isError && path) await terminalCall('file', { path, change: 'modified' })
-  })
-  pi.on('agent_settled', async () => {
-    await terminalCall('settled', { error: failure })
-  })
-  pi.on('user_bash', async () => {
-    throw new Error('Use the bash tool so this action can be checked.')
-  })
-  pi.on('session_shutdown', async () => {
-    if (timer) clearInterval(timer)
-    await terminalCall('shutdown').catch(() => {})
-  })
-  pi.registerTool({
-    name: 'ask_user_question',
-    label: 'Ask a question',
-    description: 'Ask the user a question and wait for their answer.',
-    parameters: Type.Object({
-      question: Type.String(),
-      options: Type.Optional(Type.Array(Type.Object({ label: Type.String(), description: Type.Optional(Type.String()) }))),
-      multiSelect: Type.Optional(Type.Boolean())
-    }),
-    async execute(id, input) {
-      const answer = await terminalCall('question', { requestId: id, ...input })
-      return { content: [{ type: 'text', text: JSON.stringify(answer) }], details: undefined }
-    }
-  })
-  await terminalCall('startup', { phase: 'Pi hooks registered' })
-}