@raidiant/notifai 5.0.0 → 7.0.0

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/logging.test.ts

@@ -418,14 +418,27 @@ describe('reading', () => {
     expect(records.length).toBeGreaterThan(lines(env).filter((r) => r.event === 'cli.end').length)
   })
 
-  it('skips a damaged line instead of throwing away the file', () => {
+  it('skips damaged and unknown-future lines without throwing away the file', () => {
     const env = sandbox()
     seed(env)
     // A half-written line is what a crashed process leaves behind, and a
     // reader that dies on it loses every good record around it.
     appendFileSync(activeLogPath(env), '{"v":1,"ts":"2026-0\n')
     appendFileSync(activeLogPath(env), 'not json at all\n')
-    expect(readLogRecords(env).records).toHaveLength(3)
+    appendFileSync(
+      activeLogPath(env),
+      `${JSON.stringify({
+        v: LOG_SCHEMA_VERSION + 1,
+        ts: '2026-08-18T12:00:00.000Z',
+        level: 'info',
+        event: 'future.event',
+      })}\n`,
+    )
+    expect(readLogRecords(env).records.map((record) => record.event)).toEqual([
+      'send.submitted',
+      'cli.error',
+      'ask.registered',
+    ])
   })
 
   it('reports nothing at all rather than failing when there is no log', () => {

package/src/logging.ts

@@ -534,6 +534,7 @@ function isRecord(parsed: unknown): parsed is LogRecord {
   return (
     typeof parsed === 'object' &&
     parsed !== null &&
+    (parsed as { v?: unknown }).v === LOG_SCHEMA_VERSION &&
     typeof (parsed as { event?: unknown }).event === 'string' &&
     typeof (parsed as { ts?: unknown }).ts === 'string'
   )

package/src/main.ts

@@ -313,13 +313,16 @@ 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')
   .option('--thread-id <id>', 'group related notifications')
   .option('--ttl <seconds>', 'delivery window in seconds', (v: string) => Number(v))
-  .option('--platform <platform>', 'limit optional fields to ios or macos (default: both)')
+  .option('--platform <platform>', 'limit optional fields to one supported platform')
   .optionsGroup(SEND_GROUP.reply)
   .option('--reply', 'enable the inline reply action and block for the answer')
   .option('--reply-timeout <seconds>', 'how long to wait for a reply (default: 900)', (v: string) => Number(v))
@@ -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/readiness.ts

@@ -57,8 +57,10 @@ export interface ReadinessState {
   /** Human words for what this is, not the field name. */
   title: string
   status: StateStatus
-  /** The current condition, phrased so it reads under either renderer. */
+  /** The current condition, phrased for the human renderer. */
   detail: string
+  /** Structured diagnostics emitted only by --json / non-human surfaces. */
+  technical?: unknown
   remedy?: Remedy
 }