@raidiant/notifai 10.1.1 → 10.1.2

package/src/guidance.ts

@@ -1,233 +0,0 @@
-import {
-  closeSync,
-  constants,
-  existsSync,
-  fstatSync,
-  lstatSync,
-  openSync,
-  readSync,
-  readdirSync,
-  realpathSync,
-  type Dirent,
-} from 'node:fs'
-import path from 'node:path'
-import { globalConfigDir, personalProjectIdentity } from './config.js'
-import { SHIPPED_GUIDANCE } from './guidance-content.js'
-
-/**
- * Layered notification-writing guidance with provenance. Most specific wins,
- * per topic, exactly the discipline config keys follow:
- *
- *   project-local > project > global > shipped default
- *
- * A topic is one Markdown file named `<topic>.md`. A user file replaces the
- * shipped topic of the same name wholesale — their words outrank the default,
- * not annotate it — and a file whose name matches no shipped topic is purely
- * additive house rules. There is no session layer: an instruction given in
- * conversation tunes the session by being followed, not persisted.
- *
- * Two of those layers are the User's own word and one is not. `global` and
- * `project-local` live under the User's config home: only they can write
- * there. `project` is `.notifai/guidance` inside the repository, so it
- * arrives with a clone and is written by whoever wrote the repository —
- * which may be nobody the User has ever met. It remains authoritative about
- * *how this project's notifications should read*, because shared house rules
- * are the feature; it is never the User speaking. `authority` carries that
- * distinction to every reader so a cloned repository cannot borrow the
- * User's voice.
- */
-
-export type GuidanceSource =
-  | `project-local:${string}`
-  | `project:${string}`
-  | `global:${string}`
-  | 'default'
-
-/**
- * Who is speaking in a topic.
- *
- * - `user` — the User's own standing word, from a location only they can write.
- * - `repository` — this checkout's shared house rules; committed content, and
- *   therefore untrusted input that speaks for the project, not the User.
- * - `shipped` — the default that applies when nobody said otherwise.
- */
-export type GuidanceAuthority = 'user' | 'repository' | 'shipped'
-
-export interface ResolvedGuidanceTopic {
-  name: string
-  source: GuidanceSource
-  authority: GuidanceAuthority
-  /** One line for lists; user-authored topics describe themselves by content. */
-  summary: string
-  content: string
-}
-
-export function guidanceAuthority(source: GuidanceSource): GuidanceAuthority {
-  if (source === 'default') return 'shipped'
-  return source.startsWith('project:') ? 'repository' : 'user'
-}
-
-/**
- * Topic names double as filenames, and the project layer arrives from a
- * repository — untrusted input. Anything that does not match is not a topic,
- * the same way `coerce` drops an unrecognised config value.
- */
-export const GUIDANCE_TOPIC_PATTERN = /^[a-z0-9][a-z0-9_-]{0,63}$/
-
-/**
- * One topic is capped at the body limit. Guidance is read into agent context
- * on every session, and a repository could otherwise feed it without bound.
- */
-export const GUIDANCE_TOPIC_MAX_BYTES = 16_000
-
-export function globalGuidanceDir(env: NodeJS.ProcessEnv = process.env): string {
-  return path.join(globalConfigDir(env), 'guidance')
-}
-
-function isWithin(root: string, candidate: string): boolean {
-  const relative = path.relative(root, candidate)
-  return relative === '' || (!path.isAbsolute(relative) && relative !== '..' && !relative.startsWith(`..${path.sep}`))
-}
-
-/** Walk up from cwd looking for `.notifai/guidance` (shared, committed). */
-export function findProjectGuidanceDir(startDir: string): string | null {
-  let dir = path.resolve(startDir)
-  for (;;) {
-    const candidate = path.join(dir, '.notifai', 'guidance')
-    if (existsSync(candidate)) {
-      try {
-        // A clone may contain symlinks. Repository guidance may read only
-        // regular content rooted in that repository; it must never turn a
-        // local private file into model context by pointing outside the tree.
-        const candidateStat = lstatSync(candidate)
-        const repositoryRoot = realpathSync(dir)
-        const resolved = realpathSync(candidate)
-        if (candidateStat.isDirectory() && isWithin(repositoryRoot, resolved)) return candidate
-      } catch {
-        // An unreadable or unstable candidate is not guidance. Keep walking.
-      }
-    }
-    const parent = path.dirname(dir)
-    if (parent === dir) return null
-    dir = parent
-  }
-}
-
-/**
- * Personal project guidance lives beside the personal project config file,
- * under the user's config home rather than the repository:
- * `$XDG_CONFIG_HOME/notifai/projects/<identity>/guidance`.
- */
-export function personalProjectGuidanceDir(
-  cwd: string,
-  env: NodeJS.ProcessEnv = process.env,
-): string {
-  return path.join(globalConfigDir(env), 'projects', personalProjectIdentity(cwd), 'guidance')
-}
-
-function topicsInDir(dir: string): Map<string, string> {
-  const topics = new Map<string, string>()
-  if (!existsSync(dir)) return topics
-  let entries: Dirent[]
-  try {
-    if (!lstatSync(dir).isDirectory()) return topics
-    entries = readdirSync(dir, { withFileTypes: true })
-  } catch {
-    return topics
-  }
-  for (const entry of entries.sort((left, right) => left.name.localeCompare(right.name))) {
-    // In particular, refuse symlinks. A committed link to a User-owned file
-    // must not make that file part of repository guidance output.
-    if (!entry.isFile() || !entry.name.endsWith('.md')) continue
-    const name = entry.name.slice(0, -'.md'.length)
-    if (!GUIDANCE_TOPIC_PATTERN.test(name)) continue
-    topics.set(name, path.join(dir, entry.name))
-  }
-  return topics
-}
-
-function readTopicFile(filePath: string): string | null {
-  let descriptor: number | null = null
-  try {
-    descriptor = openSync(filePath, constants.O_RDONLY | constants.O_NOFOLLOW)
-    if (!fstatSync(descriptor).isFile()) return null
-    const bytes = Buffer.alloc(GUIDANCE_TOPIC_MAX_BYTES + 1)
-    let offset = 0
-    while (offset < bytes.length) {
-      const count = readSync(descriptor, bytes, offset, bytes.length - offset, offset)
-      if (count === 0) break
-      offset += count
-    }
-    const truncated = offset > GUIDANCE_TOPIC_MAX_BYTES
-    const content = bytes.subarray(0, Math.min(offset, GUIDANCE_TOPIC_MAX_BYTES)).toString('utf8')
-    if (content.trim() === '') return null
-    return truncated
-      ? `${content}\n\n[Truncated: this guidance file exceeds ${GUIDANCE_TOPIC_MAX_BYTES} bytes.]\n`
-      : content
-  } catch {
-    return null
-  } finally {
-    if (descriptor !== null) closeSync(descriptor)
-  }
-}
-
-/**
- * Every effective topic, shipped reading order first, additive user topics
- * after it in name order. Each carries the layer that supplied it.
- */
-export function resolveGuidance(options: {
-  cwd?: string
-  env?: NodeJS.ProcessEnv
-}): ResolvedGuidanceTopic[] {
-  const env = options.env ?? process.env
-  const cwd = options.cwd ?? process.cwd()
-
-  // Ascending precedence: a later layer overwrites an earlier one per topic.
-  const layers: { dir: string | null; label: 'global' | 'project' | 'project-local' }[] = [
-    { dir: globalGuidanceDir(env), label: 'global' },
-    { dir: findProjectGuidanceDir(cwd), label: 'project' },
-    { dir: personalProjectGuidanceDir(cwd, env), label: 'project-local' },
-  ]
-
-  const winners = new Map<string, { source: GuidanceSource; content: string }>()
-  for (const layer of layers) {
-    if (layer.dir === null) continue
-    for (const [name, filePath] of topicsInDir(layer.dir)) {
-      const content = readTopicFile(filePath)
-      if (content === null) continue
-      winners.set(name, { source: `${layer.label}:${filePath}`, content })
-    }
-  }
-
-  const resolved: ResolvedGuidanceTopic[] = SHIPPED_GUIDANCE.map((topic) => {
-    const override = winners.get(topic.name)
-    winners.delete(topic.name)
-    return override === undefined
-      ? {
-          name: topic.name,
-          source: 'default' as const,
-          authority: 'shipped' as const,
-          summary: topic.summary,
-          content: topic.content,
-        }
-      : {
-          name: topic.name,
-          source: override.source,
-          authority: guidanceAuthority(override.source),
-          summary: topic.summary,
-          content: override.content,
-        }
-  })
-  for (const name of [...winners.keys()].sort()) {
-    const extra = winners.get(name)!
-    const authority = guidanceAuthority(extra.source)
-    resolved.push({
-      name,
-      source: extra.source,
-      authority,
-      summary: authority === 'repository' ? 'Project house rules' : 'User-added guidance',
-      content: extra.content,
-    })
-  }
-  return resolved
-}

