@raidiant/notifai 6.0.0 → 7.0.1

package/src/commands.test.ts

@@ -180,6 +180,14 @@ class PlainInteractiveIo extends CapturedIo {
   interactive = true
 }
 
+class OutroCapturedIo extends CapturedIo {
+  outros: string[] = []
+
+  async outro(message: string) {
+    this.outros.push(message)
+  }
+}
+
 class InteractiveIo extends CapturedIo {
   interactive = true
   selectAnswer: string | null = 'global'
@@ -500,11 +508,162 @@ describe('command contracts', () => {
       session_id: 'opaque-claude-session-42',
       harness: 'claude-code',
     })
-    expect(submitted?.draft.source?.session_label).toMatch(/^[A-Z][a-z]+ [A-Z][a-z]+$/)
+    expect(submitted?.draft.source?.session_label).toBe('Rapid Antelope')
     expect(io.outLines.join('\n')).not.toContain('opaque-claude-session-42')
     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 () => {
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-orca-claude-title-'))
+    const io = new CapturedIo()
+    let submitted: SubmitNotificationRequestT | undefined
+    const client = {
+      submit: async (body: SubmitNotificationRequestT) => {
+        submitted = body
+        return receipt
+      },
+    } as unknown as ApiClient
+    const worktreeId = `repo-123::${cwd}`
+    const env = {
+      XDG_CONFIG_HOME: path.join(cwd, 'config'),
+      XDG_STATE_HOME: path.join(cwd, 'state'),
+      CLAUDECODE: '1',
+      CLAUDE_CODE_SESSION_ID: 'orca-claude-session',
+      TERM_PROGRAM: 'Orca',
+      ORCA_WORKTREE_ID: worktreeId,
+    }
+    const deps = {
+      ...makeDeps(io, client),
+      cwd,
+      env,
+      orcaSessionTitle: (lookupEnv: NodeJS.ProcessEnv) => {
+        expect(lookupEnv['ORCA_WORKTREE_ID']).toBe(worktreeId)
+        return 'Worker - semantic session implementation'
+      },
+    }
+
+    expect(
+      await sendCommand(deps, {
+        title: 'Resolver implemented',
+        body: 'The Orca worktree title was frozen locally.',
+        kind: 'done',
+      }),
+    ).toBe(EXIT.ok)
+
+    expect(submitted?.draft.source).toMatchObject({
+      session_id: 'orca-claude-session',
+      session_label: 'Worker - semantic session implementation',
+      harness: 'claude-code',
+    })
+  })
+
+  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()
+    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: {
+        XDG_CONFIG_HOME: path.join(cwd, 'config'),
+        XDG_STATE_HOME: path.join(cwd, 'state'),
+        CLAUDECODE: '1',
+        CLAUDE_CODE_SESSION_ID: 'orca-private-title-session',
+        TERM_PROGRAM: 'Orca',
+        ORCA_WORKTREE_ID: `repo-123::${cwd}`,
+      },
+      orcaSessionTitle: () => '/private/untrusted/worktree',
+    }
+
+    expect(
+      await sendCommand(deps, {
+        title: 'Resolver implemented',
+        body: 'Unsafe metadata must never become a visible name.',
+        kind: 'done',
+      }),
+    ).toBe(EXIT.ok)
+
+    expect(submitted?.draft.source?.session_label).toMatch(/^[A-Z][a-z]+ [A-Z][a-z]+$/)
+    expect(submitted?.draft.source?.session_label).not.toContain('/private/')
+  })
+
+  it('uses the trusted OpenCode session title published by its managed adapter', async () => {
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-opencode-title-'))
+    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: {
+        XDG_CONFIG_HOME: path.join(cwd, 'config'),
+        XDG_STATE_HOME: path.join(cwd, 'state'),
+        NOTIFAI_ACTIVE_HARNESS: 'opencode',
+        NOTIFAI_ACTIVE_SESSION_ID: 'opencode-session',
+        NOTIFAI_ACTIVE_SESSION_LABEL: 'Semantic session names',
+      },
+    }
+
+    expect(
+      await sendCommand(deps, {
+        title: 'Resolver implemented',
+        body: 'The first-party title was frozen locally.',
+        kind: 'done',
+      }),
+    ).toBe(EXIT.ok)
+
+    expect(submitted?.draft.source).toMatchObject({
+      session_id: 'opencode-session',
+      session_label: 'Semantic session names',
+      harness: 'opencode',
+    })
+  })
+
+  it('does not freeze or submit an OpenCode placeholder title', async () => {
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-opencode-pending-'))
+    const io = new CapturedIo()
+    let submitted = false
+    const client = {
+      submit: async () => {
+        submitted = true
+        return receipt
+      },
+    } 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'),
+        NOTIFAI_ACTIVE_HARNESS: 'opencode',
+        NOTIFAI_ACTIVE_SESSION_ID: 'opencode-session',
+        NOTIFAI_ACTIVE_SESSION_LABEL_PENDING: '1',
+      },
+    }
+
+    expect(
+      await sendCommand(deps, {
+        title: 'Resolver implemented',
+        body: 'Wait for the semantic title before freezing a name.',
+        kind: 'done',
+      }),
+    ).toBe(EXIT.usage)
+    expect(submitted).toBe(false)
+    expect(io.errLines.join('\n')).toContain('still generating this session')
+    expect(existsSync(path.join(cwd, 'state', 'notifai', 'session-labels.json'))).toBe(false)
+  })
+
   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')
