@xingular/harness 2.0.0 → 2.0.1-unstable

package/src/sessions/contracts.ts

@@ -1,336 +0,0 @@
-// Run records and the run-event stream: the one contract every session shares. Every event is
-// validated against these schemas before it is persisted or handed to a listener.
-import { z } from 'zod'
-
-export const runStatusSchema = z.enum(['queued', 'running', 'waiting_for_approval', 'waiting_for_input', 'interrupted', 'completed', 'failed'])
-export type RunStatus = z.infer<typeof runStatusSchema>
-
-export const runEventTypeSchema = z.enum([
-  'started',
-  'context.snapshot',
-  'message.delta',
-  'message.completed',
-  'message.steered',
-  'tool.started',
-  'tool.completed',
-  'retry.started',
-  'retry.ended',
-  'compaction.started',
-  'compaction.ended',
-  'approval.requested',
-  'approval.resolved',
-  'question.requested',
-  'question.answered',
-  'extension.notice',
-  'reaction.added',
-  'agent.message',
-  'artifact.added',
-  'file.changed',
-  'usage.updated',
-  'account.status',
-  'status.changed',
-  'failed',
-  'completed'
-])
-export type RunEventType = z.infer<typeof runEventTypeSchema>
-
-const messageDeltaPayload = z.object({ messageId: z.string(), text: z.string() })
-const messageCompletedPayload = z.object({ messageId: z.string(), role: z.enum(['user', 'assistant']), text: z.string() })
-/** A message the person sent into the run while it was going; the model reads it from its next request on. */
-const messageSteeredPayload = z.object({ text: z.string() })
-const contextSnapshotPayload = z.object({
-  systemPrompt: z.string().max(100_000),
-  contextUpdate: z.string().max(100_000).optional(),
-  tools: z.array(z.object({ name: z.string(), description: z.string().max(2_000), parameters: z.unknown() })).max(120),
-  systemPromptTruncated: z.boolean().optional(),
-  contextUpdateTruncated: z.boolean().optional(),
-  toolsTruncated: z.boolean().optional()
-})
-/** Generic reference to content a provider stores outside the run-event stream. */
-export const toolAttachmentRefSchema = z.object({
-  id: z.string().min(1).max(300),
-  name: z.string().min(1).max(500),
-  mimeType: z.string().min(1).max(100)
-}).strict()
-export const toolAttachmentRefsSchema = z.array(toolAttachmentRefSchema).max(16)
-export type ToolAttachmentRef = z.infer<typeof toolAttachmentRefSchema>
-
-const toolPayload = z.object({
-  toolCallId: z.string(),
-  name: z.string(),
-  summary: z.string().max(200).optional(),
-  input: z.string().max(24_000).optional(),
-  inputTruncated: z.boolean().optional(),
-  output: z.string().max(24_000).optional(),
-  outputTruncated: z.boolean().optional(),
-  ok: z.boolean().optional(),
-  /** On `tool.completed`: how long the call ran, and the size of what it returned to the model. */
-  durationMs: z.number().optional(),
-  resultChars: z.number().optional(),
-  /** Opaque attachment references. Content stays outside the run event stream. */
-  attachments: toolAttachmentRefsSchema.optional()
-})
-const retryStartedPayload = z.object({ attempt: z.number(), maxAttempts: z.number(), delayMs: z.number(), error: z.string().max(1_000).optional() })
-const retryEndedPayload = z.object({ attempt: z.number(), success: z.boolean(), error: z.string().max(1_000).optional() })
-const compactionStartedPayload = z.object({ reason: z.string() })
-const compactionEndedPayload = z.object({
-  reason: z.string(),
-  aborted: z.boolean(),
-  willRetry: z.boolean().optional(),
-  error: z.string().max(1_000).optional(),
-  tokensBefore: z.number().optional(),
-  tokensAfter: z.number().optional(),
-  summary: z.string().max(24_000).optional(),
-  summaryTruncated: z.boolean().optional()
-})
-/** Granted without asking: the standing switch, a remembered tool, or the embedding application's own scope. */
-const approvalAutomaticSchema = z.enum(['always', 'remembered', 'scope'])
-const approvalRequestedPayload = z.object({
-  approvalId: z.string(),
-  target: z.string(),
-  action: z.string(),
-  screenshotRef: z.string().optional(),
-  operation: z.object({ tool: z.string(), args: z.unknown() }).optional(),
-  /** A tool the user may choose to always allow for this session. */
-  rememberable: z.boolean().optional(),
-  /** Set when the request was granted as it was made, so nobody is waiting on it. */
-  automatic: approvalAutomaticSchema.optional()
-})
-const approvalResolvedPayload = z.object({ approvalId: z.string(), decision: z.enum(['approved', 'denied', 'native']), automatic: approvalAutomaticSchema.optional() })
-export const questionOptionSchema = z.object({ label: z.string().min(1), description: z.string().optional() })
-export type QuestionOption = z.infer<typeof questionOptionSchema>
-const questionBatchFields = {
-  batchId: z.string().min(1).optional(),
-  batchIndex: z.number().int().min(1).max(5).optional(),
-  batchCount: z.number().int().min(1).max(5).optional()
-}
-const questionBatchRefinement = <T extends { batchId?: string; batchIndex?: number; batchCount?: number }>(value: T, context: z.RefinementCtx): void => {
-  const fields = [value.batchId, value.batchIndex, value.batchCount]
-  if (fields.some((field) => field !== undefined) && fields.some((field) => field === undefined)) {
-    context.addIssue({ code: z.ZodIssueCode.custom, message: 'Question batch fields must be supplied together.' })
-  }
-  if (value.batchIndex !== undefined && value.batchCount !== undefined && value.batchIndex > value.batchCount) {
-    context.addIssue({ code: z.ZodIssueCode.custom, message: 'Question batch index cannot exceed its count.' })
-  }
-}
-const questionRequestedPayload = z.object({
-  questionId: z.string(),
-  question: z.string().min(1),
-  summary: z.string().min(1).max(100).optional(),
-  options: z.array(questionOptionSchema),
-  multiSelect: z.boolean(),
-  allowText: z.boolean(),
-  userOnly: z.boolean().optional(),
-  ...questionBatchFields
-}).superRefine(questionBatchRefinement)
-const questionAnsweredPayload = z.object({
-  questionId: z.string(),
-  selected: z.array(z.string()),
-  text: z.string().optional(),
-  notes: z.record(z.string(), z.string().max(10_000)).optional(),
-  ...questionBatchFields
-}).superRefine(questionBatchRefinement)
-/** A short emoji sequence, never words or numbers. */
-const reactionAddedPayload = z.object({ emoji: z.string().min(1).refine((text) => Buffer.byteLength(text) <= 16 && !/[A-Za-z0-9\s]/.test(text)) })
-/** A message this run's agent sent to (`to`) or received back from (`from`) another agent. */
-const agentMessagePayload = z.object({ direction: z.enum(['to', 'from']), agentId: z.string(), agentName: z.string(), text: z.string() })
-/** A status line, a notification or an error from a Pi extension loaded in the session. */
-const extensionNoticePayload = z.object({
-  kind: z.enum(['notify', 'status', 'widget', 'title', 'error']),
-  level: z.enum(['info', 'warning', 'error']).optional(),
-  key: z.string().optional(),
-  text: z.string(),
-  extension: z.string().optional()
-})
-const artifactPayload = z.object({ artifactId: z.string(), name: z.string(), file: z.unknown().optional() })
-const fileChangedPayload = z.object({ path: z.string(), change: z.enum(['added', 'modified', 'deleted']) })
-/** Where a cost figure comes from: Pi reported it, or the tokens were priced at list rates. */
-export const costSourceSchema = z.enum(['harness', 'estimate', 'mixed'])
-export type CostSource = z.infer<typeof costSourceSchema>
-/** What one model request used. Token fields mean the same as on the run's totals. */
-export const usageRequestSchema = z.object({
-  /** Position in the run, from 1. */
-  index: z.number(),
-  responseId: z.string().optional(),
-  model: z.string().optional(),
-  provider: z.string().optional(),
-  inputTokens: z.number().optional(),
-  cacheReadTokens: z.number().optional(),
-  cacheWriteTokens: z.number().optional(),
-  outputTokens: z.number().optional(),
-  reasoningTokens: z.number().optional(),
-  costUsd: z.number().optional(),
-  costSource: z.enum(['harness', 'estimate']).optional(),
-  /** Separate provider-supplied summary; never generic private thinking content. */
-  reasoningSummary: z.string().max(4_000).optional(),
-  /** From sending the request to the end of the response, and to its first output. */
-  durationMs: z.number().optional(),
-  ttftMs: z.number().optional(),
-  stopReason: z.string().optional()
-})
-export type UsageRequest = z.infer<typeof usageRequestSchema>
-/** Token totals so far in this run (cumulative for the run, not the native session). */
-export const usagePayloadSchema = z.object({
-  /** Input tokens that were not read from the provider's cache. */
-  inputTokens: z.number().optional(),
-  /** Includes reasoning tokens. */
-  outputTokens: z.number().optional(),
-  cacheReadTokens: z.number().optional(),
-  cacheWriteTokens: z.number().optional(),
-  reasoningTokens: z.number().optional(),
-  costUsd: z.number().optional(),
-  costSource: costSourceSchema.optional(),
-  /** Model requests made so far. */
-  requests: z.number().optional(),
-  /** Size of the latest request (not cumulative), and the model's limit. */
-  contextTokens: z.number().optional(),
-  contextWindow: z.number().optional(),
-  model: z.string().optional(),
-  provider: z.string().optional(),
-  /** The request this update reports. */
-  request: usageRequestSchema.optional()
-})
-export type UsagePayload = z.infer<typeof usagePayloadSchema>
-export const accountIssueCategorySchema = z.enum(['auth_expired', 'rate_limited', 'quota', 'network', 'unknown'])
-export type AccountIssueCategory = z.infer<typeof accountIssueCategorySchema>
-export const accountLimitSchema = z.object({
-  id: z.string(),
-  label: z.string(),
-  usedPercent: z.number().nullable().optional(),
-  resetsAt: z.string().nullable().optional(),
-  windowMinutes: z.number().nullable().optional(),
-  status: z.string().nullable().optional()
-})
-export type AccountLimit = z.infer<typeof accountLimitSchema>
-/** Limit snapshots, plan changes, and classified account failures. */
-const accountStatusPayload = z.object({
-  accountId: z.string(),
-  category: accountIssueCategorySchema.optional(),
-  message: z.string().optional(),
-  resetsAt: z.string().optional(),
-  plan: z.string().optional(),
-  limits: z.array(accountLimitSchema).optional()
-})
-const statusPayload = z.object({ status: runStatusSchema, reason: z.string().optional() })
-const failedPayload = z.object({ code: z.string(), message: z.string() })
-const emptyPayload = z.object({}).passthrough()
-
-/** Payload schema per discriminant. */
-export const runEventPayloadSchemas = {
-  started: emptyPayload,
-  'context.snapshot': contextSnapshotPayload,
-  'message.delta': messageDeltaPayload,
-  'message.completed': messageCompletedPayload,
-  'message.steered': messageSteeredPayload,
-  'tool.started': toolPayload,
-  'tool.completed': toolPayload,
-  'retry.started': retryStartedPayload,
-  'retry.ended': retryEndedPayload,
-  'compaction.started': compactionStartedPayload,
-  'compaction.ended': compactionEndedPayload,
-  'approval.requested': approvalRequestedPayload,
-  'approval.resolved': approvalResolvedPayload,
-  'question.requested': questionRequestedPayload,
-  'question.answered': questionAnsweredPayload,
-  'extension.notice': extensionNoticePayload,
-  'reaction.added': reactionAddedPayload,
-  'agent.message': agentMessagePayload,
-  'artifact.added': artifactPayload,
-  'file.changed': fileChangedPayload,
-  'usage.updated': usagePayloadSchema,
-  'account.status': accountStatusPayload,
-  'status.changed': statusPayload,
-  failed: failedPayload,
-  completed: emptyPayload
-} satisfies Record<RunEventType, z.ZodType>
-
-export const runEventSchema = z
-  .object({
-    id: z.string(),
-    runId: z.string(),
-    sessionId: z.string(),
-    sequence: z.number().int().nonnegative(),
-    timestamp: z.string(),
-    type: runEventTypeSchema,
-    payload: z.unknown(),
-    /** The native event this one was derived from, kept as evidence. */
-    native: z.unknown().optional(),
-    /** Set when consecutive text deltas were merged for relay; covers sequences coalescedFrom..sequence. */
-    coalescedFrom: z.number().int().nonnegative().optional()
-  })
-  .superRefine((event, context) => {
-    if (!runEventPayloadSchemas[event.type].safeParse(event.payload).success) {
-      context.addIssue({ code: 'custom', path: ['payload'], message: `Invalid payload for ${event.type}` })
-    }
-  })
-export type RunEvent = z.infer<typeof runEventSchema>
-
-/**
- * One tracked execution interval of a session. `mode`, `harness`, `sessionType`, `worktreeId`,
- * `attachmentCount`, `exitCode`, `handoffId` and `trigger` belong to the embedding application:
- * the harness stores and returns them, and reads only `mode` (`chat` is an agent's own
- * conversation, `code` is a session in a project).
- */
-export interface RunRecord {
-  resumedFromRunId: string | null
-  /** Opaque run lineage supplied by the embedding application. */
-  parentRunId: string | null
-  relation: string | null
-  terminalReason: string | null
-  id: string
-  projectId: string | null
-  mode: string
-  harness: string
-  sessionType: string
-  sessionId: string
-  nativeSessionId: string | null
-  workingDirectory: string | null
-  worktreeId: string | null
-  goal: string | null
-  attachmentCount: number
-  startedAt: string
-  endedAt: string | null
-  status: string
-  exitCode: number | null
-  handoffId: string | null
-  /** The account the run used. */
-  accountId: string | null
-  /** The agent that replied. */
-  agentId: string | null
-  /** What started the run. */
-  trigger: string | null
-}
-
-const text = z.string().nullish().transform((value) => value ?? null)
-
-export const runRecordSchema = z.object({
-  resumedFromRunId: text,
-  parentRunId: text,
-  relation: text,
-  terminalReason: text,
-  id: z.string(),
-  projectId: text,
-  mode: z.string(),
-  harness: z.string(),
-  sessionType: z.string(),
-  sessionId: z.string(),
-  nativeSessionId: text,
-  workingDirectory: text,
-  worktreeId: text,
-  goal: text,
-  attachmentCount: z.number().int().nonnegative().default(0),
-  startedAt: z.string(),
-  endedAt: text,
-  status: z.string(),
-  exitCode: z.number().int().nullish().transform((value) => value ?? null),
-  handoffId: text,
-  accountId: text,
-  agentId: text,
-  trigger: text
-}) satisfies z.ZodType<RunRecord, unknown>
-
-export const ACTIVE_STATUSES: readonly string[] = ['queued', 'running', 'waiting_for_approval', 'waiting_for_input']
-
-export function isActiveStatus(status: string): boolean {
-  return ACTIVE_STATUSES.includes(status)
-}

