@raidiant/notifai 6.0.0 → 7.0.0

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', () => {

package/src/invocation-context.test.ts

@@ -1,5 +1,7 @@
+import { mkdtempSync } from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
 import { describe, expect, it } from 'vitest'
-import { sessionLabelFromId } from '@raidiant/notifai-protocol'
 import {
   buildSourceContext,
   inferInvocationContext,
@@ -13,6 +15,13 @@ function fixtureGit(values: Record<string, string | null>): GitCommand {
   return (_cwd, args) => values[args.join(' ')] ?? null
 }
 
+function stateEnv(overrides: NodeJS.ProcessEnv = {}): NodeJS.ProcessEnv {
+  return {
+    XDG_STATE_HOME: mkdtempSync(path.join(os.tmpdir(), 'notifai-source-context-')),
+    ...overrides,
+  }
+}
+
 describe('projectSlugFrom', () => {
   it.each([
     ['My Project', 'my-project'],
@@ -155,17 +164,19 @@ describe('truncateContext', () => {
 
 describe('buildSourceContext', () => {
   const invocation = { project: 'repo', branch: 'main', worktree: 'topic' }
+  const now = new Date(2026, 7, 20, 14, 5).getTime()
 
   it('applies flag, environment, then inferred precedence per session field', () => {
     const built = buildSourceContext({
-      env: {
+      env: stateEnv({
         NOTIFAI_SESSION_ID: 'env-id',
         NOTIFAI_SESSION_LABEL: 'Environment Label',
-      },
+      }),
       invocation,
       sessionId: 'flag-id',
       sessionLabel: 'Flag Label',
-      activeHarness: { harness: 'claude-code', sessionId: 'inferred-id' },
+      activeHarness: { harness: 'claude-code', sessionId: 'flag-id' },
+      now,
     })
     expect(built).toEqual({
       ok: true,
@@ -182,12 +193,13 @@ describe('buildSourceContext', () => {
   it('uses environment values ahead of an inferred exact session', () => {
     expect(
       buildSourceContext({
-        env: {
+        env: stateEnv({
           NOTIFAI_SESSION_ID: 'env-id',
           NOTIFAI_SESSION_LABEL: 'Environment Label',
-        },
+        }),
         invocation: { project: 'repo' },
-        activeHarness: { harness: 'codex', sessionId: 'inferred-id' },
+        activeHarness: { harness: 'codex', sessionId: 'env-id' },
+        now,
       }),
     ).toEqual({
       ok: true,
@@ -199,32 +211,117 @@ describe('buildSourceContext', () => {
     })
   })
 
-  it('generates a stable non-identifying label for an inferred exact session', () => {
-    const sessionId = 'opaque-thread-1234567890'
+  it('uses and freezes a trusted harness-native title', () => {
+    const env = stateEnv()
+    const sessionId = 'opencode-thread'
     expect(
       buildSourceContext({
-        env: {},
+        env,
         invocation: { project: 'repo', branch: 'main' },
-        activeHarness: { harness: 'opencode', sessionId },
+        activeHarness: {
+          harness: 'opencode',
+          sessionId,
+          sessionLabel: 'Semantic session names',
+        },
+        now,
       }),
     ).toEqual({
       ok: true,
       source: {
         session_id: sessionId,
-        session_label: sessionLabelFromId(sessionId),
+        session_label: 'Semantic session names',
         harness: 'opencode',
         branch: 'main',
       },
     })
-    expect(sessionLabelFromId(sessionId)).not.toContain('1234567890')
+    expect(
+      buildSourceContext({
+        env,
+        invocation: { project: 'repo' },
+        activeHarness: { harness: 'opencode', sessionId, sessionLabel: 'Changed title' },
+        now: now + 1_000,
+      }),
+    ).toEqual({
+      ok: true,
+      source: {
+        session_id: sessionId,
+        session_label: 'Semantic session names',
+        harness: 'opencode',
+      },
+    })
+  })
+
+  it('does not freeze an OpenCode placeholder while its semantic title is pending', () => {
+    expect(
+      buildSourceContext({
+        env: stateEnv(),
+        invocation: { project: 'repo' },
+        activeHarness: {
+          harness: 'opencode',
+          sessionId: 'pending-session',
+          sessionLabelPending: true,
+        },
+        now,
+      }),
+    ).toEqual({
+      ok: false,
+      error:
+        "OpenCode is still generating this session's title; retry shortly or pass --session-label.",
+    })
+  })
+
+  it('uses a stable generated fallback when no semantic name exists', () => {
+    const env = stateEnv()
+    const sessionId = 'opaque-thread-1234567890'
+    const expected = {
+      ok: true,
+      source: {
+        session_id: sessionId,
+        session_label: 'Ivory Koala',
+        harness: 'opencode' as const,
+        branch: 'main',
+      },
+    }
+    expect(
+      buildSourceContext({
+        env,
+        invocation: { project: 'repo', branch: 'main' },
+        activeHarness: { harness: 'opencode', sessionId },
+        now,
+      }),
+    ).toEqual(expected)
+    expect(expected.source.session_label).not.toContain('1234567890')
+  })
+
+  it('does not borrow harness identity or title for an explicit different session id', () => {
+    expect(
+      buildSourceContext({
+        env: stateEnv(),
+        invocation: { project: 'repo' },
+        sessionId: 'other-session',
+        activeHarness: {
+          harness: 'claude-code',
+          sessionId: 'current-session',
+          sessionLabel: 'Current work',
+        },
+        now,
+      }),
+    ).toEqual({
+      ok: true,
+      source: {
+        session_id: 'other-session',
+        session_label: 'Golden Lynx',
+      },
+    })
   })
 
   it('does not emit a harness or label when no exact session id is available', () => {
     expect(
       buildSourceContext({
-        env: {},
+        env: stateEnv(),
         invocation: { project: 'repo', branch: 'main' },
         activeHarness: { harness: 'cursor' },
+        now,
       }),
     ).toEqual({ ok: true, source: { branch: 'main' } })
   })
@@ -232,8 +329,9 @@ describe('buildSourceContext', () => {
   it('ignores the deleted NOTIFAI_SESSION variable', () => {
     expect(
       buildSourceContext({
-        env: { NOTIFAI_SESSION: 'legacy-id' },
+        env: stateEnv({ NOTIFAI_SESSION: 'legacy-id' }),
         invocation: { project: 'repo' },
+        now,
       }),
     ).toEqual({ ok: true })
   })
@@ -241,9 +339,10 @@ describe('buildSourceContext', () => {
   it('rejects a display label without an exact session id', () => {
     expect(
       buildSourceContext({
-        env: {},
+        env: stateEnv(),
         invocation: { project: 'repo' },
         sessionLabel: 'Unbound Label',
+        now,
       }),
     ).toEqual({
       ok: false,

package/src/invocation-context.ts

@@ -1,10 +1,8 @@
 import { execFileSync } from 'node:child_process'
 import path from 'node:path'
-import {
-  sessionLabelFromId,
-  type SourceContextT,
-} from '@raidiant/notifai-protocol'
+import { type SourceContextT } from '@raidiant/notifai-protocol'
 import type { Harness } from './harnesses.js'
+import { resolveSessionLabel } from './session-labels.js'
 
 export type GitCommand = (cwd: string, args: readonly string[]) => string | null
 
@@ -139,7 +137,13 @@ export interface SourceContextInput {
   invocation: InvocationContext
   sessionId?: string
   sessionLabel?: string
-  activeHarness?: { harness: Harness; sessionId?: string }
+  activeHarness?: {
+    harness: Harness
+    sessionId?: string
+    sessionLabel?: string
+    sessionLabelPending?: boolean
+  }
+  now?: number
 }
 
 export type SourceContextBuild =
@@ -161,14 +165,31 @@ export function buildSourceContext(input: SourceContextInput): SourceContextBuil
     return { ok: false, error: '--session-id must not be empty.' }
   }
 
-  const sessionLabel =
-    sessionId === undefined ? undefined : (explicitLabel ?? sessionLabelFromId(sessionId))
+  const activeOwnsSession =
+    sessionId !== undefined && input.activeHarness?.sessionId === sessionId
+  const harness = activeOwnsSession ? input.activeHarness?.harness : undefined
+  const label =
+    sessionId === undefined
+      ? undefined
+      : resolveSessionLabel({
+          env: input.env,
+          sessionId,
+          ...(harness === undefined ? {} : { harness }),
+          ...(explicitLabel === undefined ? {} : { explicitLabel }),
+          ...(activeOwnsSession && input.activeHarness?.sessionLabel !== undefined
+            ? { harnessLabel: input.activeHarness.sessionLabel }
+            : {}),
+          ...(activeOwnsSession && input.activeHarness?.sessionLabelPending === true
+            ? { harnessLabelPending: true }
+            : {}),
+          ...(input.now === undefined ? {} : { now: input.now }),
+        })
+  if (label !== undefined && !label.ok) return label
+
   const source: SourceContextT = {
     ...(sessionId !== undefined ? { session_id: sessionId } : {}),
-    ...(sessionLabel !== undefined ? { session_label: sessionLabel } : {}),
-    ...(sessionId !== undefined && input.activeHarness !== undefined
-      ? { harness: input.activeHarness.harness }
-      : {}),
+    ...(label !== undefined ? { session_label: label.label } : {}),
+    ...(harness !== undefined ? { harness } : {}),
     ...(input.invocation.branch !== undefined ? { branch: input.invocation.branch } : {}),
     ...(input.invocation.worktree !== undefined ? { worktree: input.invocation.worktree } : {}),
   }

package/src/main.ts

@@ -313,7 +313,10 @@ const send = program
   .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>', 'opaque exact-session override (env: NOTIFAI_SESSION_ID)')
-  .option('--session-label <text>', 'human session label override (env: NOTIFAI_SESSION_LABEL)')
+  .option(
+    '--session-label <text>',
+    'first human session name, frozen locally (env: NOTIFAI_SESSION_LABEL)',
+  )
   .option('--event <event>', 'agent event name, e.g. tests_passed')
   .optionsGroup(SEND_GROUP.presentation)
   .option('--collapse-key <key>', 'replace earlier notifications with the same key')
@@ -445,7 +448,10 @@ program
   )
   .option('--project <id>', 'project identifier override (otherwise configured or inferred)')
   .option('--session-id <id>', 'opaque exact-session override (env: NOTIFAI_SESSION_ID)')
-  .option('--session-label <text>', 'human session label override (env: NOTIFAI_SESSION_LABEL)')
+  .option(
+    '--session-label <text>',
+    'first human session name, frozen locally (env: NOTIFAI_SESSION_LABEL)',
+  )
   .action(async (question: string | undefined, opts: {
     choice?: string[]
     multi?: boolean

package/src/opencode-plugin.ts

@@ -31,7 +31,7 @@ export const OPENCODE_PLUGIN_MARKER = '// notifai managed opencode plugin'
 export const OPENCODE_PLUGIN_FILENAME = 'notifai.js'
 
 /** Bump when an installed generated file must be rewritten to remain functional. */
-const OPENCODE_ADAPTER_VERSION = 6
+const OPENCODE_ADAPTER_VERSION = 8
 
 export function opencodePluginDir(
   global: boolean,
@@ -103,6 +103,8 @@ import { spawn } from "node:child_process"
 ${nodeConstant}const ADAPTER = ${JSON.stringify(adapterPath)}
 const TIMEOUT_MS = ${timeoutSeconds * 1000}
 const ADAPTER_VERSION = ${OPENCODE_ADAPTER_VERSION}
+const PENDING_SESSION_TITLE =
+  /^New session(?: *- *[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}(?:[.][0-9]+)?Z)?$/i
 
 /**
  * Runs \`notifai hook <event>\`, feeding it the same JSON envelope the other
@@ -152,16 +154,29 @@ function runHook(event, envelope) {
   })
 }
 
-export const NotifAIPlugin = async ({ directory }) => {
+export const NotifAIPlugin = async ({ directory, client }) => {
   const cwd = typeof directory === "string" && directory.length > 0 ? directory : process.cwd()
 
   return {
-    /** Exact active-harness identity for shell commands such as \`notifai ask\`. */
+    /** Exact active-harness identity and first-party title for agent shell commands. */
     "shell.env": async (input, output) => {
       output.env.NOTIFAI_ACTIVE_HARNESS = "opencode"
       const sessionID = input?.sessionID
       if (typeof sessionID === "string" && sessionID.length > 0) {
         output.env.NOTIFAI_ACTIVE_SESSION_ID = sessionID
+        try {
+          const response = await client.session.get({ path: { id: sessionID } })
+          const title = response?.data?.title
+          if (typeof title === "string" && title.trim().length > 0) {
+            if (PENDING_SESSION_TITLE.test(title.trim())) {
+              output.env.NOTIFAI_ACTIVE_SESSION_LABEL_PENDING = "1"
+            } else {
+              output.env.NOTIFAI_ACTIVE_SESSION_LABEL = title
+            }
+          }
+        } catch {
+          // Identity remains useful when this OpenCode build cannot expose a title.
+        }
       }
     },