@xingular/harness 2.0.0 → 2.0.1-unstable

package/src/sessions/sessions.ts

@@ -1,331 +0,0 @@
-// Starting a session turn: the account, the run record, the compiled prompt, the tools and
-// their gate, then Pi. Everything before Pi answers is synchronous with the caller; the reply
-// itself streams as run events.
-import { existsSync, mkdirSync } from 'node:fs'
-import { join } from 'node:path'
-
-import type { Accounts } from '../accounts/accounts'
-import { log } from '../core/bus'
-import type { HarnessEnv } from '../core/env'
-import { HarnessError, invalid } from '../core/errors'
-import { capabilitySet as parseCapabilitySet, freezeRun } from '../capabilities/runSnapshot'
-import type { CapabilitySet } from '../capabilities/types'
-import { now, writeJson } from '../core/fs'
-import { takeChars } from '../core/text'
-import type { CallerContext } from '../memory/caller'
-import type { DispatchEnv } from '../memory/dispatch'
-import type { Plugins } from '../plugins/plugins'
-import { sessionLaunch, type Launch } from '../prompt/compile'
-import * as attachments from '../plugins/attachments'
-import { FIRST_PARTY_PLUGINS, firstPartyExtensions, type InlineExtension } from '../plugins/firstParty'
-import * as registry from '../skills/registry'
-import { ASK_USER, askUserTool } from '../tools/askUser'
-import { PLUGIN_PROPOSE, pluginProposeTool } from '../tools/pluginPropose'
-import { subagentTools } from '../tools/spawnSubagent'
-import { WIKI_TOOL_NAMES } from '../tools/definitions'
-import { memoryTools } from '../tools/memoryTools'
-import type { ToolProvider, ToolSession, ToolSpec } from '../tools/types'
-import type { RunRecord } from './contracts'
-import { SPAWN_SUBAGENT, WAIT_SUBAGENTS, subagentDepth, subagentHistory, subagentNesting, type SubagentInput, type SubagentOptions } from './subagents'
-import type { Subagents } from './subagentService'
-import { selectHistory } from './history'
-import { runLineageJoin } from './lineageJoin'
-import type { ToolPolicy } from './policy'
-import type { ActiveRun, RunRegistry } from './registry'
-import { piSessionFactory, runTurn, summarize, type Effort, type PiSessionLike, type SessionFactory, type ToolGate, type TurnParams } from './runner'
-import { loadRun, runDir, saveRun, updateRun } from './runStore'
-
-/** The fields of a run record the caller decides; the harness fills in the rest. */
-export type RunFields = Pick<RunRecord, 'id' | 'sessionId'> & Partial<Pick<RunRecord, 'mode' | 'harness' | 'sessionType' | 'projectId' | 'agentId' | 'trigger' | 'goal' | 'attachmentCount' | 'resumedFromRunId' | 'parentRunId' | 'relation' | 'worktreeId' | 'handoffId'>>
-
-export interface SessionRunInput {
-  run: RunFields
-  /** The account this session is pinned to. A new session may name a pool, or neither for the default. */
-  accountId?: string | null
-  poolId?: string | null
-  model?: string | null
-  effort?: Effort | null
-  cwd: string
-  /** Where this session's native history lives. */
-  sessionDir: string
-  /** Continue exactly this recorded history; never another one. */
-  resume?: { sessionFile?: string | null; nativeSessionId?: string | null } | null
-  text: string
-  images?: { mediaType: string; data: string }[]
-  /** Reject a resolved model that cannot inspect image content. */
-  requiresImageInput?: boolean
-  preamble?: string | null
-  /** Unattended: no project extensions, no context files, nothing may ask a person. */
-  automatic?: boolean
-  /** Who the session works as, for memory and the prompt. */
-  caller: CallerContext
-  /** What the application adds to the prompt, and which tools it describes. */
-  launch?: Launch
-  /** The tools switched on, in the order the model sees them, and those that ask before each call. */
-  tools: { allow: string[]; gated?: string[] }
-  /** Give the session the connected-apps broker. */
-  connections?: boolean | { readOnly?: boolean }
-  /** Optional narrower set for a child run; the harness intersects it with current availability. */
-  capabilities?: CapabilitySet
-  /** Hops from the user to this session (0 when the user started it). */
-  depth?: number
-  /** Interactive default: native child tools. Null disables; unattended callers must opt in. */
-  subagents?: SubagentOptions | null
-  /** Ask the application's tool providers for tools (the default). False runs with the harness's own tools only. */
-  providers?: boolean
-}
-
-/** The connected-apps broker, as a session sees it. */
-export interface SessionBroker {
-  toolNames: readonly string[]
-  tools(session: ToolSession, options: { readOnly: boolean }): ToolSpec[]
-}
-
-export interface SessionsOptions {
-  subagents: Subagents
-  env: DispatchEnv
-  accounts: Accounts
-  runs: RunRegistry
-  policy: ToolPolicy
-  broker?: SessionBroker | null
-  /** Chooses what a session loads. Without it Pi discovers extensions and skills on its own. */
-  plugins?: Plugins
-  /** Resolves the caller's capability set from the harness's stores. */
-  resolveCapabilities?: (caller: CallerContext, tools: readonly string[], cwd: string) => Promise<CapabilitySet>
-  factory?: SessionFactory
-}
-
-/** The harness's own plugins a person switched on for this caller, with the numbers they set. */
-function firstPartyFor(root: string, contributions: readonly string[]): InlineExtension[] {
-  const choices = attachments.load(root)
-  const allowed = new Set(contributions)
-  return firstPartyExtensions((id) => FIRST_PARTY_PLUGINS.find((plugin) => plugin.id === id)?.code?.some((code) => allowed.has(`${id}/code/${code.name}`)) ?? false, choices.settings)
-}
-
-export class Sessions {
-  private readonly providers: ToolProvider[] = []
-  private readonly factory: SessionFactory
-
-  constructor(private readonly options: SessionsOptions) {
-    this.factory = options.factory ?? piSessionFactory
-
-  }
-
-  private get env(): HarnessEnv {
-    return this.options.env
-  }
-
-  /** Adds tools an application provides. Providers are asked in the order they were added. */
-  provide(provider: ToolProvider): void {
-    this.providers.push(provider)
-  }
-
-  private gate(run: ActiveRun, caller: CallerContext, gated: Set<string>): ToolGate {
-    const { policy } = this.options
-    return {
-      ask: (names) => {
-        for (const name of names) gated.add(name)
-      },
-      check: async (tool, args) => {
-        const call = { run: loadRun(this.env.root, run.runId), caller, tool, args }
-        const scope = (await policy.scope?.(call)) ?? { allowed: true }
-        if (!scope.allowed && (scope.automatic || !scope.requiresApproval)) return scope.reason ?? 'Outside the approved work scope.'
-        try {
-          await policy.authorize?.(call)
-        } catch (error) {
-          return error instanceof Error ? error.message : 'Tool unavailable in the app settings.'
-        }
-        if (scope.allowed && !scope.humanOnly && (scope.automatic || !gated.has(tool))) return null
-        // A call outside the scope is approved one at a time; a gated tool may be remembered, unless only a person may decide it.
-        const decision = await run.requestApproval({
-          target: tool,
-          action: summarize(args),
-          operation: { tool, args: (args && typeof args === 'object' ? args : {}) as Record<string, unknown> },
-          rememberable: scope.allowed && !scope.humanOnly,
-          standing: scope.humanOnly ? (scope.allowGlobalApproval ? 'switch' : 'none') : undefined
-        })
-        if (decision !== 'approved') return 'The user denied this action. Ask how they would like to proceed.'
-        try {
-          await policy.authorize?.(call)
-        } catch (error) {
-          return error instanceof Error ? error.message : 'Tool was disabled while waiting.'
-        }
-        return null
-      }
-    }
-  }
-
-  /** Compatibility alias for the shared native service. */
-  spawnSubagent(request: SubagentInput): Promise<{ runId: string; nativeSessionId: string | null }> {
-    return this.options.subagents.spawn(request)
-  }
-
-  /**
-   * Starts one turn. Returns once the Pi session is open; the reply arrives as run events. A
-   * session that cannot be opened ends its run as failed and returns no native session id.
-   */
-  async run(input: SessionRunInput): Promise<{ runId: string; nativeSessionId: string | null }> {
-    const { root } = this.env
-    if (!input?.run?.id || !input.run.sessionId || typeof input.text !== 'string') throw invalid('A session turn needs a run id, a session, and text.')
-    input = structuredClone(input)
-    const historyFile = selectHistory({ sessionDir: input.sessionDir, resume: input.resume })
-    const account = this.options.accounts.resolve(input.accountId, input.poolId)
-    const context = this.options.accounts.context(account)
-    const runId = input.run.id
-    const caller: CallerContext = { ...input.caller, maintenanceJobIds: input.caller.maintenanceJobIds?.slice(), runId, sessionId: input.caller.sessionId ?? input.run.sessionId }
-    const broker = input.connections ? this.options.broker : null
-    const depth = input.depth ?? 0
-    const canSpawn = input.subagents !== null && (!input.automatic || input.subagents !== undefined) && subagentNesting(root, input.run) < subagentDepth(input.subagents ?? undefined)
-    const requestedTools = [...new Set([
-      ...input.tools.allow.filter((name) => name !== SPAWN_SUBAGENT && name !== WAIT_SUBAGENTS),
-      ASK_USER,
-      ...(input.automatic ? [] : [PLUGIN_PROPOSE]),
-      ...WIKI_TOOL_NAMES,
-      ...(broker?.toolNames ?? []),
-      ...(canSpawn ? [SPAWN_SUBAGENT, WAIT_SUBAGENTS] : [])
-    ])]
-    const available = this.options.resolveCapabilities
-      ? await this.options.resolveCapabilities(caller, requestedTools, input.cwd)
-      : { version: 1 as const, tools: requestedTools, connectors: [], contributions: [] }
-    const requested = input.capabilities ? parseCapabilitySet(input.capabilities) : available
-    const capabilities: CapabilitySet = {
-      version: 1,
-      tools: available.tools.filter((tool) => requested.tools.includes(tool)),
-      connectors: available.connectors.filter((id) => requested.connectors.includes(id)),
-      contributions: available.contributions.filter((id) => requested.contributions.includes(id))
-    }
-    freezeRun(root, runId, caller, capabilities)
-
-    saveRun(root, {
-      resumedFromRunId: input.run.resumedFromRunId ?? null,
-      parentRunId: input.run.parentRunId ?? null,
-      relation: input.run.relation ?? null,
-      terminalReason: null,
-      id: runId,
-      projectId: input.run.projectId ?? caller.projectId ?? null,
-      mode: input.run.mode ?? 'chat',
-      harness: input.run.harness ?? 'pi',
-      sessionType: input.run.sessionType ?? 'structured',
-      sessionId: input.run.sessionId,
-      nativeSessionId: null,
-      workingDirectory: input.cwd,
-      worktreeId: input.run.worktreeId ?? null,
-      goal: input.run.goal ?? takeChars(input.text, 4000),
-      attachmentCount: input.run.attachmentCount ?? 0,
-      startedAt: now(),
-      endedAt: null,
-      status: 'queued',
-      exitCode: null,
-      handoffId: input.run.handoffId ?? null,
-      accountId: account.id,
-      agentId: input.run.agentId ?? caller.agentId ?? null,
-      trigger: input.run.trigger ?? null
-    })
-
-    // What the session is, kept with the run so later consolidation knows which memory it had.
-    try {
-      writeJson(join(runDir(root, runId), 'caller.json'), caller)
-    } catch {
-      // Consolidation falls back to what the run record says.
-    }
-
-    const fail = (error: unknown, code = 'provider_unavailable'): void => {
-      const message = error instanceof Error ? error.message : String(error)
-      updateRun(root, runId, (record) => Object.assign(record, { status: 'failed', endedAt: now(), terminalReason: message }))
-      log(`session ${runId} did not start: ${message}`, code)
-    }
-
-    let system: string
-    let update: TurnParams['update']
-    try {
-      if (!existsSync(input.sessionDir)) mkdirSync(input.sessionDir, { recursive: true })
-      const launch = input.launch ?? {}
-      const effectiveLaunch = {
-        ...launch,
-        tools: capabilities.tools,
-        connectionTools: (launch.connectionTools ?? []).filter((name) => capabilities.tools.includes(name)),
-        toolGroups: launch.toolGroups?.map((group) => ({ ...group, tools: group.tools.filter((name) => capabilities.tools.includes(name)) })).filter((group) => group.tools.length > 0)
-      }
-      ;({ system, update } = sessionLaunch(this.env, caller, effectiveLaunch, historyFile, capabilities.contributions))
-    } catch (error) {
-      fail(error)
-      throw error
-    }
-
-    const run = this.options.runs.start(input.run.sessionId, runId)
-    if (run.finished) return { runId, nativeSessionId: null }
-    // What every session has, after the tools the caller switched on and in a fixed order.
-    const allow = capabilities.tools
-    const session: ToolSession = { run, caller, allow, depth, cwd: input.cwd, capabilities }
-    const { plugins } = this.options
-
-    let pi: PiSessionLike | undefined
-    try {
-      const tools: ToolSpec[] = [
-        ...(broker ? broker.tools(session, { readOnly: typeof input.connections === 'object' && input.connections.readOnly === true }) : []),
-        ...memoryTools(this.options.env, caller, capabilities.contributions),
-        askUserTool(run),
-        pluginProposeTool(this.options.env, caller),
-        ...subagentTools(this.options.subagents, runId).filter(tool => allow.includes(tool.name))
-      ]
-      if (input.providers !== false) for (const provider of this.providers) tools.push(...(await provider(session)))
-      const params: TurnParams = {
-        runId,
-        restrictTools: input.run.relation === 'subagent',
-        cwd: input.cwd,
-        sessionDir: input.sessionDir,
-        historyFile,
-        model: input.model ?? null,
-        effort: input.effort ?? null,
-        text: input.text,
-        images: input.images,
-        requiresImageInput: input.requiresImageInput,
-        preamble: input.preamble ?? null,
-        automatic: input.automatic,
-        account: context,
-        resources: registry.resources(root, caller.projectId ?? null, caller.agentId ?? null, capabilities.contributions),
-        inline: [...firstPartyFor(root, capabilities.contributions), runLineageJoin(root, runId), this.options.subagents.extension(runId)],
-        ...(plugins ? { plugins: { loading: () => plugins.loading({ cwd: input.cwd, agentDir: context.configDir, install: true, caller: { agentId: caller.agentId ?? null, projectId: caller.projectId ?? null }, contributions: capabilities.contributions }), loaded: (extensions) => plugins.loaded(extensions) } } : {}),
-        system,
-        update
-      }
-      pi = await this.factory({
-        params,
-        allow,
-        gate: (() => {
-          const gate = this.gate(run, caller, new Set((input.tools.gated ?? []).filter((name) => capabilities.tools.includes(name))))
-          return { ...gate, check: (name: string, args: unknown) => input.run.relation === 'subagent' && !capabilities.tools.includes(name) ? Promise.resolve('This tool is outside the child capability snapshot.') : gate.check(name, args) }
-        })(),
-        tools,
-        runtime: () => this.options.accounts.runtime(context),
-        // An unattended run loads no extension, so it has nobody to relay for.
-        ...(input.automatic ? {} : { extensions: { ask: (question) => run.requestAnswer(question), notice: (notice) => run.emit('extension.notice', notice) } })
-      })
-      if (run.finished) {
-        pi.dispose()
-        return { runId, nativeSessionId: null }
-      }
-      if ((input.requiresImageInput || input.images?.length) && !pi.model?.input.includes('image')) {
-        throw new HarnessError('image_input_unsupported', 'Choose a model that supports images, or remove the image attachments and send again.')
-      }
-      if (input.resume?.nativeSessionId && pi.sessionId !== input.resume.nativeSessionId) {
-        run.finish('failed', { code: 'native_resume_unavailable', message: 'The saved conversation could not be restored.' })
-        throw new HarnessError('native_resume_unavailable', 'The saved conversation could not be restored.')
-      }
-      const opened = pi
-      updateRun(root, runId, (record) => void (record.nativeSessionId = opened.sessionId))
-      this.options.subagents.register(input, account.id, capabilities, Boolean(pi.sessionManager))
-      if (pi.model?.id && pi.model.provider) this.options.subagents.resolvedModel(runId, `${pi.model.provider}/${pi.model.id}`, pi.thinkingLevel)
-      params.settle = () => this.options.subagents.verify(runId, opened.sessionManager ? subagentHistory(opened.sessionManager.getBranch()) : undefined)
-      void runTurn(run, pi, params)
-      return { runId, nativeSessionId: pi.sessionId }
-    } catch (error) {
-      pi?.dispose()
-      if (error instanceof HarnessError && error.code === 'native_resume_unavailable') throw error
-      const message = error instanceof Error ? error.message : String(error)
-      log('session failed to start', message)
-      run.finish('failed', { code: error instanceof HarnessError ? error.code : 'provider_unavailable', message })
-      return { runId, nativeSessionId: null }
-    }
-  }
-}