package/src/sessions/conversation.test.ts

@@ -1,233 +0,0 @@
-// Whole replies, through everything the harness does for one: the compiled prompt, the plugins
-// it chose to load, the gate, the run's events. Pi is real and so are the extensions; only the
-// model is scripted, so no request leaves the machine.
-import { existsSync, mkdtempSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { afterEach, describe, expect, it } from 'vitest'
-
-import { memorySecretStore } from '../accounts/secrets'
-import { createHarness, type Harness } from '../harness'
-import { listInbox } from '../memory/operations'
-import { wikiDir } from '../memory/store'
-import type { Plugin } from '../plugins/types'
-import { methods } from '../server/methods'
-import { fauxModel } from '../../tests/faux'
-import { rootWithProject, writeFile } from '../../tests/helpers'
-import type { RunEvent } from './contracts'
-
-const open: Harness[] = []
-afterEach(async () => {
-  for (const harness of open.splice(0)) await harness.close()
-})
-
-const EXTENSION = `import { Type } from 'typebox'
-export default function (pi) {
-  pi.registerTool({ name: 'kit_scan', label: 'Scan', description: 'Scan a folder.', parameters: Type.Object({ path: Type.String() }), async execute(id, input, signal, onUpdate, ctx) {
-    ctx.ui.notify('Scanning ' + input.path, 'info')
-    return { content: [{ type: 'text', text: 'scanned ' + input.path }], details: undefined }
-  } })
-}
-`
-
-async function setup() {
-  const root = rootWithProject()
-  const base = mkdtempSync(join(tmpdir(), 'conversation-'))
-  const harness = createHarness({ dataRoot: root, stateDir: join(base, 'state'), secrets: memorySecretStore(), maintainerFactory: async () => ({ prompt: async () => undefined, dispose: () => undefined, error: () => null }) })
-  open.push(harness)
-  harness.accounts.create('Main', 'apiKey')
-  const model = await fauxModel(harness)
-  const events: RunEvent[] = []
-  harness.runs.listen((event) => void events.push(event))
-  const table = methods(harness)
-  const call = <T>(method: string, params: Record<string, unknown> = {}) => table[method](params) as Promise<T>
-  const settled = (id: string) => events.some((event) => event.runId === id && (event.type === 'completed' || event.type === 'failed'))
-  const until = async (done: () => boolean) => {
-    for (let waited = 0; waited < 400 && !done(); waited += 1) await new Promise((resolve) => setTimeout(resolve, 25))
-  }
-  let count = 0
-  const start = async (extra: Record<string, unknown> = {}) => {
-    const id = `run-${(count += 1)}`
-    await harness.sessions.run({ run: { id, sessionId: 'a1' }, cwd: base, sessionDir: join(root, 'sessions', 'a1'), text: 'Go.', model: model.model, caller: { agentId: 'a1', agentName: 'Helper', actor: 'Chat' }, tools: { allow: ['read'] }, ...extra })
-    return id
-  }
-  const of = (id: string) => events.filter((event) => event.runId === id)
-  return { harness, root, base, model, call, start, until, settled, of }
-}
-
-describe('a whole reply, with a scripted model', () => {
-  it('joins async native children and persists one result receipt before the final reply', async () => {
-    const { harness, root, model, start, until, settled, of } = await setup()
-    const route = (context: { messages: Array<{ role: string; content: unknown }> }) => {
-      const users = context.messages.filter(message => message.role === 'user').map(message => typeof message.content === 'string' ? message.content : (message.content as Array<{ text?: string }>).map(part => part.text ?? '').join(''))
-      if (users.includes('native-child-brief')) return model.says('CHILD_EVIDENCE')
-      if (JSON.stringify(context.messages).includes('CHILD_EVIDENCE')) return model.says('Final with CHILD_EVIDENCE')
-      if (!context.messages.some(message => message.role === 'toolResult')) return model.calls(['spawn_subagent', { brief: 'native-child-brief' }])
-      return model.says('Draft before joining')
-    }
-    model.script(Array(8).fill(route))
-    const id = await start()
-    await until(() => settled(id))
-    expect(of(id).at(-1)?.type).toBe('completed')
-    expect(of(id).filter(event => event.type === 'message.completed').at(-1)?.payload).toMatchObject({ text: 'Final with CHILD_EVIDENCE' })
-    const { sessionFile } = await import('../prompt/compile')
-    const { readFileSync } = await import('node:fs')
-    const entries = readFileSync(sessionFile(join(root, 'sessions', 'a1'))!, 'utf8').trim().split('\n').map(line => JSON.parse(line))
-    expect(entries.filter(entry => entry.customType === 'xingular-subagent-results')).toHaveLength(1)
-    expect(model.requests()).toBeLessThanOrEqual(4)
-    expect(harness.runs.activeRunIds()).toEqual([])
-  })
-
-  it('uses blocking native results without adding an unsolicited duplicate delivery', async () => {
-    const { root, model, start, until, settled, of } = await setup()
-    model.script([model.calls(['spawn_subagent', { brief: 'Find proof', wait: true }]), model.says('INLINE_CHILD_PROOF'), model.says('Final')])
-    const id = await start()
-    await until(() => settled(id))
-    expect(of(id).at(-1)?.type).toBe('completed')
-    expect(model.lastToolResults().join('')).toContain('INLINE_CHILD_PROOF')
-    const { sessionFile } = await import('../prompt/compile')
-    const { readFileSync } = await import('node:fs')
-    expect(readFileSync(sessionFile(join(root, 'sessions', 'a1'))!, 'utf8')).not.toContain('"customType":"xingular-subagent-results"')
-    expect(model.requests()).toBe(3)
-  })
-
-  it('interrupts a parent waiting on a child question without deadlocking SDK abort', async () => {
-    const { harness, model, start, until, settled } = await setup()
-    const ai = await import('@earendil-works/pi-ai')
-    model.script([
-      model.calls(['spawn_subagent', { brief: 'Ask for a decision', wait: true }]),
-      ai.fauxAssistantMessage([ai.fauxToolCall('ask_user', { questions: [{ summary: 'A decision', question: 'Which approach?' }] })], { stopReason: 'toolUse' })
-    ])
-    let childRunId: string | null = null
-    harness.runs.listen((event, run) => { if (event.type === 'question.requested' && run?.relation === 'subagent') childRunId = event.runId })
-    const id = await start()
-    await until(() => childRunId !== null || settled(id))
-    expect(childRunId).not.toBeNull()
-    await harness.runs.interrupt(id)
-    const { loadRun } = await import('./runStore')
-    expect(loadRun(harness.env.root, id).status).toBe('interrupted')
-    expect(loadRun(harness.env.root, childRunId!).status).toBe('interrupted')
-    const { readEvents } = await import('./runStore')
-    expect(readEvents(harness.env.root, childRunId!).some(event => event.type === 'question.answered')).toBe(true)
-    expect(harness.runs.activeRunIds()).toEqual([])
-  })
-
-  it('dispatches a registered command with notes without making a provider request', async () => {
-    const { harness, model, start, until, settled, of } = await setup()
-    const account = harness.accounts.context(harness.accounts.resolve(null, null))
-    writeFile(join(account.configDir, 'extensions/command.ts'), `export default function(pi) { pi.registerCommand('hello', { description: 'Hello', handler: async (args, ctx) => ctx.ui.notify('hello ' + args) }) }`)
-    const id = await start({ text: '/hello original arguments', preamble: '[A note for the next request]' })
-    await until(() => settled(id))
-    expect(of(id).at(-1)?.type).toBe('completed')
-    expect(of(id).find((event) => event.type === 'extension.notice')?.payload).toMatchObject({ text: 'hello original arguments' })
-    expect(model.requests()).toBe(0)
-  })
-
-  it('asks before an extension tool that uses the name of an allowed native read', async () => {
-    const { harness, model, start, until, settled, of } = await setup()
-    const account = harness.accounts.context(harness.accounts.resolve(null, null))
-    writeFile(join(account.configDir, 'extensions/override.ts'), EXTENSION.replaceAll('kit_scan', 'read'))
-    model.script([model.calls(['read', { path: 'src' }]), model.says('Done.')])
-    const id = await start()
-    await until(() => of(id).some((event) => event.type === 'approval.requested') || settled(id))
-    const approval = of(id).find((event) => event.type === 'approval.requested')?.payload as { approvalId: string; target: string }
-    expect(approval?.target).toBe('read')
-    expect(of(id).some((event) => event.type === 'extension.notice')).toBe(false)
-    harness.runs.resolveApproval(id, approval.approvalId, 'denied')
-    await until(() => settled(id))
-    expect(model.lastToolResults().at(-1)).toContain('denied')
-    expect(of(id).some((event) => event.type === 'extension.notice')).toBe(false)
-  })
-
-  it("offers an installed plugin's tool only once the plugin is switched on and trusted, and asks before the tool runs", async () => {
-    const { harness, base, model, call, start, until, settled, of } = await setup()
-    writeFile(join(base, 'kit/package.json'), JSON.stringify({ name: 'review-kit', version: '1.0.0', description: 'Review helpers.' }))
-    writeFile(join(base, 'kit/extensions/scan.ts'), EXTENSION)
-    const plugin = (await call<Plugin[]>('plugins.install', { source: join(base, 'kit') })).find((candidate) => candidate.id === 'package:review-kit')!
-    const scan = () => model.script([model.calls(['kit_scan', { path: 'src' }]), model.says('Scanned.')])
-
-    // Installed, switched off, untrusted: the model names a tool the session does not have.
-    scan()
-    const first = await start()
-    await until(() => settled(first))
-    expect(of(first).some((event) => event.type === 'approval.requested')).toBe(false)
-    expect(model.lastToolResults().at(-1)).toMatch(/kit_scan/)
-    expect(model.lastToolResults().at(-1)).not.toContain('scanned src')
-
-    await call('plugins.attach', { id: plugin.id })
-    await call('plugins.trust', { hash: plugin.code!.hash })
-    scan()
-    const second = await start()
-    await until(() => of(second).some((event) => event.type === 'approval.requested') || settled(second))
-    const approval = of(second).find((event) => event.type === 'approval.requested')!.payload as { approvalId: string; target: string }
-    expect(approval.target).toBe('kit_scan')
-    // Nothing ran while the person was deciding.
-    expect(of(second).some((event) => event.type === 'extension.notice')).toBe(false)
-    harness.runs.resolveApproval(second, approval.approvalId, 'approved')
-    await until(() => settled(second))
-    expect(model.lastToolResults().at(-1)).toBe('scanned src')
-    // What the extension told the person arrived as a run event.
-    expect(of(second).find((event) => event.type === 'extension.notice')?.payload).toEqual({ kind: 'notify', level: 'info', text: 'Scanning src' })
-    expect(of(second).at(-1)?.type).toBe('completed')
-    // Having loaded once, the plugin's details say what its extension adds.
-    expect((await call<Plugin[]>('plugins.list')).find((candidate) => candidate.id === plugin.id)!.contributions[0].description).toBe('Adds tools kit_scan.')
-
-    // Denied, the tool does not run and the model is told.
-    scan()
-    const third = await start()
-    await until(() => of(third).some((event) => event.type === 'approval.requested') || settled(third))
-    harness.runs.resolveApproval(third, (of(third).find((event) => event.type === 'approval.requested')!.payload as { approvalId: string }).approvalId, 'denied')
-    await until(() => settled(third))
-    expect(model.lastToolResults().at(-1)).toMatch(/denied/)
-  })
-
-  it('lets the agent propose a plugin, which reaches the Inbox and nothing else', async () => {
-    const { root, model, start, until, settled, of } = await setup()
-    model.script([
-      model.calls(['plugin_propose', { name: 'Memory to Docs', description: 'Copies each saved memory to the team document.', extends: ['memory'] as never, files: [{ path: 'hooks.mjs', content: "export default function (harness) { harness.on('memory.saved', async () => {}) }\n" }] as never }]),
-      model.says('I proposed it; it is in your Inbox.')
-    ])
-    const id = await start()
-    await until(() => settled(id))
-    expect(model.lastToolResults().at(-1)).toContain('The plugin "memory-to-docs" is waiting in the Inbox')
-    expect(listInbox(wikiDir(root)).map((item) => item.title)).toEqual(['Proposed plugin "Memory to Docs"'])
-    expect(existsSync(join(root, 'plugins'))).toBe(false)
-    // Proposing is not something a person is asked to approve: it changes nothing until they accept.
-    expect(of(id).some((event) => event.type === 'approval.requested')).toBe(false)
-  })
-
-  it('has no plugin proposal tool in unattended work', async () => {
-    const { model, start, until, settled } = await setup()
-    model.script([model.calls(['plugin_propose', { name: 'x', description: 'y', files: [] as never }]), model.says('Done.')])
-    const id = await start({ automatic: true })
-    await until(() => settled(id))
-    expect(model.lastToolResults().at(-1)).not.toContain('waiting in the Inbox')
-  })
-
-  it('delivers a message sent during a tool call after that call, before the next request', async () => {
-    const { harness, model, call, start, until, settled, of } = await setup()
-    model.script([model.calls(['bash', { command: 'ls' }]), model.says('Noted.')])
-    const id = await start({ tools: { allow: ['read', 'bash'], gated: ['bash'] } })
-    await until(() => of(id).some((event) => event.type === 'approval.requested'))
-    const approval = of(id).find((event) => event.type === 'approval.requested')!.payload as { approvalId: string }
-    await call('runs.steer', { runId: id, text: 'Also check the logs.' })
-    harness.runs.resolveApproval(id, approval.approvalId, 'denied')
-    await until(() => settled(id))
-    const types = of(id).map((event) => event.type)
-    expect(of(id).find((event) => event.type === 'message.steered')?.payload).toEqual({ text: 'Also check the logs.' })
-    expect(types.indexOf('message.steered')).toBeGreaterThan(types.indexOf('approval.resolved'))
-    expect(model.requests()).toBe(2)
-    // The context update reaches the model as a user-role message too; the prompt and the steer come last.
-    expect(model.lastUserTexts().slice(-2)).toEqual(['Go.', 'Also check the logs.'])
-    expect(of(id).at(-1)?.type).toBe('completed')
-  })
-
-  it('refuses a message once the reply has ended, so the app sends it as a new reply', async () => {
-    const { call, model, start, until, settled, of } = await setup()
-    model.script([model.says('Done.')])
-    const id = await start()
-    await until(() => settled(id))
-    await expect(call('runs.steer', { runId: id, text: 'Too late.' })).rejects.toMatchObject({ code: 'run_not_active' })
-    expect(of(id).some((event) => event.type === 'message.steered')).toBe(false)
-  })
-})

package/src/sessions/extensionSession.test.ts

@@ -1,74 +0,0 @@
-// A real Pi session with a real extension, and no provider: nothing here makes a model request.
-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 { writeFile } from '../../tests/helpers'
-import type { ExtensionNotice } from './extensionUi'
-import type { QuestionInput } from './registry'
-import { piSessionFactory, type TurnParams } from './runner'
-
-const open: Harness[] = []
-afterEach(async () => {
-  for (const harness of open.splice(0)) await harness.close()
-})
-
-const EXTENSION = `import { Type } from 'typebox'
-export default function (pi) {
-  pi.registerTool({ name: 'kit_scan', label: 'Scan', description: 'Scan a folder.', parameters: Type.Object({ path: Type.String() }), async execute() { return { content: [{ type: 'text', text: 'scanned' }], details: undefined } } })
-  pi.registerCommand('hello', { description: 'Says hello', handler: async (args, ctx) => {
-    const sure = await ctx.ui.confirm('Say hello?', args)
-    ctx.ui.notify(sure ? 'hello ' + args : 'kept quiet', 'info')
-  } })
-  pi.on('session_start', async (_event, ctx) => { ctx.ui.setStatus('kit', 'ready in ' + ctx.mode) })
-}
-`
-
-it('binds an extension in a session without a terminal: its start hook runs, its tool is offered and asks, its command can ask and tell', async () => {
-  const base = mkdtempSync(join(tmpdir(), 'ext-session-'))
-  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))
-  writeFile(join(account.configDir, 'extensions/kit.ts'), EXTENSION)
-
-  const notices: ExtensionNotice[] = []
-  const asked: QuestionInput[] = []
-  const gated: string[] = []
-  const params: TurnParams = {
-    runId: 'r1',
-    cwd: base,
-    sessionDir: join(base, 'sessions'),
-    historyFile: null,
-    model: null,
-    text: '',
-    account,
-    system: '',
-    update: null,
-    plugins: { loading: () => harness.plugins.loading({ cwd: base, agentDir: account.configDir }), loaded: (extensions) => harness.plugins.loaded(extensions) }
-  }
-  const session = await piSessionFactory({
-    params,
-    allow: ['read'],
-    gate: { check: async () => null, ask: (names) => void gated.push(...names) },
-    tools: [],
-    runtime: () => harness.accounts.runtime(account),
-    extensions: { ask: async (input) => (asked.push(input), { selected: ['Yes'] }), notice: (notice) => void notices.push(notice) }
-  })
-  try {
-    expect(notices).toEqual([{ kind: 'status', key: 'kit', text: 'ready in rpc' }])
-    expect(gated).toEqual(['kit_scan'])
-    expect(session.getActiveToolNames?.()).toEqual(expect.arrayContaining(['read', 'kit_scan']))
-    expect(session.getActiveToolNames?.()).not.toContain('bash')
-
-    await session.prompt('/hello there')
-    expect(asked).toEqual([{ question: 'Say hello?\n\nthere', options: [{ label: 'Yes' }, { label: 'No' }], multiSelect: false, allowText: false }])
-    expect(notices.at(-1)).toEqual({ kind: 'notify', level: 'info', text: 'hello there' })
-    expect(Object.values(harness.plugins.registered())[0]).toMatchObject({ tools: ['kit_scan'], commands: ['hello'], hooks: ['session_start'] })
-  } finally {
-    session.dispose()
-  }
-})