@xingular/harness 0.1.6 → 1.0.0

package/src/terminal/standalone.test.ts

@@ -1,130 +0,0 @@
-import { EventEmitter } from 'node:events'
-import { createHash } from 'node:crypto'
-import { existsSync, mkdtempSync, rmSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join, resolve } from 'node:path'
-import type { ChildProcess, spawn as nodeSpawn } from 'node:child_process'
-import { afterEach, describe, expect, it, vi } from 'vitest'
-
-import { memorySecretStore } from '../accounts/secrets'
-import { createHarness, type Harness, type HarnessOptions } from '../harness'
-import { defaultAssets } from './terminals'
-import { parseStandaloneOptions, runStandaloneTerminal, standaloneArguments } from './standalone'
-import { socketPath } from './socket'
-
-const scratch: string[] = []
-const harnesses: Harness[] = []
-
-afterEach(async () => {
-  for (const harness of harnesses.splice(0)) await harness.close()
-  for (const path of scratch.splice(0)) rmSync(path, { recursive: true, force: true })
-  vi.restoreAllMocks()
-})
-
-function temporaryDirectory(prefix: string): string {
-  const path = mkdtempSync(join(tmpdir(), prefix))
-  scratch.push(path)
-  return path
-}
-
-function fakeSpawn(onSpawn: (program: string, args: string[], options: { cwd?: string; env?: NodeJS.ProcessEnv; stdio?: string }) => void, outcome: { code?: number; error?: Error } = {}): typeof nodeSpawn {
-  return ((program: string, args: string[], options: { cwd?: string; env?: NodeJS.ProcessEnv; stdio?: string }) => {
-    onSpawn(program, args, options)
-    const child = new EventEmitter() as ChildProcess
-    child.kill = vi.fn(() => true)
-    queueMicrotask(() => {
-      if (outcome.error) child.emit('error', outcome.error)
-      else child.emit('exit', outcome.code ?? 0, null)
-    })
-    return child
-  }) as unknown as typeof nodeSpawn
-}
-
-function harnessFactory(options: HarnessOptions): Harness {
-  const harness = createHarness({ ...options, secrets: memorySecretStore(), piProgram: () => '/opt/pi/bin/pi' })
-  harnesses.push(harness)
-  return harness
-}
-
-describe('standalone terminal startup', () => {
-  it('routes the no-command and terminal invocations to Pi, leaving host commands explicit', () => {
-    expect(standaloneArguments([])).toEqual([])
-    expect(standaloneArguments(['--data', '/tmp/data'])).toEqual(['--data', '/tmp/data'])
-    expect(standaloneArguments(['terminal', '--state', '/tmp/state'])).toEqual(['--state', '/tmp/state'])
-    expect(standaloneArguments(['serve', '--state', '/tmp/state'])).toBeNull()
-  })
-
-  it('uses a dedicated default data and state root and accepts path overrides', () => {
-    expect(parseStandaloneOptions([], '/home/test', '/work/project')).toEqual({
-      dataRoot: '/home/test/.xingular-harness/data',
-      stateDir: '/home/test/.xingular-harness/state'
-    })
-    expect(parseStandaloneOptions(['--data', './knowledge', '--state', './device'], '/home/test', '/work/project')).toEqual({
-      dataRoot: '/work/project/knowledge',
-      stateDir: '/work/project/device'
-    })
-    expect(() => parseStandaloneOptions(['--data'])).toThrow('--data needs a directory path.')
-    expect(() => parseStandaloneOptions(['--model', 'unknown'])).toThrow('Unknown standalone option: --model')
-  })
-
-  it('refuses default folders under a home that is not a folder path, and accepts explicit absolute folders', () => {
-    expect(() => parseStandaloneOptions([], 'HOME', '/work/project')).toThrow('is not an absolute path')
-    expect(parseStandaloneOptions(['--data', '/data', '--state', '/state'], 'HOME', '/work/project')).toEqual({ dataRoot: '/data', stateDir: '/state' })
-  })
-
-  it('starts Pi in the current directory, creates the first isolated account, and cleans up on exit', async () => {
-    const home = temporaryDirectory('harness-standalone-')
-    const cwd = temporaryDirectory('harness-cwd-')
-    const paths = parseStandaloneOptions([], home)
-    let invocation: { program: string; args: string[]; options: { cwd?: string; env?: NodeJS.ProcessEnv; stdio?: string } } | undefined
-    const spawn = fakeSpawn((program, args, options) => {
-      invocation = { program, args, options }
-    })
-
-    expect(await runStandaloneTerminal([], { home, cwd, stdinIsTTY: true, stdoutIsTTY: true, createSessionId: () => 'standalone', createHarness: harnessFactory, spawn })).toBe(0)
-
-    const harness = harnesses.shift()!
-    expect(harness.accounts.overview().accounts).toMatchObject([{ label: 'Default', isDefault: true }])
-    expect(invocation?.program).toBe('/opt/pi/bin/pi')
-    expect(invocation?.options).toMatchObject({ cwd, stdio: 'inherit' })
-    expect(invocation?.args).toContain('--extension')
-    expect(invocation?.args).toContain(defaultAssets().piExtension)
-    expect(invocation?.args).toContain(join(paths.dataRoot, 'sessions', 'terminal', createHash('sha256').update(resolve(cwd)).digest('hex'), 'pi'))
-    expect(invocation?.options.env?.PI_CODING_AGENT_DIR).toContain(join(paths.stateDir, 'accounts'))
-    expect(invocation?.options.env?.XINGULAR_HARNESS_SOCKET).toBeTruthy()
-    expect(invocation?.options.env?.XINGULAR_HARNESS_TOKEN).toBeTruthy()
-    expect(existsSync(join(paths.stateDir, 'accounts', harness.accounts.overview().accounts[0].id, 'home', 'pi', 'auth.json'))).toBe(false)
-    expect(existsSync(socketPath(paths.stateDir))).toBe(false)
-    expect(harness.terminals.has('standalone')).toBe(false)
-  })
-
-  it('requires an interactive TTY before creating Harness data', async () => {
-    const create = vi.fn(harnessFactory)
-    await expect(runStandaloneTerminal([], { stdinIsTTY: false, stdoutIsTTY: true, createHarness: create })).rejects.toThrow('needs a TTY')
-    expect(create).not.toHaveBeenCalled()
-  })
-
-  it('cleans up the prepared terminal when Pi cannot be spawned', async () => {
-    const home = temporaryDirectory('harness-standalone-fail-')
-    const cwd = temporaryDirectory('harness-cwd-fail-')
-    const spawn = fakeSpawn(() => undefined, { error: new Error('spawn failed') })
-
-    await expect(runStandaloneTerminal([], { home, cwd, stdinIsTTY: true, stdoutIsTTY: true, createSessionId: () => 'failed', createHarness: harnessFactory, spawn })).rejects.toThrow('spawn failed')
-
-    const harness = harnesses.shift()!
-    const account = harness.accounts.overview().accounts[0]
-    expect(existsSync(join(harness.accounts.dir, account.id, 'home', 'pi', 'auth.json'))).toBe(false)
-    expect(existsSync(socketPath(harness.stateDir))).toBe(false)
-    expect(harness.terminals.has('failed')).toBe(false)
-  })
-
-  it('explains a missing Pi executable in terms of the terminal launch', async () => {
-    const home = temporaryDirectory('harness-standalone-enoent-')
-    const cwd = temporaryDirectory('harness-cwd-enoent-')
-    const error = Object.assign(new Error('spawn /opt/pi/bin/pi ENOENT'), { code: 'ENOENT' })
-    const spawn = fakeSpawn(() => undefined, { error })
-
-    await expect(runStandaloneTerminal([], { home, cwd, stdinIsTTY: true, stdoutIsTTY: true, createSessionId: () => 'missing-pi', createHarness: harnessFactory, spawn }))
-      .rejects.toThrow(/Could not start Pi terminal.*Pi executable.*\/opt\/pi\/bin\/pi/)
-  })
-})

