@raidiant/notifai 10.1.1 → 10.1.2

package/src/harnesses.ts

@@ -1,164 +0,0 @@
-/** Every harness Notifai can name in Source Context when authoritatively known. */
-export const SOURCE_CONTEXT_HARNESSES = [
-  'claude-code',
-  'codex',
-  'cursor',
-  'opencode',
-  'openclaw',
-  'hermes',
-] as const
-
-export type SourceContextHarness = (typeof SOURCE_CONTEXT_HARNESSES)[number]
-
-/**
- * Harnesses whose lifecycle Notifai can install and manage.
- *
- * Source Context is the broader vocabulary. Managed hook installation is a
- * narrower, independently proven cell: Hermes can appear in Source Context
- * without being hook-installable.
- */
-export const HOOK_INSTALLABLE_HARNESSES = [
-  'claude-code',
-  'codex',
-  'cursor',
-  'opencode',
-  'openclaw',
-] as const
-
-export type HookInstallableHarness = (typeof HOOK_INSTALLABLE_HARNESSES)[number]
-
-export function isHookInstallableHarness(value: string): value is HookInstallableHarness {
-  return (HOOK_INSTALLABLE_HARNESSES as readonly string[]).includes(value)
-}
-
-export const HARNESS_LABELS: Record<SourceContextHarness, string> = {
-  'claude-code': 'Claude Code',
-  codex: 'Codex',
-  cursor: 'Cursor',
-  opencode: 'OpenCode',
-  openclaw: 'OpenClaw',
-  hermes: 'Hermes',
-}
-
-export type DeliveryRoute =
-  | 'hook-continuation'
-  | 'inbox-socket'
-  | 'owned-control-plane'
-  | 'cold-resume'
-  | 'hold-for-next-turn'
-  | 'unsupported'
-
-export type StopContinuation = 'decision-block' | 'unsupported'
-
-export interface HarnessCapability {
-  /** How an answer is admitted to another turn in the already-open session. */
-  stopContinuation: StopContinuation
-  /** Available answer-delivery routes, best current route first. */
-  deliveryRoutes: readonly DeliveryRoute[]
-  /** Concise, honest readiness text for doctor and installation guidance. */
-  deliveryContract: string
-}
-
-const CLAUDE_CODE_CAPABILITY: HarnessCapability = {
-  stopContinuation: 'decision-block',
-  deliveryRoutes: ['hook-continuation', 'inbox-socket', 'cold-resume', 'hold-for-next-turn'],
-  deliveryContract:
-    'the Stop hook returns at once and waits out of band through the complete answer window, then posts the answer into this same session over its own inbox socket; a session that has stopped is resumed only once a liveness probe proves it stopped',
-}
-
-const CODEX_CAPABILITY: HarnessCapability = {
-  stopContinuation: 'decision-block',
-  deliveryRoutes: ['hook-continuation', 'cold-resume', 'hold-for-next-turn'],
-  deliveryContract:
-    'live Stop continuation while the turn is held through the complete answer window; crash recovery may resume only a stopped thread behind its writer lock',
-}
-
-const CURSOR_CAPABILITY: HarnessCapability = {
-  stopContinuation: 'unsupported',
-  deliveryRoutes: ['unsupported'],
-  deliveryContract:
-    'the hook can return a live follow-up, but the invoking shell exposes no exact conversation id; asynchronous ask is unsupported',
-}
-
-const OPENCODE_CAPABILITY: HarnessCapability = {
-  stopContinuation: 'unsupported',
-  deliveryRoutes: ['unsupported'],
-  deliveryContract:
-    'no proven answer continuation after session.idle; use a blocking reply command',
-}
-
-const OPENCLAW_CAPABILITY: HarnessCapability = {
-  stopContinuation: 'unsupported',
-  deliveryRoutes: ['unsupported'],
-  deliveryContract:
-    'no proven answer continuation after agent_end; use a blocking reply command',
-}
-
-export const HERMES_QUESTION_ROUTING_UNAVAILABLE: HarnessCapability = {
-  stopContinuation: 'unsupported',
-  deliveryRoutes: ['unsupported'],
-  deliveryContract:
-    'Hermes asynchronous ask has no proven continuation owner on this integration surface. Use a blocking `notifai send --reply` question',
-}
-
-/**
- * The one Hermes integration instance proven by the pinned vertical probe.
- *
- * This is evidence-bearing capability data, not an adapter. Unsupported and
- * deferred surfaces intentionally have no empty implementation object here.
- */
-export const HERMES_CLASSIC_CLI_LOCAL_CAPABILITY = {
-  instance: {
-    harness: 'hermes',
-    surface: 'classic-cli',
-    terminalBackend: 'local',
-  },
-  setup: 'unsupported',
-  activation: 'unsupported',
-  sourceContext: 'hermes-session-id-and-invocation-cwd',
-  continuation: 'unsupported',
-} as const
-
-export type HermesClassicCliLocalInstance =
-  (typeof HERMES_CLASSIC_CLI_LOCAL_CAPABILITY)['instance']
-
-/**
- * Resolve only the Hermes instance whose complete marker envelope was proven.
- *
- * `HERMES_SESSION_ID` is also bridged by deferred gateway, TUI, API, ACP, and
- * remote-backend paths. Their first-party routing/source/backend markers keep
- * those cells distinct. Missing source/backend values are the pinned classic
- * CLI defaults; a gateway key is never part of that instance.
- */
-export function hermesClassicCliLocalInstance(
-  env: NodeJS.ProcessEnv,
-): HermesClassicCliLocalInstance | null {
-  const sessionId = (env['HERMES_SESSION_ID'] ?? '').trim()
-  const sessionKey = (env['HERMES_SESSION_KEY'] ?? '').trim()
-  const platform = (env['HERMES_SESSION_PLATFORM'] ?? '').trim().toLowerCase()
-  const source = (env['HERMES_SESSION_SOURCE'] ?? '').trim().toLowerCase()
-  const terminalBackend = (env['TERMINAL_ENV'] ?? '').trim().toLowerCase()
-  if (sessionId === '' || sessionKey !== '' || platform !== '') return null
-  if (source !== '' && source !== 'cli') return null
-  if (terminalBackend !== '' && terminalBackend !== 'local') return null
-  return HERMES_CLASSIC_CLI_LOCAL_CAPABILITY.instance
-}
-
-/**
- * Question-routing contract for hook-installable harnesses.
- *
- * Hermes is deliberately absent: a send-only surface must not occupy this
- * table with a fake managed-hook continuation route.
- */
-export const HARNESS_CAPABILITIES: Record<HookInstallableHarness, HarnessCapability> = {
-  'claude-code': CLAUDE_CODE_CAPABILITY,
-  codex: CODEX_CAPABILITY,
-  cursor: CURSOR_CAPABILITY,
-  opencode: OPENCODE_CAPABILITY,
-  openclaw: OPENCLAW_CAPABILITY,
-}
-
-/** Question-routing capability for the active harness integration. */
-export function questionRoutingCapability(harness: HookInstallableHarness): HarnessCapability {
-  return HARNESS_CAPABILITIES[harness]
-}

