@agfpd/iapeer 0.2.77 → 0.2.78

package/src/launch/invocation.test.ts

@@ -1,174 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-import { homedir } from 'os'
-import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join, dirname } from 'node:path'
-import { CODEX_BEARER_ENV_VAR, CODEX_DUMMY_BEARER } from '../core/constants.ts'
-import { readLaunchEnv, peerLaunchEnvPath } from '../storage/index.ts'
-import { claudeAdapter } from './adapters/claude.ts'
-import { codexAdapter } from './adapters/codex.ts'
-import { buildLaunchInvocation } from './invocation.ts'
-import type { LaunchAdapterConfig, LaunchSpec, RuntimeAdapter } from './types.ts'
-
-// NON-CIRCULAR GOLDEN (boris's bar): the ORACLE is the PRE-extraction inline build copied VERBATIM
-// from launch/index.ts @595b0f4 — the source of truth is the OLD code, NOT buildLaunchInvocation.
-// The differential test asserts the extracted function reproduces the oracle byte-for-byte; the
-// independent contract assertions (hardcoded from the contract, not from the function's output) catch
-// the case where oracle and function are wrong together. Two anchors: differential catches a
-// reorganization drift, contract catches a shared error.
-function oracleInline(
-  spec: LaunchSpec,
-  adapter: RuntimeAdapter,
-  cfg: LaunchAdapterConfig & { env?: NodeJS.ProcessEnv },
-): { argv: string[]; env: NodeJS.ProcessEnv } {
-  const env = cfg.env ?? process.env
-  const cwd = spec.cwd
-  const identity = spec.identity
-  const launchEnv = readLaunchEnv(cwd, spec.runtime)
-  const specWithArgs: LaunchSpec =
-    launchEnv.startArgs.length > 0
-      ? { ...spec, extraArgs: [...(spec.extraArgs ?? []), ...launchEnv.startArgs] }
-      : spec
-  const runtimeArgv = adapter.buildArgv(specWithArgs, cfg)
-  const childEnv: NodeJS.ProcessEnv = {
-    ...env,
-    ...launchEnv.env,
-    ...(spec.runtime === 'codex' ? { [CODEX_BEARER_ENV_VAR]: CODEX_DUMMY_BEARER } : {}),
-    PEER_PERSONALITY: spec.personality,
-    PEER_RUNTIME: spec.runtime,
-    PEER_IDENTITY: identity,
-    PATH: env.PATH ?? `${homedir()}/.bun/bin:${homedir()}/.local/bin:/opt/homebrew/bin:/usr/bin:/bin`,
-  }
-  return { argv: runtimeArgv, env: childEnv }
-}
-
-const CFG: LaunchAdapterConfig & { env: NodeJS.ProcessEnv } = {
-  claudeBin: '/bin/claude',
-  codexBin: '/bin/codex',
-  env: { PATH: '/test/path', BASE_VAR: 'base' },
-}
-
-function spec(over: Partial<LaunchSpec>): LaunchSpec {
-  return {
-    personality: 'p',
-    runtime: 'claude',
-    cwd: '/nonexistent-cwd-no-launchenv',
-    identity: 'claude-p',
-    socketPath: '/tmp/s.sock',
-    extraArgs: [],
-    ...over,
-  }
-}
-
-const adapterFor = (s: LaunchSpec): RuntimeAdapter => (s.runtime === 'codex' ? codexAdapter : claudeAdapter)
-
-// Representative specs: both runtimes × {bare, with system-prompt, with resume + extraArgs}.
-const SPECS: Array<{ name: string; spec: LaunchSpec }> = [
-  { name: 'claude bare', spec: spec({ runtime: 'claude', identity: 'claude-p' }) },
-  {
-    name: 'claude + system-prompt + resume + extras',
-    spec: spec({ runtime: 'claude', identity: 'claude-p', systemPromptFile: '/sp.md', resume: true, resumeRef: 'uuid-9', extraArgs: ['--foo'] }),
-  },
-  { name: 'codex bare', spec: spec({ runtime: 'codex', identity: 'codex-p' }) },
-  {
-    name: 'codex + system-prompt + resume',
-    spec: spec({ runtime: 'codex', identity: 'codex-p', systemPromptFile: '/sp.md', resume: true }),
-  },
-]
-
-describe('buildLaunchInvocation — differential vs the verbatim pre-extraction oracle', () => {
-  for (const { name, spec: s } of SPECS) {
-    test(`byte-identical to the inline build: ${name}`, () => {
-      const got = buildLaunchInvocation(s, adapterFor(s), CFG)
-      const want = oracleInline(s, adapterFor(s), CFG)
-      expect(got.argv).toEqual(want.argv)
-      expect(got.env).toEqual(want.env)
-    })
-  }
-
-  test('the launch.env merge branch (non-empty startArgs + extra env) is byte-identical too', () => {
-    const cwd = mkdtempSync(join(tmpdir(), 'inv-launchenv-'))
-    try {
-      const p = peerLaunchEnvPath(cwd, 'codex')
-      mkdirSync(dirname(p), { recursive: true })
-      writeFileSync(p, 'PEER_START_ARGS=--from-env-a --from-env-b\nEXTRA_VAR=xyz\n')
-      const s = spec({ runtime: 'codex', identity: 'codex-p', cwd, extraArgs: ['--explicit'] })
-      const got = buildLaunchInvocation(s, codexAdapter, CFG)
-      const want = oracleInline(s, codexAdapter, CFG)
-      expect(got.argv).toEqual(want.argv)
-      expect(got.env).toEqual(want.env)
-      // sanity on the branch itself: explicit extras precede launch.env startArgs, both after base flags
-      expect(got.argv).toContain('--explicit')
-      expect(got.argv).toContain('--from-env-a')
-      expect(got.env.EXTRA_VAR).toBe('xyz')
-    } finally {
-      rmSync(cwd, { recursive: true, force: true })
-    }
-  })
-})
-
-// Silent-loss guard — the claude-hosting canary caught a warm-deliver false-fail: a launch INITIATED
-// from inside a claude session leaked CLAUDE_CODE_SESSION_ID + CLAUDE_CODE_CHILD_SESSION into the
-// child, which then wrote no own transcript → newestActivityMtime null → landed-confirm blind while
-// the message landed. buildLaunchInvocation must strip the claude-code-internal namespace so a
-// launched claude is always a FRESH top-level session, regardless of initiator env.
-describe('buildLaunchInvocation — strips the claude-code-internal session namespace', () => {
-  const DIRTY: LaunchAdapterConfig & { env: NodeJS.ProcessEnv } = {
-    claudeBin: '/bin/claude',
-    codexBin: '/bin/codex',
-    env: {
-      PATH: '/test/path',
-      BASE_VAR: 'base',
-      CLAUDE_CODE_SESSION_ID: 'spawner-session-uuid', // the corruptor (pins the child to the spawner's session)
-      CLAUDE_CODE_CHILD_SESSION: '1', // the corruptor (marks a child sub-session → suppresses own transcript)
-      CLAUDECODE: '1',
-      CLAUDE_CODE_ENTRYPOINT: 'cli',
-      CLAUDE_CODE_EXECPATH: '/v/2.1.177',
-      CLAUDE_EFFORT: 'xhigh', // NOT in the claude-code namespace → must survive (scoped strip, not a wipe)
-    },
-  }
-  test('claude launch: the whole CLAUDE_CODE_* namespace + CLAUDECODE is removed', () => {
-    const { env } = buildLaunchInvocation(spec({ runtime: 'claude', identity: 'claude-p' }), claudeAdapter, DIRTY)
-    expect(env.CLAUDE_CODE_SESSION_ID).toBeUndefined()
-    expect(env.CLAUDE_CODE_CHILD_SESSION).toBeUndefined()
-    expect(env.CLAUDECODE).toBeUndefined()
-    expect(env.CLAUDE_CODE_ENTRYPOINT).toBeUndefined()
-    expect(env.CLAUDE_CODE_EXECPATH).toBeUndefined()
-    // scoped: non-namespace vars (incl. a CLAUDE_-prefixed-but-not-CLAUDE_CODE_ one) survive
-    expect(env.BASE_VAR).toBe('base')
-    expect(env.CLAUDE_EFFORT).toBe('xhigh')
-    expect(env.PEER_IDENTITY).toBe('claude-p')
-  })
-  test('codex launch: same strip applies (harmless — codex ignores CLAUDE_*) and the bearer stub stays', () => {
-    const { env } = buildLaunchInvocation(spec({ runtime: 'codex', identity: 'codex-p' }), codexAdapter, DIRTY)
-    expect(env.CLAUDE_CODE_SESSION_ID).toBeUndefined()
-    expect(env.CLAUDECODE).toBeUndefined()
-    expect(env[CODEX_BEARER_ENV_VAR]).toBe(CODEX_DUMMY_BEARER)
-  })
-})
-
-// Independent contract anchors — expectations come from the CONTRACT, not from the function output.
-describe('buildLaunchInvocation — identity ABI + system-prompt swap (contract values)', () => {
-  test('codex carries the non-secret IAPEER_BEARER stub; claude does NOT (identity in .mcp.json)', () => {
-    expect(buildLaunchInvocation(spec({ runtime: 'codex', identity: 'codex-p' }), codexAdapter, CFG).env[CODEX_BEARER_ENV_VAR]).toBe(
-      CODEX_DUMMY_BEARER,
-    )
-    expect(
-      buildLaunchInvocation(spec({ runtime: 'claude', identity: 'claude-p' }), claudeAdapter, CFG).env[CODEX_BEARER_ENV_VAR],
-    ).toBeUndefined()
-  })
-
-  test('the identity ABI is present and matches the spec', () => {
-    const { env } = buildLaunchInvocation(spec({ runtime: 'codex', personality: 'boris', identity: 'codex-boris' }), codexAdapter, CFG)
-    expect(env.PEER_PERSONALITY).toBe('boris')
-    expect(env.PEER_RUNTIME).toBe('codex')
-    expect(env.PEER_IDENTITY).toBe('codex-boris')
-  })
-
-  test('the per-session system-prompt swap rides in argv (codex -c, claude --system-prompt-file)', () => {
-    const codexArgv = buildLaunchInvocation(spec({ runtime: 'codex', identity: 'codex-p', systemPromptFile: '/sp.md' }), codexAdapter, CFG).argv
-    expect(codexArgv).toContain('model_instructions_file=/sp.md')
-    const claudeArgv = buildLaunchInvocation(spec({ runtime: 'claude', identity: 'claude-p', systemPromptFile: '/sp.md' }), claudeAdapter, CFG).argv
-    expect(claudeArgv.join(' ')).toContain('--system-prompt-file /sp.md')
-  })
-})