package/src/harness-integration.test.ts

@@ -1,294 +0,0 @@
-import { readFileSync } from 'node:fs'
-import { mkdtempSync } from 'node:fs'
-import os from 'node:os'
-import path from 'node:path'
-import { describe, expect, it } from 'vitest'
-import {
-  resolveActiveHarness,
-  sourceContextHarnessSession,
-} from './commands-harness-context.js'
-import {
-  HARNESS_CAPABILITIES,
-  HERMES_CLASSIC_CLI_LOCAL_CAPABILITY,
-  HERMES_QUESTION_ROUTING_UNAVAILABLE,
-} from './harnesses.js'
-import { buildSourceContext, inferInvocationContext, type GitCommand } from './invocation-context.js'
-
-const PINNED = JSON.parse(
-  readFileSync(new URL('./fixtures/hermes-0.20.6-classic-cli-local.json', import.meta.url), 'utf8'),
-) as {
-  durableSessionId: string
-  observedToolSubprocessEnv: { HERMES_SESSION_ID: string }
-  instance: { harness: 'hermes'; surface: 'classic-cli'; terminalBackend: 'local' }
-  cwd: { invocation: string }
-  evidence: {
-    nativeHostOs: 'macos'
-    portableFixtureFamilies: ['posix', 'windows']
-    nativeOsUnrun: ['linux', 'windows']
-  }
-  compression: {
-    defaultMode: 'in-place'
-    sessionIdBefore: string
-    sessionIdAfter: string
-    legacyRotatingSessionId: string
-  }
-}
-
-const SYNTHETIC_GATEWAY_SESSION_KEY = 'synthetic-gateway-route-key-not-a-session-id'
-
-function stateEnv(overrides: NodeJS.ProcessEnv = {}): NodeJS.ProcessEnv {
-  return {
-    XDG_STATE_HOME: mkdtempSync(path.join(os.tmpdir(), 'notifai-hermes-context-')),
-    ...overrides,
-  }
-}
-
-function fixtureGit(values: Record<string, string | null>): GitCommand {
-  return (_cwd, args) => values[args.join(' ')] ?? null
-}
-
-describe('Hermes classic CLI/local Source Context seam', () => {
-  it('attributes an uncontested HERMES_SESSION_ID as the durable Agent Session', () => {
-    const cwd = PINNED.cwd.invocation
-    const now = 1
-    const resolution = resolveActiveHarness(
-      { HERMES_SESSION_ID: PINNED.observedToolSubprocessEnv.HERMES_SESSION_ID },
-      cwd,
-      now,
-    )
-    expect(resolution.contested).toEqual([])
-    expect(resolution.active).toMatchObject({
-      harness: 'hermes',
-      sessionId: PINNED.durableSessionId,
-    })
-    expect(sourceContextHarnessSession({ HERMES_SESSION_ID: PINNED.durableSessionId }, cwd, now)).toEqual(
-      resolution.active,
-    )
-  })
-
-  it('never treats HERMES_SESSION_KEY as Agent Session identity', () => {
-    const cwd = '/workspace'
-    const now = 1
-    const keyOnly = resolveActiveHarness(
-      { HERMES_SESSION_KEY: SYNTHETIC_GATEWAY_SESSION_KEY },
-      cwd,
-      now,
-    )
-    expect(keyOnly.active).toBeNull()
-
-    const gatewayEnv = {
-      HERMES_SESSION_ID: PINNED.observedToolSubprocessEnv.HERMES_SESSION_ID,
-      HERMES_SESSION_KEY: SYNTHETIC_GATEWAY_SESSION_KEY,
-    }
-    const both = resolveActiveHarness(gatewayEnv, cwd, now)
-    expect(both.active?.sessionId).toBe(PINNED.durableSessionId)
-    expect(both.active?.sessionId).not.toBe(SYNTHETIC_GATEWAY_SESSION_KEY)
-    expect(sourceContextHarnessSession(gatewayEnv, cwd, now)).toBeNull()
-  })
-
-  it('fails closed when Hermes markers nest with a hook-installable harness', () => {
-    const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-hermes-nested-'))
-    const env = {
-      CLAUDECODE: '1',
-      CLAUDE_CODE_SESSION_ID: 'claude-orchestrator',
-      HERMES_SESSION_ID: PINNED.durableSessionId,
-    }
-    const resolution = resolveActiveHarness(env, cwd, 42)
-    expect(resolution.contested.map((candidate) => candidate.harness).sort()).toEqual([
-      'claude-code',
-      'hermes',
-    ])
-    expect(sourceContextHarnessSession(env, cwd, 42)).toBeNull()
-  })
-
-  it('does not apply the send-only mix rule to a Hermes-free Claude/Codex nest', () => {
-    // Existing send attribution still uses declared order when nothing has
-    // fired. Live-evidence ownership for ask lives in commands.test.ts.
-    const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-claude-codex-pair-'))
-    const env = {
-      CLAUDECODE: '1',
-      CLAUDE_CODE_SESSION_ID: 'claude-orchestrator',
-      CODEX_THREAD_ID: 'codex-current-thread',
-    }
-    const resolution = resolveActiveHarness(env, cwd, 42)
-    expect(resolution.contested.map((candidate) => candidate.harness).sort()).toEqual([
-      'claude-code',
-      'codex',
-    ])
-    expect(sourceContextHarnessSession(env, cwd, 42)?.harness).toBe('claude-code')
-  })
-
-  it('builds Source Context from HERMES_SESSION_ID plus invocation cwd git/worktree', () => {
-    const env = stateEnv({
-      HERMES_SESSION_ID: PINNED.durableSessionId,
-      HERMES_SESSION_KEY: SYNTHETIC_GATEWAY_SESSION_KEY,
-    })
-    const invocation = inferInvocationContext(
-      '/worktrees/hermes-topic/apps/cli',
-      fixtureGit({
-        'rev-parse --git-common-dir': '/code/notifai/.git',
-        'rev-parse --git-dir': '/code/notifai/.git/worktrees/hermes-topic',
-        'rev-parse --show-toplevel': '/worktrees/hermes-topic/',
-        'rev-parse --abbrev-ref HEAD': 'feature/hermes-send',
-      }),
-    )
-    const active = resolveActiveHarness(env, '/worktrees/hermes-topic/apps/cli', Date.now()).active
-    const built = buildSourceContext({
-      env,
-      invocation,
-      ...(active === null ? {} : { activeHarness: active }),
-      now: new Date(2026, 7, 28, 11, 13).getTime(),
-    })
-    expect(built).toMatchObject({
-      ok: true,
-      source: {
-        session_id: PINNED.durableSessionId,
-        harness: 'hermes',
-        branch: 'feature/hermes-send',
-        worktree: 'hermes-topic',
-      },
-    })
-    if (built.ok) {
-      expect(JSON.stringify(built.source)).not.toContain('gateway-route-key')
-      expect(JSON.stringify(built.source)).not.toContain('/worktrees/')
-      expect(JSON.stringify(built.source)).not.toContain('/code/')
-    }
-  })
-
-  it('omits harness attribution when nested markers make ownership ambiguous', () => {
-    const env = stateEnv({
-      CLAUDECODE: '1',
-      CLAUDE_CODE_SESSION_ID: 'claude-orchestrator',
-      HERMES_SESSION_ID: PINNED.durableSessionId,
-    })
-    const invocation = inferInvocationContext('/workspace', fixtureGit({}))
-    const active = sourceContextHarnessSession(env, '/workspace', 1)
-    expect(active).toBeNull()
-    expect(
-      buildSourceContext({
-        env,
-        invocation,
-        now: 1,
-      }),
-    ).toEqual({ ok: true })
-  })
-
-  it('does not invent a Question Routing route for the pinned Hermes instance', () => {
-    expect(HERMES_CLASSIC_CLI_LOCAL_CAPABILITY.instance).toEqual(PINNED.instance)
-    expect(HERMES_QUESTION_ROUTING_UNAVAILABLE.stopContinuation).toBe('unsupported')
-    expect(Object.keys(HARNESS_CAPABILITIES)).not.toContain('hermes')
-  })
-
-  it('keeps unproven Hermes surfaces out of Source Context', () => {
-    for (const extra of [
-      { HERMES_SESSION_KEY: SYNTHETIC_GATEWAY_SESSION_KEY },
-      { HERMES_SESSION_PLATFORM: 'api_server' },
-      { HERMES_SESSION_SOURCE: 'tui' },
-      { TERMINAL_ENV: 'docker' },
-      { TERMINAL_ENV: 'ssh' },
-    ]) {
-      expect(
-        sourceContextHarnessSession(
-          { HERMES_SESSION_ID: PINNED.durableSessionId, ...extra },
-          '/workspace',
-          1,
-        ),
-      ).toBeNull()
-    }
-  })
-
-  it('records the precise platform-fixture and compression evidence boundary', () => {
-    expect(PINNED.evidence).toEqual({
-      nativeHostOs: 'macos',
-      portableFixtureFamilies: ['posix', 'windows'],
-      nativeOsUnrun: ['linux', 'windows'],
-    })
-    expect(PINNED.compression.defaultMode).toBe('in-place')
-    expect(PINNED.compression.sessionIdAfter).toBe(PINNED.compression.sessionIdBefore)
-    expect(PINNED.compression.legacyRotatingSessionId).not.toBe(
-      PINNED.compression.sessionIdBefore,
-    )
-  })
-})
-
-describe('OpenClaw agent-local Source Context seam', () => {
-  const PINNED_OPENCLAW = JSON.parse(
-    readFileSync(new URL('./fixtures/openclaw-2026.7.1-2-agent-local.json', import.meta.url), 'utf8'),
-  ) as {
-    durableSessionKey: string
-    rotatingSessionId: string
-    observedPluginEnv: { NOTIFAI_ACTIVE_HARNESS: 'openclaw'; NOTIFAI_ACTIVE_SESSION_ID: string }
-    instance: { harness: 'openclaw'; surface: 'agent-local'; execHost: 'gateway' }
-    hooks: {
-      proven: { activation: string; stop: string; execMarkers: string }
-      unprovenOnThisSurface: { presence: string; sessionEnd: string }
-    }
-    deferred: string[]
-  }
-
-  it('pins only the probed agent-local surface, not Gateway-embedded', () => {
-    expect(PINNED_OPENCLAW.instance).toEqual({
-      harness: 'openclaw',
-      surface: 'agent-local',
-      execHost: 'gateway',
-    })
-    expect(PINNED_OPENCLAW.durableSessionKey).toBe('agent:main:probe-owner')
-    expect(PINNED_OPENCLAW.observedPluginEnv.NOTIFAI_ACTIVE_SESSION_ID).toBe(
-      PINNED_OPENCLAW.durableSessionKey,
-    )
-    expect(PINNED_OPENCLAW.hooks.proven).toEqual({
-      activation: 'before_prompt_build',
-      stop: 'agent_end',
-      execMarkers: 'resolve_exec_env',
-    })
-    expect(PINNED_OPENCLAW.hooks.unprovenOnThisSurface).toEqual({
-      presence: 'message_received',
-      sessionEnd: 'session_end',
-    })
-    expect(PINNED_OPENCLAW.deferred).toContain('gateway-embedded')
-  })
-
-  it('attributes Source Context to the plugin-injected sessionKey', () => {
-    const env = stateEnv(PINNED_OPENCLAW.observedPluginEnv)
-    const cwd = '/workspace'
-    const active = resolveActiveHarness(env, cwd, Date.now()).active
-    expect(active).toMatchObject({
-      harness: 'openclaw',
-      sessionId: PINNED_OPENCLAW.durableSessionKey,
-    })
-    const built = buildSourceContext({
-      env,
-      invocation: inferInvocationContext(cwd, fixtureGit({})),
-      ...(active === null ? {} : { activeHarness: active }),
-      now: Date.now(),
-    })
-    expect(built).toMatchObject({
-      ok: true,
-      source: {
-        harness: 'openclaw',
-        session_id: PINNED_OPENCLAW.durableSessionKey,
-      },
-    })
-    if (built.ok) {
-      expect(JSON.stringify(built.source)).not.toContain(PINNED_OPENCLAW.rotatingSessionId)
-    }
-  })
-
-  it('treats nested OpenClaw and Claude markers as contested until live evidence exists', () => {
-    const env = stateEnv({
-      ...PINNED_OPENCLAW.observedPluginEnv,
-      CLAUDECODE: '1',
-      CLAUDE_CODE_SESSION_ID: 'claude-orchestrator',
-    })
-    const resolution = resolveActiveHarness(env, '/workspace', 1)
-    expect(resolution.contested.map((candidate) => candidate.harness).sort()).toEqual([
-      'claude-code',
-      'openclaw',
-    ])
-  })
-
-  it('keeps OpenClaw Question Routing unsupported', () => {
-    expect(HARNESS_CAPABILITIES.openclaw.stopContinuation).toBe('unsupported')
-    expect(HARNESS_CAPABILITIES.openclaw.deliveryRoutes).toEqual(['unsupported'])
-  })
-})