package/src/sessions/subagentService.test.ts

@@ -1,159 +0,0 @@
-import { 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 type { SessionRunInput } from './sessions'
-import { SUBAGENT_OWNER, SUBAGENT_RECEIPT, subagentHistory } from './subagents'
-import { loadRun, recordSubagent, saveRun } from './runStore'
-
-const open: Harness[] = []
-afterEach(async () => { for (const harness of open.splice(0)) await harness.close() })
-
-function setup() {
-  const finish = new Map<string, (text: string) => void>()
-  const root = mkdtempSync(join(tmpdir(), 'native-subagents-'))
-  const harness = createHarness({ dataRoot: join(root, 'data'), stateDir: join(root, 'state'), secrets: memorySecretStore(), sessionFactory: async ({ params }) => {
-    let emit: (event: any) => void = () => {}
-    let done: () => void = () => {}
-    return { sessionId: 'native-history', subscribe: (listener) => { emit = listener; return () => {} }, sendCustomMessage: async () => {},
-      prompt: () => new Promise<void>((resolve) => { done = resolve; finish.set(params.runId, (text) => {
-        emit({ type: 'message_end', message: { role: 'assistant', content: [{ type: 'text', text }] } }); resolve()
-      }) }), abort: async () => done(), dispose: () => {} }
-  } })
-  open.push(harness)
-  harness.accounts.create('Main', 'apiKey')
-  const start = (id: string, extra: Partial<SessionRunInput> = {}) => harness.sessions.run({
-    run: { id, sessionId: 'opaque-parent' }, caller: { agentId: 'caller', actor: 'Chat' }, cwd: root,
-    sessionDir: join(root, 'history'), text: 'Parent', tools: { allow: ['read'] }, ...extra
-  })
-  return { harness, finish, start }
-}
-const empty = () => ({ owners: [], receipts: [] })
-
-describe('native subagent ownership and delivery', () => {
-  it('spawns asynchronously, joins selected children, and rejects foreign handles', async () => {
-    const { harness, finish, start } = setup()
-    await start('parent')
-    const a = await harness.subagents.spawn({ parentRunId: 'parent', brief: 'First', tools: ['read'] })
-    const b = await harness.subagents.spawn({ parentRunId: 'parent', brief: 'Second', tools: [] })
-    expect(harness.subagents.results({ parentRunId: 'parent' }).map(result => result.status)).toEqual(['running', 'running'])
-    await expect(harness.subagents.wait({ parentRunId: 'parent', runIds: ['foreign'] })).rejects.toMatchObject({ code: 'invalid_request' })
-    let joined = false
-    const pending = harness.subagents.wait({ parentRunId: 'parent', runIds: [b.runId] }).then(results => { joined = true; return results })
-    finish.get(a.runId)!('First result')
-    await harness.runs.wait(a.runId)
-    expect(joined).toBe(false)
-    const canceled = new AbortController()
-    canceled.abort()
-    await expect(harness.subagents.wait({ parentRunId: 'parent', runIds: [b.runId] }, canceled.signal)).rejects.toMatchObject({ code: 'run_not_active' })
-    finish.get(b.runId)!('Second result')
-    expect(await pending).toMatchObject([{ runId: b.runId, status: 'completed', text: 'Second result' }])
-    expect(loadRun(harness.env.root, a.runId).sessionId).not.toContain(':subagent:')
-  })
-
-  it('delivers already-settled results, retries uncommitted drafts, and trusts only typed receipts', async () => {
-    const { harness, finish, start } = setup()
-    await start('parent')
-    const child = await harness.subagents.spawn({ parentRunId: 'parent', brief: 'Find evidence' })
-    finish.get(child.runId)!('Evidence')
-    await harness.runs.wait(child.runId)
-    const mentioned = subagentHistory([{ content: `I mentioned ${child.runId}` }])
-    const first = await harness.subagents.delivery('parent', mentioned, true)
-    expect(first?.text).toContain('Evidence')
-    expect(await harness.subagents.delivery('parent', empty(), true)).toEqual(first)
-    const committed = subagentHistory([{ type: 'custom_message', details: { [SUBAGENT_RECEIPT]: first!.receipt } }])
-    expect(await harness.subagents.delivery('parent', committed, true)).toBeNull()
-  })
-
-  it('waits before final delivery and releases pending joins when the parent stops', async () => {
-    const { harness, start } = setup()
-    await start('parent')
-    const child = await harness.subagents.spawn({ parentRunId: 'parent', brief: 'Wait' })
-    const pending = harness.subagents.delivery('parent', empty(), true)
-    const interrupted = expect(pending).rejects.toMatchObject({ code: 'run_not_active' })
-    await harness.runs.interrupt('parent')
-    await interrupted
-    expect(loadRun(harness.env.root, child.runId).status).toBe('interrupted')
-    expect(harness.subagents.results({ parentRunId: 'parent' })).toMatchObject([{ runId: child.runId, status: 'interrupted' }])
-  })
-
-  it('recovers a child whose spawn return was lost, only from its owning history and account', async () => {
-    const { harness, finish, start } = setup()
-    await start('original')
-    const child = await harness.subagents.spawn({ parentRunId: 'original', brief: 'Recover' })
-    finish.get(child.runId)!('Retained result')
-    await harness.runs.wait(child.runId)
-    recordSubagent(harness.env.root, 'original', 'reserved-before-crash')
-    await harness.runs.interrupt('original')
-    await start('resumed')
-    expect(await harness.subagents.delivery('resumed', empty(), true)).toBeNull()
-    const branch = subagentHistory([{ type: 'custom', customType: SUBAGENT_OWNER, data: { runId: 'original' } }])
-    const recovered = await harness.subagents.delivery('resumed', branch, true)
-    expect(recovered?.text).toContain('Retained result')
-    expect(recovered?.receipt.delivered).toEqual([child.runId, 'reserved-before-crash'])
-    expect(loadRun(harness.env.root, 'reserved-before-crash')).toMatchObject({ status: 'interrupted', relation: 'subagent', parentRunId: 'original' })
-    await harness.runs.interrupt('resumed')
-    const other = harness.accounts.create('Other', 'apiKey').accounts.find(account => account.label === 'Other')!
-    await start('wrong-account', { accountId: other.id })
-    expect(await harness.subagents.delivery('wrong-account', branch, true)).toBeNull()
-  })
-
-  it('reconstructs disk ownership after reopening without automatically restarting model work', async () => {
-    const { harness, finish, start } = setup()
-    await start('original')
-    const child = await harness.subagents.spawn({ parentRunId: 'original', brief: 'Persisted work' })
-    finish.get(child.runId)!('On-disk result')
-    await harness.runs.wait(child.runId)
-    recordSubagent(harness.env.root, 'original', 'orphan-after-crash')
-    const original = loadRun(harness.env.root, 'original')
-    saveRun(harness.env.root, { ...original, id: 'orphan-after-crash', sessionId: 'orphan-session', parentRunId: 'original', relation: 'subagent', status: 'running' })
-    const dataRoot = harness.env.root
-    const stateDir = harness.stateDir
-    await harness.close()
-    open.splice(open.indexOf(harness), 1)
-    let opened = 0
-    const restarted = createHarness({ dataRoot, stateDir, secrets: memorySecretStore(), sessionFactory: async () => {
-      opened++
-      return { sessionId: 'native-history', subscribe: () => () => {}, prompt: async () => new Promise<void>(() => {}), sendCustomMessage: async () => {}, abort: async () => {}, dispose: () => {} }
-    } })
-    open.push(restarted)
-    expect(opened).toBe(0)
-    expect(loadRun(dataRoot, 'orphan-after-crash').status).toBe('interrupted')
-    await restarted.sessions.run({ run: { id: 'explicit-resume', sessionId: original.sessionId, resumedFromRunId: original.id }, caller: { agentId: 'caller', actor: 'Chat' }, cwd: original.workingDirectory!, sessionDir: join(original.workingDirectory!, 'history'), text: 'Resume', tools: { allow: ['read'] } })
-    const delivery = await restarted.subagents.delivery('explicit-resume', { owners: ['original'], receipts: [] }, true)
-    expect(delivery?.text).toContain('On-disk result')
-    expect(delivery?.receipt.delivered).toEqual([child.runId, 'orphan-after-crash'])
-    expect(opened).toBe(1)
-  })
-
-  it('enables interactive callers at a host depth without extending native nesting or unattended access', async () => {
-    const { harness, start } = setup()
-    await start('host-depth', { depth: 3 })
-    const child = await harness.subagents.spawn({ parentRunId: 'host-depth', brief: 'One native level' })
-    await expect(harness.subagents.spawn({ parentRunId: child.runId, brief: 'Too deep' })).rejects.toMatchObject({ code: 'invalid_request' })
-    await harness.runs.interrupt('host-depth')
-    await start('unattended', { automatic: true })
-    await expect(harness.subagents.spawn({ parentRunId: 'unattended', brief: 'Not enabled' })).rejects.toMatchObject({ code: 'invalid_request' })
-  })
-
-  it('does not acknowledge results omitted from a bounded delivery batch', async () => {
-    const { harness, finish, start } = setup()
-    await start('parent')
-    const children = await Promise.all([1, 2, 3].map(n => harness.subagents.spawn({ parentRunId: 'parent', brief: String(n) })))
-    for (const child of children) finish.get(child.runId)!('x'.repeat(16_000))
-    await harness.subagents.wait({ parentRunId: 'parent' })
-    const receipts: any[] = []
-    const delivered: string[] = []
-    for (let i = 0; i < 3; i++) {
-      const batch = await harness.subagents.delivery('parent', { owners: [], receipts }, true)
-      expect(batch).not.toBeNull()
-      delivered.push(...batch!.receipt.delivered!)
-      receipts.push(batch!.receipt)
-    }
-    expect(delivered).toEqual(children.map(child => child.runId))
-    expect(await harness.subagents.delivery('parent', { owners: [], receipts }, true)).toBeNull()
-  })
-})