package/src/launch/launch.test.ts

@@ -1,359 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-import { exitCauseHook, exitLogPath, getAdapter, launch, paneTail } from './index.ts'
-import { claudeAdapter } from './adapters/claude.ts'
-import { codexAdapter } from './adapters/codex.ts'
-import { telegramAdapter } from './adapters/telegram.ts'
-import { notifierAdapter } from './adapters/notifier.ts'
-import type { LaunchAdapterConfig, LaunchConfig, LaunchSpec } from './types.ts'
-
-const cfg: LaunchAdapterConfig = { claudeBin: '/bin/claude', codexBin: 'codex' }
-// Full LaunchConfig for the gate tests — the intelligence gate returns FAILED at
-// step 0, BEFORE any tmux/FS work, so these values are never exercised.
-const launchCfg: LaunchConfig = {
-  claudeBin: '/bin/claude',
-  codexBin: 'codex',
-  sockDir: '/tmp',
-  bootDeadlineSecs: 1,
-  readyGateSecs: 1,
-  logDir: '/tmp/iapeer-test-logs',
-}
-function spec(over: Partial<LaunchSpec> = {}): LaunchSpec {
-  return {
-    personality: 'p',
-    runtime: 'claude',
-    cwd: '/tmp/p',
-    identity: 'claude-p',
-    socketPath: '/tmp/tmux-iap-claude-p.sock',
-    ...over,
-  }
-}
-
-describe('getAdapter', () => {
-  test('dispatches each runtime to its adapter', () => {
-    expect(getAdapter('claude')).toBe(claudeAdapter)
-    expect(getAdapter('codex')).toBe(codexAdapter)
-    expect(getAdapter('telegram')).toBe(telegramAdapter)
-    expect(getAdapter('notifier')).toBe(notifierAdapter)
-  })
-  test('codex is tui+doctrine, telegram is router+no-doctrine', () => {
-    expect(codexAdapter.kind).toBe('tui')
-    expect(codexAdapter.usesDoctrine).toBe(true)
-    expect(telegramAdapter.kind).toBe('router')
-    expect(telegramAdapter.usesDoctrine).toBe(false)
-  })
-  test('unknown runtime throws', () => {
-    expect(() => getAdapter('webhook')).toThrow()
-  })
-})
-
-describe('codexAdapter.buildArgv', () => {
-  test('bare (no resume, no doctrine): --no-alt-screen -C cwd --dangerously-bypass', () => {
-    expect(codexAdapter.buildArgv(spec({ runtime: 'codex', cwd: '/w' }), cfg)).toEqual([
-      'codex',
-      '--no-alt-screen',
-      '-C',
-      '/w',
-      '--dangerously-bypass-approvals-and-sandbox',
-    ])
-  })
-  test('with resume + model_instructions_file (exact order)', () => {
-    expect(
-      codexAdapter.buildArgv(spec({ runtime: 'codex', cwd: '/w', resume: true, systemPromptFile: '/sp.md' }), cfg),
-    ).toEqual([
-      'codex',
-      'resume',
-      '--last',
-      '--no-alt-screen',
-      '-C',
-      '/w',
-      '-c',
-      'model_instructions_file=/sp.md',
-      '--dangerously-bypass-approvals-and-sandbox',
-    ])
-  })
-})
-
-describe('codexAdapter.isInputReady', () => {
-  test('fresh boot: splash + composer → true', () => {
-    const pane = [
-      '╭───────────────────────────────╮',
-      '│ >_ OpenAI Codex (v0.138.0)    │',
-      '╰───────────────────────────────╯',
-      '› Explain this codebase',
-      'gpt-5.5 xhigh · ~/Peers/p',
-    ].join('\n')
-    expect(codexAdapter.isInputReady(pane)).toBe(true)
-  })
-
-  test('resume replay scrolled the splash off — composer alone is READY (12.06 incident)', () => {
-    // The live zombie pane shape: history tail + MCP noise + composer, NO
-    // 'OpenAI Codex' anywhere in the visible capture. The old predicate required
-    // the splash and spun false for the whole 240 s boot deadline.
-    const pane = [
-      '  <message><![CDATA[Компакт прошел?]]></message>',
-      '  </iap>',
-      '• Принял. Ответ пиру не слал: он явно написал, что больше ничего не нужно.',
-      '⚠ MCP startup incomplete (failed: iap)',
-      '› Explain this codebase',
-      'gpt-5.5 xhigh · ~/Peers/p',
-    ].join('\n')
-    expect(pane.includes('OpenAI Codex')).toBe(false) // fixture honesty
-    expect(codexAdapter.isInputReady(pane)).toBe(true)
-  })
-
-  test('update screen up → false even with a composer-looking line', () => {
-    const pane = ['Update available!', 'Press enter to continue', '› something'].join('\n')
-    expect(codexAdapter.isInputReady(pane)).toBe(false)
-  })
-
-  test('no composer row yet (box only, model loading) → false', () => {
-    const pane = ['│ >_ OpenAI Codex (v0.138.0) │', '│ model: loading │'].join('\n')
-    expect(codexAdapter.isInputReady(pane)).toBe(false)
-  })
-
-  test('bare › without trailing space (a stray glyph) → false', () => {
-    expect(codexAdapter.isInputReady('›\nnothing else')).toBe(false)
-  })
-})
-
-describe('paneTail (never-became-ready observability)', () => {
-  test('last two non-empty lines, joined, quotes flattened', () => {
-    const pane = 'first\n\n  middle  line \n⚠ MCP "failed"\n› composer\n\n'
-    expect(paneTail(pane)).toBe("⚠ MCP 'failed' ⏎ › composer")
-  })
-  test('single line and empty captures', () => {
-    expect(paneTail('only')).toBe('only')
-    expect(paneTail('')).toBe('')
-    expect(paneTail('\n  \n')).toBe('')
-  })
-  test('clips to 160 chars', () => {
-    expect(paneTail('x'.repeat(300)).length).toBe(160)
-  })
-})
-
-describe('telegramAdapter (router — no TUI surface)', () => {
-  test('router predicates are trivial', () => {
-    expect(telegramAdapter.bootDialogKeys('anything')).toBeNull()
-    expect(telegramAdapter.isInputReady('anything')).toBe(true)
-    expect(telegramAdapter.newestActivityMtime('/w')).toBeNull()
-  })
-})
-
-describe('notifierAdapter (router — infra/always-on)', () => {
-  test('kind:router, no doctrine', () => {
-    expect(notifierAdapter.runtime).toBe('notifier')
-    expect(notifierAdapter.kind).toBe('router')
-    expect(notifierAdapter.usesDoctrine).toBe(false)
-  })
-  test('buildArgv = notifier-runtime run [+extra], default bin', () => {
-    expect(notifierAdapter.buildArgv(spec({ runtime: 'notifier' }), cfg)).toEqual(['notifier-runtime', 'run'])
-    expect(
-      notifierAdapter.buildArgv(spec({ runtime: 'notifier', extraArgs: ['--foo'] }), { ...cfg, notifierBin: '/n/bin' }),
-    ).toEqual(['/n/bin', 'run', '--foo'])
-  })
-  test('router predicates are trivial (no TUI surface)', () => {
-    expect(notifierAdapter.bootDialogKeys('anything')).toBeNull()
-    expect(notifierAdapter.isInputReady('anything')).toBe(true)
-    expect(notifierAdapter.newestActivityMtime('/w')).toBeNull()
-    expect(notifierAdapter.resolveResume('/w')).toEqual({ ok: true })
-  })
-})
-
-describe('claudeAdapter', () => {
-  test('kind/usesDoctrine', () => {
-    expect(claudeAdapter.kind).toBe('tui')
-    expect(claudeAdapter.usesDoctrine).toBe(true)
-  })
-
-  test('buildArgv bare (no system-prompt, no resume)', () => {
-    expect(claudeAdapter.buildArgv(spec(), cfg)).toEqual([
-      '/bin/claude',
-      '--dangerously-skip-permissions',
-      '--disallowedTools',
-      'AskUserQuestion',
-    ])
-  })
-
-  test('buildArgv with system-prompt-file + resume + extras → --continue (NOT --resume <uuid>)', () => {
-    // resume uses `--continue` (continue the cwd's most-recent session), NOT
-    // `--resume <uuid>` — in claude 2.1.169 `--resume <arg>` is a search query, not a
-    // session-id. resumeRef is set by the daemon but no longer consumed by the launch.
-    const argv = claudeAdapter.buildArgv(
-      spec({ systemPromptFile: '/tmp/sp.md', resume: true, resumeRef: 'uuid-1', extraArgs: ['--foo'] }),
-      cfg,
-    )
-    expect(argv).toEqual([
-      '/bin/claude',
-      '--dangerously-skip-permissions',
-      '--disallowedTools',
-      'AskUserQuestion',
-      '--system-prompt-file',
-      '/tmp/sp.md',
-      '--continue',
-      '--foo',
-    ])
-    expect(argv).not.toContain('--resume')
-    expect(argv).not.toContain('uuid-1')
-  })
-
-  test('buildArgv: resume FALSE (fresh) → no --continue / --resume', () => {
-    const argv = claudeAdapter.buildArgv(spec({ resume: false, resumeRef: 'uuid-1' }), cfg)
-    expect(argv).not.toContain('--continue')
-    expect(argv).not.toContain('--resume')
-  })
-
-  test('buildArgv carries NO currency (no marketplace/plugin tokens)', () => {
-    const flat = claudeAdapter.buildArgv(spec({ systemPromptFile: '/x' }), cfg).join(' ')
-    expect(flat).not.toMatch(/marketplace|plugin (install|update|marketplace)/)
-  })
-
-  test('isInputReady: ❯ + bypass banner, dialogs gone → true', () => {
-    expect(claudeAdapter.isInputReady('… ❯ …\nbypass permissions on')).toBe(true)
-  })
-  test('isInputReady: a boot dialog present → false even with ❯', () => {
-    expect(claudeAdapter.isInputReady('trust this folder\n❯ bypass permissions on')).toBe(false)
-  })
-  test('isInputReady: no bypass banner → false', () => {
-    expect(claudeAdapter.isInputReady('❯ just a prompt')).toBe(false)
-  })
-
-  test('bootDialogKeys: proceed-modals → [Enter]; clean/load pane → null', () => {
-    expect(claudeAdapter.bootDialogKeys('I am using this for local development')).toEqual(['Enter'])
-    expect(claudeAdapter.bootDialogKeys('trust this folder')).toEqual(['Enter'])
-    expect(claudeAdapter.bootDialogKeys('Allow external CLAUDE.md file imports?')).toEqual(['Enter'])
-    // the post-select "Resuming…" load state is NOT a modal to Enter — just wait.
-    expect(claudeAdapter.bootDialogKeys('Resuming the full session')).toBeNull()
-    expect(claudeAdapter.bootDialogKeys('❯ ready')).toBeNull()
-  })
-
-  test('bootDialogKeys: resume compact-picker is CURSOR-VERIFIED — Enter ONLY after ❯ is seen on "2. full"', () => {
-    // Regression (boris 10.06, 313k resume): the blind ['Down','Enter'] burst lost the
-    // Down in one pty chunk and Enter confirmed the DEFAULT "1. Resume from summary"
-    // → silent /compact. Owner's invariant: NO compact on resume. One key per boot
-    // iteration; confirm only on a PROVEN cursor position.
-    const cursorOn1 = '❯ 1. Resume from summary (recommended)\n  2. Resume full session as-is'
-    const cursorOn2 = '  1. Resume from summary (recommended)\n❯ 2. Resume full session as-is'
-    // cursor on the compacting default → step down, do NOT confirm
-    expect(claudeAdapter.bootDialogKeys(cursorOn1)).toEqual(['Down'])
-    // a swallowed Down self-heals: the unchanged pane just gets another Down
-    expect(claudeAdapter.bootDialogKeys(cursorOn1)).toEqual(['Down'])
-    // cursor PROVEN on "2. Resume full session" → now (and only now) confirm
-    expect(claudeAdapter.bootDialogKeys(cursorOn2)).toEqual(['Enter'])
-    // Enter can never reach the compacting default: option-1 cursor never maps to Enter
-    expect(claudeAdapter.bootDialogKeys(cursorOn1)).not.toContain('Enter')
-    // the 2.1.170 live layout (3rd item present) behaves the same
-    const live170 =
-      "This session is 7h 3m old and 314.2k tokens.\n❯ 1. Resume from summary (recommended)\n  2. Resume full session as-is\n  3. Don't ask me again\nEnter to confirm · Esc to cancel"
-    expect(claudeAdapter.bootDialogKeys(live170)).toEqual(['Down'])
-  })
-})
-
-// ─── exit-cause observability: the pane-died hook builder (pure string) ──────
-describe('exitCauseHook (exit-cause observability)', () => {
-  const hook = exitCauseHook('claude-iapeer', '/r/logs/iapeer/exits.log')
-
-  test('exitLogPath → exits.log sibling to lifecycle.log', () => {
-    expect(exitLogPath('/r/logs/iapeer')).toBe('/r/logs/iapeer/exits.log')
-  })
-  test('reads pane_dead_status AND pane_dead_signal (both death classes)', () => {
-    // graceful exit populates #{pane_dead_status}; a signal populates #{pane_dead_signal}.
-    expect(hook).toContain('dead_status=#{pane_dead_status}')
-    expect(hook).toContain('dead_signal=#{pane_dead_signal}')
-  })
-  test('one logfmt line: ts + ev=session-exit + identity, appended to the exit log', () => {
-    expect(hook).toContain('ev=session-exit')
-    expect(hook).toContain('identity=claude-iapeer')
-    expect(hook).toContain('ts=%s')
-    expect(hook).toContain('>> "/r/logs/iapeer/exits.log"')
-    expect(hook).toContain('\\n') // literal backslash-n for sh printf, not a real newline
-  })
-  test('logs BEFORE it reaps: run-shell (sync, no -b) then tmux-native kill-session', () => {
-    // run-shell must NOT be backgrounded (-b) — the printf has to finish before the
-    // kill tears the server down, else the line is lost to the race (verified live).
-    expect(hook).not.toContain('run-shell -b')
-    expect(hook.indexOf('run-shell')).toBeLessThan(hook.indexOf('kill-session'))
-    // tmux-NATIVE kill-session (no shell `tmux`) → needs no PATH (launchd minimal env).
-    expect(hook).toContain('kill-session -t "claude-iapeer"')
-  })
-  test('silences the server-death canary (native wait-for -S) BEFORE kill-session — no double record', () => {
-    // kill-session on a single-session server → exit-empty takes the server down;
-    // without the signal the canary would add a second `ev=server-exit` record for
-    // a death this hook just captured (session-exit carries the code/signal).
-    expect(hook).toContain('wait-for -S "iap-canary-claude-iapeer"')
-    expect(hook.indexOf('wait-for -S')).toBeLessThan(hook.indexOf('kill-session'))
-    expect(hook.indexOf('run-shell')).toBeLessThan(hook.indexOf('wait-for -S')) // log first
-  })
-  test('quoting: single-quoted run-shell arg (tmux layer) wrapping double-quoted sh', () => {
-    expect(hook).toMatch(/run-shell '.*'/)
-    expect(hook).not.toContain("''") // no empty/again-collapsed single-quote pair
-  })
-})
-
-// ─── Ф-A #2: deliveryMarkers OWNED by the adapter (07.06 refactor) ───────────
-describe('deliveryMarkers (adapter-owned, was transport PROMPT_GLYPHS)', () => {
-  test('claude: ❯ glyph + paste patterns', () => {
-    expect(claudeAdapter.deliveryMarkers.promptGlyphs).toEqual(['❯'])
-    expect(claudeAdapter.deliveryMarkers.pastePatterns?.some(re => re.test('[Pasted text +5 lines]'))).toBe(true)
-    expect(claudeAdapter.deliveryMarkers.ghostTextSgr).toEqual(['2', '38;5;246'])
-  })
-  test('codex: › glyph (not ❯) — per-runtime, no false cross-match', () => {
-    expect(codexAdapter.deliveryMarkers.promptGlyphs).toEqual(['›'])
-    expect(codexAdapter.deliveryMarkers.promptGlyphs).not.toContain('❯')
-    expect(codexAdapter.deliveryMarkers.ghostTextSgr).toEqual(['2', '38;5;246'])
-  })
-  test('routers have no submit surface → empty glyphs', () => {
-    expect(telegramAdapter.deliveryMarkers.promptGlyphs).toEqual([])
-    expect(notifierAdapter.deliveryMarkers.promptGlyphs).toEqual([])
-  })
-})
-
-// ─── Ф-A #3: intelligence gate (telegram launch requires natural) ────────────
-describe('launch intelligence gate (adapter.requiresIntelligence)', () => {
-  test('telegram declares requiresIntelligence=natural; tui runtimes declare none', () => {
-    expect(telegramAdapter.requiresIntelligence).toBe('natural')
-    expect(claudeAdapter.requiresIntelligence).toBeUndefined()
-    expect(codexAdapter.requiresIntelligence).toBeUndefined()
-    expect(notifierAdapter.requiresIntelligence).toBeUndefined()
-  })
-
-  test('launch REFUSES a non-natural peer on telegram (fail-loud, before any tmux)', async () => {
-    const r = await launch(
-      spec({ runtime: 'telegram', identity: 'telegram-bot', socketPath: '/tmp/tmux-iap-telegram-bot.sock', intelligence: 'artificial' }),
-      telegramAdapter,
-      'first',
-      launchCfg,
-    )
-    expect(r.status).toBe('FAILED')
-    expect(r.reason).toMatch(/requires intelligence=natural/)
-  })
-
-  test('launch REFUSES when intelligence is unknown (cannot confirm natural)', async () => {
-    const r = await launch(
-      spec({ runtime: 'telegram', identity: 'telegram-bot', socketPath: '/tmp/tmux-iap-telegram-bot.sock' }),
-      telegramAdapter,
-      'first',
-      launchCfg,
-    )
-    expect(r.status).toBe('FAILED')
-    expect(r.reason).toMatch(/unknown/)
-  })
-})
-
-// ─── Ф-E #control: executeControl (adapter-owned in-session control mapping) ──
-describe('executeControl (Ф-E control commands)', () => {
-  test('claude: interrupt → [Escape]; compact → type /compact then Enter', () => {
-    expect(claudeAdapter.executeControl({ name: 'interrupt' })).toEqual({ sequence: [['Escape']] })
-    expect(claudeAdapter.executeControl({ name: 'compact' })).toEqual({ sequence: [['-l', '/compact'], ['Enter']], stepDelayMs: 300 })
-    expect(claudeAdapter.executeControl({ name: 'bogus' })).toBeNull()
-  })
-  test('codex: interrupt → [Escape] (×1, snapped live); compact → /compact + Enter (snapped live 12.06, codex-cli 0.138)', () => {
-    expect(codexAdapter.executeControl({ name: 'interrupt' })).toEqual({ sequence: [['Escape']] })
-    expect(codexAdapter.executeControl({ name: 'compact' })).toEqual({ sequence: [['-l', '/compact'], ['Enter']], stepDelayMs: 300 })
-    expect(codexAdapter.executeControl({ name: 'bogus' })).toBeNull()
-  })
-  test('routers (telegram/notifier) refuse all control (no TUI turn)', () => {
-    expect(telegramAdapter.executeControl({ name: 'interrupt' })).toBeNull()
-    expect(notifierAdapter.executeControl({ name: 'interrupt' })).toBeNull()
-    expect(telegramAdapter.executeControl({ name: 'compact' })).toBeNull()
-  })
-})