package/src/harnesses.test.ts

@@ -1,149 +0,0 @@
-import { readFileSync } from 'node:fs'
-import { describe, expect, it } from 'vitest'
-import {
-  HARNESS_CAPABILITIES,
-  HARNESS_LABELS,
-  HERMES_CLASSIC_CLI_LOCAL_CAPABILITY,
-  HERMES_QUESTION_ROUTING_UNAVAILABLE,
-  HOOK_INSTALLABLE_HARNESSES,
-  SOURCE_CONTEXT_HARNESSES,
-  hermesClassicCliLocalInstance,
-  isHookInstallableHarness,
-  questionRoutingCapability,
-} from './harnesses.js'
-
-const PINNED_HERMES_TRACE = JSON.parse(
-  readFileSync(new URL('./fixtures/hermes-0.20.6-classic-cli-local.json', import.meta.url), 'utf8'),
-) as {
-  instance: { harness: 'hermes'; surface: 'classic-cli'; terminalBackend: 'local' }
-  observedToolSubprocessEnv: { HERMES_SESSION_ID: string }
-  supported: string[]
-  unsupported: string[]
-  deferred: string[]
-}
-
-/**
- * This file used to hold a verbatim copy of the table below it, which meant
- * changing a harness contract required changing the same words twice and the
- * test could never disagree with the code — only with whoever forgot the second
- * edit. What is worth asserting is the shape the rest of the CLI assumes.
- */
-describe('harness contract', () => {
-  it('describes every shipped Source Context harness, and only those', () => {
-    expect(Object.keys(HARNESS_LABELS).sort()).toEqual([...SOURCE_CONTEXT_HARNESSES].sort())
-  })
-
-  it('keeps managed hook installation a strict subset of Source Context', () => {
-    expect(HOOK_INSTALLABLE_HARNESSES).toEqual([
-      'claude-code',
-      'codex',
-      'cursor',
-      'opencode',
-      'openclaw',
-    ])
-    expect(SOURCE_CONTEXT_HARNESSES).toContain('hermes')
-    expect(HOOK_INSTALLABLE_HARNESSES).not.toContain('hermes')
-    expect(Object.keys(HARNESS_CAPABILITIES).sort()).toEqual([...HOOK_INSTALLABLE_HARNESSES].sort())
-    for (const harness of HOOK_INSTALLABLE_HARNESSES) {
-      expect(isHookInstallableHarness(harness)).toBe(true)
-    }
-    expect(isHookInstallableHarness('hermes')).toBe(false)
-  })
-
-  it('gives a harness that cannot continue a turn no route to pretend with', () => {
-    // `ask` fails closed on these, and the reason it can is that the two facts
-    // agree. A harness claiming a delivery route while declaring it cannot
-    // continue would accept an answer into a void.
-    for (const harness of HOOK_INSTALLABLE_HARNESSES) {
-      const capability = questionRoutingCapability(harness)
-      if (capability.stopContinuation !== 'unsupported') continue
-      expect(capability.deliveryRoutes, harness).toEqual(['unsupported'])
-    }
-    expect(HERMES_QUESTION_ROUTING_UNAVAILABLE.deliveryRoutes).toEqual(['unsupported'])
-  })
-
-  it('gives a harness that can continue a turn at least one real route', () => {
-    for (const harness of HOOK_INSTALLABLE_HARNESSES) {
-      const capability = HARNESS_CAPABILITIES[harness]
-      if (capability.stopContinuation === 'unsupported') continue
-      expect(capability.deliveryRoutes.length, harness).toBeGreaterThan(0)
-      expect(capability.deliveryRoutes, harness).not.toContain('unsupported')
-      // The journal is the floor under every supported route: without it an
-      // answer that misses its turn has nowhere to wait.
-      expect(capability.deliveryRoutes, harness).toContain('hold-for-next-turn')
-    }
-  })
-
-  it('explains each harness in prose an operator can act on', () => {
-    for (const harness of HOOK_INSTALLABLE_HARNESSES) {
-      expect(questionRoutingCapability(harness).deliveryContract.length, harness).toBeGreaterThan(40)
-    }
-    expect(HERMES_QUESTION_ROUTING_UNAVAILABLE.deliveryContract.length).toBeGreaterThan(40)
-  })
-
-  it('keeps Claude Code, Codex, Cursor, and OpenCode continuation contracts unchanged', () => {
-    expect(HARNESS_CAPABILITIES['claude-code'].stopContinuation).toBe('decision-block')
-    expect(HARNESS_CAPABILITIES['claude-code'].deliveryRoutes).toEqual([
-      'hook-continuation',
-      'inbox-socket',
-      'cold-resume',
-      'hold-for-next-turn',
-    ])
-    expect(HARNESS_CAPABILITIES.codex.stopContinuation).toBe('decision-block')
-    expect(HARNESS_CAPABILITIES.codex.deliveryRoutes).toEqual([
-      'hook-continuation',
-      'cold-resume',
-      'hold-for-next-turn',
-    ])
-    expect(HARNESS_CAPABILITIES.cursor).toEqual({
-      stopContinuation: 'unsupported',
-      deliveryRoutes: ['unsupported'],
-      deliveryContract: HARNESS_CAPABILITIES.cursor.deliveryContract,
-    })
-    expect(HARNESS_CAPABILITIES.opencode.stopContinuation).toBe('unsupported')
-    expect(HARNESS_CAPABILITIES.opencode.deliveryRoutes).toEqual(['unsupported'])
-    expect(HARNESS_CAPABILITIES.openclaw.stopContinuation).toBe('unsupported')
-    expect(HARNESS_CAPABILITIES.openclaw.deliveryRoutes).toEqual(['unsupported'])
-  })
-
-  it('treats the pinned Hermes classic CLI/local trace as send-only', () => {
-    expect(HERMES_CLASSIC_CLI_LOCAL_CAPABILITY.instance).toEqual(PINNED_HERMES_TRACE.instance)
-    expect(PINNED_HERMES_TRACE.supported).toContain('deliberate-send')
-    expect(PINNED_HERMES_TRACE.unsupported).toContain('question-routing')
-    expect(PINNED_HERMES_TRACE.deferred).toContain('gateway')
-    expect(HERMES_CLASSIC_CLI_LOCAL_CAPABILITY.sourceContext).toBe(
-      'hermes-session-id-and-invocation-cwd',
-    )
-    expect(HERMES_QUESTION_ROUTING_UNAVAILABLE.stopContinuation).toBe('unsupported')
-    expect(HERMES_QUESTION_ROUTING_UNAVAILABLE.deliveryRoutes).toEqual(['unsupported'])
-  })
-
-  it('resolves only the pinned classic CLI/local marker envelope', () => {
-    expect(
-      hermesClassicCliLocalInstance({
-        HERMES_SESSION_ID: PINNED_HERMES_TRACE.observedToolSubprocessEnv.HERMES_SESSION_ID,
-      }),
-    ).toEqual(PINNED_HERMES_TRACE.instance)
-    expect(
-      hermesClassicCliLocalInstance({
-        HERMES_SESSION_ID: PINNED_HERMES_TRACE.observedToolSubprocessEnv.HERMES_SESSION_ID,
-        HERMES_SESSION_SOURCE: 'cli',
-        TERMINAL_ENV: 'local',
-      }),
-    ).toEqual(PINNED_HERMES_TRACE.instance)
-    for (const env of [
-      { HERMES_SESSION_KEY: 'gateway-key' },
-      { HERMES_SESSION_PLATFORM: 'api_server' },
-      { HERMES_SESSION_SOURCE: 'tui' },
-      { TERMINAL_ENV: 'docker' },
-      { TERMINAL_ENV: 'ssh' },
-    ]) {
-      expect(
-        hermesClassicCliLocalInstance({
-          HERMES_SESSION_ID: PINNED_HERMES_TRACE.observedToolSubprocessEnv.HERMES_SESSION_ID,
-          ...env,
-        }),
-      ).toBeNull()
-    }
-  })
-})