package/src/hook-adapter.test.ts

@@ -1,496 +0,0 @@
-import { spawnSync } from 'node:child_process'
-import {
-  chmodSync,
-  mkdirSync,
-  mkdtempSync,
-  readFileSync,
-  rmSync,
-  statSync,
-  symlinkSync,
-  writeFileSync,
-} from 'node:fs'
-import os from 'node:os'
-import path from 'node:path'
-import { fileURLToPath } from 'node:url'
-import { describe, expect, it } from 'vitest'
-import {
-  hookAdapterPath,
-  hookAdapterSource,
-  inspectHookAdapter,
-  installHookAdapter,
-  isNpxAdapterTarget,
-} from './hook-adapter.js'
-import { buildHookConfig, codexHookIdentityHash, type InstalledHandler } from './install-hooks.js'
-import { enableProject, projectBinding } from './project-enablement.js'
-
-function isolated(): { root: string; homeDir: string } {
-  const root = mkdtempSync(path.join(os.tmpdir(), 'notifai-hook-adapter-'))
-  return { root, homeDir: path.join(root, 'home') }
-}
-
-describe('stable hook adapter', () => {
-  it('keeps the installed adapter silent until the Project is enabled', () => {
-    const { root, homeDir } = isolated()
-    const env = {
-      ...process.env,
-      HOME: homeDir,
-      XDG_CONFIG_HOME: path.join(root, 'config'),
-      XDG_STATE_HOME: path.join(root, 'state'),
-    }
-    const scriptPath = fileURLToPath(new URL('../dist/main.js', import.meta.url))
-    const installed = installHookAdapter({ execPath: process.execPath, scriptPath }, homeDir)
-    const disabled = spawnSync(
-      installed.path,
-      ['hook', 'session-start', '--owner', 'notifai', '--harness', 'codex'],
-      {
-        encoding: 'utf8',
-        input: JSON.stringify({ session_id: 'adapter-session', cwd: root, source: 'startup' }),
-        env,
-      },
-    )
-
-    expect(disabled.status).toBe(0)
-    expect(disabled.stderr).toBe('')
-    expect(disabled.stdout).toBe('')
-
-    const binding = projectBinding(root, env)
-    if (binding === null) throw new Error('test Project binding unavailable')
-    enableProject(binding)
-    const run = spawnSync(
-      installed.path,
-      ['hook', 'session-start', '--owner', 'notifai', '--harness', 'codex'],
-      {
-        encoding: 'utf8',
-        input: JSON.stringify({ session_id: 'adapter-session', cwd: root, source: 'startup' }),
-        env,
-      },
-    )
-
-    expect(run.status).toBe(0)
-    expect(run.stderr).toBe('')
-    expect(JSON.parse(run.stdout)).toMatchObject({
-      hookSpecificOutput: {
-        hookEventName: 'SessionStart',
-        additionalContext: expect.stringMatching(/Notifai.*enabled.*Project/i),
-      },
-    })
-  })
-
-  it('executes paths with spaces, quotes, and shell syntax without evaluating them', () => {
-    const { root, homeDir } = isolated()
-    const odd = path.join(root, "odd ' $(touch should-not-run)")
-    mkdirSync(odd, { recursive: true })
-    const script = path.join(odd, 'target script.js')
-    writeFileSync(script, 'process.stdout.write(JSON.stringify(process.argv.slice(2)))\n')
-
-    const installed = installHookAdapter({ execPath: process.execPath, scriptPath: script }, homeDir)
-    const run = spawnSync(installed.path, ['hook', 'stop', '--owner', 'notifai'], {
-      encoding: 'utf8',
-    })
-
-    expect(run.status).toBe(0)
-    expect(JSON.parse(run.stdout)).toEqual(['hook', 'stop', '--owner', 'notifai'])
-    expect(statSync(installed.path).mode & 0o777).toBe(0o700)
-    expect(inspectHookAdapter(homeDir).problems).toEqual([])
-  })
-
-  it('retargets Node and CLI paths without changing any harness definition or Codex hash', () => {
-    const { root, homeDir } = isolated()
-    const first = path.join(root, 'first.js')
-    const second = path.join(root, 'second.js')
-    writeFileSync(first, '')
-    writeFileSync(second, '')
-    const adapter = installHookAdapter({ execPath: process.execPath, scriptPath: first }, homeDir)
-    const before = buildHookConfig({
-      adapterPath: adapter.path,
-      harness: 'codex',
-    })
-    const beforeSource = readFileSync(adapter.path, 'utf8')
-
-    installHookAdapter({ execPath: process.execPath, scriptPath: second }, homeDir)
-    const after = buildHookConfig({
-      adapterPath: hookAdapterPath(homeDir),
-      harness: 'codex',
-    })
-    const afterSource = readFileSync(adapter.path, 'utf8')
-    const stop = (config: typeof before): InstalledHandler => {
-      const handler = config['Stop']![0]!.hooks[0]!
-      return {
-        event: 'Stop',
-        groupIndex: 0,
-        handlerIndex: 0,
-        command: handler.command,
-        timeout: handler.timeout,
-      }
-    }
-
-    expect(after).toEqual(before)
-    expect(afterSource).not.toBe(beforeSource)
-    expect(codexHookIdentityHash(stop(after))).toBe(codexHookIdentityHash(stop(before)))
-    const inspected = inspectHookAdapter(homeDir).target
-    expect(inspected && !isNpxAdapterTarget(inspected) ? inspected.scriptPath : null).toBe(second)
-  })
-
-  it('executes a pinned npx spec through npm-cli.js without evaluating it', () => {
-    const { root, homeDir } = isolated()
-    const npmCli = path.join(root, 'npm-cli.js')
-    writeFileSync(
-      npmCli,
-      'process.stdout.write(JSON.stringify(process.argv.slice(2)))\n',
-    )
-    const installed = installHookAdapter(
-      {
-        kind: 'npx',
-        execPath: process.execPath,
-        npmCli,
-        spec: '@raidiant/notifai@0.5.1',
-      },
-      homeDir,
-    )
-    const run = spawnSync(installed.path, ['hook', 'stop', '--owner', 'notifai'], {
-      encoding: 'utf8',
-    })
-
-    expect(run.status).toBe(0)
-    expect(JSON.parse(run.stdout)).toEqual([
-      'exec',
-      '--yes',
-      '--package',
-      '@raidiant/notifai@0.5.1',
-      '--',
-      'notifai',
-      'hook',
-      'stop',
-      '--owner',
-      'notifai',
-    ])
-    const inspected = inspectHookAdapter(homeDir)
-    expect(inspected.problems).toEqual([])
-    expect(inspected.target && isNpxAdapterTarget(inspected.target) ? inspected.target.spec : null).toBe(
-      '@raidiant/notifai@0.5.1',
-    )
-  })
-
-  it('carries the stable POSIX harness parent through direct and npx targets', () => {
-    const { root, homeDir } = isolated()
-    const direct = path.join(root, 'direct.js')
-    const npmCli = path.join(root, 'npm-cli.js')
-    const source = 'process.stdout.write(process.env.NOTIFAI_HOOK_SOURCE_PID ?? "missing")\n'
-    writeFileSync(direct, source)
-    writeFileSync(npmCli, source)
-
-    const directAdapter = installHookAdapter(
-      { execPath: process.execPath, scriptPath: direct },
-      homeDir,
-    )
-    const directRun = spawnSync(directAdapter.path, [], { encoding: 'utf8' })
-    const npxAdapter = installHookAdapter(
-      {
-        kind: 'npx',
-        execPath: process.execPath,
-        npmCli,
-        spec: '@raidiant/notifai@0.5.1',
-      },
-      homeDir,
-    )
-    const npxRun = spawnSync(npxAdapter.path, [], { encoding: 'utf8' })
-
-    expect(directRun.status).toBe(0)
-    expect(npxRun.status).toBe(0)
-    expect(directRun.stdout).toBe(String(process.pid))
-    expect(npxRun.stdout).toBe(String(process.pid))
-  })
-
-  it('uses a fixed home-relative pathname with no XDG input surface', () => {
-    const { homeDir } = isolated()
-    expect(hookAdapterPath(homeDir)).toBe(
-      path.join(homeDir, '.notifai', 'bin', 'hook-adapter'),
-    )
-  })
-
-  it('uses the OS account home even when HOME is overridden', () => {
-    const original = process.env['HOME']
-    process.env['HOME'] = '/tmp/attacker-selected-home'
-    try {
-      expect(hookAdapterPath()).toBe(
-        path.join(os.userInfo().homedir, '.notifai', 'bin', 'hook-adapter'),
-      )
-      expect(hookAdapterPath()).not.toContain('attacker-selected-home')
-    } finally {
-      if (original === undefined) delete process.env['HOME']
-      else process.env['HOME'] = original
-    }
-  })
-
-  it('repairs permissive adapter permissions without changing its path', () => {
-    const { root, homeDir } = isolated()
-    const script = path.join(root, 'target.js')
-    writeFileSync(script, '')
-    const first = installHookAdapter({ execPath: process.execPath, scriptPath: script }, homeDir)
-    chmodSync(first.path, 0o755)
-
-    const repaired = installHookAdapter({ execPath: process.execPath, scriptPath: script }, homeDir)
-
-    expect(repaired).toEqual({ path: first.path, changed: true })
-    expect(statSync(first.path).mode & 0o777).toBe(0o700)
-  })
-
-  it('refuses a symlinked adapter instead of reading or replacing its target', () => {
-    const { root, homeDir } = isolated()
-    const target = path.join(root, 'foreign')
-    const adapter = hookAdapterPath(homeDir)
-    mkdirSync(path.dirname(adapter), { recursive: true })
-    writeFileSync(target, 'leave me')
-    symlinkSync(target, adapter)
-
-    expect(() =>
-      installHookAdapter({ execPath: process.execPath, scriptPath: target }, homeDir),
-    ).toThrow(/not a regular file/)
-    expect(readFileSync(target, 'utf8')).toBe('leave me')
-  })
-
-  it('refuses a symlinked Notifai-owned parent directory', () => {
-    const { root, homeDir } = isolated()
-    const foreign = path.join(root, 'foreign-dir')
-    const script = path.join(root, 'target.js')
-    mkdirSync(homeDir, { recursive: true })
-    mkdirSync(foreign)
-    writeFileSync(script, '')
-    symlinkSync(foreign, path.join(homeDir, '.notifai'))
-
-    expect(() =>
-      installHookAdapter({ execPath: process.execPath, scriptPath: script }, homeDir),
-    ).toThrow(/not a regular directory/)
-    expect(readFileSync(script, 'utf8')).toBe('')
-  })
-
-  it('diagnoses a stale registered runtime and CLI without executing either', () => {
-    const { root, homeDir } = isolated()
-    const missingRuntime = path.join(root, 'removed-node')
-    const missingCli = path.join(root, 'removed-cli.js')
-    writeFileSync(missingRuntime, '#!/bin/sh\n')
-    chmodSync(missingRuntime, 0o700)
-    writeFileSync(missingCli, '')
-    installHookAdapter({ execPath: missingRuntime, scriptPath: missingCli }, homeDir)
-    rmSync(missingRuntime)
-    rmSync(missingCli)
-
-    expect(inspectHookAdapter(homeDir).problems).toEqual([
-      `registered runtime ${missingRuntime} is missing`,
-      `registered CLI ${missingCli} is missing`,
-    ])
-  })
-
-  it('keeps working when a node upgrade moved the pinned runtime but left the CLI', () => {
-    const { root, homeDir } = isolated()
-    const bin = path.join(root, 'fallback-bin')
-    mkdirSync(bin, { recursive: true })
-    const pathNode = path.join(bin, 'node')
-    writeFileSync(pathNode, '#!/bin/sh\nprintf "ran %s" "$1"\n')
-    chmodSync(pathNode, 0o700)
-    const pinnedNode = path.join(root, 'pinned-node')
-    const cli = path.join(root, 'cli.js')
-    writeFileSync(pinnedNode, '#!/bin/sh\n')
-    chmodSync(pinnedNode, 0o700)
-    writeFileSync(cli, '')
-    const installed = installHookAdapter({ execPath: pinnedNode, scriptPath: cli }, homeDir)
-    // What `brew upgrade node` and `nvm uninstall` both do: the interpreter
-    // moves, the installed CLI does not.
-    rmSync(pinnedNode)
-
-    const run = spawnSync(installed.path, ['hook', 'stop'], {
-      encoding: 'utf8',
-      env: { PATH: bin },
-    })
-
-    expect(run.status).toBe(0)
-    expect(run.stdout).toBe(`ran ${cli}`)
-  })
-
-  it('fails closed instead of executing an unregistered PATH target after the registered target vanished', () => {
-    const { root, homeDir } = isolated()
-    const bin = path.join(root, 'new-bin')
-    const replacement = path.join(bin, 'notifai')
-    mkdirSync(bin, { recursive: true })
-    writeFileSync(replacement, '#!/bin/sh\nprintf "%s" "$*"\n')
-    chmodSync(replacement, 0o700)
-    const oldNode = path.join(root, 'old-node')
-    const oldCli = path.join(root, 'old-cli.js')
-    writeFileSync(oldNode, '#!/bin/sh\n')
-    chmodSync(oldNode, 0o700)
-    writeFileSync(oldCli, '')
-    const installed = installHookAdapter({ execPath: oldNode, scriptPath: oldCli }, homeDir)
-    rmSync(oldNode)
-    rmSync(oldCli)
-
-    const run = spawnSync(installed.path, ['hook', 'stop'], {
-      encoding: 'utf8',
-      env: { PATH: bin },
-    })
-
-    expect(run.status).toBe(127)
-    expect(run.stdout).toBe('')
-    expect(run.stderr).toMatch(/target is stale/)
-  })
-})
-
-describe('Windows hook adapter', () => {
-  it('keeps POSIX adapter source bytes identical to the trusted /bin/sh form', () => {
-    const target = {
-      execPath: '/usr/local/bin/node',
-      scriptPath: '/opt/notifai/dist/main.js',
-    }
-    expect(hookAdapterSource(target, 'posix')).toBe(`#!/bin/sh
-# notifai managed hook adapter
-# adapter-version: 2
-# target-exec-json: "/usr/local/bin/node"
-# target-script-json: "/opt/notifai/dist/main.js"
-set -eu
-
-NOTIFAI_HOOK_SOURCE_PID=$PPID
-export NOTIFAI_HOOK_SOURCE_PID
-
-registered_exec='/usr/local/bin/node'
-registered_script='/opt/notifai/dist/main.js'
-
-if [ -x "$registered_exec" ] && [ -f "$registered_script" ]; then
-  exec "$registered_exec" "$registered_script" "$@"
-fi
-
-if [ -f "$registered_script" ] && command -v node >/dev/null 2>&1; then
-  exec node "$registered_script" "$@"
-fi
-
-printf '%s
-' 'Notifai hook adapter target is stale; run notifai hooks install.' >&2
-exit 127
-`)
-  })
-
-  it('generates a JavaScript adapter instead of a shebang script', () => {
-    const { root, homeDir } = isolated()
-    const script = path.join(root, 'target.js')
-    writeFileSync(script, '')
-    const installed = installHookAdapter(
-      { execPath: process.execPath, scriptPath: script },
-      homeDir,
-      'win32',
-    )
-    const source = readFileSync(installed.path, 'utf8')
-
-    expect(source.startsWith('// notifai managed hook adapter\n')).toBe(true)
-    expect(source).not.toContain('#!/bin/sh')
-    expect(source).toContain('require("node:child_process")')
-    expect(source).toContain(JSON.stringify(process.execPath))
-    expect(source).toContain(JSON.stringify(script))
-  })
-
-  it('forwards argv through Node without depending on a shebang or executable bit', () => {
-    const { root, homeDir } = isolated()
-    const script = path.join(root, 'target script.js')
-    writeFileSync(script, 'process.stdout.write(JSON.stringify(process.argv.slice(2)))\n')
-    const runtime = path.join(root, 'node-runtime')
-    writeFileSync(runtime, 'dummy-node')
-    chmodSync(runtime, 0o644)
-
-    const installed = installHookAdapter(
-      { execPath: process.execPath, scriptPath: script },
-      homeDir,
-      'win32',
-    )
-    const run = spawnSync(process.execPath, [installed.path, 'hook', 'stop', '--owner', 'notifai'], {
-      encoding: 'utf8',
-    })
-
-    expect(run.status).toBe(0)
-    expect(JSON.parse(run.stdout)).toEqual(['hook', 'stop', '--owner', 'notifai'])
-    expect(() =>
-      installHookAdapter({ execPath: runtime, scriptPath: script }, homeDir, 'win32'),
-    ).not.toThrow()
-  })
-
-  it('carries the stable Windows harness parent into each CLI process', () => {
-    const { root, homeDir } = isolated()
-    const script = path.join(root, 'source-pid.js')
-    writeFileSync(
-      script,
-      'process.stdout.write(process.env.NOTIFAI_HOOK_SOURCE_PID ?? "missing")\n',
-    )
-    const installed = installHookAdapter(
-      { execPath: process.execPath, scriptPath: script },
-      homeDir,
-      'win32',
-    )
-
-    const run = spawnSync(process.execPath, [installed.path], { encoding: 'utf8' })
-
-    expect(run.status).toBe(0)
-    expect(run.stdout).toBe(String(process.pid))
-  })
-
-  it('does not treat 0666 as a protection or health failure', () => {
-    const { root, homeDir } = isolated()
-    const script = path.join(root, 'target.js')
-    writeFileSync(script, '')
-    const installed = installHookAdapter(
-      { execPath: process.execPath, scriptPath: script },
-      homeDir,
-      'win32',
-    )
-    chmodSync(installed.path, 0o666)
-
-    expect(inspectHookAdapter(homeDir, 'win32').problems).toEqual([])
-    expect(
-      installHookAdapter({ execPath: process.execPath, scriptPath: script }, homeDir, 'win32'),
-    ).toEqual({ path: installed.path, changed: false })
-  })
-
-  it('fails closed when the registered Windows target vanishes', () => {
-    const { root, homeDir } = isolated()
-    const oldNode = path.join(root, 'old-node')
-    const oldCli = path.join(root, 'old-cli.js')
-    writeFileSync(oldNode, '#!/bin/sh\n')
-    writeFileSync(oldCli, '')
-    const installed = installHookAdapter(
-      { execPath: oldNode, scriptPath: oldCli },
-      homeDir,
-      'win32',
-    )
-    rmSync(oldNode)
-    rmSync(oldCli)
-
-    const inspected = inspectHookAdapter(homeDir, 'win32')
-    expect(inspected.problems).toEqual([
-      `registered runtime ${oldNode} is missing`,
-      `registered CLI ${oldCli} is missing`,
-    ])
-    const run = spawnSync(process.execPath, [installed.path, 'hook', 'stop'], {
-      encoding: 'utf8',
-    })
-    expect(run.status).toBe(127)
-    expect(run.stdout).toBe('')
-    expect(run.stderr).toMatch(/target is stale/)
-  })
-
-  it('retargets the CLI without changing the adapter pathname', () => {
-    const { root, homeDir } = isolated()
-    const first = path.join(root, 'first.js')
-    const second = path.join(root, 'second.js')
-    writeFileSync(first, '')
-    writeFileSync(second, '')
-    const firstInstall = installHookAdapter(
-      { execPath: process.execPath, scriptPath: first },
-      homeDir,
-      'win32',
-    )
-    const secondInstall = installHookAdapter(
-      { execPath: process.execPath, scriptPath: second },
-      homeDir,
-      'win32',
-    )
-    const inspected = inspectHookAdapter(homeDir, 'win32').target
-
-    expect(secondInstall.path).toBe(firstInstall.path)
-    expect(inspected && !isNpxAdapterTarget(inspected) ? inspected.scriptPath : null).toBe(second)
-  })
-})