package/src/terminal/standalone.ts

@@ -1,144 +0,0 @@
-// The standalone entry point for people using the harness directly. Pi owns the interface;
-// the harness prepares the isolated account, context, extension, and session socket.
-import { spawn as nodeSpawn } from 'node:child_process'
-import { createHash, randomUUID } from 'node:crypto'
-import { homedir } from 'node:os'
-import { isAbsolute, join, resolve } from 'node:path'
-
-import { createHarness, type Harness, type HarnessOptions } from '../harness'
-import type { TerminalLaunch } from './terminals'
-
-export interface StandalonePaths {
-  dataRoot: string
-  stateDir: string
-}
-
-export interface StandaloneDependencies {
-  home?: string
-  cwd?: string
-  stdinIsTTY?: boolean
-  stdoutIsTTY?: boolean
-  createSessionId?: () => string
-  createHarness?: (options: HarnessOptions) => Harness
-  spawn?: typeof nodeSpawn
-}
-
-export function standaloneArguments(argv: string[]): string[] | null {
-  const command = argv[0]
-  if (!command || command.startsWith('--') || command === '-h') return argv
-  return command === 'terminal' ? argv.slice(1) : null
-}
-
-export function parseStandaloneOptions(argv: string[], home = homedir(), cwd = process.cwd()): StandalonePaths {
-  const root = join(home, '.xingular-harness')
-  const paths: StandalonePaths = {
-    dataRoot: join(root, 'data'),
-    stateDir: join(root, 'state')
-  }
-
-  const given = new Set<string>()
-  for (let index = 0; index < argv.length; index += 1) {
-    const argument = argv[index]
-    if (argument !== '--data' && argument !== '--state') throw new Error(`Unknown standalone option: ${argument}`)
-    const value = argv[index + 1]
-    if (!value || value.startsWith('--')) throw new Error(`${argument} needs a directory path.`)
-    paths[argument === '--data' ? 'dataRoot' : 'stateDir'] = resolve(cwd, value)
-    given.add(argument)
-    index += 1
-  }
-
-  // A home that is not a folder path (for example HOME set to the word "HOME") would put the
-  // defaults, and the session socket, in whatever folder the command was started from.
-  if (!isAbsolute(home) && !(given.has('--data') && given.has('--state'))) {
-    throw new Error(`The home folder "${home}" is not an absolute path, so the default data and state folders cannot be placed. Set HOME to your home folder, or pass --data and --state with absolute folders.`)
-  }
-
-  return paths
-}
-
-function processEnvironment(overrides: Record<string, string | null>): NodeJS.ProcessEnv {
-  const environment = { ...process.env }
-  for (const [name, value] of Object.entries(overrides)) {
-    if (value === null) delete environment[name]
-    else environment[name] = value
-  }
-  return environment
-}
-
-function exitCode(code: number | null, signal: NodeJS.Signals | null): number {
-  if (code !== null) return code
-  if (signal === 'SIGINT') return 130
-  if (signal === 'SIGTERM') return 143
-  if (signal === 'SIGHUP') return 129
-  return 1
-}
-
-function spawnError(error: Error, launch: TerminalLaunch): Error {
-  const code = (error as NodeJS.ErrnoException).code
-  if (code !== 'ENOENT' && code !== 'EACCES' && code !== 'EPERM') return error
-  if (launch.program === process.execPath || launch.env.XINGULAR_HARNESS_NODE === launch.program) {
-    return new Error(`Could not start the Pi terminal because Node could not run "${launch.args[0] ?? 'the bundled Pi CLI'}" (${code}). Verify Node and the bundled Pi package are installed.`, { cause: error })
-  }
-  const problem = code === 'ENOENT' ? 'was not found' : `could not start (${code})`
-  return new Error(`Could not start Pi terminal. Pi executable "${launch.program}" ${problem}; verify it is installed and executable or check the configured terminal executable.`, { cause: error })
-}
-
-function spawnPi(launch: TerminalLaunch, cwd: string, spawn = nodeSpawn): Promise<number> {
-  return new Promise((resolveExit, reject) => {
-    const child = spawn(launch.program, launch.args, {
-      cwd,
-      env: processEnvironment(launch.env),
-      stdio: 'inherit'
-    })
-    let settled = false
-    const cleanup = (): void => {
-      process.off('SIGINT', onInterrupt)
-      process.off('SIGTERM', onTerminate)
-      process.off('SIGHUP', onHangup)
-    }
-    const finish = (action: () => void): void => {
-      if (settled) return
-      settled = true
-      cleanup()
-      action()
-    }
-    // Ctrl+C is delivered to both processes in the foreground process group. Keep this host
-    // alive while Pi handles it so the account credentials and harness socket are cleaned up.
-    const onInterrupt = (): void => undefined
-    const onTerminate = (): void => {
-      child.kill('SIGTERM')
-    }
-    const onHangup = (): void => undefined
-
-    process.on('SIGINT', onInterrupt)
-    process.on('SIGTERM', onTerminate)
-    process.on('SIGHUP', onHangup)
-    child.once('error', (error) => finish(() => reject(spawnError(error, launch))))
-    child.once('exit', (code, signal) => finish(() => resolveExit(exitCode(code, signal))))
-  })
-}
-
-export async function runStandaloneTerminal(argv: string[], dependencies: StandaloneDependencies = {}): Promise<number> {
-  if (!(dependencies.stdinIsTTY ?? process.stdin.isTTY) || !(dependencies.stdoutIsTTY ?? process.stdout.isTTY)) {
-    throw new Error('The interactive Harness terminal needs a TTY. Run it from a terminal, or use `xingular-harness serve` for a host process.')
-  }
-
-  const cwd = resolve(dependencies.cwd ?? process.cwd())
-  const paths = parseStandaloneOptions(argv, dependencies.home, cwd)
-  const makeHarness = dependencies.createHarness ?? createHarness
-  const harness = makeHarness({ dataRoot: paths.dataRoot, stateDir: paths.stateDir, productName: 'Xingular Harness' })
-  const sessionId = (dependencies.createSessionId ?? randomUUID)()
-
-  try {
-    await harness.ready
-    if (harness.accounts.overview().accounts.length === 0) harness.accounts.create('Default', 'subscription')
-
-    const cwdHash = createHash('sha256').update(cwd).digest('hex')
-    const sessionFolder = join(paths.dataRoot, 'sessions', 'terminal', cwdHash)
-    const launch = await harness.terminals.prepare({ sessionId, cwd, sessionFolder })
-    return await spawnPi(launch, cwd, dependencies.spawn)
-  } finally {
-    await harness.terminals.dispose(sessionId)
-    await harness.close()
-  }
-}

