@raidiant/notifai 6.0.0 → 7.0.1

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.
+        }
       }
     },
 

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

@@ -0,0 +1,95 @@
+import { describe, expect, it } from 'vitest'
+import { readOrcaSessionTitle, type OrcaCommand } from './orca-session-title.js'
+
+const worktreeId = 'repo-123::/worktrees/semantic-session-implementation'
+
+function response(overrides: Record<string, unknown> = {}): string {
+  return JSON.stringify({
+    ok: true,
+    result: {
+      worktree: {
+        id: worktreeId,
+        path: '/worktrees/semantic-session-implementation',
+        displayName: 'Worker - semantic session implementation',
+        ...overrides,
+      },
+    },
+  })
+}
+
+describe('Orca semantic session title', () => {
+  it('accepts only the display name returned for the exact managed worktree', () => {
+    const calls: { executable: string; args: readonly string[] }[] = []
+    const command: OrcaCommand = (executable, args) => {
+      calls.push({ executable, args })
+      return response()
+    }
+
+    expect(
+      readOrcaSessionTitle(
+        { TERM_PROGRAM: 'Orca', ORCA_WORKTREE_ID: worktreeId },
+        command,
+      ),
+    ).toBe('Worker - semantic session implementation')
+    expect(calls).toEqual([
+      {
+        executable: 'orca',
+        args: ['worktree', 'show', '--worktree', `id:${worktreeId}`, '--json'],
+      },
+    ])
+  })
+
+  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) => {
+    expect(
+      readOrcaSessionTitle(
+        { TERM_PROGRAM: 'Orca', ORCA_WORKTREE_ID: worktreeId },
+        command,
+      ),
+    ).toBeUndefined()
+  })
+})

package/src/orca-session-title.ts

@@ -0,0 +1,105 @@
+import { execFileSync } from 'node:child_process'
+import path from 'node:path'
+
+export type OrcaSessionTitleLookup = (env: NodeJS.ProcessEnv) => string | undefined
+export type OrcaCommand = (executable: string, args: readonly string[]) => string | null
+
+const runOrcaCommand: OrcaCommand = (executable, args) => {
+  try {
+    return execFileSync(executable, args, {
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+      timeout: 2_000,
+      maxBuffer: 512 * 1024,
+      windowsHide: true,
+    }).trim()
+  } catch {
+    return null
+  }
+}
+
+function containsControlCharacter(value: string): boolean {
+  return Array.from(value).some((character) => {
+    const codePoint = character.codePointAt(0) ?? 0
+    return codePoint < 32 || codePoint === 127
+  })
+}
+
+function worktreePathFromId(value: string): string | 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)
+  const worktreePath = value.slice(separator + 2)
+  if (!/^[A-Za-z0-9._-]+$/u.test(repoId) || worktreePath.length === 0) return null
+  return path.posix.isAbsolute(worktreePath) || path.win32.isAbsolute(worktreePath)
+    ? worktreePath
+    : null
+}
+
+function orcaExecutable(env: NodeJS.ProcessEnv): string | null {
+  const configured = env['ORCA_CLI_COMMAND']?.trim()
+  if (configured !== undefined && configured.length > 0) {
+    return containsControlCharacter(configured) ? null : configured
+  }
+  return env['ORCA_DEV_REPO_ROOT'] === undefined ? 'orca' : 'orca-dev'
+}
+
+/**
+ * Read the semantic display 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.
+ */
+export function readOrcaSessionTitle(
+  env: NodeJS.ProcessEnv,
+  command: OrcaCommand = runOrcaCommand,
+): string | undefined {
+  if (env['TERM_PROGRAM'] !== 'Orca') return undefined
+  const worktreeId = env['ORCA_WORKTREE_ID']
+  if (worktreeId === undefined) return undefined
+  const expectedPath = worktreePathFromId(worktreeId)
+  if (expectedPath === null) return undefined
+  const executable = orcaExecutable(env)
+  if (executable === null) return undefined
+
+  let output: string | null
+  try {
+    output = command(executable, [
+      'worktree',
+      'show',
+      '--worktree',
+      `id:${worktreeId}`,
+      '--json',
+    ])
+  } catch {
+    return undefined
+  }
+  if (output === null || output === '') return undefined
+
+  let parsed: unknown
+  try {
+    parsed = JSON.parse(output)
+  } catch {
+    return undefined
+  }
+  if (typeof parsed !== 'object' || parsed === null) return undefined
+  const response = parsed as {
+    ok?: unknown
+    result?: { worktree?: { id?: unknown; path?: unknown; displayName?: unknown } }
+  }
+  const worktree = response.result?.worktree
+  if (
+    response.ok !== true ||
+    worktree?.id !== worktreeId ||
+    worktree.path !== expectedPath ||
+    typeof worktree.displayName !== 'string' ||
+    worktree.displayName.trim().length === 0
+  ) {
+    return undefined
+  }
+  return worktree.displayName
+}