@raidiant/notifai 9.2.2 → 10.0.0

package/src/config.test.ts

@@ -141,10 +141,9 @@ describe('harness config layers', () => {
     expect(config.ask_grace_seconds).toEqual({ value: 0, source: 'default' })
   })
 
-  it('bounds the terminal-first window so a reply window always survives it', () => {
+  it('bounds the terminal-first window to the supported preference', () => {
     // Config is readable from a repository, so an unbounded grace is hostile
-    // input: it would eat the waiter's whole ceiling and leave no window the
-    // server would accept an answer into.
+    // input rather than permission to hold question delivery arbitrarily.
     const { env, cwd } = setup({ globalToml: 'ask_grace_seconds = 100000\n' })
     expect(loadConfig({ cwd, env }).ask_grace_seconds.value).toBe(360)
   })
@@ -178,14 +177,29 @@ describe('config precedence', () => {
     expect(config.wait_seconds.source).toBe('flag')
   })
 
-  it('uses the prior default when a newer CLI wrote an unknown enum value', () => {
+  it('uses the prior default when a newer CLI wrote an unknown interruption level', () => {
     const { env, cwd } = setup({
-      globalToml: 'sound = "future-sound"\ninterruption_level = "future-level"\n',
+      globalToml: 'interruption_level = "future-level"\n',
     })
     const config = loadConfig({ cwd, env })
-    expect(config.sound).toEqual({ value: null, source: 'default' })
     expect(config.interruption_level).toEqual({ value: null, source: 'default' })
   })
+
+  it('keeps a custom sound name written by the user', () => {
+    const { env, cwd } = setup({
+      globalToml: 'sound = "Kitchen timer"\n',
+    })
+    const config = loadConfig({ cwd, env })
+    expect(config.sound).toEqual({ value: 'Kitchen timer', source: expect.stringMatching(/^global:/) })
+  })
+
+  it('drops a sound value that cannot be a name or id', () => {
+    const { env, cwd } = setup({
+      globalToml: `sound = "${'n'.repeat(200)}"\n`,
+    })
+    const config = loadConfig({ cwd, env })
+    expect(config.sound).toEqual({ value: null, source: 'default' })
+  })
 })
 
 describe('draft building', () => {
@@ -200,29 +214,23 @@ describe('draft building', () => {
       presentation: { title: 'T', body: 'B' },
       targets: { mode: 'all' },
       delivery: { ttl_seconds: 86400, collapse_key: null },
-      // An unlabelled draft is ordinary news, and news has a sound.
-      platform: {
-        ios: { sound: 'default' },
-        macos: { sound: 'default' },
-        android: { sound: 'default' },
-      },
     })
   })
 
   it.each([
-    { flags: {}, sound: 'default' },
-    { flags: { kind: 'update' }, sound: 'default' },
-    { flags: { kind: 'done' }, sound: 'done' },
-    { flags: { kind: 'failed' }, sound: 'alert' },
-    { flags: { kind: 'blocked' }, sound: 'attention' },
-    { flags: { kind: 'question' }, sound: 'attention' },
-    { flags: { reply: true }, sound: 'attention' },
-  ])('gives $flags the $sound sound when nobody chose one', ({ flags, sound }) => {
+    { flags: {} },
+    { flags: { kind: 'update' } },
+    { flags: { kind: 'done' } },
+    { flags: { kind: 'failed' } },
+    { flags: { kind: 'blocked' } },
+    { flags: { kind: 'question' } },
+    { flags: { reply: true } },
+  ])('omits sound from the draft for $flags so the server can resolve it', ({ flags }) => {
     const config = loadConfig({ cwd: base.cwd, env: base.env })
     const build = buildDraft(config, { title: 'T', body: 'B', ...flags })
     if (!build.ok) throw new Error(build.error)
-    expect(build.draft.platform?.ios?.sound).toBe(sound)
-    expect(build.draft.platform?.android?.sound).toBe(sound)
+    expect(build.draft.platform?.ios?.sound).toBeUndefined()
+    expect(build.draft.platform?.android?.sound).toBeUndefined()
     expect(build.draft.platform?.ios?.interruption_level).toBeUndefined()
   })
 
@@ -552,9 +560,22 @@ describe('draft building', () => {
   it('rejects malformed inputs with usage errors', () => {
     const config = loadConfig({ cwd: base.cwd, env: base.env })
     expect(buildDraft(config, { title: '', body: 'B' }).ok).toBe(false)
-    expect(buildDraft(config, { title: 'T', body: 'B', sound: 'airhorn' }).ok).toBe(false)
+    expect(buildDraft(config, { title: 'T', body: 'B', sound: 'n'.repeat(200) }).ok).toBe(false)
     expect(buildDraft(config, { title: 'T', body: 'B', data: ['nokey'] }).ok).toBe(false)
     expect(buildDraft(config, { title: 'T', body: 'B', level: 'shouting' }).ok).toBe(false)
     expect(buildDraft(config, { title: 'T', body: 'B', platform: 'linux' }).ok).toBe(false)
   })
+
+  it('puts a custom sound name on the draft for the server to resolve', () => {
+    const config = loadConfig({ cwd: base.cwd, env: base.env })
+    const byName = buildDraft(config, { title: 'T', body: 'B', sound: 'airhorn' })
+    if (!byName.ok) throw new Error(byName.error)
+    expect(byName.draft.platform?.ios?.sound).toBe('airhorn')
+    expect(byName.draft.platform?.android?.sound).toBe('airhorn')
+
+    const byId = buildDraft(config, { title: 'T', body: 'B', sound: 'snd_01HQTEST' })
+    if (!byId.ok) throw new Error(byId.error)
+    expect(byId.draft.platform?.ios?.sound).toBe('snd_01HQTEST')
+    expect(byId.draft.platform?.android?.sound).toBe('snd_01HQTEST')
+  })
 })

package/src/config.ts

@@ -1,5 +1,4 @@
 import {
-  CLI_SOUNDS,
   INTERRUPTION_LEVELS,
   REPLY_MAX_WINDOW_SECONDS,
 } from '@raidiant/notifai-protocol'
@@ -8,6 +7,7 @@ import { existsSync, readFileSync, realpathSync } from 'node:fs'
 import path from 'node:path'
 import { parse as parseToml } from 'smol-toml'
 import { configHome, stateHome } from './platform.js'
+import { isCliSoundRef } from './sound-ref.js'
 import { normalizeOrigin } from './url-policy.js'
 
 /**
@@ -41,7 +41,6 @@ export interface ResolvedValue<T> {
   source: ConfigSource
 }
 
-type CliSound = (typeof CLI_SOUNDS)[number]
 type CliInterruptionLevel = (typeof INTERRUPTION_LEVELS)[number]
 
 /**
@@ -58,7 +57,7 @@ export interface CliConfig {
   ttl_seconds: ResolvedValue<number>
   collapse_key: ResolvedValue<string | null>
   devices: ResolvedValue<string[] | null>
-  sound: ResolvedValue<CliSound | null>
+  sound: ResolvedValue<string | null>
   interruption_level: ResolvedValue<CliInterruptionLevel | null>
   /** Project identifier stamped on sends; typically set in .notifai/config.toml. */
   project: ResolvedValue<string | null>
@@ -70,8 +69,8 @@ export interface CliConfig {
    * elapses does the question reach companion devices.
    *
    * A timer, and only a timer. Whether the user happens to be at this keyboard
-   * decides nothing — the waiter no longer holds their terminal, so there is
-   * nothing for their presence to protect them from.
+   * decides nothing; the harness-specific owner continues waiting either in
+   * the held turn or out of band.
    */
   ask_grace_seconds: ResolvedValue<number>
   /**
@@ -90,7 +89,7 @@ export interface CliConfig {
    * usefulness.
    */
   log_max_bytes: ResolvedValue<number>
-  /** How long the server keeps accepting an answer to a question. */
+  /** How long the server accepts an answer and Question Routing owns its return path. */
   reply_window_seconds: ResolvedValue<number>
   /** Log files kept in total, the active one included. */
   log_max_files: ResolvedValue<number>
@@ -159,7 +158,6 @@ export const NUMERIC_CONFIG_KEYS: readonly ConfigKey[] = [
  * is the same discipline the numeric bounds follow.
  */
 export const ENUM_CONFIG_VALUES: Partial<Record<ConfigKey, readonly string[]>> = {
-  sound: CLI_SOUNDS,
   interruption_level: INTERRUPTION_LEVELS,
   log_level: LOG_LEVELS,
 }
@@ -330,17 +328,14 @@ export function findProjectLocalConfigPath(
 
 /**
  * Ranges every layer is clamped to. Config is readable from a repository, so an
- * out-of-range value is attacker input, not a typo: an unbounded grace window
- * would consume the waiter's whole ceiling and silently leave no time at all in
- * which the user's answer could still be accepted.
+ * out-of-range value is attacker input, not a typo.
  */
 const NUMERIC_BOUNDS: Partial<Record<ConfigKey, { min: number; max: number }>> = {
   wait_seconds: { min: 0, max: 300 },
   ttl_seconds: { min: 0, max: 7 * 24 * 3600 },
-  // A plain number, no longer derived from a hook budget's leftovers. Six
-  // minutes leaves two clear minutes of the waiter's 480s ceiling, so the
-  // longest window a user can choose still leaves an answer window the server
-  // will accept — with room to spare for a timer that wakes late.
+  // Six minutes is the supported terminal-first preference bound. The Stop
+  // owner carries separate startup headroom, so this never shortens the answer
+  // window that begins after submission.
   ask_grace_seconds: { min: 0, max: 360 },
   // The floor is the shortest window the wire contract accepts; the ceiling is
   // the point past which a question would outlive the retained content it
@@ -368,6 +363,9 @@ function coerce(key: ConfigKey, value: unknown): unknown | undefined {
     const origins = value.map((entry) => (typeof entry === 'string' ? normalizeOrigin(entry) : null))
     return origins.every((origin): origin is string => origin !== null) ? origins : undefined
   }
+  if (key === 'sound') {
+    return typeof value === 'string' && isCliSoundRef(value) ? value : undefined
+  }
   const allowed = ENUM_CONFIG_VALUES[key]
   if (allowed !== undefined) {
     return typeof value === 'string' && allowed.includes(value) ? value : undefined
@@ -393,7 +391,7 @@ export interface FlagOverrides {
   ttl_seconds?: number
   collapse_key?: string | null
   devices?: string[]
-  sound?: CliSound
+  sound?: string
   interruption_level?: CliInterruptionLevel
 }
 

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/guidance-content.ts

@@ -24,6 +24,28 @@ export interface GuidanceTopic {
   content: string
 }
 
+/** Canonical lifecycle vocabulary, always emitted from trusted CLI source. */
+export const AGENT_TERMS_PREAMBLE = `# Notifai terms
+
+An **Agent Event** is something that happened in the agent's work: completion,
+failure, a blocker, a question that needs the User, or another meaningful
+change. It stays inside the agent team until the Notification Request owner
+decides it should reach the User.
+
+A **Notification Request** is the deliberate User-visible message or question
+submitted through Notifai about an Agent Event. It is not every event and it
+is not an internal worker report.
+
+The root agent owns Notification Requests by default. Ordinary workers report
+Agent Events to their parent and do not notify the User themselves. Explicit
+delegation transfers that ownership for the delegated work.`
+
+export const AGENT_TERMS_FALLBACK = `# Notifai terms
+
+An **Agent Event** is a meaningful occurrence in agent work. A **Notification
+Request** is a deliberate User-visible message about one. Root owns requests;
+workers report events unless ownership is explicitly delegated.`
+
 const WHEN_TO_NOTIFY = `# When to notify
 
 Notify when something changed for the user:

package/src/guidance-render.ts

@@ -1,6 +1,6 @@
 import { Buffer } from 'node:buffer'
 import { describeSource } from './config-schema.js'
-import { GUIDANCE_TRUST_PREAMBLE } from './guidance-content.js'
+import { AGENT_TERMS_FALLBACK, AGENT_TERMS_PREAMBLE, GUIDANCE_TRUST_PREAMBLE } from './guidance-content.js'
 import { resolveGuidance, type GuidanceAuthority, type ResolvedGuidanceTopic } from './guidance.js'
 
 const AUTHORITY_LABEL: Record<GuidanceAuthority, string> = {
@@ -24,7 +24,7 @@ export function renderGuidance(topics: readonly ResolvedGuidanceTopic[]): string
       `${filePath === null ? '' : ` file=${encodeURIComponent(filePath)}`} -->`
     return `${marker}\n${markerSafe(topic.content).trimEnd()}`
   })
-  return [GUIDANCE_TRUST_PREAMBLE, ...blocks].join('\n\n')
+  return [GUIDANCE_TRUST_PREAMBLE, AGENT_TERMS_PREAMBLE, ...blocks].join('\n\n')
 }
 
 /** Hard ceiling for model-visible lifecycle context, including repository topics. */
@@ -48,7 +48,7 @@ export function boundedEffectiveGuidance(options: {
     bytes,
     max_bytes: maxBytes,
     fallback:
-      `${GUIDANCE_TRUST_PREAMBLE}\n\n` +
+      `${GUIDANCE_TRUST_PREAMBLE}\n\n${AGENT_TERMS_FALLBACK}\n\n` +
       `Notifai guidance is ${bytes} bytes, above the ${maxBytes}-byte lifecycle limit. ` +
       'Before deciding whether or how to notify, run `notifai guidance` once in this session. ' +
       'Do not infer or partially follow the omitted topics.',

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,
+    )
+  })
+})