@raidiant/notifai 9.2.1 → 9.3.0

package/src/commands-hooks.ts

@@ -43,7 +43,6 @@ import {
   readSessionState,
   resetCursorStopActivation,
   registerQuestion,
-  waiterCeilingSeconds,
   withdrawUnpushedQuestions,
   type EscalationDeliveryRoute,
   type HookContext,
@@ -51,7 +50,7 @@ import {
   type PendingQuestion,
 } from './hooks.js'
 import {
-  BLOCKING_STOP_TIMEOUT_SECONDS,
+  NON_ROUTING_BLOCKING_STOP_TIMEOUT_SECONDS,
   HARNESSES,
   applyPlan,
   buildCursorHookConfig,
@@ -75,14 +74,16 @@ import {
   removeCursorHooks,
   removeHooks,
   settingsFile,
-  stopHandlerIsDetached,
   withCodexLayerTransaction,
   type Harness,
   type Installation,
 } from './install-hooks.js'
+import { QUESTION_WAITER_CEILING_SECONDS } from './question-timing.js'
+import { inferInvocationContext } from './invocation-context.js'
 import { logConfigResolved, logSettingsFrom } from './logging.js'
 import { isOurOpencodePlugin, opencodePluginSource } from './opencode-plugin.js'
 import { packageVersion } from './release.js'
+import { enableProject, projectBinding, projectEnabled } from './project-enablement.js'
 import { rejectAccidentalEscapedNewlines } from './send.js'
 import {
   cursorStopActivationOutput,
@@ -176,11 +177,10 @@ export async function hookRunCommand(
   // would grant slow setup a second budget and let the harness kill us before
   // an accepted answer is journaled or written to stdout.
   const now = deps.now ?? Date.now
-  // The waiter may spend a long wall clock exactly when no turn is held open
-  // for it, which is the same condition the installer used to declare
-  // `async: true`. One predicate decides it for both.
-  const detachedWaiter = stopHandlerIsDetached(harness, deps.hookPlatform ?? process.platform)
-  const processDeadlineAt = now() + waiterCeilingSeconds(detachedWaiter) * 1000
+  // One owner lifetime covers startup and the longest answer window. Claude
+  // runs it detached; Codex holds the turn. The delivery mechanism does not
+  // change how long the exact Agent Session remains reachable.
+  const processDeadlineAt = now() + QUESTION_WAITER_CEILING_SECONDS * 1000
 
   const logger = log(deps)
   logger.bind({ cmd: `hook ${event}` })
@@ -253,11 +253,29 @@ export async function hookRunCommand(
   const cwd = envelope.cwd ?? deps.cwd
   const sessionEnd = hookDefersDiagnosticsUntilAfterCleanup(event)
   logger.bind({ session: envelope.session_id ?? null })
-  // Session activation is local model context, not authenticated routing. It
-  // must survive the exact first-run states it exists to repair: no config,
-  // no credential, no Companion device, and no network.
+  const lifecycleEnabled = (): boolean => {
+    try {
+      const activationConfig = loadConfig({ cwd, env: deps.env, sessionId: envelope.session_id })
+      return projectEnabled(projectBinding(cwd, deps.env, activationConfig.project.value))
+    } catch (err) {
+      logger.error('hook.end', { hook: event, outcome: 'enablement-unavailable', ...failureData(err) })
+      return false
+    }
+  }
+  // Installation only makes lifecycle hooks available. Model-visible
+  // activation is a separate User-owned Project decision, checked anew on
+  // every run so disabling takes effect without reinstalling anything.
   if (event === 'session-start' || event === 'subagent-start') {
     start({ cwd, source: envelope.source ?? null })
+    if (!lifecycleEnabled()) {
+      logger.info('hook.end', {
+        hook: event,
+        outcome: 'ignored',
+        reason: 'project-disabled',
+        decided: false,
+      })
+      return EXIT.ok
+    }
     if (event === 'session-start' && harness === 'cursor' && envelope.session_id !== undefined) {
       try {
         resetCursorStopActivation(envelope.session_id, deps.env)
@@ -307,6 +325,15 @@ export async function hookRunCommand(
       logger.info('hook.end', { hook: event, outcome: 'unsupported-harness', decided: false })
       return EXIT.ok
     }
+    if (!lifecycleEnabled()) {
+      logger.info('hook.end', {
+        hook: event,
+        outcome: 'ignored',
+        reason: 'project-disabled',
+        decided: false,
+      })
+      return EXIT.ok
+    }
     if (envelope.status === 'aborted') {
       logger.info('hook.end', {
         hook: event,
@@ -507,7 +534,15 @@ export async function hookRunCommand(
       ...outcome.log,
     })
     for (const note of outcome.notes) deps.io.err(`notifai: ${note}`)
-    if (outcome.stdout !== undefined) deps.io.out(outcome.stdout)
+    if (outcome.stdout !== undefined) {
+      // No work, await, or diagnostic may sit between this cross-process
+      // SessionEnd fence and the irreversible harness stdout write.
+      if (outcome.commitStdout === undefined || outcome.commitStdout()) {
+        deps.io.out(outcome.stdout)
+      } else {
+        deps.io.err('notifai: the Agent Session ended before answer delivery; no continuation was written')
+      }
+    }
     return EXIT.ok
   } catch (err) {
     // SessionEnd defers its start record until after cleanup; if cleanup itself
@@ -1028,6 +1063,17 @@ export function askCommand(
   if (mediaInputError !== null) {
     return askFailure(deps, flags, 'invalid_input', 'media', mediaInputError, 'fix the media flags and retry')
   }
+  let explicitUseConfig: CliConfig
+  try {
+    explicitUseConfig = loadConfig({ cwd: deps.cwd, env: deps.env })
+  } catch (err) {
+    return askFailure(deps, flags, 'config_invalid', 'configuration', `Question routing configuration is invalid: ${String(err)}`, 'fix the reported Notifai configuration and retry')
+  }
+  const explicitProject = flags.project ?? explicitUseConfig.project.value ?? inferInvocationContext(deps.cwd).project
+  if (explicitProject !== null) {
+    const binding = projectBinding(deps.cwd, deps.env, explicitProject)
+    if (binding !== null) enableProject(binding)
+  }
   if (deps.store.load() === null) {
     return askFailure(
       deps,
@@ -1124,12 +1170,12 @@ export function askCommand(
       flags,
       'session_identity_missing',
       'exact_session',
-      'Could not prove which live harness session owns this command.',
-      'run it from a supported harness with exact session identity, or use a blocking `notifai send --reply` question',
+      'Could not prove which live Agent Session owns this command.',
+      'run it from a supported harness with exact Agent Session identity, or use a blocking `notifai send --reply` question',
     )
   }
   if (!sessionId) {
-    return askFailure(deps, flags, 'session_identity_missing', 'exact_session', 'No exact active session is available.', 'use a blocking `notifai send --reply` question')
+    return askFailure(deps, flags, 'session_identity_missing', 'exact_session', 'No exact active Agent Session is available.', 'use a blocking `notifai send --reply` question')
   }
   let routingConfig: CliConfig
   try {
@@ -1732,7 +1778,7 @@ export function hooksInstallCommand(deps: CommandDeps, flags: HooksInstallFlags)
   if (harness === 'opencode') {
     return installOpencodePlugin(deps, settingsTarget, {
       adapterPath,
-      timeoutSeconds: BLOCKING_STOP_TIMEOUT_SECONDS,
+      timeoutSeconds: NON_ROUTING_BLOCKING_STOP_TIMEOUT_SECONDS,
       platform: hookPlatform,
       nodePath,
       ...(flags.narrate === undefined ? {} : { narrate: flags.narrate }),

package/src/commands-init.ts

@@ -43,6 +43,7 @@ import {
   writeSetupProof,
 } from './commands-setup-proof.js'
 import { listScopedNotifaiSkills, SKILLS_SOURCE } from './commands-skill.js'
+import { enableProject, projectBinding } from './project-enablement.js'
 
 // ---------------------------------------------------------------------------
 // init
@@ -139,6 +140,14 @@ async function closeGap(
     return 'closed'
   }
 
+  if (state.id === 'project-enablement') {
+    const config = loadLoggedConfig(deps, { cwd: deps.cwd, env: deps.env })
+    const binding = projectBinding(deps.cwd, deps.env, config.project.value)
+    if (binding === null) return 'failed'
+    enableProject(binding)
+    return 'closed'
+  }
+
   if (state.id === 'hooks') {
     const harnesses = await pickHarnessesToInstall(deps)
     if (harnesses === null || harnesses.length === 0) return 'failed'
@@ -534,7 +543,7 @@ async function runSetupProof(deps: CommandDeps): Promise<GapCloseResult> {
 
 /** Closing a local gap cannot have changed the service, the keychain, or devices. */
 function refreshAfterClose(id: string): readonly ReadinessRefresh[] | undefined {
-  return id === 'project' || id === 'hooks' || id === 'skill' || id === 'question-routing-settings'
+  return id === 'project' || id === 'project-enablement' || id === 'hooks' || id === 'skill' || id === 'question-routing-settings'
     ? ['local']
     : undefined
 }
@@ -548,6 +557,7 @@ function wantsOptional(deps: CommandDeps, state: ReadinessState, flags: InitFlag
   // nothing, and is undone by editing one line — so it is done rather than
   // asked about, for a human and an agent alike.
   if (state.id === 'project') return Promise.resolve(true)
+  if (state.id === 'project-enablement') return Promise.resolve(true)
   const explicit = state.id === 'hooks' ? flags.hooks : state.id === 'skill' ? flags.skills : undefined
   if (explicit !== undefined) return Promise.resolve(explicit)
   // An agent is never asked, and never assumed into a change it did not

package/src/commands-project.ts

@@ -0,0 +1,47 @@
+import { loadLoggedConfig, EXIT, type CommandDeps } from './commands-core.js'
+import {
+  disableProject,
+  enableProject,
+  projectBinding,
+  projectEnabled,
+} from './project-enablement.js'
+
+function bindingFor(deps: CommandDeps) {
+  const config = loadLoggedConfig(deps, { cwd: deps.cwd, env: deps.env })
+  return projectBinding(deps.cwd, deps.env, config.project.value)
+}
+
+export function projectEnableCommand(deps: CommandDeps): number {
+  const binding = bindingFor(deps)
+  if (binding === null) {
+    deps.io.err('No Project can be inferred here. Run inside a Project or configure an explicit Project id.')
+    return EXIT.usage
+  }
+  enableProject(binding)
+  deps.io.out(`Notifai lifecycle behavior is enabled for Project "${binding.project}".`)
+  return EXIT.ok
+}
+
+export function projectDisableCommand(deps: CommandDeps): number {
+  const binding = bindingFor(deps)
+  if (binding === null) {
+    deps.io.err('No Project can be inferred here. Run inside a Project or configure an explicit Project id.')
+    return EXIT.usage
+  }
+  disableProject(binding)
+  deps.io.out(`Notifai lifecycle behavior is disabled for Project "${binding.project}".`)
+  return EXIT.ok
+}
+
+export function projectStatusCommand(deps: CommandDeps, json = false): number {
+  const binding = bindingFor(deps)
+  const enabled = projectEnabled(binding)
+  if (json) {
+    deps.io.out(JSON.stringify({ project: binding?.project ?? null, enabled }))
+  } else if (binding === null) {
+    deps.io.out('No Project can be inferred here; lifecycle behavior is disabled.')
+  } else {
+    deps.io.out(`Project "${binding.project}": lifecycle behavior ${enabled ? 'enabled' : 'disabled'}.`)
+  }
+  return EXIT.ok
+}

package/src/commands-send-support.ts

@@ -5,42 +5,16 @@ import path from 'node:path'
 import { isRetryableReplyPollError, type ApiClient } from './client.js'
 import { fetchMediaUrl } from './url-policy.js'
 import { buildSourceContext, inferInvocationContext } from './invocation-context.js'
-import { readOrcaSessionTitle } from './orca-session-title.js'
 import { type DraftInvocation, type SendFlags } from './send.js'
 import { EXIT, reportError, type CommandDeps } from './commands-core.js'
 import type { ActiveHarnessSession } from './commands-harness-context.js'
 
-function managedSessionTitle(
-  deps: CommandDeps,
-  flags: Pick<SendFlags, 'sessionLabel'>,
-  active: ActiveHarnessSession | null,
-): string | undefined {
-  if (active?.sessionLabel !== undefined) return active.sessionLabel
-  // The Orca worktree title names the workspace, not one harness: every
-  // harness session Orca starts inside that worktree inherits the same
-  // environment selector, so any active session with an identity to label
-  // may use it. An explicit label still wins without paying for the lookup.
-  if (
-    active?.sessionId === undefined ||
-    flags.sessionLabel !== undefined ||
-    deps.env['NOTIFAI_SESSION_LABEL'] !== undefined
-  ) {
-    return undefined
-  }
-  try {
-    return (deps.orcaSessionTitle ?? readOrcaSessionTitle)(deps.env)
-  } catch {
-    return undefined
-  }
-}
-
 export function resolveDraftInvocation(
   deps: CommandDeps,
   flags: Pick<SendFlags, 'sessionId' | 'sessionLabel'>,
   active: ActiveHarnessSession | null,
 ): { ok: true; invocation: DraftInvocation } | { ok: false; error: string } {
   const inferred = inferInvocationContext(deps.cwd)
-  const sessionTitle = managedSessionTitle(deps, flags, active)
   const source = buildSourceContext({
     env: deps.env,
     invocation: inferred,
@@ -52,7 +26,7 @@ export function resolveDraftInvocation(
           activeHarness: {
             harness: active.harness,
             ...(active.sessionId === undefined ? {} : { sessionId: active.sessionId }),
-            ...(sessionTitle === undefined ? {} : { sessionLabel: sessionTitle }),
+            ...(active.sessionLabel === undefined ? {} : { sessionLabel: active.sessionLabel }),
             ...(active.sessionLabelPending === true ? { sessionLabelPending: true } : {}),
           },
         }),

package/src/commands-send.ts

@@ -9,6 +9,7 @@ import {
 import { ApiCallError, NetworkError } from './client.js'
 import type { FlagOverrides, loadConfig } from './config.js'
 import { MIN_REPLY_WINDOW_SECONDS, readSessionState } from './hooks.js'
+import { enableProject, projectBinding } from './project-enablement.js'
 import {
   buildDraft,
   formatReceipt,
@@ -148,9 +149,6 @@ export async function sendCommand(
     deps.io.err(source.error)
     return EXIT.usage
   }
-  const authed = authedClient(deps, config)
-  if (!authed) return EXIT.auth
-  const credential = deps.store.load()!
   let semanticImages: string[]
   try {
     semanticImages = semanticMediaIds(flags.image ?? [], deps.cwd)
@@ -167,6 +165,13 @@ export async function sendCommand(
     deps.io.err(semanticBuild.error)
     return EXIT.usage
   }
+  if (semanticBuild.draft.project !== undefined) {
+    const binding = projectBinding(deps.cwd, deps.env, semanticBuild.draft.project)
+    if (binding !== null) enableProject(binding)
+  }
+  const authed = authedClient(deps, config)
+  if (!authed) return EXIT.auth
+  const credential = deps.store.load()!
   const attempt = beginSendAttempt({
     env: deps.env,
     credential,
@@ -392,7 +397,7 @@ function emitSendWarnings(
   }
   if (/^(?:update|done|question|failed|blocked)\s*(?:[·:—-]|$)/i.test(flags.title.trim())) {
     deps.io.err(
-      'Heads up: keep the title to the specific substance. Put notification type in --kind; project identity is inferred separately.',
+      'Heads up: keep the title to the specific substance. Put notification type in --kind; Project identity is inferred separately.',
     )
   }
   if (

package/src/commands-skill.test.ts

@@ -0,0 +1,44 @@
+import { mkdirSync, mkdtempSync, writeFileSync } from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { describe, expect, it } from 'vitest'
+import type { CommandDeps } from './commands-core.js'
+import { skillReadiness, SKILLS_SOURCE } from './commands-skill.js'
+
+describe('development CLI skill parity', () => {
+  it('reports an exact gap instead of calling a stale released skill ready', async () => {
+    const root = mkdtempSync(path.join(os.tmpdir(), 'notifai-dev-skill-'))
+    const installedPath = path.join(root, 'skills', 'notifai')
+    mkdirSync(installedPath, { recursive: true })
+    writeFileSync(path.join(installedPath, 'SKILL.md'), '# stale released skill\n')
+    const match = /^([^#]+)#(.+)$/.exec(SKILLS_SOURCE ?? '')
+    if (match === null) throw new Error('test build has no skill release pin')
+    const deps = {
+      cwd: root,
+      env: {},
+      io: { out() {}, err() {}, confirm: async () => false, openUrl() {} },
+      store: { load: () => null, save() {}, clear() {}, describe: () => 'test' },
+      nativeSkills: {
+        list: async (scope: 'project' | 'global') => ({
+          skills: scope === 'global'
+            ? [{ name: 'notifai', scope, path: installedPath, source: match[1]!, sourceType: 'github' as const, sourceUrl: `https://github.com/${match[1]}.git`, ref: match[2]! }]
+            : [],
+        }),
+        add: async () => 0,
+        remove: async () => 0,
+      },
+    } satisfies CommandDeps
+
+    const state = await skillReadiness(deps)
+    expect(state).toMatchObject({
+      status: 'gap',
+      technical: {
+        resolution: 'development-cli-skill-mismatch',
+        ref: match[2],
+        checkout_digest: expect.stringMatching(/^sha256:/),
+        installed_digest: expect.stringMatching(/^sha256:/),
+      },
+    })
+    expect(state.remedy).toBeUndefined()
+  })
+})

package/src/commands-skill.ts

@@ -1,4 +1,8 @@
 import { SKILLS_INSTALLER_SPEC, type NativeSkill, type SkillScope } from './native-skills.js'
+import { createHash } from 'node:crypto'
+import { existsSync, readdirSync, readFileSync } from 'node:fs'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
 import { type ReadinessState } from './readiness.js'
 import { skillsSource } from './release.js'
 import type { CommandDeps } from './commands-core.js'
@@ -20,6 +24,40 @@ const SKILLS_SOURCE_LABEL = SKILLS_SOURCE ?? 'the public release tag matching th
 
 const SKILL_SCOPES: readonly SkillScope[] = ['project', 'global']
 
+function markdownTreeDigest(root: string): string | null {
+  if (!existsSync(root)) return null
+  const files: string[] = []
+  const walk = (directory: string): void => {
+    for (const entry of readdirSync(directory, { withFileTypes: true })) {
+      const absolute = path.join(directory, entry.name)
+      if (entry.isDirectory()) walk(absolute)
+      else if (entry.isFile() && entry.name.endsWith('.md')) files.push(absolute)
+    }
+  }
+  try {
+    walk(root)
+    const hash = createHash('sha256')
+    for (const file of files.sort()) {
+      hash.update(path.relative(root, file))
+      hash.update('\0')
+      hash.update(readFileSync(file))
+      hash.update('\0')
+    }
+    return `sha256:${hash.digest('hex')}`
+  } catch {
+    return null
+  }
+}
+
+function developmentSkillMismatch(skill: NativeSkill): { checkout: string; installed: string } | null {
+  const checkoutRoot = fileURLToPath(new URL('../../../skills/notifai/', import.meta.url))
+  const checkout = markdownTreeDigest(checkoutRoot)
+  const installed = markdownTreeDigest(skill.path)
+  return checkout !== null && installed !== null && checkout !== installed
+    ? { checkout, installed }
+    : null
+}
+
 function skillSourceParts(): { source: string; ref: string } | null {
   if (SKILLS_SOURCE === null) return null
   const match = /^([^#]+)#(.+)$/.exec(SKILLS_SOURCE)
@@ -118,6 +156,25 @@ export async function skillReadiness(
 
   const current = installed.find(expectedSkill)
   if (current !== undefined) {
+    const mismatch = developmentSkillMismatch(current)
+    if (mismatch !== null) {
+      return {
+        id: 'skill',
+        title: 'Agent guidance skill',
+        status: 'gap',
+        detail:
+          `the active development CLI's shipped guidance differs from the installer-managed ${skillPin(current)} skill. ` +
+          'Released installs remain immutable; publish a new CLI/skill release before treating this combination as ready.',
+        technical: {
+          resolution: 'development-cli-skill-mismatch',
+          scope: current.scope,
+          ref: current.ref,
+          path: current.path,
+          checkout_digest: mismatch.checkout,
+          installed_digest: mismatch.installed,
+        },
+      }
+    }
     return {
       id: 'skill',
       title: 'Agent guidance skill',

package/src/commands.test.ts

@@ -68,6 +68,7 @@ import {
   codexTrustKey,
   findInstallations,
   handlerEvent,
+  QUESTION_STOP_TIMEOUT_SECONDS,
   settingsFile,
 } from './install-hooks.js'
 import { readSessionState, writeProjectSession, writeSessionState } from './hooks.js'
@@ -78,6 +79,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 +418,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 = {
@@ -829,7 +856,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('never promotes an Orca worktree title into an 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 +879,6 @@ describe('command contracts', () => {
       ...makeDeps(io, client),
       cwd,
       env,
-      orcaSessionTitle: (lookupEnv: NodeJS.ProcessEnv) => {
-        expect(lookupEnv['ORCA_WORKTREE_ID']).toBe(worktreeId)
-        return 'Worker - semantic session implementation'
-      },
     }
 
     expect(
@@ -868,12 +891,13 @@ describe('command contracts', () => {
 
     expect(submitted?.draft.source).toMatchObject({
       session_id: 'orca-claude-session',
-      session_label: 'Worker - semantic session implementation',
       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('uses the exact Orca worktree title for an active Codex session send', async () => {
+  it('never treats an Orca worktree title as a 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 +918,6 @@ 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'
-      },
     }
 
     expect(
@@ -910,9 +930,9 @@ describe('command contracts', () => {
 
     expect(submitted?.draft.source).toMatchObject({
       session_id: 'orca-codex-thread',
-      session_label: 'Worker - semantic session implementation',
       harness: 'codex',
     })
+    expect(submitted?.draft.source?.session_label).toMatch(/^[A-Z][a-z]+ [A-Z][a-z]+$/)
   })
 
   it('falls back safely when Orca returns a private path as its title', async () => {
@@ -936,7 +956,6 @@ describe('command contracts', () => {
         TERM_PROGRAM: 'Orca',
         ORCA_WORKTREE_ID: `repo-123::${cwd}`,
       },
-      orcaSessionTitle: () => '/private/untrusted/worktree',
     }
 
     expect(
@@ -6093,7 +6112,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 +6127,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 +6139,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 +6295,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 () => {
@@ -6650,7 +6679,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`. */

package/src/commands.ts

@@ -62,4 +62,9 @@ export {
   type SetupScope,
 } from './commands-init.js'
 export { assessReadiness, doctorCommand } from './commands-doctor.js'
+export {
+  projectDisableCommand,
+  projectEnableCommand,
+  projectStatusCommand,
+} from './commands-project.js'
 export { realIo } from './commands-io.js'

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',
   },