@raidiant/notifai 9.2.2 → 10.0.0

package/src/install-hooks.test.ts

@@ -13,6 +13,7 @@ import os from 'node:os'
 import path from 'node:path'
 import { parse as parseToml, stringify as stringifyToml } from 'smol-toml'
 import { describe, expect, it } from 'vitest'
+import { REPLY_MAX_WINDOW_SECONDS } from '@raidiant/notifai-protocol'
 import { parseChoices } from './send.js'
 import {
   OPENCODE_PLUGIN_MARKER,
@@ -26,9 +27,9 @@ import {
   WORKER_ACTIVATION_CONTEXT,
 } from './session-activation.js'
 import { hookAdapterPath, installHookAdapter } from './hook-adapter.js'
+import { HOOK_INSTALLABLE_HARNESSES } from './harnesses.js'
 import {
-  BLOCKING_STOP_TIMEOUT_SECONDS,
-  HARNESSES,
+  QUESTION_STOP_TIMEOUT_SECONDS,
   applyPlan,
   detectHarness,
   detectedHarnesses,
@@ -152,18 +153,13 @@ describe('hook config', () => {
     ).toBe(true)
   })
 
-  it('lets Codex own Stop timeout while keeping short fixed lifecycle budgets', () => {
+  it('gives Codex a Stop timeout beyond the longest answer window', () => {
     const codex = buildHookConfig({ adapterPath: ADAPTER, harness: 'codex' })
 
     expect(codex['UserPromptSubmit']?.[0]?.hooks[0]?.timeout).toBe(15)
     expect(codex['SessionEnd']?.[0]?.hooks[0]?.timeout).toBe(3)
-    // Codex hashes the exact serialized definition into `trusted_hash`, so its
-    // Stop handler stays a bare blocking command: declaring a timeout would
-    // invalidate the user's approval and the handler would silently stop.
-    expect(codex['Stop']?.[0]?.hooks[0]).toEqual({
-      type: 'command',
-      command: hookCommand(ADAPTER, 'stop', 'codex'),
-    })
+    expect(codex['Stop']?.[0]?.hooks[0]?.timeout).toBe(QUESTION_STOP_TIMEOUT_SECONDS)
+    expect(QUESTION_STOP_TIMEOUT_SECONDS).toBeGreaterThan(REPLY_MAX_WINDOW_SECONDS)
   })
 
   it('gives Claude Code an asynchronous Stop with an explicit waiter budget on POSIX', () => {
@@ -176,7 +172,7 @@ describe('hook config', () => {
     expect(claude['Stop']?.[0]?.hooks[0]).toEqual({
       type: 'command',
       command: hookCommand(ADAPTER, 'stop', 'claude-code'),
-      timeout: 3600,
+      timeout: QUESTION_STOP_TIMEOUT_SECONDS,
       async: true,
     })
     expect(claude['UserPromptSubmit']?.[0]?.hooks[0]?.async).toBeUndefined()
@@ -195,7 +191,7 @@ describe('hook config', () => {
     expect(claude['Stop']?.[0]?.hooks[0]).toEqual({
       type: 'command',
       command: hookCommand(options.adapterPath, 'stop', 'claude-code', options),
-      timeout: BLOCKING_STOP_TIMEOUT_SECONDS,
+      timeout: QUESTION_STOP_TIMEOUT_SECONDS,
     })
   })
 
@@ -213,7 +209,7 @@ describe('hook config', () => {
       expect(groups.flatMap((group) => group.hooks)).toHaveLength(1)
     }
     expect(migrated.document.hooks?.['Stop']?.[0]?.hooks[0]).toMatchObject({
-      timeout: 3600,
+      timeout: QUESTION_STOP_TIMEOUT_SECONDS,
       async: true,
     })
     expect(migrated.replaced.sort()).toEqual([
@@ -1049,7 +1045,8 @@ describe('the OpenCode adapter', () => {
   })
 
   it('is a harness `hooks install` knows about', () => {
-    expect(HARNESSES).toContain('opencode')
+    expect(HOOK_INSTALLABLE_HARNESSES).toContain('opencode')
+    expect(HOOK_INSTALLABLE_HARNESSES).not.toContain('hermes')
     expect(settingsFile('opencode', false, '/repo', {})).toContain('notifai.js')
   })
 
@@ -1103,7 +1100,7 @@ describe('detectHarness', () => {
     const dir = project('AGENTS.md')
     const answer = detectHarness(dir)
     expect(answer).not.toBe('codex')
-    expect(HARNESSES.includes(answer as never) || answer === null).toBe(true)
+    expect(HOOK_INSTALLABLE_HARNESSES.includes(answer as never) || answer === null).toBe(true)
   })
 
   it('pairs AGENTS.md with CLAUDE.md as Claude Code, not Codex', () => {
@@ -1159,7 +1156,7 @@ describe('detectHarness', () => {
     // Whatever this machine has, an empty project must never crash and must
     // return either a single harness or null — never an arbitrary pick.
     const answer = detectHarness(empty)
-    expect(answer === null || HARNESSES.includes(answer)).toBe(true)
+    expect(answer === null || HOOK_INSTALLABLE_HARNESSES.includes(answer)).toBe(true)
   })
 })
 

package/src/install-hooks.ts

@@ -20,10 +20,12 @@ import {
   type HookHostPlatform,
 } from './hook-adapter.js'
 import { opencodePluginPath, opencodePluginTarget } from './opencode-plugin.js'
-import { HARNESSES, type Harness } from './harnesses.js'
+import { HOOK_INSTALLABLE_HARNESSES, type HookInstallableHarness } from './harnesses.js'
 import { accountHome } from './platform.js'
-
-export { HARNESSES, type Harness } from './harnesses.js'
+import {
+  NON_ROUTING_STOP_TIMEOUT_SECONDS,
+  QUESTION_STOP_TIMEOUT_SECONDS,
+} from './question-timing.js'
 
 /**
  * The three joints the OpenCode plugin hooks into, as (harness event, the
@@ -69,7 +71,7 @@ export interface HookGroup {
 export type HookConfig = Record<string, HookGroup[]>
 
 export interface InstallPlan {
-  harness: Harness
+  harness: HookInstallableHarness
   /** Absolute path of the settings file that will be written. */
   file: string
   /** True when the file is machine-wide rather than per-project. */
@@ -93,7 +95,7 @@ export interface HookCommandOptions {
 export function hookCommand(
   adapterPath: string,
   event: string,
-  harness?: Harness,
+  harness?: HookInstallableHarness,
   options: HookCommandOptions = {},
 ): string {
   return (
@@ -170,50 +172,28 @@ export interface BuildOptions {
   /** Stable user-level executable installed by the hook adapter module. */
   adapterPath: string
   /** The installed adapter stamps its exact harness into project pointers. */
-  harness?: Harness
+  harness?: HookInstallableHarness
   platform?: NodeJS.Platform | HookHostPlatform
   /** Registered Node named first in Windows hook commands. */
   nodePath?: string
 }
 
 /**
- * Claude Code's Stop handler returns instantly and the same process lives on
- * out of band as the escalation waiter, so this `timeout` bounds a background
- * process rather than the user's turn.
- *
- * It is always declared, and declared far above the longest wait a waiter can
- * take. Claude's default is 600 s and the kill is **silent** — the backgrounded
- * process simply vanishes, no error is reported anywhere, and the answer the
- * user already gave is never delivered. Sitting anywhere near that boundary
- * turns a slow reply into a lost one, so this does not: an explicit value
- * raises the ceiling (verified against a 660 s wait under an hour-long
- * declaration), and an hour is several times the waiter's own ceiling.
- */
-export const CLAUDE_ASYNC_STOP_TIMEOUT_SECONDS = 3600
-
-/**
- * The declared process budget for a host that holds its turn while the waiter
- * runs: the waiter's own ceiling plus a minute of host headroom, as one plain
- * number rather than a budget carved into reserves.
- *
- * Codex is deliberately absent from this. It owns its Stop timeout today, and
- * declaring one would change the serialized definition Codex hashes into
- * `trusted_hash` — which silently stops every Notifai handler from running
- * until the user re-approves them in `/hooks`.
+ * Harnesses without asynchronous Question Routing use this short Stop budget.
+ * Claude Code and Codex use `QUESTION_STOP_TIMEOUT_SECONDS` instead.
  */
-export const BLOCKING_STOP_TIMEOUT_SECONDS = 540
+export const NON_ROUTING_BLOCKING_STOP_TIMEOUT_SECONDS = NON_ROUTING_STOP_TIMEOUT_SECONDS
+export { QUESTION_STOP_TIMEOUT_SECONDS } from './question-timing.js'
 
 /**
  * Whether this harness's Stop handler runs detached from the turn.
  *
- * Three places decide this — the installer that declares `async: true`, the
- * hook runtime that picks the waiter's wall clock, and doctor's check that the
- * installed definition still has the right shape — and they must agree or the
- * waiter outlives a turn nobody left open. They were three separate spellings
- * of the same condition with nothing tying them together.
+ * The installer and doctor share this predicate so they agree whether Claude
+ * runs out of band. Owner lifetime is route-neutral and lives in
+ * `question-timing.ts`.
  */
 export function stopHandlerIsDetached(
-  harness: Harness | undefined,
+  harness: HookInstallableHarness | undefined,
   platform?: Parameters<typeof hookHostPlatform>[0],
 ): boolean {
   return harness === 'claude-code' && hookHostPlatform(platform) === 'posix'
@@ -224,22 +204,24 @@ export function stopHandlerIsDetached(
  *
  * Claude Code takes the answer over its own inbox socket, so its Stop hook is
  * `async: true`: it returns immediately, the terminal is never held, and the
- * waiter finishes out of band. Every other host still delivers by printing a
- * continuation to this process's stdout, so its Stop hook blocks and needs a
- * declared ceiling above the wait — except Codex, which owns that number
- * itself and whose definition must stay byte-stable for its trust store.
+ * waiter finishes out of band. Codex and Claude on Windows block and print a
+ * continuation to stdout. Every Question Routing owner declares the same
+ * complete-window timeout; changing Codex's definition requires one explicit
+ * trust approval.
  */
 function stopHandler(
   adapterPath: string,
-  harness: Harness | undefined,
+  harness: HookInstallableHarness | undefined,
   options: HookCommandOptions,
 ): HookHandler {
   const command = hookCommand(adapterPath, 'stop', harness, options)
   if (stopHandlerIsDetached(harness, options.platform)) {
-    return { type: 'command', command, timeout: CLAUDE_ASYNC_STOP_TIMEOUT_SECONDS, async: true }
+    return { type: 'command', command, timeout: QUESTION_STOP_TIMEOUT_SECONDS, async: true }
+  }
+  if (harness === 'codex' || harness === 'claude-code') {
+    return { type: 'command', command, timeout: QUESTION_STOP_TIMEOUT_SECONDS }
   }
-  if (harness === 'codex') return { type: 'command', command }
-  return { type: 'command', command, timeout: BLOCKING_STOP_TIMEOUT_SECONDS }
+  return { type: 'command', command, timeout: NON_ROUTING_BLOCKING_STOP_TIMEOUT_SECONDS }
 }
 
 function commandOptionsFrom(options: BuildOptions): HookCommandOptions {
@@ -350,7 +332,7 @@ export function buildCursorHookConfig(options: BuildOptions): CursorHookConfig {
       },
       {
         command: hookCommand(options.adapterPath, 'stop', 'cursor', commandOptions),
-        timeout: BLOCKING_STOP_TIMEOUT_SECONDS,
+        timeout: NON_ROUTING_BLOCKING_STOP_TIMEOUT_SECONDS,
         // A continuation may register a real follow-up question. Match the
         // session-state cap so those chains are useful but never unbounded.
         loop_limit: 3,
@@ -371,7 +353,7 @@ export function buildCursorHookConfig(options: BuildOptions): CursorHookConfig {
  * questions pushed to is not a property of the repository.
  */
 export function settingsFile(
-  harness: Harness,
+  harness: HookInstallableHarness,
   global: boolean,
   cwd: string,
   env: NodeJS.ProcessEnv = process.env,
@@ -622,7 +604,7 @@ export function withCodexLayerTransaction<T>(
 
 /** Every file in this layer Codex might already be reading hooks from. */
 export function hookDefinitionFiles(
-  harness: Harness,
+  harness: HookInstallableHarness,
   global: boolean,
   cwd: string,
   env: NodeJS.ProcessEnv = process.env,
@@ -757,8 +739,8 @@ function ourHandlerEvents(document: SettingsDocument | null): string[] {
  * document. Treating it as evidence of any one harness would be a guess
  * dressed up as detection.
  */
-function localHarnessEvidence(cwd: string): Harness[] {
-  const found: Harness[] = []
+function localHarnessEvidence(cwd: string): HookInstallableHarness[] {
+  const found: HookInstallableHarness[] = []
   if (existsSync(path.join(cwd, '.claude')) || existsSync(path.join(cwd, 'CLAUDE.md'))) {
     found.push('claude-code')
   }
@@ -772,9 +754,9 @@ function localHarnessEvidence(cwd: string): Harness[] {
 function globalHarnessEvidence(
   env: NodeJS.ProcessEnv = process.env,
   platform: NodeJS.Platform | HookHostPlatform = process.platform,
-): Harness[] {
+): HookInstallableHarness[] {
   const home = harnessAccountHome(env, platform)
-  const found: Harness[] = []
+  const found: HookInstallableHarness[] = []
   if (existsSync(path.join(home, '.claude'))) found.push('claude-code')
   if (existsSync(codexGlobalDir(env, platform))) found.push('codex')
   if (existsSync(path.join(home, '.cursor'))) found.push('cursor')
@@ -793,12 +775,12 @@ export function detectedHarnesses(
   cwd: string,
   env: NodeJS.ProcessEnv = process.env,
   platform: NodeJS.Platform | HookHostPlatform = process.platform,
-): Harness[] {
-  const seen = new Set<Harness>([
+): HookInstallableHarness[] {
+  const seen = new Set<HookInstallableHarness>([
     ...localHarnessEvidence(cwd),
     ...globalHarnessEvidence(env, platform),
   ])
-  return HARNESSES.filter((harness) => seen.has(harness))
+  return HOOK_INSTALLABLE_HARNESSES.filter((harness) => seen.has(harness))
 }
 
 /**
@@ -814,7 +796,7 @@ export function detectHarness(
   cwd: string,
   env: NodeJS.ProcessEnv = process.env,
   platform: NodeJS.Platform | HookHostPlatform = process.platform,
-): Harness | null {
+): HookInstallableHarness | null {
   const local = localHarnessEvidence(cwd)
   if (local.length > 0) return local.length === 1 ? local[0]! : null
   const global = globalHarnessEvidence(env, platform)
@@ -1209,7 +1191,7 @@ export interface InstalledHandler {
 }
 
 export interface Installation {
-  harness: Harness
+  harness: HookInstallableHarness
   file: string
   global: boolean
   handlers: InstalledHandler[]
@@ -1347,7 +1329,7 @@ export function findInstallations(
     ...(nodePath === undefined ? {} : { nodePath }),
   }
   const found: Installation[] = []
-  for (const harness of HARNESSES) {
+  for (const harness of HOOK_INSTALLABLE_HARNESSES) {
     for (const global of [false, true]) {
       const files = hookDefinitionFiles(harness, global, cwd, env, platform)
       for (const file of files) {
@@ -1427,7 +1409,7 @@ export function findInstallations(
 }
 
 function harnessMarkerProblems(
-  harness: Harness,
+  harness: HookInstallableHarness,
   handlers: InstalledHandler[],
   adapterHome?: string,
   options: HookCommandOptions = {},

package/src/invocation-context.ts

@@ -1,7 +1,7 @@
 import { execFileSync } from 'node:child_process'
 import path from 'node:path'
 import { type SourceContextT } from '@raidiant/notifai-protocol'
-import type { Harness } from './harnesses.js'
+import type { SourceContextHarness } from './harnesses.js'
 import { resolveSessionLabel } from './session-labels.js'
 
 export type GitCommand = (cwd: string, args: readonly string[]) => string | null
@@ -138,7 +138,7 @@ export interface SourceContextInput {
   sessionId?: string
   sessionLabel?: string
   activeHarness?: {
-    harness: Harness
+    harness: SourceContextHarness
     sessionId?: string
     sessionLabel?: string
     sessionLabelPending?: boolean

package/src/orca-session-title.test.ts

@@ -1,7 +1,7 @@
 import { describe, expect, it } from 'vitest'
 import { readOrcaSessionTitle, type OrcaCommand } from './orca-session-title.js'
 
-const worktreeId = 'repo-123::/worktrees/semantic-session-implementation'
+const worktreeId = 'repo-123::/worktrees/agent-session-labels'
 
 function response(overrides: Record<string, unknown> = {}): string {
   return JSON.stringify({
@@ -9,16 +9,16 @@ function response(overrides: Record<string, unknown> = {}): string {
     result: {
       worktree: {
         id: worktreeId,
-        path: '/worktrees/semantic-session-implementation',
-        displayName: 'Worker - semantic session implementation',
+        path: '/worktrees/agent-session-labels',
+        displayName: 'Agent Session context labels',
         ...overrides,
       },
     },
   })
 }
 
-describe('Orca semantic session title', () => {
-  it('accepts only the display name returned for the exact managed worktree', () => {
+describe('Orca Agent Session title context', () => {
+  it('accepts only the User-facing title returned for the exact managed worktree', () => {
     const calls: { executable: string; args: readonly string[] }[] = []
     const command: OrcaCommand = (executable, args) => {
       calls.push({ executable, args })
@@ -26,11 +26,8 @@ describe('Orca semantic session title', () => {
     }
 
     expect(
-      readOrcaSessionTitle(
-        { TERM_PROGRAM: 'Orca', ORCA_WORKTREE_ID: worktreeId },
-        command,
-      ),
-    ).toBe('Worker - semantic session implementation')
+      readOrcaSessionTitle({ TERM_PROGRAM: 'Orca', ORCA_WORKTREE_ID: worktreeId }, command),
+    ).toBe('Agent Session context labels')
     expect(calls).toEqual([
       {
         executable: 'orca',
@@ -39,52 +36,14 @@ describe('Orca semantic session title', () => {
     ])
   })
 
-  it('uses Orca-provided executable selection without invoking a shell', () => {
-    const calls: string[] = []
-    expect(
-      readOrcaSessionTitle(
-        {
-          TERM_PROGRAM: 'Orca',
-          ORCA_WORKTREE_ID: worktreeId,
-          ORCA_CLI_COMMAND: '/mnt/c/Program Files/Orca/orca.exe',
-        },
-        (executable) => {
-          calls.push(executable)
-          return response()
-        },
-      ),
-    ).toBe('Worker - semantic session implementation')
-    expect(calls).toEqual(['/mnt/c/Program Files/Orca/orca.exe'])
-  })
-
-  it('ignores non-Orca and malformed selectors without running a command', () => {
-    const command: OrcaCommand = () => {
-      throw new Error('must not run')
-    }
-    expect(readOrcaSessionTitle({ ORCA_WORKTREE_ID: worktreeId }, command)).toBeUndefined()
-    expect(
-      readOrcaSessionTitle(
-        { TERM_PROGRAM: 'Orca', ORCA_WORKTREE_ID: '/private/untrusted' },
-        command,
-      ),
-    ).toBeUndefined()
-    expect(
-      readOrcaSessionTitle(
-        { TERM_PROGRAM: 'Orca', ORCA_WORKTREE_ID: 'repo-123::relative/path' },
-        command,
-      ),
-    ).toBeUndefined()
-  })
-
   it.each([
     ['command failure', () => null],
-    ['thrown command failure', () => { throw new Error('offline') }],
     ['malformed JSON', () => '{not json}'],
     ['failed response', () => JSON.stringify({ ok: false })],
     ['different worktree id', () => response({ id: 'repo-123::/worktrees/other' })],
     ['different worktree path', () => response({ path: '/private/untrusted' })],
     ['blank display name', () => response({ displayName: '   ' })],
-  ])('fails closed for %s', (_name, command) => {
+  ])('leaves the generated fallback exceptional when context is unavailable: %s', (_name, command) => {
     expect(
       readOrcaSessionTitle(
         { TERM_PROGRAM: 'Orca', ORCA_WORKTREE_ID: worktreeId },

package/src/orca-session-title.ts

@@ -26,9 +26,7 @@ function containsControlCharacter(value: string): boolean {
 }
 
 function worktreePathFromId(value: string): string | null {
-  if (value.length === 0 || value.length > 4_096 || containsControlCharacter(value)) {
-    return null
-  }
+  if (value.length === 0 || value.length > 4_096 || containsControlCharacter(value)) return null
   const separator = value.indexOf('::')
   if (separator <= 0) return null
   const repoId = value.slice(0, separator)
@@ -48,11 +46,11 @@ function orcaExecutable(env: NodeJS.ProcessEnv): string | null {
 }
 
 /**
- * Read the semantic display name assigned to this exact Orca worktree.
+ * Read the User-facing task name assigned to this exact Orca worktree.
  *
  * The environment contributes only an opaque selector. Orca must return that
  * exact id and its matching path before its display name becomes trusted; no
- * path component or identifier is ever promoted into the User-visible label.
+ * path component or identifier is ever promoted into an Agent Session label.
  */
 export function readOrcaSessionTitle(
   env: NodeJS.ProcessEnv,

package/src/program.test.ts

@@ -98,6 +98,51 @@ describe('program argv parsing', () => {
     })
   })
 
+  it('preserves deliberate Projectless send intent at the argv boundary', async () => {
+    let seen: Record<string, unknown> | undefined
+    await parse(
+      ['send', '--kind', 'done', '--title', 'T', '--body', 'B', '--projectless'],
+      { send: (async (_deps, flags) => ((seen = flags as Record<string, unknown>), 0)) as ProgramRunners['send'] },
+    )
+    expect(seen).toMatchObject({ projectless: true })
+  })
+
+  it('dispatches User-owned Project enablement commands', async () => {
+    let enabled = 0
+    const result = await parse(['project', 'enable'], {
+      projectEnable: ((_deps) => (enabled += 1, 0)) as ProgramRunners['projectEnable'],
+    })
+    expect(result.exitCode).toBe(0)
+    expect(enabled).toBe(1)
+  })
+
+  it('dispatches the current Agent Session rename without exposing an id override', async () => {
+    let label: string | undefined
+    const result = await parse(['session', 'rename', 'Hermes Support'], {
+      agentSessionRename: (async (_deps, value) => ((label = value), 0)) as ProgramRunners['agentSessionRename'],
+    })
+    expect(result.exitCode).toBe(0)
+    expect(label).toBe('Hermes Support')
+  })
+
+  it('dispatches sounds --json onto soundsCommand', async () => {
+    let seen: Record<string, unknown> | undefined
+    const result = await parse(['sounds', '--json'], {
+      sounds: (async (_deps, flags) => ((seen = flags as Record<string, unknown>), 0)) as ProgramRunners['sounds'],
+    })
+    expect(result.exitCode).toBe(0)
+    expect(seen).toMatchObject({ json: true })
+  })
+
+  it('passes a custom sound name through --sound', async () => {
+    let seen: Record<string, unknown> | undefined
+    await parse(
+      ['send', '--kind', 'done', '--title', 'T', '--body', 'B', '--sound', 'Kitchen timer'],
+      { send: (async (_deps, flags) => ((seen = flags as Record<string, unknown>), 0)) as ProgramRunners['send'] },
+    )
+    expect(seen).toMatchObject({ sound: 'Kitchen timer' })
+  })
+
   it('drops empty collector defaults so "not passed" stays absent', async () => {
     let seen: Record<string, unknown> | undefined
     await parse(

package/src/program.ts

@@ -4,6 +4,7 @@ import {
   acknowledgeCommand,
   askCommand,
   accessStatusCommand,
+  agentSessionRenameCommand,
   authStatusCommand,
   capabilitiesCommand,
   closeCommand,
@@ -23,15 +24,19 @@ import {
   initCommand,
   loginCommand,
   logoutCommand,
+  projectDisableCommand,
+  projectEnableCommand,
+  projectStatusCommand,
   logsCommand,
   repliesCommand,
   reportAskFailure,
   sendCommand,
+  soundsCommand,
   statusCommand,
   type CommandDeps,
 } from './commands.js'
 import { packageVersion } from './release.js'
-import { HARNESSES } from './install-hooks.js'
+import { HOOK_INSTALLABLE_HARNESSES } from './harnesses.js'
 import type { Platform } from '@raidiant/notifai-protocol'
 import type { SkillScope } from './native-skills.js'
 import { GROUP, SEND_GROUP, helpConfiguration, rootHelpFooter } from './ui/help.js'
@@ -80,7 +85,12 @@ const defaultRunners = {
   authStatus: authStatusCommand,
   accessStatus: accessStatusCommand,
   devices: devicesCommand,
+  sounds: soundsCommand,
   capabilities: capabilitiesCommand,
+  projectEnable: projectEnableCommand,
+  projectDisable: projectDisableCommand,
+  projectStatus: projectStatusCommand,
+  agentSessionRename: agentSessionRenameCommand,
   send: sendCommand,
   replies: repliesCommand,
   acknowledge: acknowledgeCommand,
@@ -250,6 +260,36 @@ export function buildProgram(deps: CommandDeps, options: BuildProgramOptions = {
       exit(await runners.doctor(deps, opts))
     })
 
+  const project = program
+    .command('project')
+    .helpGroup(GROUP.daily)
+    .summary('Control Notifai for this Project')
+    .description('Inspect or change this Project\'s User-owned lifecycle enablement')
+  project.command('enable').description('Enable lifecycle guidance for this Project').action(() => {
+    exit(runners.projectEnable(deps))
+  })
+  project.command('disable').description('Disable lifecycle guidance for this Project').action(() => {
+    exit(runners.projectDisable(deps))
+  })
+  project.command('status').description('Show lifecycle enablement for this Project').option('--json').action((opts: { json?: boolean }) => {
+    exit(runners.projectStatus(deps, opts.json === true))
+  })
+
+  const session = program
+    .command('session')
+    .helpGroup(GROUP.agent)
+    .summary('Inspect or rename the current Agent Session')
+    .description('Operate on the exact Agent Session owned by the active harness')
+  session
+    .command('rename <label>')
+    .description(
+      'Rename this exact Agent Session; agents use this only after its job changes completely enough that the old label would mislead',
+    )
+    .option('--json', 'machine-readable output')
+    .action(async (label: string, opts: { json?: boolean }) => {
+      exit(await runners.agentSessionRename(deps, label, opts))
+    })
+
   program
     .command('login')
     .helpGroup(GROUP.start)
@@ -302,6 +342,18 @@ export function buildProgram(deps: CommandDeps, options: BuildProgramOptions = {
       exit(await runners.devices(deps, opts))
     })
 
+  program
+    .command('sounds')
+    .helpGroup(GROUP.daily)
+    .summary('List shipped and Account custom sounds')
+    .description(
+      'List the sounds --sound and the saved sound key accept: shipped names and this Account\'s custom sounds',
+    )
+    .option('--json', 'machine-readable output')
+    .action(async (opts: { json?: boolean }) => {
+      exit(await runners.sounds(deps, opts))
+    })
+
   program
     .command('capabilities')
     .helpGroup(GROUP.advanced)
@@ -340,6 +392,7 @@ export function buildProgram(deps: CommandDeps, options: BuildProgramOptions = {
     .optionsGroup(SEND_GROUP.routing)
     .option('--kind <kind>', 'what this is (required): update | done | failed | blocked (no User reply would resume it) — question is set by --reply')
     .option('--project <id>', 'Project identifier override (otherwise configured or inferred)')
+    .option('--projectless', 'deliberately omit Project identity for this notification')
     .option('--device <id>', 'target a device id (repeatable)', (v: string, all: string[] = []) => [...all, v])
     .option('--all', 'target all routable devices (overrides configured devices)')
     .option('--session-id <id>', 'low-level automation override for an opaque exact Agent Session (env: NOTIFAI_SESSION_ID)')
@@ -367,7 +420,10 @@ export function buildProgram(deps: CommandDeps, options: BuildProgramOptions = {
     )
     .option('--multi', 'with --choice, several answers may be selected')
     .optionsGroup(SEND_GROUP.advanced)
-    .option('--sound <sound>', 'override saved sound: default | done | attention | alert | none')
+    .option(
+      '--sound <sound>',
+      'override saved sound: default | done | attention | alert | none, or a custom name or id from notifai sounds',
+    )
     .option(
       '--level <level>',
       'Apple-only interruption level: passive | active | time_sensitive (unsupported with --platform android)',
@@ -413,7 +469,7 @@ export function buildProgram(deps: CommandDeps, options: BuildProgramOptions = {
 
   send.addHelpText(
     'after',
-    `\nKind is required, and it selects the sound the notification arrives with: done rings the completion chime, failed the most insistent tone, blocked and question a distinct attention tone, update the standard one.\nAn explicit --sound or saved sound preference outranks that default. --level is Apple-only; Android attention is owned by kind, product channels, and device settings.\n`,
+    `\nKind is required, and it selects the sound the notification arrives with: done rings the completion chime, failed the most insistent tone, blocked and question a distinct attention tone, update Device default.\nAn explicit --sound or saved sound preference outranks that default. --sound accepts a shipped name, an Account custom sound name or id from \`notifai sounds\`, or none. --level is Apple-only; Android attention is owned by kind, product channels, and device settings.\n`,
   )
 
   program
@@ -571,7 +627,7 @@ export function buildProgram(deps: CommandDeps, options: BuildProgramOptions = {
     .option('--owner <name>', 'internal ownership marker')
     .option('--harness <name>', 'internal harness output adapter')
     .action(async (event: string, opts: { harness?: string }) => {
-      const harness = HARNESSES.find((candidate) => candidate === opts.harness)
+      const harness = HOOK_INSTALLABLE_HARNESSES.find((candidate) => candidate === opts.harness)
       exit(await runners.hookRun(deps, event, () => readStdinWithTimeout(), harness))
     })