@raidiant/notifai 9.3.0 → 10.1.0

package/src/commands.test.ts

@@ -1,4 +1,6 @@
 import { CAPABILITIES_V1, PLATFORMS, REPLY_MAX_QUESTIONS } from '@raidiant/notifai-protocol'
+import { execFileSync } from 'node:child_process'
+import { createHash } from 'node:crypto'
 import {
   existsSync,
   mkdirSync,
@@ -32,6 +34,7 @@ import {
   acknowledgeCommand,
   askCommand,
   accessStatusCommand,
+  authStatusCommand,
   buildQuestions,
   assessReadiness,
   capabilitiesCommand,
@@ -56,6 +59,7 @@ import {
   repliesCommand,
   sendCommand,
   statusCommand,
+  agentSessionRenameCommand,
   type CommandDeps,
   type CommandIo,
   type CommandSpinner,
@@ -443,6 +447,16 @@ describe('command contracts', () => {
     expect(submitted?.draft.project).toBeUndefined()
     expect(projectEnabled(projectBinding(cwd, env))).toBe(false)
   })
+  it('tells an unsigned machine to run init, not login', () => {
+    const io = new CapturedIo()
+    const deps = makeDeps(io, {} as ApiClient)
+    deps.store.load = () => null
+
+    expect(authStatusCommand(deps, {})).toBe(EXIT.auth)
+    expect(io.errLines.join('\n')).toMatch(/Not signed in\. Run `notifai init`/)
+    expect(io.errLines.join('\n')).not.toContain('notifai login')
+  })
+
   it('shows an actionable no-plan access state', async () => {
     const io = new CapturedIo()
     const client = {
@@ -763,6 +777,28 @@ describe('command contracts', () => {
     expect(io.errLines).toEqual([])
   })
 
+  it('sends an Account custom sound name on the draft', async () => {
+    const io = new CapturedIo()
+    let submitted: SubmitNotificationRequestT | undefined
+    const client = {
+      submit: async (body: SubmitNotificationRequestT) => {
+        submitted = body
+        return receipt
+      },
+    } as unknown as ApiClient
+
+    expect(
+      await sendCommand(makeDeps(io, client), {
+        kind: 'done',
+        title: 'Build finished',
+        body: 'All checks passed.',
+        sound: 'Kitchen timer',
+      }),
+    ).toBe(EXIT.ok)
+    expect(submitted?.draft.platform?.ios?.sound).toBe('Kitchen timer')
+    expect(submitted?.draft.platform?.android?.sound).toBe('Kitchen timer')
+  })
+
   it('prints Android downgrade warnings before submitting', async () => {
     const io = new CapturedIo()
     let submitCalls = 0
@@ -856,7 +892,7 @@ describe('command contracts', () => {
     expect(io.errLines.join('\n')).not.toContain('opaque-claude-session-42')
   })
 
-  it('never promotes an Orca worktree title into an Agent Session label', async () => {
+  it('uses trusted Orca task context for an active Claude Agent Session label', async () => {
     const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-orca-claude-title-'))
     const io = new CapturedIo()
     let submitted: SubmitNotificationRequestT | undefined
@@ -879,6 +915,7 @@ describe('command contracts', () => {
       ...makeDeps(io, client),
       cwd,
       env,
+      orcaSessionTitle: () => 'Agent Session context labels',
     }
 
     expect(
@@ -891,13 +928,12 @@ describe('command contracts', () => {
 
     expect(submitted?.draft.source).toMatchObject({
       session_id: 'orca-claude-session',
+      session_label: 'Agent Session context labels',
       harness: 'claude-code',
     })
-    expect(submitted?.draft.source?.session_label).toMatch(/^[A-Z][a-z]+ [A-Z][a-z]+$/)
-    expect(submitted?.draft.source?.session_label).not.toBe('Worker - semantic session implementation')
   })
 
-  it('never treats an Orca worktree title as a Codex Agent Session label', async () => {
+  it('uses trusted Orca task context for an active Codex Agent Session label', async () => {
     const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-orca-codex-title-'))
     const io = new CapturedIo()
     let submitted: SubmitNotificationRequestT | undefined
@@ -918,6 +954,7 @@ describe('command contracts', () => {
         TERM_PROGRAM: 'Orca',
         ORCA_WORKTREE_ID: worktreeId,
       },
+      orcaSessionTitle: () => 'Release verification',
     }
 
     expect(
@@ -930,9 +967,77 @@ describe('command contracts', () => {
 
     expect(submitted?.draft.source).toMatchObject({
       session_id: 'orca-codex-thread',
+      session_label: 'Release verification',
       harness: 'codex',
     })
-    expect(submitted?.draft.source?.session_label).toMatch(/^[A-Z][a-z]+ [A-Z][a-z]+$/)
+  })
+
+  it('sends after isolating an invalid session-name record without losing valid names', async () => {
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-invalid-session-name-'))
+    const io = new CapturedIo()
+    const env = {
+      XDG_CONFIG_HOME: path.join(cwd, 'config'),
+      XDG_STATE_HOME: path.join(cwd, 'state'),
+      CODEX_THREAD_ID: 'current-session',
+    }
+    const file = path.join(stateDir(env), 'session-labels.json')
+    const validKey = createHash('sha256').update('unrelated-session').digest('hex')
+    mkdirSync(path.dirname(file), { recursive: true })
+    writeFileSync(
+      file,
+      `${JSON.stringify(
+        {
+          version: 1,
+          sessions: {
+            [validKey]: {
+              label: 'Unrelated work',
+              source: 'explicit',
+              first_seen_at: 1_777_777_777_000,
+              harness: 'codex',
+            },
+            obsolete: {
+              label: 'Old shape',
+              source: 'legacy',
+              first_seen_at: 'unknown',
+            },
+          },
+        },
+        null,
+        2,
+      )}\n`,
+    )
+
+    let submitted: SubmitNotificationRequestT | undefined
+    const client = {
+      submit: async (body: SubmitNotificationRequestT) => {
+        submitted = body
+        return receipt
+      },
+    } as unknown as ApiClient
+
+    expect(
+      await sendCommand(
+        { ...makeDeps(io, client), cwd, env },
+        { title: 'Store recovered', body: 'The valid Agent Session name survived.', kind: 'done' },
+      ),
+    ).toBe(EXIT.ok)
+    expect(submitted?.draft.source).toMatchObject({
+      session_id: 'current-session',
+      harness: 'codex',
+    })
+
+    const recovered = JSON.parse(readFileSync(file, 'utf8')) as {
+      sessions: Record<string, { label: string }>
+    }
+    expect(recovered.sessions[validKey]?.label).toBe('Unrelated work')
+    expect(recovered.sessions['obsolete']).toBeUndefined()
+    const backups = readdirSync(path.dirname(file)).filter((name) =>
+      /^session-labels\.invalid-[a-f0-9]{64}\.json$/u.test(name),
+    )
+    expect(backups).toHaveLength(1)
+    expect(readFileSync(path.join(path.dirname(file), backups[0]!), 'utf8')).toContain(
+      '"obsolete"',
+    )
   })
 
   it('falls back safely when Orca returns a private path as its title', async () => {
@@ -1041,6 +1146,113 @@ describe('command contracts', () => {
     expect(existsSync(path.join(cwd, 'state', 'notifai', 'session-labels.json'))).toBe(false)
   })
 
+  it('sends Hermes Source Context from HERMES_SESSION_ID and the invocation cwd', async () => {
+    const root = mkdtempSync(path.join(os.tmpdir(), 'notifai-hermes-send-'))
+    const repo = path.join(root, 'notifai')
+    const worktree = path.join(root, 'hermes-topic')
+    mkdirSync(repo)
+    const git = (...args: string[]) => execFileSync('git', ['-C', repo, ...args], { stdio: 'ignore' })
+    git('init')
+    git('config', 'user.email', 'test@example.invalid')
+    git('config', 'user.name', 'Test')
+    git('config', 'commit.gpgsign', 'false')
+    writeFileSync(path.join(repo, 'file'), 'x')
+    git('add', 'file')
+    git('commit', '-m', 'fixture')
+    git('worktree', 'add', worktree, '-b', 'feature/hermes-send')
+
+    const io = new CapturedIo()
+    let submitted: SubmitNotificationRequestT | undefined
+    const client = {
+      submit: async (body: SubmitNotificationRequestT) => {
+        submitted = body
+        return receipt
+      },
+    } as unknown as ApiClient
+    const sessionId = '20260828_111302_29a404'
+    const deps = {
+      ...makeDeps(io, client),
+      cwd: worktree,
+      env: {
+        ...isolatedEnv(worktree),
+        HERMES_SESSION_ID: sessionId,
+      },
+    }
+
+    expect(
+      await sendCommand(deps, {
+        title: 'Hermes baseline landed',
+        body: 'Classic CLI send carries exact session identity.',
+        kind: 'done',
+      }),
+    ).toBe(EXIT.ok)
+
+    expect(submitted?.draft.source).toMatchObject({
+      session_id: sessionId,
+      harness: 'hermes',
+      branch: 'feature/hermes-send',
+      worktree: 'hermes-topic',
+    })
+    expect(io.outLines.join('\n')).not.toContain(sessionId)
+
+    submitted = undefined
+    expect(
+      await sendCommand(
+        {
+          ...deps,
+          env: {
+            ...deps.env,
+            HERMES_SESSION_KEY: 'gateway-route-key-must-not-be-session-id',
+          },
+        },
+        {
+          title: 'Hermes deferred surface sent',
+          body: 'The send stays universal while unproven Source Context is omitted.',
+          kind: 'done',
+        },
+      ),
+    ).toBe(EXIT.ok)
+    expect(submitted?.draft.source).toMatchObject({
+      branch: 'feature/hermes-send',
+      worktree: 'hermes-topic',
+    })
+    expect(submitted?.draft.source).not.toHaveProperty('session_id')
+    expect(submitted?.draft.source).not.toHaveProperty('harness')
+    expect(JSON.stringify(submitted?.draft.source)).not.toContain('gateway-route-key')
+  })
+
+  it('does not attribute Hermes Source Context when another harness marker is nested', async () => {
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-hermes-nested-send-'))
+    const io = new CapturedIo()
+    let submitted: SubmitNotificationRequestT | undefined
+    const client = {
+      submit: async (body: SubmitNotificationRequestT) => {
+        submitted = body
+        return receipt
+      },
+    } as unknown as ApiClient
+    const deps = {
+      ...makeDeps(io, client),
+      cwd,
+      env: {
+        ...isolatedEnv(cwd),
+        CLAUDECODE: '1',
+        CLAUDE_CODE_SESSION_ID: 'claude-orchestrator',
+        HERMES_SESSION_ID: '20260828_111302_29a404',
+      },
+    }
+
+    expect(
+      await sendCommand(deps, {
+        title: 'Nested send stays honest',
+        body: 'Ambiguous ownership omits harness identity.',
+        kind: 'update',
+      }),
+    ).toBe(EXIT.ok)
+    expect(submitted?.draft.source?.harness).toBeUndefined()
+    expect(submitted?.draft.source?.session_id).toBeUndefined()
+  })
+
   it('uploads repeatable images in order and sends only canonical media references', async () => {
     const root = mkdtempSync(path.join(os.tmpdir(), 'notifai-media-order-'))
     const first = path.join(root, 'first.png')
@@ -1198,6 +1410,8 @@ describe('command contracts', () => {
     // Kind now selects the sound, so the help must say so — and must not carry
     // the retired separation it replaced.
     expect(source).toContain('Kind is required, and it selects the sound')
+    expect(source).toContain('Device default')
+    expect(source).toContain('custom name or id')
     expect(source).not.toContain('it never chooses banner sound or interruption level')
     expect(source).not.toContain('Kind profiles apply automatically')
   })
@@ -2393,7 +2607,7 @@ describe('credential origin pinning', () => {
     expect(io.errLines).toEqual([
       'This account has no active plan or temporary Alpha access.',
       'next: Ask the account owner for Alpha access.',
-      'After access is granted, run `notifai login` again.',
+      'After access is granted, run `notifai init` again.',
     ])
   })
 
@@ -3074,6 +3288,71 @@ describe('harness activation guidance', () => {
     expect(inspectHookAdapter(deps.hookAdapterHome).problems).toEqual([])
     expect(inspectHookAdapter(deps.hookAdapterHome).target?.scriptPath).toBe(scriptPath)
   })
+
+  it('installs an owned OpenClaw plugin and reports unsupported continuation', async () => {
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-openclaw-activation-'))
+    const io = new CapturedIo()
+    const client = {
+      health: async () => true,
+      capabilities: async () => ({ schema_version: 1, platform: 'ios' }),
+      listDevices: async () => ({ devices: [] }),
+    } as unknown as ApiClient
+    const home = path.join(cwd, 'home')
+    const deps = {
+      ...makeDeps(io, client),
+      cwd,
+      env: {
+        HOME: home,
+        XDG_CONFIG_HOME: path.join(cwd, 'config'),
+        XDG_STATE_HOME: path.join(cwd, 'state'),
+        OPENCLAW_STATE_DIR: path.join(cwd, 'openclaw-home'),
+      },
+    }
+
+    expect(hooksInstallCommand(deps, { harness: 'openclaw', execPath, scriptPath })).toBe(EXIT.ok)
+    expect(io.outLines.join('\n')).toContain('Installed openclaw hooks in')
+    expect(io.outLines.join('\n')).toContain(
+      'Restart the OpenClaw Gateway, start one fresh Agent Session, send one prompt, then run `notifai doctor`.',
+    )
+    const pluginFile = path.join(cwd, '.openclaw', 'extensions', 'notifai', 'index.js')
+    const plugin = readFileSync(pluginFile, 'utf8')
+    expect(plugin).toContain('api.on("before_prompt_build"')
+    expect(plugin).toContain('api.on("resolve_exec_env"')
+    expect(plugin).not.toContain('command:stop')
+    const config = JSON.parse(
+      readFileSync(path.join(cwd, 'openclaw-home', 'openclaw.json'), 'utf8'),
+    ) as {
+      plugins: { entries: { notifai: { enabled: boolean; hooks: { allowConversationAccess: boolean } } } }
+    }
+    expect(config.plugins.entries.notifai).toEqual({
+      enabled: true,
+      hooks: { allowConversationAccess: true },
+    })
+
+    io.outLines = []
+    expect(await doctorCommand(deps, {})).toBe(EXIT.failed)
+    expect(io.outLines.join('\n')).toContain('no proven answer continuation')
+  })
+
+  it('refuses to overwrite a foreign OpenClaw plugin', () => {
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-openclaw-foreign-'))
+    const plugin = path.join(cwd, '.openclaw', 'extensions', 'notifai', 'index.js')
+    mkdirSync(path.dirname(plugin), { recursive: true })
+    writeFileSync(plugin, 'export default { id: "foreign" }\n')
+    const io = new CapturedIo()
+    const deps = {
+      ...makeDeps(io, {} as ApiClient),
+      cwd,
+      env: {
+        HOME: path.join(cwd, 'home'),
+        XDG_STATE_HOME: path.join(cwd, 'state'),
+        OPENCLAW_STATE_DIR: path.join(cwd, 'openclaw-home'),
+      },
+    }
+    expect(hooksInstallCommand(deps, { harness: 'openclaw', execPath, scriptPath })).toBe(EXIT.failed)
+    expect(io.errLines.join('\n')).toMatch(/was not written by Notifai/)
+    expect(readFileSync(plugin, 'utf8')).toBe('export default { id: "foreign" }\n')
+  })
 })
 
 describe('stable hook installation', () => {
@@ -3539,19 +3818,20 @@ describe('config surfaces', () => {
     expect(io.errLines[0]).toBe('Unknown setting "ask_notification".')
   })
 
-  it('refuses an enum value the sender would later reject', async () => {
-    // `config set sound whatever` used to be written straight to disk: the
-    // typo only surfaced when a notification failed to carry the sound.
+  it('refuses a sound that cannot be a shipped name, custom id, or custom name', async () => {
     const io = new CapturedIo()
-    expect(await configSetCommand(configDeps(io), 'sound', 'whatever', { yes: true })).toBe(
+    expect(await configSetCommand(configDeps(io), 'sound', 'n'.repeat(200), { yes: true })).toBe(
       EXIT.usage,
     )
-    expect(io.errLines[0]).toContain('default, done, attention, alert, none')
+    expect(io.errLines[0]).toContain('custom sound')
   })
 
-  it('still accepts a legal enum value', async () => {
+  it('accepts a shipped sound and an Account custom name', async () => {
     const io = new CapturedIo()
     expect(await configSetCommand(configDeps(io), 'sound', 'none', { yes: true })).toBe(EXIT.ok)
+    expect(await configSetCommand(configDeps(io), 'sound', 'Kitchen timer', { yes: true })).toBe(
+      EXIT.ok,
+    )
   })
 
   it('removes one machine setting, preserves its siblings, and restores default provenance', async () => {
@@ -4320,8 +4600,9 @@ describe('init', () => {
     expect(await initCommand(deps, {})).toBe(EXIT.failed)
     const out = io.outLines.join('\n')
     expect(out).toContain('Next: This machine')
-    expect(out).toContain('notifai login')
-    expect(out).toContain('Then re-run `notifai init` and it will pick up from here.')
+    expect(out).toContain('notifai init')
+    expect(out).not.toContain('notifai login')
+    expect(out).not.toContain('Then re-run')
     // The device gap is real and downstream; it must stay hidden until the
     // sign-in that would let anyone actually check it has happened.
     expect(out).not.toContain('companion app')
@@ -4867,7 +5148,8 @@ describe('init', () => {
     }
 
     expect(await initCommand(deps, { setupScope: 'project' })).toBe(EXIT.failed)
-    expect(io.outLines.join('\n')).toContain('notifai login')
+    expect(io.outLines.join('\n')).toContain('notifai init')
+    expect(io.outLines.join('\n')).not.toContain('notifai login')
   })
 
   it('announces sign-in for a present human without re-confirming', async () => {
@@ -4900,7 +5182,8 @@ describe('init', () => {
     const out = io.outLines.join('\n')
     expect(out).toContain('Opening your browser to approve this machine — Ctrl-C to stop.')
     expect(out).toContain('Next: This machine')
-    expect(out).toContain('Then re-run `notifai init` and it will pick up from here.')
+    expect(out).toContain('notifai init')
+    expect(out).not.toContain('notifai login')
   })
 
   it('never prompts or opens a browser when an agent runs it unattended', async () => {
@@ -5463,8 +5746,86 @@ describe('init', () => {
     const out = io.outLines.join('\n')
     expect(out).toContain('Next: Account')
     expect(out).toContain('pair it again')
-    expect(out).toContain('notifai login')
+    expect(out).toContain('notifai init')
+    expect(out).not.toContain('notifai login')
+    expect(out.match(/^Next:/gm)).toHaveLength(1)
+  })
+
+  it('names the support next action when a paired account has no active plan', async () => {
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'init-no-plan-'))
+    const io = new CapturedIo()
+    const nextAction = 'Open https://app.notifai.sh/support to request Alpha access, then retry.'
+    const client = {
+      health: async () => true,
+      capabilities: async () => ({ schema_version: 1, platform: 'ios' }),
+      listDevices: async () => {
+        throw new ApiCallError(403, 'no_active_plan', 'No active plan.', nextAction)
+      },
+      accessStatus: async () => ({
+        status: 'no_active_plan',
+        reason: 'no_active_grant',
+        expires_at: null,
+        email: 'rafael@example.test',
+      }),
+    } as unknown as ApiClient
+    const deps = {
+      ...makeDeps(io, client),
+      cwd,
+      env: isolatedEnv(cwd),
+    }
+
+    const readiness = await assessReadiness(deps)
+    const auth = readiness.states.find((state) => state.id === 'auth')
+    expect(auth).toMatchObject({
+      status: 'gap',
+      detail: 'no active plan or temporary Alpha access (rafael@example.test)',
+      remedy: { by: 'user-elsewhere', summary: nextAction },
+    })
+    expect(auth?.remedy && 'command' in auth.remedy ? auth.remedy.command : undefined).toBeUndefined()
+
+    expect(await initCommand(deps, { hooks: false, skills: false })).toBe(EXIT.failed)
+    const out = io.outLines.join('\n')
+    expect(out).toContain('Next: Account')
+    expect(out).toContain(nextAction)
+    expect(out).not.toContain('pair it again')
+    expect(out).not.toContain('notifai login')
     expect(out.match(/^Next:/gm)).toHaveLength(1)
+
+    const doctorIo = new CapturedIo()
+    expect(await doctorCommand({ ...deps, io: doctorIo }, { json: true })).toBe(EXIT.failed)
+    const payload = JSON.parse(doctorIo.outLines[0] ?? '{}') as {
+      states: Array<{ id: string; remedy?: { summary?: string; command?: string } }>
+    }
+    const doctorAuth = payload.states.find((state) => state.id === 'auth')
+    expect(doctorAuth?.remedy?.summary).toBe(nextAction)
+    expect(doctorAuth?.remedy?.command).toBeUndefined()
+  })
+
+  it('does not treat a listDevices no-plan 403 as a revoked machine when accessStatus fails', async () => {
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'init-no-plan-devices-only-'))
+    const io = new CapturedIo()
+    const nextAction = 'Open https://app.notifai.sh/support to request Alpha access, then retry.'
+    const client = {
+      health: async () => true,
+      listDevices: async () => {
+        throw new ApiCallError(403, 'no_active_plan', 'No active plan.', nextAction)
+      },
+      accessStatus: async () => {
+        throw new ApiCallError(500, 'internal_error', 'access status unavailable')
+      },
+    } as unknown as ApiClient
+    const deps = {
+      ...makeDeps(io, client),
+      cwd,
+      env: isolatedEnv(cwd),
+    }
+
+    const readiness = await assessReadiness(deps)
+    const auth = readiness.states.find((state) => state.id === 'auth')
+    expect(auth?.status).toBe('gap')
+    expect(auth?.detail).toContain('no active plan')
+    expect(auth?.remedy).toMatchObject({ by: 'user-elsewhere', summary: nextAction })
+    expect(JSON.stringify(auth)).not.toContain('pair it again')
   })
 
   it('reuses proof across worktrees of one Project on the same Approved Machine', async () => {
@@ -6519,6 +6880,114 @@ describe('asking before the hooks have ever run', () => {
     expect(readSessionState('opencode-current', env).pending).toBeUndefined()
   })
 
+  it('rejects OpenClaw before registration even with an exact matching pointer', () => {
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-active-openclaw-unsupported-'))
+    const io = new CapturedIo()
+    const env = {
+      HOME: path.join(cwd, 'home'),
+      XDG_CONFIG_HOME: path.join(cwd, 'config'),
+      XDG_STATE_HOME: path.join(cwd, 'state'),
+      OPENCLAW_STATE_DIR: path.join(cwd, 'openclaw-home'),
+      NOTIFAI_ACTIVE_HARNESS: 'openclaw',
+      NOTIFAI_ACTIVE_SESSION_ID: 'agent:main:main',
+    }
+    const deps = { ...makeDeps(io, {} as ApiClient), cwd, env, now: () => 42 }
+    expect(hooksInstallCommand(deps, { harness: 'openclaw', execPath, scriptPath })).toBe(EXIT.ok)
+    writeSessionState('agent:main:main', env, { harness: 'openclaw', last_prompt_at: 42, last_stop_at: 41 })
+    writeProjectSession(cwd, env, 'agent:main:main', 42, 'openclaw')
+    io.outLines = []
+
+    expect(askCommand(deps, 'Ship it?', {})).toBe(EXIT.usage)
+    expect(io.errLines.join('\n')).toMatch(/no proven answer continuation/i)
+    expect(readSessionState('agent:main:main', env).pending).toBeUndefined()
+  })
+
+  it('refuses Hermes ask as unsupported rather than as missing hooks', () => {
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-hermes-ask-unsupported-'))
+    const io = new CapturedIo()
+    const env = {
+      ...isolatedEnv(cwd),
+      HERMES_SESSION_ID: '20260828_111302_29a404',
+    }
+    const deps = { ...makeDeps(io, {} as ApiClient), cwd, env, now: () => 42 }
+
+    expect(askCommand(deps, 'Ship it?', { json: true })).toBe(EXIT.usage)
+    const payload = JSON.parse(io.outLines.join('\n')) as { code: string; message: string; remedy: string }
+    expect(payload.code).toBe('question_routing_unavailable')
+    expect(payload.message).toMatch(/no proven continuation owner/i)
+    expect(payload.message).not.toMatch(/hooks are not installed/i)
+    expect(payload.remedy).toMatch(/send --reply/)
+    expect(hooksInstallCommand(deps, { harness: 'hermes', execPath, scriptPath })).toBe(EXIT.usage)
+    expect(io.errLines.join('\n')).toMatch(/Unknown harness "hermes"/)
+  })
+
+  it('fails closed when Hermes nested markers leave session ownership ambiguous', () => {
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-hermes-nested-ask-'))
+    const io = new CapturedIo()
+    const env = {
+      ...isolatedEnv(cwd),
+      CLAUDECODE: '1',
+      CLAUDE_CODE_SESSION_ID: 'claude-orchestrator',
+      HERMES_SESSION_ID: '20260828_111302_29a404',
+    }
+    const deps = { ...makeDeps(io, {} as ApiClient), cwd, env, now: () => 42 }
+    expect(hooksInstallCommand(deps, { harness: 'claude-code', execPath, scriptPath })).toBe(EXIT.ok)
+    writeSessionState('claude-orchestrator', env, {
+      harness: 'claude-code',
+      last_prompt_at: 42,
+      last_stop_at: 41,
+    })
+    writeProjectSession(cwd, env, 'claude-orchestrator', 42, 'claude-code')
+    io.outLines = []
+    io.errLines = []
+
+    expect(askCommand(deps, 'Ship it?', { json: true })).toBe(EXIT.usage)
+    const payload = JSON.parse(io.outLines.join('\n')) as { code: string; message: string }
+    expect(payload.code).toBe('session_identity_ambiguous')
+    expect(payload.message).toMatch(/Several harness sessions could own this shell/i)
+    expect(payload.message).toMatch(/Hermes/)
+    expect(readSessionState('claude-orchestrator', env).pending).toBeUndefined()
+  })
+
+  it('does not attribute doctor readiness when Hermes nested markers are ambiguous', async () => {
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-hermes-nested-doctor-'))
+    const io = new CapturedIo()
+    const env = {
+      ...isolatedEnv(cwd),
+      CLAUDECODE: '1',
+      CLAUDE_CODE_SESSION_ID: 'claude-orchestrator',
+      HERMES_SESSION_ID: '20260828_111302_29a404',
+    }
+    const readiness = await assessReadiness({
+      ...makeDeps(io, {} as ApiClient),
+      cwd,
+      env,
+      now: () => 42,
+    })
+    const hooks = readiness.states.find((state) => state.id === 'hooks')
+    expect(hooks?.status).toBe('optional-gap')
+    expect(hooks?.detail).toMatch(/Several harness sessions could own this shell/i)
+    expect(hooks?.detail).toMatch(/Claude Code, Hermes/)
+    expect(hooks?.remedy).toBeUndefined()
+    expect(JSON.stringify(hooks)).not.toContain('hooks install --harness claude-code')
+  })
+
+  it('does not tell an active Hermes session to install managed hooks', async () => {
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-hermes-doctor-'))
+    const io = new CapturedIo()
+    const env = {
+      ...isolatedEnv(cwd),
+      HERMES_SESSION_ID: '20260828_111302_29a404',
+    }
+    const deps = { ...makeDeps(io, {} as ApiClient), cwd, env, now: () => 42 }
+    const readiness = await assessReadiness(deps)
+    const hooks = readiness.states.find((state) => state.id === 'hooks')
+    expect(hooks?.status).toBe('optional-gap')
+    expect(hooks?.remedy).toBeUndefined()
+    expect(JSON.stringify(hooks)).not.toContain('hooks install --harness hermes')
+    expect(hooks?.detail).toMatch(/no proven continuation owner/i)
+  })
+
   it('refuses Cursor when its active-agent marker has no exact conversation id', () => {
     const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-active-cursor-'))
     const io = new CapturedIo()
@@ -7314,3 +7783,46 @@ describe('a second device that disagrees', () => {
     expect(contradictingAnswer([])).toBeNull()
   })
 })
+
+describe('Agent Session rename command', () => {
+  it('renames only the exact active Agent Session and updates its local frozen label', async () => {
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-session-rename-'))
+    const io = new CapturedIo()
+    const seen: { session_id: string; label: string }[] = []
+    const client = {
+      putAgentSessionLabel: async (body: { session_id: string; label: string }) => {
+        seen.push(body)
+        return {
+          ...body,
+          renamed_by: 'agent' as const,
+          updated_at: '2026-08-28T10:00:00.000Z',
+        }
+      },
+    } as unknown as ApiClient
+    const deps = {
+      ...makeDeps(io, client),
+      cwd,
+      env: {
+        XDG_CONFIG_HOME: path.join(cwd, 'config'),
+        XDG_STATE_HOME: path.join(cwd, 'state'),
+        CODEX_THREAD_ID: '01a04789-9589-76b2-82c8-bfe63062c867',
+      },
+    }
+
+    expect(await agentSessionRenameCommand(deps, '  Hermes   Runtime Support  ')).toBe(EXIT.ok)
+    expect(seen).toEqual([{
+      session_id: '01a04789-9589-76b2-82c8-bfe63062c867',
+      label: 'Hermes Runtime Support',
+    }])
+    expect(io.outLines.join('\n')).toContain('Hermes Runtime Support')
+  })
+
+  it('fails closed when the harness does not expose an exact current Agent Session', async () => {
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-session-rename-none-'))
+    const io = new CapturedIo()
+    const deps = { ...makeDeps(io, {} as ApiClient), cwd, env: isolatedEnv(cwd) }
+
+    expect(await agentSessionRenameCommand(deps, 'A new job')).toBe(EXIT.usage)
+    expect(io.errLines.join('\n')).toMatch(/exact active Agent Session/i)
+  })
+})