package/src/terminal/terminal.test.ts

@@ -1,330 +0,0 @@
-import { existsSync, mkdirSync, mkdtempSync, readFileSync, writeFileSync } from 'node:fs'
-import { spawnSync } from 'node:child_process'
-import { connect } from 'node:net'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { afterEach, describe, expect, it, vi } from 'vitest'
-
-import { memorySecretStore } from '../accounts/secrets'
-import { createHarness, type Harness } from '../harness'
-import type { RunEvent } from '../sessions/contracts'
-import type { ToolPolicy } from '../sessions/policy'
-import { loadRun } from '../sessions/runStore'
-import type { Found } from '../plugins/discover'
-import { rootWithProject, writeFile } from '../../tests/helpers'
-import { parseCli } from './cli'
-import { SOCKET_ENV, TOKEN_ENV, socketCall, type SocketConnection } from './client'
-import { SessionSocket } from './socket'
-
-const open: Harness[] = []
-afterEach(async () => {
-  vi.useRealTimers()
-  for (const harness of open.splice(0)) await harness.close()
-})
-
-async function setup(policy: ToolPolicy = {}) {
-  const root = rootWithProject()
-  const harness = createHarness({ dataRoot: root, stateDir: mkdtempSync(join(tmpdir(), 'hs-')), secrets: memorySecretStore(), policy, piProgram: () => '/opt/pi/bin/pi', assets: { node: '/opt/node', cli: '/opt/harness/cli.js', piExtension: '/opt/harness/terminal-pi.js' } })
-  const legacyBin = join(harness.stateDir, 'run', 'bin')
-  mkdirSync(legacyBin, { recursive: true })
-  writeFileSync(join(legacyBin, 'agentx-wiki'), 'old wrapper')
-  writeFileSync(join(legacyBin, 'agentx-mcp'), 'old wrapper')
-  open.push(harness)
-  const account = harness.accounts.create('Main', 'apiKey').accounts[0]
-  const events: RunEvent[] = []
-  const notices: Record<string, unknown>[] = []
-  harness.runs.listen((event) => void events.push(event))
-  harness.bus.on((notice) => void notices.push(notice))
-  const sessionFolder = join(root, 'sessions', 'p1', 'term-1')
-  const launch = await harness.terminals.prepare({ sessionId: 'term-1', accountId: account.id, projectId: 'p1', cwd: root, sessionFolder, model: 'chosen-model', launch: { connections: 'Use mcp_list_tools.' } })
-  const connection: SocketConnection = { socket: String(launch.env[SOCKET_ENV]), token: String(launch.env[TOKEN_ENV]) }
-  /** One telemetry line, as the native extension sends it. */
-  const tell = (event: string, data: Record<string, unknown> = {}) =>
-    new Promise<any>((resolve, reject) => {
-      const stream = connect(connection.socket)
-      let buffer = ''
-      stream.on('connect', () => stream.write(`${JSON.stringify({ token: connection.token, event, data })}\n`))
-      stream.on('data', (chunk) => {
-        buffer += chunk.toString()
-        if (!buffer.includes('\n')) return
-        const reply = JSON.parse(buffer.slice(0, buffer.indexOf('\n')))
-        stream.end()
-        if (reply.error) reject(new Error(reply.error.message))
-        else resolve(reply.result)
-      })
-      stream.on('error', reject)
-    })
-  return { harness, root, account, events, notices, launch, connection, tell, sessionFolder }
-}
-
-describe('a pi terminal session', () => {
-  it('launches on the pinned account with compiled instructions, the extension, and the session socket', async () => {
-    const { launch, account, harness, sessionFolder, root } = await setup()
-    expect(launch.program).toBe('/opt/pi/bin/pi')
-    expect(launch.accountId).toBe(account.id)
-    expect(launch.args[0]).toBe('--append-system-prompt')
-    expect(launch.args[1]).toContain('# Xingular Harness context')
-    expect(launch.args[1]).toContain('xagent-wiki')
-    // Pi's own discovery is off; its command's built-in extensions are named, and the harness's comes last.
-    expect(launch.args.slice(2)).toEqual([
-      '--model', 'chosen-model', '--no-extensions', '--no-skills', '--no-prompt-templates', '--no-themes',
-      '--extension', 'builtin:llama.cpp', '--extension', 'builtin:codemode', '--extension', 'builtin:tool-search', '--extension', 'builtin:mcp',
-      '--extension', '/opt/harness/terminal-pi.js', '--session-dir', join(sessionFolder, 'pi')
-    ])
-    expect(launch.env.PI_CODING_AGENT_DIR).toBe(join(harness.accounts.dir, account.id, 'home', 'pi'))
-    expect(String(launch.env.PATH).split(':')[0]).toBe(join(harness.stateDir, 'run', 'bin'))
-    expect(readFileSync(join(harness.stateDir, 'run', 'bin', 'xagent-wiki'), 'utf8')).toBe("#!/bin/sh\nexec '/opt/node' '/opt/harness/cli.js' wiki \"$@\"\n")
-    expect(readFileSync(join(harness.stateDir, 'run', 'bin', 'xagent-mcp'), 'utf8')).toContain("'/opt/harness/cli.js' mcp")
-    expect(existsSync(join(harness.stateDir, 'run', 'bin', 'agentx-wiki'))).toBe(false)
-    expect(existsSync(join(harness.stateDir, 'run', 'bin', 'agentx-mcp'))).toBe(false)
-    // The session keeps the pack it started with.
-    expect(JSON.parse(readFileSync(join(sessionFolder, 'context.json'), 'utf8')).profile).toBe('session')
-    expect(root).toBeTruthy()
-  })
-
-  it.skipIf(process.platform !== 'win32')('starts the resolved Pi CLI through Node without a model or interactive terminal', async () => {
-    const root = rootWithProject()
-    const stateDir = mkdtempSync(join(tmpdir(), 'hs-pi-smoke-'))
-    const harness = createHarness({ dataRoot: root, stateDir, secrets: memorySecretStore() })
-    open.push(harness)
-    harness.accounts.create('Main', 'subscription')
-    const launch = await harness.terminals.prepare({ sessionId: 'pi-smoke', cwd: root, sessionFolder: join(root, 'sessions', 'pi-smoke') })
-    const cli = launch.args[0]
-    const pathKeys = Object.keys(launch.env).filter((name) => name.toLowerCase() === 'path')
-
-    expect(launch.program).toBe(process.execPath)
-    expect(pathKeys).toHaveLength(1)
-    expect(launch.env[pathKeys[0]]).toContain(';')
-    expect(launch.env.XINGULAR_HARNESS_NODE).toBe(process.execPath)
-    expect(readFileSync(join(stateDir, 'run', 'bin', 'xagent-wiki.cmd'), 'utf8')).toContain(' wiki %*\r\n')
-    const result = spawnSync(launch.program, [cli, '--help'], { cwd: root, encoding: 'utf8', timeout: 20_000 })
-    expect(result.error).toBeUndefined()
-    expect(result.status).toBe(0)
-    expect(`${result.stdout}${result.stderr}`).toMatch(/usage|options|pi coding agent/i)
-  })
-
-  it('passes what the harness found as paths, the enabled registry items with them, and its own extension last', async () => {
-    const root = rootWithProject()
-    writeFile(join(root, 'registry/skills/release/SKILL.md'), '# Release\n')
-    writeFile(join(root, 'registry/prompts/review.md'), 'Review this.\n')
-    writeFile(join(root, 'config/registry-enabled.json'), JSON.stringify({ p1: ['skills/release', 'prompts/review'] }))
-    writeFile(join(root, '.pi/extensions/local.ts'), 'export default function () {}\n')
-    const item = (kind: Found['kind'], path: string, origin: Found['origin'], enabled = true): Found => ({ kind, path, origin, project: origin === 'project', packageRoot: null, source: null, enabled })
-    const found = [
-      item('extension', join(root, '.pi/extensions/local.ts'), 'project'),
-      item('extension', '/shared/extensions/mine.ts', 'shared'),
-      item('extension', '/shared/extensions/off.ts', 'shared', false),
-      item('extension', 'builtin:mcp', 'builtin'),
-      item('skill', '/shared/skills/alpha/SKILL.md', 'shared'),
-      item('prompt', '/shared/prompts/p.md', 'shared'),
-      item('theme', '/shared/themes/dark.json', 'shared')
-    ]
-    const harness = createHarness({ dataRoot: root, stateDir: mkdtempSync(join(tmpdir(), 'hs-')), secrets: memorySecretStore(), piProgram: () => '/opt/pi/bin/pi', assets: { node: '/opt/node', cli: '/opt/harness/cli.js', piExtension: '/opt/harness/terminal-pi.js' }, resolver: async () => found })
-    open.push(harness)
-    const account = harness.accounts.create('Main', 'apiKey').accounts[0]
-    const prepare = async () => (await harness.terminals.prepare({ sessionId: 'term-1', accountId: account.id, projectId: 'p1', cwd: root, sessionFolder: join(root, 'sessions', 'p1', 'term-1') })).args.slice(2)
-
-    const loaded = [
-      '--extension', '/shared/extensions/mine.ts', '--extension', 'builtin:mcp',
-      '--skill', join(root, 'registry/skills/release/SKILL.md'), '--skill', '/shared/skills/alpha/SKILL.md',
-      '--prompt-template', join(root, 'registry/prompts/review.md'), '--prompt-template', '/shared/prompts/p.md',
-      '--theme', '/shared/themes/dark.json',
-      '--extension', '/opt/harness/terminal-pi.js', '--session-dir', join(root, 'sessions', 'p1', 'term-1', 'pi')
-    ]
-    const flags = ['--no-extensions', '--no-skills', '--no-prompt-templates', '--no-themes']
-    expect(await prepare()).toEqual([...flags, ...loaded])
-
-    // The working folder's own code joins only once a person trusted it.
-    const code = (await harness.plugins.loading({ cwd: root, agentDir: join(harness.accounts.dir, account.id, 'home', 'pi') })).projectCode!
-    harness.plugins.trust.grant(code, root)
-    expect(await prepare()).toEqual([...flags, '--extension', join(root, '.pi/extensions/local.ts'), ...loaded])
-  })
-
-  it('refuses to launch without the pi command, and never on another account', async () => {
-    const harness = createHarness({ dataRoot: rootWithProject(), stateDir: mkdtempSync(join(tmpdir(), 'hs-')), secrets: memorySecretStore(), piProgram: () => null })
-    open.push(harness)
-    harness.accounts.create('Main', 'apiKey')
-    await expect(harness.terminals.prepare({ sessionId: 's', cwd: '/tmp', sessionFolder: join(harness.env.root, 'sessions', 's') })).rejects.toMatchObject({ code: 'harness_unavailable' })
-    const other = createHarness({ dataRoot: rootWithProject(), stateDir: mkdtempSync(join(tmpdir(), 'hs-')), secrets: memorySecretStore(), piProgram: () => '/opt/pi' })
-    open.push(other)
-    other.accounts.create('Main', 'apiKey')
-    await expect(other.terminals.prepare({ sessionId: 's', accountId: 'missing-account', cwd: '/tmp', sessionFolder: join(other.env.root, 'sessions', 's') })).rejects.toThrow()
-    expect(other.terminals.has('s')).toBe(false)
-  })
-
-  it('records what the person typed as a run and follows it to the end', async () => {
-    const { tell, events, harness, root, notices } = await setup()
-    await tell('startup', { phase: 'Pi extension loaded' })
-    await tell('ready', { nativeSessionId: '/history/native.jsonl' })
-    expect(notices).toContainEqual({ type: 'terminal.native', sessionId: 'term-1', nativeSessionId: '/history/native.jsonl' })
-    await tell('begin', { text: 'Fix the build' })
-    const runId = events[0].runId
-    expect(loadRun(root, runId)).toMatchObject({ mode: 'code', harness: 'pi', sessionType: 'terminal', sessionId: 'term-1', projectId: 'p1', goal: 'Fix the build', nativeSessionId: '/history/native.jsonl' })
-    await tell('tool', { phase: 'start', id: 't1', name: 'read', summary: '{"path":"a"}' })
-    await tell('tool', { phase: 'end', id: 't1', name: 'read', ok: true, durationMs: 4, resultChars: 12 })
-    await tell('message', { text: 'Done.' })
-    await tell('usage', { inputTokens: 5, outputTokens: 2, cacheReadTokens: 0, cacheWriteTokens: 0, requests: 1 })
-    await tell('settled', {})
-    expect(events.map((event) => event.type)).toEqual(['started', 'status.changed', 'message.completed', 'tool.started', 'tool.completed', 'message.completed', 'usage.updated', 'completed'])
-    expect(loadRun(root, runId).status).toBe('completed')
-    expect(harness.terminals.state('term-1')).toEqual({ ready: true, dirty: false, active: false })
-    // The run has the pack its session started with.
-    expect(JSON.parse(readFileSync(join(root, 'runs', runId, 'context.json'), 'utf8')).runId).toBe(runId)
-  })
-
-  it('delivers an instruction through the extension and reserves its run first', async () => {
-    const { tell, harness, root, events } = await setup()
-    await tell('ready', {})
-    const sent = harness.terminals.send({ sessionId: 'term-1', runId: 'reserved', text: 'Run the tests' })
-    await vi.waitFor(async () => expect(await tell('poll')).toEqual({ command: { type: 'send', text: 'Run the tests' } }))
-    expect(loadRun(root, 'reserved')).toMatchObject({ status: 'queued', goal: 'Run the tests' })
-    await tell('begin', { text: 'Run the tests' })
-    expect(await sent).toEqual({ runId: 'reserved' })
-    expect(events[0]).toMatchObject({ runId: 'reserved', type: 'started' })
-    await expect(harness.terminals.send({ sessionId: 'term-1', text: 'Another' })).rejects.toMatchObject({ code: 'session_busy' })
-    await harness.runs.interrupt('reserved')
-    expect(await tell('poll')).toEqual({ command: { type: 'interrupt' } })
-    expect(loadRun(root, 'reserved').status).toBe('interrupted')
-  })
-
-  it('sends a memory block that changed since the session started along with the next instruction', async () => {
-    const { tell, harness, connection } = await setup()
-    await tell('ready', {})
-    await socketCall(connection, 'memory.append', { block: 'project', text: 'Prefers pnpm.' })
-    const first = harness.terminals.send({ sessionId: 'term-1', text: 'Continue' })
-    let delivered = ''
-    await vi.waitFor(async () => {
-      const { command } = await tell('poll')
-      expect(command?.type).toBe('send')
-      delivered = command.text
-    })
-    await tell('begin', { text: delivered })
-    await first
-    expect(delivered.startsWith('[Memory updated since this session')).toBe(true)
-    expect(delivered).toContain('Prefers pnpm.')
-    expect(delivered.endsWith('\n\nContinue')).toBe(true)
-  })
-
-  it('will not send over a draft the person is typing, and fails a delivery the native session never acknowledges', async () => {
-    const { tell, harness, root } = await setup()
-    await tell('ready', {})
-    harness.terminals.input('term-1', 'half a thought')
-    await expect(harness.terminals.send({ sessionId: 'term-1', runId: 'draft', text: 'Task' })).rejects.toMatchObject({ code: 'terminal_has_draft' })
-    expect(loadRun(root, 'draft').status).toBe('failed')
-    harness.terminals.input('term-1', '\u0015')
-    vi.useFakeTimers()
-    const send = harness.terminals.send({ sessionId: 'term-1', runId: 'lost', text: 'Task' })
-    const rejected = expect(send).rejects.toMatchObject({ code: 'delivery_uncertain' })
-    await vi.advanceTimersByTimeAsync(25_001)
-    await rejected
-    vi.useRealTimers()
-    expect(loadRun(root, 'lost').status).toBe('failed')
-    // A late acknowledgement does not start a run for an instruction reported as lost.
-    await expect(tell('begin', { text: 'Task' })).rejects.toThrow('will not be resent')
-    expect(await tell('poll')).toEqual({ command: { type: 'interrupt' } })
-  })
-
-  it('asks before a native action unless the policy allows it, and reads never ask', async () => {
-    const { tell, events, harness } = await setup()
-    await tell('ready', {})
-    await tell('begin', { text: 'Edit' })
-    expect(await tell('policy', { tool: 'read', args: { path: 'a' } })).toEqual({ allowed: true })
-    expect(await tell('policy', { tool: 'bash', args: { command: 'rm -rf x' } })).toMatchObject({ allowed: false, requiresApproval: true })
-    const decision = tell('approval', { requestId: 'call-1', target: 'bash', action: '{"command":"rm -rf x"}', tool: 'bash', args: { command: 'rm -rf x' } })
-    await vi.waitFor(() => expect(events.some((event) => event.type === 'approval.requested')).toBe(true))
-    const request = events.find((event) => event.type === 'approval.requested')!
-    harness.runs.resolveApproval(request.runId, (request.payload as { approvalId: string }).approvalId, 'approved')
-    expect(await decision).toEqual({ decision: 'approved' })
-  })
-
-  it('applies the application policy to native tool calls', async () => {
-    const seen: string[] = []
-    const { tell } = await setup({
-      scope: async (call) => {
-        seen.push(`${call.run.sessionId}:${call.tool}`)
-        return call.tool === 'bash' ? { allowed: false, reason: 'Outside the task.' } : { allowed: true }
-      },
-      authorize: async (call) => {
-        if (call.tool === 'write') throw new Error('Switched off.')
-      }
-    })
-    await tell('ready', {})
-    await tell('begin', { text: 'Go' })
-    expect(await tell('policy', { tool: 'bash', args: {} })).toEqual({ allowed: false, reason: 'Outside the task.' })
-    expect(await tell('policy', { tool: 'write', args: {} })).toEqual({ allowed: false, reason: 'Switched off.' })
-    expect(await tell('policy', { tool: 'edit', args: {} })).toMatchObject({ allowed: true })
-    expect(seen).toEqual(['term-1:bash', 'term-1:write', 'term-1:edit'])
-  })
-
-  it('fails the turn and releases its decisions when the native process hangs up mid-question', async () => {
-    const { tell, events, harness, connection } = await setup()
-    await tell('ready', {})
-    await tell('begin', { text: 'task' })
-    const socket = connect(connection.socket)
-    await new Promise<void>((resolve, reject) => {
-      socket.once('connect', resolve)
-      socket.once('error', reject)
-    })
-    socket.write(`${JSON.stringify({ token: connection.token, event: 'question', data: { requestId: 'native-one', question: 'Continue?' } })}\n`)
-    await vi.waitFor(() => expect(events.some((event) => event.type === 'question.requested')).toBe(true))
-    socket.destroy()
-    await vi.waitFor(() => expect(events.some((event) => event.type === 'failed')).toBe(true))
-    expect((events.find((event) => event.type === 'failed')!.payload as { message: string }).message).toContain('callback disconnected')
-    expect(harness.runs.activeRunIds()).toEqual([])
-    expect(harness.terminals.state('term-1').ready).toBe(false)
-  })
-
-  it('serves memory and connected apps to the session over the socket, until the terminal ends', async () => {
-    const { connection, harness, tell } = await setup()
-    await tell('ready', {})
-    expect(await socketCall<string>(connection, 'wiki.entrypoint')).toContain('# Xingular Harness context')
-    expect(await socketCall<string>(connection, 'wiki.list')).toContain('library')
-    const listed = await socketCall<{ tools: { name: string; parameters: { type: string } }[] }>(connection, 'tools.list')
-    expect(listed.tools.map((tool) => tool.name)).toEqual(['mcp_list_tools', 'mcp_call_tool'])
-    expect(listed.tools[0].parameters.type).toBe('object')
-    await expect(socketCall(connection, 'accounts.list')).rejects.toMatchObject({ code: 'unknown_method' })
-    await expect(socketCall({ ...connection, token: 'guess' }, 'wiki.list')).rejects.toMatchObject({ code: 'unauthorized' })
-    await harness.terminals.dispose('term-1')
-    await expect(socketCall(connection, 'wiki.list')).rejects.toMatchObject({ code: 'unauthorized' })
-    expect(harness.terminals.has('term-1')).toBe(false)
-  })
-
-  it('writes the account credentials for the pi command only while a terminal runs', async () => {
-    const { harness, account } = await setup()
-    const auth = join(harness.accounts.dir, account.id, 'home', 'pi', 'auth.json')
-    expect(JSON.parse(readFileSync(auth, 'utf8'))).toEqual({})
-    await harness.terminals.dispose('term-1')
-    expect(() => readFileSync(auth, 'utf8')).toThrow()
-  })
-})
-
-describe('the session socket', () => {
-  it('answers only calls it knows, for tokens it issued', async () => {
-    const socket = new SessionSocket(join(mkdtempSync(join(tmpdir(), 'sock-')), 's.sock'), { memory: (caller, call) => `${caller.runId}:${call}`, apps: async () => 'apps' })
-    const token = socket.issue({ sessionId: 's1', caller: () => ({ runId: 'r1' }), broker: null })
-    expect(await socket.handle(JSON.stringify({ token, call: 'wiki.search', params: { query: 'x' } }))).toEqual({ result: 'r1:wiki.search' })
-    expect(await socket.handle(JSON.stringify({ token, call: 'agents.create' }))).toMatchObject({ error: { code: 'unknown_method' } })
-    expect(await socket.handle(JSON.stringify({ token, call: 'mcp.list' }))).toMatchObject({ error: { code: 'mcp_unauthorized' } })
-    expect(await socket.handle(JSON.stringify({ token: 'guess', call: 'wiki.search' }))).toMatchObject({ error: { code: 'unauthorized' } })
-    expect(await socket.handle('not json')).toMatchObject({ error: { code: 'invalid_request' } })
-    socket.revokeSession('s1')
-    expect(await socket.handle(JSON.stringify({ token, call: 'wiki.search' }))).toMatchObject({ error: { code: 'unauthorized' } })
-  })
-})
-
-describe('xagent-wiki command', () => {
-  it('maps commands onto memory and Wiki calls', () => {
-    expect(parseCli(['search', 'deploy', 'steps', '--kind', 'page'])).toEqual({ kind: 'call', call: 'wiki.search', params: { query: 'deploy steps', kinds: ['page'] } })
-    expect(parseCli(['read', '/projects/app/arch'])).toEqual({ kind: 'call', call: 'wiki.read', params: { id: '/projects/app/arch' } })
-    expect(parseCli(['list'])).toEqual({ kind: 'call', call: 'wiki.list', params: {} })
-    expect(parseCli(['skill', 'review'])).toEqual({ kind: 'call', call: 'wiki.skill', params: { name: 'review' } })
-    expect(parseCli(['memory', '--namespace', '/projects/app'])).toEqual({ kind: 'call', call: 'wiki.memory', params: { namespace: '/projects/app' } })
-    expect(parseCli(['recall', 'the', 'outage', '--scope', 'all'])).toEqual({ kind: 'call', call: 'recall.search', params: { query: 'the outage', scope: 'all' } })
-    expect(parseCli(['propose', '{"kind":"memory","title":"t","body":"b"}'])).toMatchObject({ kind: 'call', call: 'wiki.propose', params: { kind: 'memory' } })
-    expect(parseCli(['propose', '-'])).toEqual({ kind: 'stdin-propose' })
-    expect(parseCli(['block', 'append', 'project', 'Uses', 'pnpm.'])).toEqual({ kind: 'call', call: 'memory.append', params: { block: 'project', text: 'Uses pnpm.' } })
-    expect(parseCli(['block', 'replace', 'project', '--old', 'npm', '--new', 'pnpm'])).toEqual({ kind: 'call', call: 'memory.replace', params: { block: 'project', old: 'npm', new: 'pnpm' } })
-    expect(parseCli(['search'])).toEqual({ kind: 'help' })
-    expect(parseCli(['nonsense'])).toEqual({ kind: 'help' })
-  })
-})