@raidiant/notifai 9.3.0 → 10.0.0

package/src/credentials.test.ts

@@ -285,6 +285,25 @@ describe('KeychainStore', () => {
 })
 
 describe('WindowsDpapiStore', () => {
+  it('round-trips through real Windows CurrentUser DPAPI without plaintext on disk', () => {
+    if (process.platform !== 'win32') return
+
+    const local = path.join(tmp, 'real dpapi & Ω', 'local app data')
+    mkdirSync(local, { recursive: true })
+    const env = { ...process.env, LOCALAPPDATA: local }
+    const store = new WindowsDpapiStore(env)
+    store.save(SAMPLE)
+
+    const file = path.join(local, 'notifai', 'credentials.dpapi')
+    const onDisk = readFileSync(file, 'utf8')
+    expect(onDisk).not.toContain(SAMPLE.secret)
+    expect(onDisk).not.toContain(SAMPLE.machineId)
+    expect(new WindowsDpapiStore(env).load()).toEqual(SAMPLE)
+
+    store.clear()
+    expect(existsSync(file)).toBe(false)
+  })
+
   it('protects under LOCALAPPDATA and never writes roaming or config trees', () => {
     const { env, roaming, config } = sandbox('dpapi-location')
     const { runner, calls } = mockDpapi()
@@ -304,6 +323,7 @@ describe('WindowsDpapiStore', () => {
     expect(calls[0]?.args).toEqual(
       expect.arrayContaining(['-NoProfile', '-NonInteractive', '-ExecutionPolicy', 'Bypass']),
     )
+    expect(calls.every((call) => call.timeoutMs === 30_000)).toBe(true)
     assertNoSecretInArgs(calls)
   })
 

package/src/credentials.ts

@@ -47,7 +47,10 @@ const SERVICE = 'io.notifai.cli'
 const CREDENTIAL_FORMAT = 'notifai.machine-credential.v1'
 const DPAPI_FORMAT = 'notifai.dpapi.current-user.v1'
 const DPAPI_ENTROPY = 'io.notifai.cli'
-const DPAPI_TIMEOUT_MS = 15_000
+// Inbox Windows PowerShell can have a slow first start on a newly provisioned
+// or heavily loaded machine. Keep the helper bounded without rejecting a
+// valid DPAPI operation during that cold-start window.
+const DPAPI_TIMEOUT_MS = 30_000
 const DPAPI_FILE = 'credentials.dpapi'
 const KEYCHAIN_TIMEOUT_MS = 15_000
 

package/src/fixtures/hermes-0.20.6-classic-cli-local.json

@@ -0,0 +1,50 @@
+{
+  "vendor": "NousResearch/hermes-agent",
+  "release": "0.20.6",
+  "commit": "5f75ec197b16d1a055688fb9df63ac49586a2230",
+  "instance": {
+    "harness": "hermes",
+    "surface": "classic-cli",
+    "terminalBackend": "local"
+  },
+  "durableSessionId": "20260828_111302_29a404",
+  "observedToolSubprocessEnv": {
+    "HERMES_SESSION_ID": "20260828_111302_29a404"
+  },
+  "cwd": {
+    "invocation": "/workspace",
+    "shellHookCwdIsProcessCwd": true,
+    "promptSectionCwdRequiresTerminalOverride": true
+  },
+  "evidence": {
+    "nativeHostOs": "macos",
+    "portableFixtureFamilies": ["posix", "windows"],
+    "nativeOsUnrun": ["linux", "windows"]
+  },
+  "compression": {
+    "defaultMode": "in-place",
+    "sessionIdBefore": "20260828_120000_inplace",
+    "sessionIdAfter": "20260828_120000_inplace",
+    "legacyRotatingSessionId": "20260828_111114_88ae83"
+  },
+  "supported": ["deliberate-send", "source-context-from-invocation-cwd"],
+  "unsupported": [
+    "managed-setup",
+    "lifecycle-activation",
+    "question-routing"
+  ],
+  "deferred": [
+    "tui",
+    "gateway",
+    "api",
+    "acp-session",
+    "safe-mode",
+    "native-linux",
+    "native-windows",
+    "live-auto-compression",
+    "interactive-reset",
+    "docker-backend",
+    "ssh-backend",
+    "other-remote-backends"
+  ]
+}

package/src/harness-integration.test.ts

@@ -0,0 +1,212 @@
+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,
+    )
+  })
+})

package/src/harnesses.test.ts

@@ -1,5 +1,26 @@
+import { readFileSync } from 'node:fs'
 import { describe, expect, it } from 'vitest'
