@raidiant/notifai 9.2.2 → 10.0.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,
@@ -56,6 +58,7 @@ import {
   repliesCommand,
   sendCommand,
   statusCommand,
+  agentSessionRenameCommand,
   type CommandDeps,
   type CommandIo,
   type CommandSpinner,
@@ -68,6 +71,7 @@ import {
   codexTrustKey,
   findInstallations,
   handlerEvent,
+  QUESTION_STOP_TIMEOUT_SECONDS,
   settingsFile,
 } from './install-hooks.js'
 import { readSessionState, writeProjectSession, writeSessionState } from './hooks.js'
@@ -78,6 +82,7 @@ import { resetLatestPublishedCliVersionForTest } from './cli-release.js'
 import { activeLogPath, createLogger, logsDiskUsage, readLogRecords } from './logging.js'
 import { hookAdapterPath, inspectHookAdapter } from './hook-adapter.js'
 import type { Tone } from './ui/theme.js'
+import { projectBinding, projectEnabled } from './project-enablement.js'
 
 afterEach(() => {
   resetLatestPublishedCliVersionForTest()
@@ -416,6 +421,31 @@ function replyResponse(
 }
 
 describe('command contracts', () => {
+  it('durably enables a valid in-Project send before missing authentication stops it', async () => {
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-explicit-enable-'))
+    const io = new CapturedIo()
+    const env = isolatedEnv(cwd)
+    const deps = {
+      ...makeDeps(io, {} as ApiClient),
+      cwd,
+      env,
+      store: { load: () => null, save: () => {}, clear: () => {}, describe: () => 'empty store' },
+    }
+    expect(await sendCommand(deps, { title: 'Ready', body: 'Ready.', kind: 'done' })).toBe(EXIT.auth)
+    expect(projectEnabled(projectBinding(cwd, env))).toBe(true)
+  })
+
+  it('sends deliberately Projectless without enabling the inferred Project', async () => {
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-projectless-'))
+    const io = new CapturedIo()
+    const env = isolatedEnv(cwd)
+    let submitted: SubmitNotificationRequestT | undefined
+    const client = { submit: async (body: SubmitNotificationRequestT) => ((submitted = body), receipt) } as unknown as ApiClient
+    const deps = { ...makeDeps(io, client), cwd, env }
+    expect(await sendCommand(deps, { title: 'Ready', body: 'Ready.', kind: 'done', projectless: true })).toBe(EXIT.ok)
+    expect(submitted?.draft.project).toBeUndefined()
+    expect(projectEnabled(projectBinding(cwd, env))).toBe(false)
+  })
   it('shows an actionable no-plan access state', async () => {
     const io = new CapturedIo()
     const client = {
@@ -736,6 +766,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
@@ -829,7 +881,7 @@ describe('command contracts', () => {
     expect(io.errLines.join('\n')).not.toContain('opaque-claude-session-42')
   })
 
-  it('uses the exact Orca worktree title for an active Claude session send', 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
@@ -852,10 +904,7 @@ describe('command contracts', () => {
       ...makeDeps(io, client),
       cwd,
       env,
-      orcaSessionTitle: (lookupEnv: NodeJS.ProcessEnv) => {
-        expect(lookupEnv['ORCA_WORKTREE_ID']).toBe(worktreeId)
-        return 'Worker - semantic session implementation'
-      },
+      orcaSessionTitle: () => 'Agent Session context labels',
     }
 
     expect(
@@ -868,12 +917,12 @@ describe('command contracts', () => {
 
     expect(submitted?.draft.source).toMatchObject({
       session_id: 'orca-claude-session',
-      session_label: 'Worker - semantic session implementation',
+      session_label: 'Agent Session context labels',
       harness: 'claude-code',
     })
   })
 
-  it('uses the exact Orca worktree title for an active Codex session send', 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
@@ -894,10 +943,7 @@ describe('command contracts', () => {
         TERM_PROGRAM: 'Orca',
         ORCA_WORKTREE_ID: worktreeId,
       },
-      orcaSessionTitle: (lookupEnv: NodeJS.ProcessEnv) => {
-        expect(lookupEnv['ORCA_WORKTREE_ID']).toBe(worktreeId)
-        return 'Worker - semantic session implementation'
-      },
+      orcaSessionTitle: () => 'Release verification',
     }
 
     expect(
@@ -910,11 +956,79 @@ describe('command contracts', () => {
 
     expect(submitted?.draft.source).toMatchObject({
       session_id: 'orca-codex-thread',
-      session_label: 'Worker - semantic session implementation',
+      session_label: 'Release verification',
       harness: 'codex',
     })
   })
 
+  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 () => {
     const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-orca-private-title-'))
     const io = new CapturedIo()
@@ -936,7 +1050,6 @@ describe('command contracts', () => {
         TERM_PROGRAM: 'Orca',
         ORCA_WORKTREE_ID: `repo-123::${cwd}`,
       },
-      orcaSessionTitle: () => '/private/untrusted/worktree',
     }
 
     expect(
@@ -1022,6 +1135,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')
@@ -1179,6 +1399,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')
   })
@@ -3520,19 +3742,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 () => {
@@ -6093,7 +6316,7 @@ describe('asking before the hooks have ever run', () => {
     expect(readSessionState('codex-orchestrator', env).pending).toBeUndefined()
   })
 
-  it('registers an Orca-managed Claude question under the semantic worktree title', () => {
+  it('registers an Orca-managed Claude question without borrowing the worktree title', () => {
     const cwd = scratchDir('notifai-orca-claude-ask-')
     const io = new CapturedIo()
     const env = {
@@ -6108,7 +6331,6 @@ describe('asking before the hooks have ever run', () => {
       cwd,
       env,
       now: () => 42,
-      orcaSessionTitle: () => 'Worker - semantic session implementation',
     }
 
     expect(hooksInstallCommand(deps, { harness: 'claude-code', execPath, scriptPath })).toBe(
@@ -6121,9 +6343,10 @@ describe('asking before the hooks have ever run', () => {
     expect(askCommand(deps, 'Ship the semantic resolver?', {})).toBe(EXIT.ok)
     expect(readSessionState('orca-claude-question', env).pending?.[0]?.source).toMatchObject({
       session_id: 'orca-claude-question',
-      session_label: 'Worker - semantic session implementation',
       harness: 'claude-code',
     })
+    expect(readSessionState('orca-claude-question', env).pending?.[0]?.source?.session_label)
+      .toMatch(/^[A-Z][a-z]+ [A-Z][a-z]+$/)
   })
 
   it('judges the fired check against the active harness, not a global installation of another', async () => {
@@ -6276,6 +6499,16 @@ describe('asking before the hooks have ever run', () => {
     await doctorCommand(deps, {})
     expect(io.outLines.join('\n')).toMatch(/FAIL\s+Codex hook trust.*Stop/is)
     expect(io.outLines.join('\n')).toMatch(/best-effort.*never writes.*\/hooks/is)
+    const readiness = await assessReadiness(deps)
+    expect(readiness.states.find((state) => state.id === 'hooks-trust')?.remedy).toMatchObject({
+      command: '/hooks',
+      user_action: {
+        code: 'codex_hook_approval_required',
+        harness: 'codex',
+        action: 'approve_or_enable_notifai_hooks',
+        message: expect.stringContaining('Open `/hooks` in Codex'),
+      },
+    })
   })
 
   it('gives doctor the same active-Codex diagnosis as ask', async () => {
@@ -6490,6 +6723,92 @@ describe('asking before the hooks have ever run', () => {
     expect(readSessionState('opencode-current', 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()
@@ -6650,7 +6969,8 @@ describe('asking before the hooks have ever run', () => {
     const out = io.outLines.join('\n')
     expect(out).toMatch(/FAIL\s+Turn\-end hook shape/)
     expect(out).toContain('needs `async: true`')
-    expect(out).toContain('kills the backgrounded waiter at its 600s default')
+    expect(out).toContain('kills the backgrounded waiter silently before the complete answer window')
+    expect(out).toContain(`needs an explicit ${QUESTION_STOP_TIMEOUT_SECONDS}s`)
   })
 
   /** A configured Claude Code project with one live session claiming `pid`. */
@@ -7284,3 +7604,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)
+  })
+})

package/src/commands.ts

@@ -17,6 +17,7 @@ export {
   deviceInventory,
   devicesCommand,
 } from './commands-devices.js'
+export { soundsCommand } from './commands-sounds.js'
 export {
   contradictingAnswer,
   repliesCommand,
@@ -62,4 +63,13 @@ export {
   type SetupScope,
 } from './commands-init.js'
 export { assessReadiness, doctorCommand } from './commands-doctor.js'
+export {
+  projectDisableCommand,
+  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

@@ -100,7 +100,7 @@ const INFO: Record<ConfigKey, Omit<ConfigKeyInfo, 'key'>> = {
     unit: 's',
     summary: 'Optional delay before a question may reach your devices',
     detail:
-      'Zero (the default) sends the question to your devices as soon as the agent turn ends. Set a positive duration to offer the terminal an exclusive answer window first; the timer is measured from the moment the agent asked.\n\nA timer and nothing more. Whether you happen to be at this keyboard does not change it: waiting no longer holds your terminal, so there is nothing your being here would protect you from.',
+      'Zero (the default) sends the question to your devices as soon as the agent turn ends. Set a positive duration to offer the terminal an exclusive answer window first; the timer is measured from the moment the agent asked.\n\nThis controls when the question reaches devices, not how the harness keeps the Agent Session available afterward. Claude Code waits out of band; Codex holds the asking turn.',
     example: '0',
   },
 
@@ -111,7 +111,7 @@ const INFO: Record<ConfigKey, Omit<ConfigKeyInfo, 'key'>> = {
     unit: 's',
     summary: 'How long the service keeps accepting your answer to a question',
     detail:
-      'A question stays answerable for this long after it is asked. The default is a day, so a question that arrives while you are away is still yours to answer when you come back.\n\nThis is not how long anything waits on you. The agent ends its turn immediately; if it is still running when you answer, the answer reaches it directly, and otherwise it is delivered at that session\'s next turn. Shortening this only makes an answer arrive too late to be accepted.',
+      'A question stays answerable for this long after it reaches the service. The default is a day, so a question that arrives while you are away is still yours to answer when you come back.\n\nQuestion Routing keeps the exact Agent Session available for this complete window. Claude Code waits out of band and wakes the Agent Session; Codex keeps its turn held. This is separate from `--reply-timeout`, which controls how long a direct `send --reply` command blocks.',
     example: '86400',
   },
 
@@ -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'