@raidiant/notifai 9.3.0 → 10.1.0

package/src/commands.ts

@@ -17,6 +17,7 @@ export {
   deviceInventory,
   devicesCommand,
 } from './commands-devices.js'
+export { soundsCommand } from './commands-sounds.js'
 export {
   contradictingAnswer,
   repliesCommand,
@@ -67,4 +68,8 @@ export {
   projectEnableCommand,
   projectStatusCommand,
 } from './commands-project.js'
+export {
+  agentSessionRenameCommand,
+  type AgentSessionRenameFlags,
+} from './commands-agent-sessions.js'
 export { realIo } from './commands-io.js'

package/src/config-schema.test.ts

@@ -70,6 +70,7 @@ describe('acceptedValues', () => {
 
   it('lists the choices for an enum', () => {
     expect(acceptedValues('sound')).toContain('none')
+    expect(acceptedValues('sound')).toContain('custom sound')
   })
 
   it('names both values for a toggle', () => {

package/src/config-schema.ts

@@ -121,7 +121,7 @@ const INFO: Record<ConfigKey, Omit<ConfigKeyInfo, 'key'>> = {
     kind: 'enum',
     choices: CLI_SOUNDS,
     choiceHints: {
-      default: 'the standard notification tone',
+      default: 'Device default',
       done: 'the completion chime',
       attention: 'a distinct attention tone',
       alert: 'the most insistent tone',
@@ -129,7 +129,7 @@ const INFO: Record<ConfigKey, Omit<ConfigKeyInfo, 'key'>> = {
     },
     summary: 'Set the sound notifications from here use',
     detail:
-      'Setting this pins one sound for every notification sent from here, whatever kind it is.\n\nLeave it unset and each notification arrives with the sound its kind implies: the completion chime when work finished, the most insistent tone when it failed, a distinct attention tone for a question or blocked work, and the standard tone for ordinary news. A common explicit preference is `none`, to make a noisy project completely silent.',
+      'Setting this pins one sound for every notification sent from here, whatever kind it is. Shipped names are `default` (Device default), `done`, `attention`, `alert`, and `none`; an Account custom sound name or id from `notifai sounds` is accepted too.\n\nLeave it unset and each notification arrives with the sound its kind implies: the completion chime when work finished, the most insistent tone when it failed, a distinct attention tone for a question or blocked work, and Device default for ordinary news. A common explicit preference is `none`, to make a noisy project completely silent.',
     unsetMeans: 'not set; each kind brings its own sound',
   },
   interruption_level: {
@@ -281,6 +281,9 @@ export function boundsHint(key: ConfigKey): string | null {
 /** What a `config set` caller may legally pass, phrased for an error message. */
 export function acceptedValues(key: ConfigKey): string {
   const info = INFO[key]
+  if (key === 'sound') {
+    return `${CLI_SOUNDS.join(', ')}, a custom sound id, or a custom sound name`
+  }
   switch (info.kind) {
     case 'boolean':
       return 'true or false'

package/src/config.test.ts

@@ -177,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', () => {
@@ -199,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()
   })
 
@@ -551,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>
@@ -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,
 }
@@ -365,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
@@ -390,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/fixtures/openclaw-2026.7.1-2-agent-local.json

@@ -0,0 +1,57 @@
+{
+  "vendor": "openclaw/openclaw",
+  "release": "2026.7.1-2",
+  "commit": "0790d9f",
+  "instance": {
+    "harness": "openclaw",
+    "surface": "agent-local",
+    "execHost": "gateway"
+  },
+  "durableSessionKey": "agent:main:probe-owner",
+  "rotatingSessionId": "ae6686a4-d632-4750-b73b-56faec5fff9a",
+  "observedPluginEnv": {
+    "NOTIFAI_ACTIVE_HARNESS": "openclaw",
+    "NOTIFAI_ACTIVE_SESSION_ID": "agent:main:probe-owner"
+  },
+  "worker": {
+    "sessionKeySubstring": ":subagent:",
+    "provedSessionKey": "agent:main:subagent:probe-worker",
+    "missingIdentity": "fail-closed-worker"
+  },
+  "hooks": {
+    "proven": {
+      "activation": "before_prompt_build",
+      "stop": "agent_end",
+      "execMarkers": "resolve_exec_env"
+    },
+    "unprovenOnThisSurface": {
+      "presence": "message_received",
+      "sessionEnd": "session_end"
+    }
+  },
+  "evidence": {
+    "nativeHostOs": "macos",
+    "command": "openclaw agent --local",
+    "nativeOsUnrun": ["linux", "windows"]
+  },
+  "supported": [
+    "managed-setup",
+    "lifecycle-activation",
+    "source-context-from-session-key"
+  ],
+  "unsupported": [
+    "question-routing",
+    "command-stop-as-turn-end",
+    "2026.2.26-cli"
+  ],
+  "deferred": [
+    "gateway-embedded",
+    "gateway-remote",
+    "agent-exec",
+    "acp-nested",
+    "exec-sandbox",
+    "exec-node",
+    "native-linux",
+    "native-windows"
+  ]
+}

package/src/harness-integration.test.ts

@@ -0,0 +1,294 @@
+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'])
+  })
+})