-import { HARNESS_CAPABILITIES, HARNESS_LABELS, HARNESSES } from './harnesses.js'
+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
@@ -8,23 +29,36 @@ import { HARNESS_CAPABILITIES, HARNESS_LABELS, HARNESSES } from './harnesses.js'
  * edit. What is worth asserting is the shape the rest of the CLI assumes.
  */
 describe('harness contract', () => {
-  it('describes every shipped harness, and only those', () => {
-    expect(Object.keys(HARNESS_CAPABILITIES).sort()).toEqual([...HARNESSES].sort())
-    expect(Object.keys(HARNESS_LABELS).sort()).toEqual([...HARNESSES].sort())
+  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'])
+    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, capability] of Object.entries(HARNESS_CAPABILITIES)) {
+    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, capability] of Object.entries(HARNESS_CAPABILITIES)) {
+    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')
@@ -35,8 +69,73 @@ describe('harness contract', () => {
   })
 
   it('explains each harness in prose an operator can act on', () => {
-    for (const [harness, capability] of Object.entries(HARNESS_CAPABILITIES)) {
-      expect(capability.deliveryContract.length, harness).toBeGreaterThan(40)
+    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'])
+  })
+
+  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()
     }
   })
 })

package/src/harnesses.ts

@@ -1,13 +1,29 @@
-/** Every harness Notifai ships. This is the sole source of the harness union. */
-export const HARNESSES = ['claude-code', 'codex', 'cursor', 'opencode'] as const
+/** Every harness Notifai can name in Source Context when authoritatively known. */
+export const SOURCE_CONTEXT_HARNESSES = ['claude-code', 'codex', 'cursor', 'opencode', 'hermes'] as const
 
-export type Harness = (typeof HARNESSES)[number]
+export type SourceContextHarness = (typeof SOURCE_CONTEXT_HARNESSES)[number]
 
-export const HARNESS_LABELS: Record<Harness, string> = {
+/**
+ * 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'] 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',
+  hermes: 'Hermes',
 }
 
 export type DeliveryRoute =
@@ -29,33 +45,98 @@ export interface HarnessCapability {
   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',
+}
+
+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',
+}
+
 /**
- * Exhaustive runtime contract. Adding a harness without deciding every
- * continuation joint is a type error, not a silently degraded notification.
+ * 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 HARNESS_CAPABILITIES: Record<Harness, HarnessCapability> = {
-  'claude-code': {
-    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',
-  },
-  codex: {
-    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',
-  },
-  cursor: {
-    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',
-  },
-  opencode: {
-    stopContinuation: 'unsupported',
-    deliveryRoutes: ['unsupported'],
-    deliveryContract:
-      'no proven answer continuation after session.idle; use a blocking reply command',
+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,
+}
+
+/** Question-routing capability for the active harness integration. */
+export function questionRoutingCapability(harness: HookInstallableHarness): HarnessCapability {
+  return HARNESS_CAPABILITIES[harness]
 }

package/src/hooks.test.ts

@@ -561,8 +561,9 @@ describe('pushing a registered question', () => {
       title: 'Ship it?',
       body: 'Ship it?',
     })
-    // A pushed question is a question, and a question has an attention tone.
-    expect(h.recorder.submitted[0]?.draft.platform?.ios?.sound).toBe('attention')
+    // Kind default sounds are resolved server-side; stamping one here would
+    // skip Account and Project maps.
+    expect(h.recorder.submitted[0]?.draft.platform?.ios?.sound).toBeUndefined()
   })
 
   it('routes a registered question to an answer-capable Android installation', async () => {
@@ -594,7 +595,7 @@ describe('pushing a registered question', () => {
       mode: 'selected',
       device_ids: ['dev_android'],
     })
-    expect(h.recorder.submitted[0]?.draft.platform?.android?.sound).toBe('attention')
+    expect(h.recorder.submitted[0]?.draft.platform?.android?.sound).toBeUndefined()
   })
 
   it('keeps sparse alt text paired with its original media item', async () => {

package/src/hooks.ts

@@ -48,9 +48,9 @@ import { inferInvocationContext } from './invocation-context.js'
 import type { Logger } from './logging.js'
 import {
   HARNESS_CAPABILITIES,
-  HARNESSES,
+  HOOK_INSTALLABLE_HARNESSES,
   type DeliveryRoute,
-  type Harness,
+  type HookInstallableHarness,
 } from './harnesses.js'
 
 /**
@@ -896,7 +896,7 @@ function storedProjectSessionPointer(candidate: unknown): StoredProjectSessionPo
   }
   if (typeof entry.session_id !== 'string' || entry.session_id === '') return null
   if (typeof entry.updated_at !== 'number') return null
-  if (!(HARNESSES as readonly unknown[]).includes(entry.harness)) return null
+  if (!(HOOK_INSTALLABLE_HARNESSES as readonly unknown[]).includes(entry.harness)) return null
   return {
     sessionId: entry.session_id,
     updatedAt: entry.updated_at,
@@ -1135,7 +1135,7 @@ function gate(
   ctx.log?.info('hook.gate', { verdict, reason, stage: 'queued', ...data })
 }
 
-export type HookHarness = Harness
+export type HookHarness = HookInstallableHarness
 
 /**
  * One round of the waiter's reply poll. Short enough that several questions