@@ -653,7 +812,7 @@ describe('command contracts', () => {
       expect(grammar).not.toContain(".option('--session <")
       expect(grammar).toContain(".option('--body-file")
       expect(grammar).toContain(".option('--session-id")
-      expect(grammar).toContain(".option('--session-label")
+      expect(grammar).toContain("'--session-label <text>'")
       expect(grammar).toContain("'--image <path|url|media_id>'")
       expect(grammar).toContain("'--image-alt <text>'")
     }
@@ -2867,7 +3026,7 @@ describe('compatibility-first update guidance', () => {
         listDevices: async () => ({ devices: [] }),
         accessStatus: async () => ({ email: 'user@example.test' }),
       } as unknown as ApiClient
-      const humanIo = new PlainInteractiveIo()
+      const humanIo = new InteractiveIo()
       const deps = {
         ...makeDeps(humanIo, client),
         cwd,
@@ -2882,6 +3041,9 @@ describe('compatibility-first update guidance', () => {
       ).toBe(exit)
       expect(humanIo.outLines).toEqual(humanLines)
       expect(humanIo.errLines).toEqual([])
+      expect(humanIo.outros).toEqual(
+        status === 'ready' ? ['Everything looks good'] : [],
+      )
 
       const jsonIo = new CapturedIo()
       expect(
@@ -3140,7 +3302,7 @@ describe('init', () => {
 
   it('resumes the same init after a required CLI update becomes current', async () => {
     const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-init-update-resume-'))
-    const io = new CapturedIo()
+    const io = new OutroCapturedIo()
     let cliSupport = compatibilityWithCli({
       state: 'must_update',
       reason: 'minimum_not_met',
@@ -3175,11 +3337,13 @@ describe('init', () => {
     expect(await initCommand(deps, { hooks: false, skills: false })).toBe(EXIT.failed)
     expect(io.outLines).toContain("Notifai can't send notifications until you update.")
     expect(io.outLines).toContain('npm install -g @raidiant/notifai')
+    expect(io.outros).toEqual([])
     expect(submissions).toBe(0)
 
     cliSupport = currentCompatibility
     io.outLines = []
     io.errLines = []
+    io.outros = []
 
     expect(await initCommand(deps, { hooks: false, skills: false })).toBe(EXIT.ok)
     expect(submissions).toBe(1)
@@ -4352,7 +4516,7 @@ describe('asking before the hooks have ever run', () => {
     })
     expect(
       readSessionState('codex-current-thread', env).pending?.[0]?.source?.session_label,
-    ).toMatch(/^[A-Z][a-z]+ [A-Z][a-z]+$/)
+    ).toBe('Gentle Salmon')
   })
 
   it('uploads ask images before registration and freezes canonical body media', async () => {
@@ -4484,6 +4648,39 @@ 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', () => {
+    const cwd = scratchDir('notifai-orca-claude-ask-')
+    const io = new CapturedIo()
+    const env = {
+      ...isolatedEnv(cwd),
+      CLAUDECODE: '1',
+      CLAUDE_CODE_SESSION_ID: 'orca-claude-question',
+      TERM_PROGRAM: 'Orca',
+      ORCA_WORKTREE_ID: `repo-123::${cwd}`,
+    }
+    const deps = {
+      ...makeDeps(io, {} as ApiClient),
+      cwd,
+      env,
+      now: () => 42,
+      orcaSessionTitle: () => 'Worker - semantic session implementation',
+    }
+
+    expect(hooksInstallCommand(deps, { harness: 'claude-code', execPath, scriptPath })).toBe(
+      EXIT.ok,
+    )
+    writeSessionState('orca-claude-question', env, { last_prompt_at: 42, last_stop_at: 41 })
+    writeProjectSession(cwd, env, 'orca-claude-question', 42, 'claude-code')
+    io.outLines = []
+
+    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',
+    })
+  })
+
   it('judges the fired check against the active harness, not a global installation of another', async () => {
     const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-fired-active-harness-'))
     const io = new CapturedIo()
@@ -5386,7 +5583,7 @@ describe('command failures carrying server details', () => {
 
     expect(io.errLines).toEqual([
       "feature_unavailable: The selected device can't answer questions.",
-      'next: Update Notifai on the named device.',
+      'next: Update Notifai on Old phone.',
     ])
     expect(io.errLines.join(' ')).not.toContain('untrusted')
     expect(io.errLines.join(' ')).not.toContain('disagree about the contract')

package/src/config.ts

@@ -188,9 +188,9 @@ export function globalConfigPath(env: NodeJS.ProcessEnv = process.env): string {
 }
 
 /**
- * Machine-local mutable state: presence markers, pending questions, and
- * session config overrides. Separate from the config dir because none of it is
- * user-authored and none of it should ever be synced or committed.
+ * Machine-local mutable state: presence markers, pending questions, frozen
+ * session names, and session config overrides. Separate from the config dir
+ * because none of it should ever be synced or committed.
  */
 export function stateDir(
   env: NodeJS.ProcessEnv = process.env,

package/src/generated-session-label.ts

@@ -0,0 +1,155 @@
+const FNV1A_64_OFFSET = 0xcbf29ce484222325n
+const FNV1A_64_PRIME = 0x100000001b3n
+const WORD_COUNT = 64n
+
+/** Frozen word lists keep generated fallbacks stable for a given opaque id. */
+const ADJECTIVES = [
+  'Amber',
+  'Arctic',
+  'Ash',
+  'Azure',
+  'Blue',
+  'Bold',
+  'Bright',
+  'Bronze',
+  'Calm',
+  'Cedar',
+  'Clear',
+  'Copper',
+  'Coral',
+  'Crisp',
+  'Dawn',
+  'Deep',
+  'Ember',
+  'Fern',
+  'Frost',
+  'Gentle',
+  'Golden',
+  'Green',
+  'Harbor',
+  'Hazel',
+  'Indigo',
+  'Ivory',
+  'Jade',
+  'Keen',
+  'Lively',
+  'Lunar',
+  'Maple',
+  'Meadow',
+  'Mellow',
+  'Misty',
+  'Noble',
+  'Ocean',
+  'Olive',
+  'Onyx',
+  'Quiet',
+  'Rapid',
+  'Red',
+  'River',
+  'Royal',
+  'Sage',
+  'Silver',
+  'Solar',
+  'Steady',
+  'Stone',
+  'Sunny',
+  'Swift',
+  'Teal',
+  'Timber',
+  'True',
+  'Velvet',
+  'Verdant',
+  'Violet',
+  'Warm',
+  'Wild',
+  'Winter',
+  'Wise',
+  'Witty',
+  'Yellow',
+  'Young',
+  'Zealous',
+] as const
+
+const NOUNS = [
+  'Alpaca',
+  'Antelope',
+  'Badger',
+  'Bear',
+  'Beaver',
+  'Bison',
+  'Bobcat',
+  'Caribou',
+  'Cougar',
+  'Coyote',
+  'Crane',
+  'Deer',
+  'Dolphin',
+  'Dragonfly',
+  'Eagle',
+  'Elk',
+  'Falcon',
+  'Finch',
+  'Firefly',
+  'Fox',
+  'Gazelle',
+  'Gecko',
+  'Hare',
+  'Heron',
+  'Ibex',
+  'Jay',
+  'Kestrel',
+  'Kingfisher',
+  'Koala',
+  'Lark',
+  'Leopard',
+  'Lynx',
+  'Magpie',
+  'Mantis',
+  'Marten',
+  'Moose',
+  'Osprey',
+  'Otter',
+  'Owl',
+  'Panda',
+  'Panther',
+  'Pelican',
+  'Penguin',
+  'Puma',
+  'Quail',
+  'Rabbit',
+  'Raven',
+  'Robin',
+  'Sable',
+  'Salmon',
+  'Seal',
+  'Shark',
+  'Sparrow',
+  'Stag',
+  'Swan',
+  'Tiger',
+  'Tortoise',
+  'Trout',
+  'Turtle',
+  'Viper',
+  'Whale',
+  'Wolf',
+  'Wren',
+  'Yak',
+] as const
+
+function fnv1a64(value: string): bigint {
+  let hash = FNV1A_64_OFFSET
+  for (const byte of new TextEncoder().encode(value)) {
+    hash ^= BigInt(byte)
+    hash = BigInt.asUintN(64, hash * FNV1A_64_PRIME)
+  }
+  return hash
+}
+
+/** Deterministic fallback for a session whose work has no semantic title. */
+export function generatedSessionLabel(sessionId: string): string {
+  const hash = fnv1a64(sessionId)
+  const adjective = ADJECTIVES[Number(hash % WORD_COUNT)]
+  const noun = NOUNS[Number((hash >> 6n) % WORD_COUNT)]
+  return `${adjective} ${noun}`
+}

package/src/hooks.test.ts

@@ -15,7 +15,6 @@ import os from 'node:os'
 import path from 'node:path'
 import { PassThrough } from 'node:stream'
 import {
-  sessionLabelFromId,
   type ListRepliesResponse,
   type ReplyView,
   type SubmissionReceipt,
@@ -3139,7 +3138,7 @@ describe('telling concurrent agents apart', () => {
         question: 'Ship it?',
         source: {
           session_id: 'sess-abc',
-          session_label: sessionLabelFromId('sess-abc'),
+          session_label: 'Semantic session',
           harness: 'claude-code',
         },
       },
@@ -3150,7 +3149,7 @@ describe('telling concurrent agents apart', () => {
 
     expect(h.recorder.submitted[0]?.draft.source).toEqual({
       session_id: 'sess-abc',
-      session_label: sessionLabelFromId('sess-abc'),
+      session_label: 'Semantic session',
       harness: 'claude-code',
     })
   })
@@ -3164,7 +3163,7 @@ describe('telling concurrent agents apart', () => {
         question: 'Ship it?',
         source: {
           session_id: 'sess-abc',
-          session_label: sessionLabelFromId('sess-abc'),
+          session_label: 'Semantic session',
           harness: 'claude-code',
         },
       },
@@ -3183,7 +3182,7 @@ describe('telling concurrent agents apart', () => {
     const retirement = h.recorder.submitted.find((s) => s.draft.event === 'question_retired')
     expect(retirement?.draft.source).toEqual({
       session_id: 'sess-abc',
-      session_label: sessionLabelFromId('sess-abc'),
+      session_label: 'Semantic session',
       harness: 'claude-code',
     })
   })

package/src/install-hooks.test.ts

@@ -838,11 +838,94 @@ describe('the OpenCode adapter', () => {
     expect(source).not.toContain('synthetic: true')
   })
 
-  it('injects an exact active-harness and session marker into OpenCode shells', () => {
+  it('injects exact identity and the first-party OpenCode title into agent shells', () => {
     expect(source).toContain('"shell.env"')
     expect(source).toContain('NOTIFAI_ACTIVE_HARNESS')
     expect(source).toContain('NOTIFAI_ACTIVE_SESSION_ID')
+    expect(source).toContain('NOTIFAI_ACTIVE_SESSION_LABEL')
+    expect(source).toContain('NOTIFAI_ACTIVE_SESSION_LABEL_PENDING')
     expect(source).toContain('input?.sessionID')
+    expect(source).toContain('client.session.get({ path: { id: sessionID } })')
+    expect(source).toContain('response?.data?.title')
+  })
+
+  it('executes the generated adapter and publishes the SDK session title', async () => {
+    let requested = ''
+    const generated = (await import(
+      `data:text/javascript;base64,${Buffer.from(source).toString('base64')}`
+    )) as {
+      NotifAIPlugin(input: {
+        directory: string
+        client: {
+          session: {
+            get(input: { path: { id: string } }): Promise<{ data: { title: string } }>
+          }
+        }
+      }): Promise<{
+        'shell.env'?: (
+          input: { sessionID?: string },
+          output: { env: Record<string, string> },
+        ) => Promise<void>
+      }>
+    }
+    const plugin = await generated.NotifAIPlugin({
+      directory: '/repo',
+      client: {
+        session: {
+          get: async ({ path: request }) => {
+            requested = request.id
+            return { data: { title: 'Semantic session names' } }
+          },
+        },
+      },
+    })
+    const output = { env: {} as Record<string, string> }
+    await plugin['shell.env']?.({ sessionID: 'opencode-session' }, output)
+
+    expect(requested).toBe('opencode-session')
+    expect(output.env).toMatchObject({
+      NOTIFAI_ACTIVE_HARNESS: 'opencode',
+      NOTIFAI_ACTIVE_SESSION_ID: 'opencode-session',
+      NOTIFAI_ACTIVE_SESSION_LABEL: 'Semantic session names',
+    })
+  })
+
+  it('marks OpenCode placeholder titles as pending instead of publishing them', async () => {
+    const generated = (await import(
+      `data:text/javascript;base64,${Buffer.from(source).toString('base64')}`
+    )) as {
+      NotifAIPlugin(input: {
+        directory: string
+        client: {
+          session: {
+            get(input: { path: { id: string } }): Promise<{ data: { title: string } }>
+          }
+        }
+      }): Promise<{
+        'shell.env'?: (
+          input: { sessionID?: string },
+          output: { env: Record<string, string> },
+        ) => Promise<void>
+      }>
+    }
+    const plugin = await generated.NotifAIPlugin({
+      directory: '/repo',
+      client: {
+        session: {
+          get: async () => ({
+            data: { title: 'New session - 2026-08-20T13:05:00.000Z' },
+          }),
+        },
+      },
+    })
+    const output = { env: {} as Record<string, string> }
+    await plugin['shell.env']?.({ sessionID: 'opencode-session' }, output)
+
+    expect(output.env).toEqual({
+      NOTIFAI_ACTIVE_HARNESS: 'opencode',
+      NOTIFAI_ACTIVE_SESSION_ID: 'opencode-session',
+      NOTIFAI_ACTIVE_SESSION_LABEL_PENDING: '1',
+    })
   })
 
   it('carries the ownership marker so a second checkout replaces it', () => {