@xingular/harness 2.0.0 → 2.0.1-unstable

package/src/sessions/runner.ts

@@ -1,610 +0,0 @@
-// A session turn on Pi. Pi owns the model loop, native history, and tool use; this module opens
-// the session with the compiled prompt and the session's tools, and maps Pi's events onto the
-// run-event contract. Gated tools pause for the user's approval before they run.
-import type { CreateAgentSessionOptions, ModelRuntime, SettingsManager } from '@earendil-works/pi-coding-agent'
-
-import { classifyMessage } from '../accounts/accounts'
-import type { AccountContext } from '../accounts/env'
-import { HarnessError } from '../core/errors'
-import type { InlineExtension } from '../plugins/firstParty'
-import type { Loading, Registered } from '../plugins/plugins'
-import { CONTEXT_MESSAGE_TYPE, CONTEXT_SNAPSHOT_KEY, type ContextUpdate } from '../prompt/compile'
-import type { RegistryResources } from '../skills/registry'
-import type { ToolSpec } from '../tools/types'
-import { toolAttachmentRefsSchema, type UsageRequest } from './contracts'
-import { completedReasoningSummary, REASONING_SUMMARY_APIS, requestConciseReasoningSummary } from './reasoningSummaries'
-import { extensionUi, type ExtensionHost } from './extensionUi'
-import { observeResources, registrationHash } from '../plugins/runtime'
-import type { ActiveRun } from './registry'
-
-export const EFFORTS = ['off', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max'] as const
-export type Effort = (typeof EFFORTS)[number]
-
-/** What one turn needs once its prompt is compiled and its tools are chosen. */
-export interface TurnParams {
-  runId: string
-  /** Child runs may not gain tools registered by extensions outside their snapshot. */
-  restrictTools?: boolean
-  settle?: () => Promise<void>
-  cwd: string
-  sessionDir: string
-  /** The native history to open, or `null` to start a fresh one. */
-  historyFile: string | null
-  model: string | null
-  effort?: Effort | null
-  text: string
-  images?: { mediaType: string; data: string }[]
-  requiresImageInput?: boolean
-  /** App-origin notes placed before the text of the request. */
-  preamble?: string | null
-  /** Unattended: no project extensions, no context files, settings held in memory. */
-  automatic?: boolean
-  account: AccountContext
-  resources?: RegistryResources
-  /**
-   * What the harness found for this session to load, and where it reports what loaded. Pi's own
-   * discovery is off whenever this is set, so only these paths and the registry's reach the session.
-   */
-  plugins?: { loading(): Promise<Loading>; loaded(extensions: Registered[]): void }
-  /** The harness's own switched-on extensions. They are code in this process, so they load in every kind of run. */
-  inline?: InlineExtension[]
-  /** The stable part of the compiled prompt: the only text added to Pi's own. */
-  system: string
-  /** Changed state, saved as a hidden message in native history before the request. */
-  update: ContextUpdate | null
-}
-
-// ---- Pi session seam (real implementation below; tests inject a fake) ----------------
-
-/** Structural view of the Pi events the harness consumes. */
-export type PiEvent =
-  | { type: 'message_start'; message: { role: string } }
-  | { type: 'message_update'; message: { role: string }; assistantMessageEvent: { type: string; delta?: string } }
-  | {
-      type: 'message_end'
-      message: {
-        role: string
-        content?: Array<{ type: string; text?: string; thinkingSignature?: string }>
-        api?: string
-        usage?: { input?: number; output?: number; cacheRead?: number; cacheWrite?: number; reasoning?: number; cost?: { total?: number } }
-        model?: string
-        provider?: string
-        responseId?: string
-        stopReason?: string
-        errorMessage?: string
-      }
-    }
-  | { type: 'tool_execution_start'; toolCallId: string; toolName: string; args: unknown }
-  | { type: 'tool_execution_end'; toolCallId: string; toolName: string; isError: boolean; result?: unknown }
-  | { type: string }
-
-export interface PiSessionLike {
-  sessionId: string
-  sessionManager?: { getBranch(): unknown[] }
-  thinkingLevel?: Effort
-  systemPrompt?: string
-  extensionCommands?: readonly string[]
-  model?: { input: string[]; contextWindow?: number; id?: string; provider?: string }
-  getActiveToolNames?(): string[]
-  getAllTools?(): Array<{ name: string; description?: string; parameters?: unknown }>
-  subscribe(listener: (event: PiEvent) => void): () => void
-  prompt(text: string, options?: { images?: unknown[] }): Promise<void>
-  /** Queues a message for the model after the current step. Resolves `handled` when Pi takes it without queueing. */
-  steer?(text: string): Promise<'handled' | 'queued'>
-  /** Drops queued messages Pi has not delivered. */
-  clearQueue?(): unknown
-  sendCustomMessage?(message: { customType: string; content: string; display: boolean; details: unknown }, options: { triggerTurn: boolean }): Promise<void>
-  abort(): Promise<void>
-  dispose(): void
-}
-
-export interface ToolGate {
-  /** Resolves to a block reason, or null to let the call run. */
-  check(toolName: string, input: unknown): Promise<string | null>
-  /** Makes these tools ask before each call. Used for tools an extension brought, which no one switched on by name. */
-  ask?(toolNames: readonly string[]): void
-}
-
-export type SessionFactory = (input: {
-  params: TurnParams
-  /** Pi's own tools and the custom tools switched on for this turn, in order. */
-  allow: string[]
-  gate: ToolGate
-  /** Custom tools already bound to this run. */
-  tools: ToolSpec[]
-  runtime: () => Promise<ModelRuntime>
-  /** Where a loaded extension's dialogs and notices go. Without it extensions have no interface. */
-  extensions?: ExtensionHost
-}) => Promise<PiSessionLike>
-
-/** A one-line description of a tool call, for an approval request or the activity list. */
-export function summarize(input: unknown, toolName = ''): string {
-  if (input && typeof input === 'object') {
-    const record = input as Record<string, unknown>
-    // Typed text is never recorded, only its length.
-    if (/_type$/.test(toolName) && typeof record.text === 'string') return `${String(record.selector ?? record.app ?? '')} (${record.text.length} characters)`.trim()
-    const primary = record.command ?? record.path ?? record.file_path ?? record.query
-    if (typeof primary === 'string') return primary.slice(0, 200)
-  }
-  return JSON.stringify(input ?? {}).slice(0, 200)
-}
-
-function assistantText(message: { content?: Array<{ type: string; text?: string }> }): string {
-  return (message.content ?? []).filter((part) => part.type === 'text' && typeof part.text === 'string').map((part) => part.text).join('')
-}
-
-/** How much text a tool handed back to the model: what its result adds to every later request. */
-export function resultSize(result: unknown): number | null {
-  if (typeof result === 'string') return result.length
-  const content = (result as { content?: unknown } | null | undefined)?.content
-  if (!Array.isArray(content)) return null
-  return content.reduce((total: number, part: { type?: string; text?: unknown }) => total + (part?.type === 'text' && typeof part.text === 'string' ? part.text.length : 0), 0)
-}
-
-const MAX_EVIDENCE_CHARS = 24_000
-const MAX_SYSTEM_PROMPT_CHARS = 100_000
-const MAX_TOOL_SPECS = 120
-
-function limitedText(value: string, maximum = MAX_EVIDENCE_CHARS): { text: string; truncated: boolean } {
-  const characters = Array.from(value)
-  const marker = '\n…[truncated]'
-  return characters.length > maximum ? { text: `${characters.slice(0, Math.max(0, maximum - Array.from(marker).length)).join('')}${marker}`, truncated: true } : { text: value, truncated: false }
-}
-
-function evidenceText(value: unknown): string | null {
-  if (typeof value === 'string') return value
-  if (value === undefined) return null
-  const content = (value as { content?: unknown } | null)?.content
-  if (Array.isArray(content)) {
-    const parts = content.flatMap((part) => {
-      if (!part || typeof part !== 'object') return []
-      const item = part as { type?: unknown; text?: unknown }
-      if (item.type === 'text' && typeof item.text === 'string') return [item.text]
-      return item.type === 'image' ? ['[image content omitted]'] : []
-    })
-    if (parts.length) return parts.join('\n')
-  }
-  try {
-    return JSON.stringify(value, null, 2) ?? String(value)
-  } catch {
-    return String(value)
-  }
-}
-
-/** Pi keeps provider-only metadata in `details`; only a bounded, generic reference enters the event. */
-function toolAttachmentRefs(result: unknown) {
-  const details = (result as { details?: unknown } | null | undefined)?.details
-  const refs = details && typeof details === 'object' ? (details as { attachments?: unknown }).attachments : undefined
-  const parsed = toolAttachmentRefsSchema.safeParse(refs)
-  return parsed.success && parsed.data.length ? parsed.data : undefined
-}
-
-function boundedSchema(value: unknown, budget: { remaining: number }, depth = 0): { value: unknown; truncated: boolean } {
-  if (budget.remaining <= 0 || depth > 12) return { value: '[truncated]', truncated: true }
-  if (typeof value === 'string') {
-    const { text, truncated } = limitedText(value, Math.min(MAX_EVIDENCE_CHARS, budget.remaining))
-    budget.remaining -= Array.from(text).length
-    return { value: text, truncated }
-  }
-  if (Array.isArray(value)) {
-    const values: unknown[] = []
-    let truncated = value.length > 200
-    for (const item of value.slice(0, 200)) {
-      const next = boundedSchema(item, budget, depth + 1)
-      values.push(next.value)
-      truncated ||= next.truncated
-      if (budget.remaining <= 0) break
-    }
-    return { value: values, truncated: truncated || values.length < value.length }
-  }
-  if (value && typeof value === 'object') {
-    const entries = Object.entries(value as Record<string, unknown>)
-    const output: Record<string, unknown> = {}
-    let truncated = entries.length > 200
-    for (const [key, item] of entries.slice(0, 200)) {
-      if (budget.remaining <= 0) {
-        truncated = true
-        break
-      }
-      const next = boundedSchema(item, budget, depth + 1)
-      output[key] = next.value
-      truncated ||= next.truncated
-    }
-    return { value: output, truncated }
-  }
-  return { value: value ?? null, truncated: false }
-}
-
-function contextToolSpecs(session: PiSessionLike): { tools: Array<{ name: string; description: string; parameters: unknown }>; truncated: boolean } {
-  const allTools = session.getAllTools?.() ?? []
-  const activeNames = session.getActiveToolNames?.()
-  const source = activeNames ? allTools.filter((tool) => activeNames.includes(tool.name)) : allTools
-  const tools = source.slice(0, MAX_TOOL_SPECS).map((tool) => {
-    const description = limitedText(tool.description ?? '', 2_000)
-    const parameters = boundedSchema(tool.parameters ?? {}, { remaining: 4_000 })
-    return { spec: { name: tool.name, description: description.text, parameters: parameters.value }, truncated: description.truncated || parameters.truncated }
-  })
-  return { tools: tools.map((entry) => entry.spec), truncated: source.length > MAX_TOOL_SPECS || tools.some((entry) => entry.truncated) }
-}
-
-const numberField = (event: Record<string, unknown>, key: string, fallback = 0): number => (typeof event[key] === 'number' && Number.isFinite(event[key]) ? (event[key] as number) : fallback)
-const stringField = (event: Record<string, unknown>, key: string, fallback = ''): string => (typeof event[key] === 'string' ? (event[key] as string) : fallback)
-
-/** Streams one request through a Pi session, translating events for the run. */
-export async function runTurn(run: ActiveRun, session: PiSessionLike, params: TurnParams): Promise<void> {
-  let messageIndex = 0
-  let requestIndex = 0
-  let currentMessageId: string | null = null
-  let lastError: string | null = null
-  let aborted = false
-  const usage = { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0, costUsd: 0, requests: 0 }
-  let usageReported = false
-  // Only some providers report a reasoning split; absent stays absent rather than zero.
-  let reasoningTokens: number | undefined
-  // One model request runs from a turn's start to its assistant message's end.
-  let requestStartedAt: number | null = null
-  let firstOutputAt: number | null = null
-  let costReported = false
-  const toolStartedAt = new Map<string, number>()
-
-  const systemPrompt = limitedText(session.systemPrompt ?? params.system, MAX_SYSTEM_PROMPT_CHARS)
-  const contextUpdate = limitedText(params.update?.content ?? '', MAX_SYSTEM_PROMPT_CHARS)
-  const toolSpecs = contextToolSpecs(session)
-  run.emit('context.snapshot', {
-    systemPrompt: systemPrompt.text,
-    ...(contextUpdate.text ? { contextUpdate: contextUpdate.text } : {}),
-    tools: toolSpecs.tools,
-    ...(systemPrompt.truncated ? { systemPromptTruncated: true } : {}),
-    ...(contextUpdate.truncated ? { contextUpdateTruncated: true } : {}),
-    ...(toolSpecs.truncated ? { toolsTruncated: true } : {})
-  })
-
-  run.onInterrupt(async () => {
-    aborted = true
-    await session.abort()
-  })
-
-  // Steers handed to Pi and not yet delivered, oldest first. Pi delivers them in that order, after
-  // the prompt's own user message, which is the first user message it starts.
-  const pendingSteers: string[] = []
-  let accepting = false
-  let promptStarted = false
-  const forgetSteer = (text: string): void => {
-    const index = pendingSteers.lastIndexOf(text)
-    if (index >= 0) pendingSteers.splice(index, 1)
-  }
-  run.onSteer(async (text) => {
-    if (!accepting || !session.steer) throw new HarnessError('run_not_active', 'This reply is not accepting messages.')
-    pendingSteers.push(text)
-    try {
-      if ((await session.steer(text)) === 'handled') forgetSteer(text)
-    } catch (error) {
-      forgetSteer(text)
-      throw error
-    }
-  })
-
-  const unsubscribe = session.subscribe((event) => {
-    switch (event.type) {
-      case 'message_start': {
-        const { message } = event as Extract<PiEvent, { type: 'message_start' }>
-        if (message.role === 'assistant') currentMessageId = `${run.runId}:m${messageIndex++}`
-        else if (message.role === 'user' && promptStarted) {
-          const text = pendingSteers.shift()
-          if (text !== undefined) run.emit('message.steered', { text })
-        } else if (message.role === 'user') promptStarted = true
-        break
-      }
-      case 'turn_start': {
-        requestStartedAt = Date.now()
-        firstOutputAt = null
-        break
-      }
-      case 'message_update': {
-        const update = event as Extract<PiEvent, { type: 'message_update' }>
-        if (update.message.role === 'assistant') firstOutputAt ??= Date.now()
-        if (update.message.role === 'assistant' && update.assistantMessageEvent.type === 'text_delta' && update.assistantMessageEvent.delta) {
-          currentMessageId ??= `${run.runId}:m${messageIndex++}`
-          run.emit('message.delta', { messageId: currentMessageId, text: update.assistantMessageEvent.delta })
-        }
-        break
-      }
-      case 'message_end': {
-        const { message } = event as Extract<PiEvent, { type: 'message_end' }>
-        if (message.role !== 'assistant') break
-        requestIndex += 1
-        const messageId = currentMessageId ?? `${run.runId}:m${messageIndex++}`
-        currentMessageId = null
-        const text = assistantText(message)
-        if (text) run.emit('message.completed', { messageId, role: 'assistant', text })
-        const reasoningSummary = completedReasoningSummary(message)
-        if (message.usage || reasoningSummary) {
-          const reported = message.usage
-          if (reported) {
-            usageReported = true
-            usage.inputTokens += reported.input ?? 0
-            usage.outputTokens += reported.output ?? 0
-            usage.cacheReadTokens += reported.cacheRead ?? 0
-            usage.cacheWriteTokens += reported.cacheWrite ?? 0
-            usage.costUsd += reported.cost?.total ?? 0
-            if (typeof reported.reasoning === 'number') reasoningTokens = (reasoningTokens ?? 0) + reported.reasoning
-          }
-          usage.requests = requestIndex
-          const cost = reported?.cost?.total
-          if (typeof cost === 'number') costReported = true
-          const ended = Date.now()
-          const request: UsageRequest = {
-            index: requestIndex,
-            ...(message.responseId ? { responseId: message.responseId } : {}),
-            ...(message.model ? { model: message.model } : {}),
-            ...(message.provider ? { provider: message.provider } : {}),
-            ...(reported
-              ? {
-                  inputTokens: reported.input ?? 0,
-                  cacheReadTokens: reported.cacheRead ?? 0,
-                  cacheWriteTokens: reported.cacheWrite ?? 0,
-                  outputTokens: reported.output ?? 0,
-                  ...(typeof reported.reasoning === 'number' ? { reasoningTokens: reported.reasoning } : {})
-                }
-              : {}),
-            ...(reasoningSummary ? { reasoningSummary } : {}),
-            ...(typeof cost === 'number' ? { costUsd: cost, costSource: 'harness' as const } : {}),
-            ...(requestStartedAt === null ? {} : { durationMs: ended - requestStartedAt }),
-            ...(requestStartedAt === null || firstOutputAt === null ? {} : { ttftMs: Math.max(0, firstOutputAt - requestStartedAt) }),
-            ...(message.stopReason ? { stopReason: message.stopReason } : {})
-          }
-          requestStartedAt = null
-          const contextWindow = session.model?.contextWindow
-          const { costUsd, ...tokens } = usage
-          run.emit('usage.updated', {
-            ...(usageReported ? tokens : { requests: requestIndex }),
-            // A cost nobody reported is unknown, not zero.
-            ...(usageReported && costReported ? { costUsd, costSource: 'harness' as const } : {}),
-            ...(reasoningTokens === undefined ? {} : { reasoningTokens }),
-            ...(reported ? { contextTokens: (reported.input ?? 0) + (reported.cacheRead ?? 0) + (reported.cacheWrite ?? 0) } : {}),
-            ...(contextWindow ? { contextWindow } : {}),
-            ...(message.model ? { model: message.model } : {}),
-            ...(message.provider ? { provider: message.provider } : {}),
-            request
-          })
-        }
-        if (message.stopReason === 'error' && message.errorMessage) {
-          lastError = message.errorMessage
-          const category = classifyMessage(message.errorMessage)
-          if (category) run.emit('account.status', { accountId: params.account.id, category, message: message.errorMessage.slice(0, 500) })
-        }
-        if (message.stopReason === 'aborted') aborted = true
-        break
-      }
-      case 'tool_execution_start': {
-        const tool = event as Extract<PiEvent, { type: 'tool_execution_start' }>
-        toolStartedAt.set(tool.toolCallId, Date.now())
-        const input = evidenceText(tool.args)
-        const boundedInput = input === null ? null : limitedText(input)
-        run.emit('tool.started', {
-          toolCallId: tool.toolCallId,
-          name: tool.toolName,
-          summary: summarize(tool.args, tool.toolName),
-          ...(boundedInput ? { input: boundedInput.text, ...(boundedInput.truncated ? { inputTruncated: true } : {}) } : {})
-        })
-        break
-      }
-      case 'tool_execution_end': {
-        const tool = event as Extract<PiEvent, { type: 'tool_execution_end' }>
-        const started = toolStartedAt.get(tool.toolCallId)
-        toolStartedAt.delete(tool.toolCallId)
-        const resultChars = resultSize(tool.result)
-        const output = evidenceText(tool.result)
-        const boundedOutput = output === null ? null : limitedText(output)
-        const attachments = toolAttachmentRefs(tool.result)
-        run.emit('tool.completed', {
-          toolCallId: tool.toolCallId,
-          name: tool.toolName,
-          ok: !tool.isError,
-          ...(started === undefined ? {} : { durationMs: Date.now() - started }),
-          ...(resultChars === null ? {} : { resultChars }),
-          ...(attachments ? { attachments } : {}),
-          ...(boundedOutput ? { output: boundedOutput.text, ...(boundedOutput.truncated ? { outputTruncated: true } : {}) } : {})
-        })
-        break
-      }
-      case 'auto_retry_start': {
-        const retry = event as unknown as Record<string, unknown>
-        run.emit('retry.started', {
-          attempt: numberField(retry, 'attempt', 1),
-          maxAttempts: numberField(retry, 'maxAttempts', 1),
-          delayMs: numberField(retry, 'delayMs'),
-          ...(stringField(retry, 'errorMessage') ? { error: stringField(retry, 'errorMessage').slice(0, 1000) } : {})
-        })
-        break
-      }
-      case 'auto_retry_end': {
-        const retry = event as unknown as Record<string, unknown>
-        run.emit('retry.ended', { attempt: numberField(retry, 'attempt', 1), success: retry.success === true, ...(stringField(retry, 'finalError') ? { error: stringField(retry, 'finalError').slice(0, 1000) } : {}) })
-        break
-      }
-      case 'compaction_start': {
-        run.emit('compaction.started', { reason: stringField(event as unknown as Record<string, unknown>, 'reason', 'context limit') })
-        break
-      }
-      case 'compaction_end': {
-        const compaction = event as unknown as Record<string, unknown>
-        const summary = evidenceText(compaction.result)
-        const boundedSummary = summary ? limitedText(summary) : null
-        run.emit('compaction.ended', {
-          reason: stringField(compaction, 'reason', 'context limit'),
-          aborted: compaction.aborted === true,
-          ...(typeof compaction.willRetry === 'boolean' ? { willRetry: compaction.willRetry } : {}),
-          ...(stringField(compaction, 'errorMessage') ? { error: stringField(compaction, 'errorMessage').slice(0, 1000) } : {}),
-          ...(boundedSummary ? { summary: boundedSummary.text, ...(boundedSummary.truncated ? { summaryTruncated: true } : {}) } : {})
-        })
-        break
-      }
-    }
-  })
-
-  try {
-    if (params.update) {
-      if (!session.sendCustomMessage) throw new HarnessError('provider_error', 'The Pi session cannot receive the compiled context update.')
-      // The delivered snapshot is saved with the message, so the next turn compares against what Pi really holds.
-      await session.sendCustomMessage({ customType: CONTEXT_MESSAGE_TYPE, content: params.update.content, display: false, details: { [CONTEXT_SNAPSHOT_KEY]: params.update.snapshot } }, { triggerTurn: false })
-    }
-    const command = /^\/(\S+)/.exec(params.text)?.[1]
-    const extensionCommand = command && session.extensionCommands?.includes(command)
-    if (params.preamble && extensionCommand) {
-      if (!session.sendCustomMessage) throw new HarnessError('provider_error', 'The Pi session cannot receive the command context.')
-      await session.sendCustomMessage({ customType: 'xingular-preamble', content: params.preamble, display: false, details: {} }, { triggerTurn: false })
-    }
-    const prompt = params.preamble && !extensionCommand ? `${params.preamble}\n\n${params.text}` : params.text
-    const images = (params.images ?? []).map((image) => ({ type: 'image', mimeType: image.mediaType, data: image.data }))
-    accepting = true
-    try {
-      await session.prompt(prompt, images.length ? { images } : undefined)
-    } finally {
-      // A message Pi has not delivered by now never will be; the caller sends it again as a new reply.
-      accepting = false
-      session.clearQueue?.()
-    }
-    if (!aborted && !lastError) await params.settle?.()
-    if (aborted) run.finish('interrupted')
-    else if (lastError) run.finish('failed', { code: 'provider_error', message: lastError })
-    else run.finish('completed')
-  } catch (error) {
-    if (aborted) run.finish('interrupted')
-    else run.finish('failed', { code: 'provider_error', message: error instanceof Error ? error.message : String(error) })
-  } finally {
-    unsubscribe()
-    session.dispose()
-  }
-}
-
-/**
- * Loads what a session may use besides its tools: Pi's context files, the registry's skills and
- * prompts, and what the harness found for it. `gate` is loaded after every extension on disk.
- */
-export async function loadResources(pi: typeof import('@earendil-works/pi-coding-agent'), params: Pick<TurnParams, 'cwd' | 'account' | 'automatic' | 'resources' | 'plugins' | 'system' | 'inline'>, gate: unknown, automaticSettings?: SettingsManager) {
-  const loading = params.automatic ? null : ((await params.plugins?.loading()) ?? null)
-  const resourceLoader = new pi.DefaultResourceLoader({
-    ...(automaticSettings ? { settingsManager: automaticSettings, noExtensions: true, noContextFiles: true } : {}),
-    // The loader gets empty settings and no discovery of its own: it loads the paths below and
-    // nothing else. The session still reads the account's real settings for everything but resources.
-    ...(loading ? { settingsManager: pi.SettingsManager.inMemory({}), noExtensions: true, noSkills: true, noPromptTemplates: true, noThemes: true, additionalExtensionPaths: loading.extensionPaths } : {}),
-    cwd: params.cwd,
-    agentDir: params.account.configDir,
-    // Inline extensions load after the ones on disk, and the gate after all of them, so it sees
-    // what every plugin made of a call.
-    extensionFactories: [...(params.inline ?? []).map((extension) => ({ name: extension.name, factory: extension.factory as never, hidden: true })), { name: 'xagent-approvals', factory: gate as never, hidden: true }],
-    additionalSkillPaths: [...(params.resources?.skillPaths ?? []), ...(loading?.skillPaths ?? [])],
-    additionalPromptTemplatePaths: [...(params.resources?.promptPaths ?? []), ...(loading?.promptPaths ?? [])],
-    // The compiler writes one prompt; nothing else is appended here.
-    appendSystemPromptOverride: (base) => [...base, ...(params.system.trim() ? [params.system] : [])]
-  })
-  await resourceLoader.reload()
-  if (loading) {
-    const records = registeredBy(resourceLoader).map((record) => ({ ...record, hash: registrationHash(loading, record.path) }))
-    const publish = () => params.plugins?.loaded(records)
-    observeResources(pi, resourceLoader, loading, records, publish)
-    publish()
-  }
-  return resourceLoader
-}
-
-/** What each extension on disk registered when it was loaded. The harness's own gate is not one of them. */
-export function registeredBy(loader: { getExtensions(): { extensions: readonly unknown[] } }): Registered[] {
-  const names = (map: { keys(): Iterable<unknown> } | undefined): string[] => (map ? [...map.keys()].map(String) : [])
-  type Loaded = { hidden?: boolean; path: string; resolvedPath?: string } & Record<'handlers' | 'tools' | 'commands' | 'flags' | 'shortcuts', { keys(): Iterable<unknown> } | undefined>
-  return (loader.getExtensions().extensions as Loaded[])
-    .filter((extension) => !extension.hidden)
-    .map((extension) => ({ path: extension.resolvedPath || extension.path, hooks: names(extension.handlers), tools: names(extension.tools), commands: names(extension.commands), flags: names(extension.flags), shortcuts: names(extension.shortcuts) }))
-}
-
-/** Opens a Pi session for one turn: the account's runtime, the compiled prompt, and the gated tools. */
-export const piSessionFactory: SessionFactory = async ({ params, allow, gate, tools, runtime: loadRuntime, extensions: host }) => {
-  const pi = await import('@earendil-works/pi-coding-agent')
-  const { Type } = await import('typebox')
-  const runtime = await loadRuntime()
-
-  let model: unknown
-  let thinkingLevel: CreateAgentSessionOptions['thinkingLevel'] = params.effort ?? undefined
-  if (params.model) {
-    const resolved = pi.resolveCliModel({ cliModel: params.model, modelRuntime: runtime })
-    if (resolved.error || !resolved.model) throw new HarnessError('provider_unavailable', resolved.error ?? `Model ${params.model} is not available.`)
-    model = resolved.model
-    thinkingLevel ??= resolved.thinkingLevel
-  }
-
-  const gatedExtension = (api: { on: (event: 'tool_call', handler: (event: { toolName: string; input: unknown }) => Promise<unknown>) => void }) => {
-    api.on('tool_call', async (event) => {
-      const reason = await gate.check(event.toolName, event.input)
-      return reason ? { block: true, reason } : undefined
-    })
-  }
-
-  const agentDir = params.account.configDir
-  const automaticSettings = params.automatic ? pi.SettingsManager.inMemory({}) : undefined
-  const resourceLoader = await loadResources(pi, params, gatedExtension, automaticSettings)
-  const loaded = registeredBy(resourceLoader)
-  // A tool an extension brought is offered to the model, and asks before every call: the person
-  // trusted the code to load, and still decides each thing it does through a tool.
-  const extensionTools = [...new Set(loaded.flatMap((extension) => extension.tools))].filter((name) => !allow.includes(name) && !params.restrictTools)
-  gate.ask?.([...new Set(loaded.flatMap((extension) => extension.tools))])
-
-  let supportsImageInput = false
-  const customTools = tools
-    .filter((tool) => allow.includes(tool.name))
-    .map((spec) =>
-      pi.defineTool({
-        name: spec.name,
-        label: spec.label,
-        description: spec.description,
-        parameters: spec.parameters(Type) as never,
-        execute: async (_toolCallId, input) => {
-          const result = await spec.execute(input as Record<string, unknown>)
-          const output = typeof result === 'string' ? { text: result } : result
-          if (output.image && !supportsImageInput) throw new HarnessError('image_input_unsupported', 'This model cannot inspect images. Choose a model that supports image input.')
-          return {
-            content: [{ type: 'text', text: output.text }, ...(output.image ? [{ type: 'image', data: output.image.data, mimeType: output.image.mimeType }] : [])] as never,
-            details: { ...output.details, ...(output.attachments?.length ? { attachments: output.attachments } : {}) }
-          }
-        }
-      })
-    )
-
-  const { session } = await pi.createAgentSession({
-    cwd: params.cwd,
-    agentDir,
-    modelRuntime: runtime,
-    ...(model ? { model: model as never } : {}),
-    ...(thinkingLevel ? { thinkingLevel } : {}),
-    tools: [...allow, ...extensionTools],
-    customTools: customTools as never,
-    resourceLoader,
-    ...(automaticSettings ? { settingsManager: automaticSettings } : {}),
-    sessionManager: params.historyFile ? pi.SessionManager.open(params.historyFile, params.sessionDir, params.cwd) : pi.SessionManager.continueRecent(params.cwd, params.sessionDir)
-  })
-  if (loaded.length && host) {
-    // Without this an extension never hears that its session started and has nobody to ask.
-    await session.bindExtensions({
-      uiContext: extensionUi(host),
-      mode: 'rpc',
-      onError: (error) => host.notice({ kind: 'error', text: `${error.event}: ${error.error}`.slice(0, 1000), extension: error.extensionPath })
-    })
-  }
-  const piSession = session as unknown as PiSessionLike & { agent: { streamFunction: typeof runtime.streamSimple } }
-  piSession.extensionCommands = loaded.flatMap((extension) => extension.commands)
-  supportsImageInput = piSession.model?.input.includes('image') ?? false
-  const streamAgent = piSession.agent
-  const originalStream = streamAgent.streamFunction
-  streamAgent.streamFunction = (streamModel, context, options) => {
-    if (!streamModel.reasoning || !REASONING_SUMMARY_APIS.has(streamModel.api)) return originalStream(streamModel, context, options)
-    return originalStream(streamModel, context, {
-      ...options,
-      onPayload: async (payload, requestModel) => {
-        const overridden = await options?.onPayload?.(payload, requestModel)
-        const requested = requestConciseReasoningSummary(overridden ?? payload)
-        return requested.requested || overridden !== undefined ? requested.payload : undefined
-      }
-    })
-  }
-  return piSession
-}

package/src/sessions/runtimeResources.test.ts

@@ -1,61 +0,0 @@
-import { mkdtempSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { afterEach, expect, it } from 'vitest'
-
-import { memorySecretStore } from '../accounts/secrets'
-import { createHarness, type Harness } from '../harness'
-import { methods } from '../server/methods'
-import { writeFile } from '../../tests/helpers'
-import { fauxModel } from '../../tests/faux'
-import type { Inventory, Plugin } from '../plugins/types'
-import { piSessionFactory } from './runner'
-
-const open: Harness[] = []
-afterEach(async () => { for (const harness of open.splice(0)) await harness.close() })
-
-it('attributes discovered resources and tools, respects caller switches, and discards stale observations', async () => {
-  const base = mkdtempSync(join(tmpdir(), 'runtime-resources-'))
-  const harness = createHarness({ dataRoot: join(base, 'data'), stateDir: join(base, 'state'), secrets: memorySecretStore() })
-  open.push(harness)
-  harness.accounts.create('Main', 'apiKey')
-  const account = harness.accounts.context(harness.accounts.resolve(null, null))
-  await fauxModel(harness)
-  const skill = join(base, 'resources/audit/SKILL.md')
-  const prompt = join(base, 'resources/review.md')
-  writeFile(skill, '---\nname: runtime-audit\ndescription: Audit at runtime.\n---\nAudit instructions.\n')
-  writeFile(prompt, '---\nname: runtime-review\ndescription: Review at runtime.\n---\nReview instructions.\n')
-  const extension = join(account.configDir, 'extensions/kit.ts')
-  writeFile(extension, `import { Type } from 'typebox'
-export default function(pi) {
- pi.registerTool({ name: 'kit_scan', label: 'Scan', description: 'Scan', parameters: Type.Object({}), async execute() { return { content: [], details: {} } } })
- pi.on('resources_discover', () => ({ skillPaths: [${JSON.stringify(skill)}], promptPaths: [${JSON.stringify(prompt)}] }))
-}`)
-  const table = methods(harness)
-  const load = async (agentId: string) => piSessionFactory({ params: { runId: 'r', cwd: base, sessionDir: join(base, agentId), historyFile: null, model: null, text: '', account, system: '', update: null,
-    plugins: { loading: () => harness.plugins.loading({ cwd: base, agentDir: account.configDir, caller: { agentId } }), loaded: (records) => harness.plugins.loaded(records) } },
-    allow: ['read'], tools: [], gate: { check: async () => null }, runtime: () => harness.accounts.runtime(account), extensions: { ask: async () => ({ selected: [] }), notice: () => {} } })
-  const first = await load('a1')
-  expect(first.systemPrompt).toContain('runtime-audit')
-  first.dispose()
-  const list = await table['plugins.list']({ cwd: base }) as Plugin[]
-  expect(list.find((plugin) => plugin.id === 'shared')?.contributions).toEqual(expect.arrayContaining([
-    expect.objectContaining({ kind: 'tool', name: 'kit_scan', state: 'on' }),
-    expect.objectContaining({ kind: 'skill', name: 'runtime-audit', path: skill, state: 'on' }),
-    expect.objectContaining({ kind: 'command', name: 'runtime-review', path: prompt })
-  ]))
-  await table['plugins.detach']({ cwd: base, id: 'shared/skill/runtime-audit', scope: { agentId: 'a1' } })
-  const off = await load('a1')
-  expect(off.systemPrompt).not.toContain('runtime-audit')
-  off.dispose()
-  const on = await load('a2')
-  expect(on.systemPrompt).toContain('runtime-audit')
-  on.dispose()
-  const inventory = await table['plugins.inventory']({ cwd: base, context: { agentId: 'a2' }, tools: ['read', 'kit_scan'] }) as Inventory
-  expect(inventory.items).toEqual(expect.arrayContaining([expect.objectContaining({ pluginId: 'shared', kind: 'tool', name: 'kit_scan' }), expect.objectContaining({ pluginId: 'shared', kind: 'skill', name: 'runtime-audit', chars: expect.any(Number) })]))
-  expect(inventory.unattributed).toEqual([])
-  expect(inventory.items.filter((entry) => entry.kind === 'tool' && entry.name === 'kit_scan')).toHaveLength(1)
-  writeFile(extension, 'export default function() {}\n')
-  const changed = await table['plugins.list']({ cwd: base }) as Plugin[]
-  expect(changed.find((plugin) => plugin.id === 'shared')?.contributions.some((item) => item.name === 'runtime-audit' || item.name === 'kit_scan')).toBe(false)
-})