@raidiant/notifai 9.1.0 → 9.2.0

package/src/commands-hooks.ts

@@ -30,14 +30,13 @@ import {
 } from './hook-adapter.js'
 import {
   clearAcknowledgementObligation,
-  claimPromptActivation,
   claimCursorStopActivation,
   confirmCursorStopActivation,
   dropPendingQuestion,
   handleSessionEnd,
   handleStop,
   handleUserPromptSubmit,
-  markSessionActivation,
+  recordSessionStart,
   parkForRetirement,
   parseHookInput,
   pruneAbandonedSessions,
@@ -254,14 +253,6 @@ export async function hookRunCommand(
   const cwd = envelope.cwd ?? deps.cwd
   const sessionEnd = hookDefersDiagnosticsUntilAfterCleanup(event)
   logger.bind({ session: envelope.session_id ?? null })
-  const declaredSourcePid = declaredHookSourcePid(deps)
-  const activationOwnerPid =
-    harness === 'claude-code'
-      ? (deps.claudeSourcePid ?? declaredSourcePid ?? claudeSessionPid(deps.env))
-      : harness === 'codex'
-        ? (deps.codexSourcePid ?? declaredSourcePid ?? process.ppid)
-        : undefined
-
   // 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.
@@ -285,22 +276,14 @@ export async function hookRunCommand(
       deps.env,
     )
     if (stdout !== undefined) deps.io.out(stdout)
-    if (
-      stdout !== undefined &&
-      event === 'session-start' &&
-      activationOwnerPid !== undefined &&
-      envelope.session_id !== undefined
-    ) {
+    if (event === 'session-start' && envelope.session_id !== undefined) {
       try {
-        // Write stdout first. If the process dies between these operations a
-        // later prompt may duplicate context, but it cannot suppress context
-        // that the host never received.
-        markSessionActivation(envelope.session_id, deps.env, now(), activationOwnerPid, harness, cwd)
+        recordSessionStart(envelope.session_id, deps.env, harness, cwd)
       } catch (err) {
         logger.error('hook.end', {
           hook: event,
-          outcome: 'mark-failed',
-          reason: 'activation-state-failed',
+          outcome: 'record-failed',
+          reason: 'session-state-failed',
           ...failureData(err),
         })
       }
@@ -313,33 +296,6 @@ export async function hookRunCommand(
     return EXIT.ok
   }
 
-  // SessionStart is the preferred model-visible activation seam. A few
-  // managed hosts regenerate older hook definitions that retain
-  // UserPromptSubmit but omit newer lifecycle events. Claim the first prompt
-  // once per exact session as a compatibility fallback, before config/auth/
-  // device/network work, and stay silent when SessionStart already ran.
-  let promptActivationStdout: string | undefined
-  if (
-    event === 'user-prompt-submit' &&
-    (harness === 'claude-code' || harness === 'codex') &&
-    activationOwnerPid !== undefined &&
-    envelope.session_id !== undefined
-  ) {
-    try {
-      if (claimPromptActivation(envelope.session_id, deps.env, now(), activationOwnerPid, harness, cwd)) {
-        promptActivationStdout = sessionActivationOutput(harness, 'UserPromptSubmit', cwd, deps.env)
-        if (promptActivationStdout !== undefined) deps.io.out(promptActivationStdout)
-      }
-    } catch (err) {
-      logger.error('hook.end', {
-        hook: event,
-        outcome: 'claim-failed',
-        reason: 'activation-state-failed',
-        ...failureData(err),
-      })
-    }
-  }
-
   // Cursor has a confirmed host bug in which sessionStart.additional_context
   // is accepted but never reaches the model. A native Stop follow-up is the
   // host's guaranteed model-visible channel. Claim it once per conversation,
@@ -443,7 +399,6 @@ export async function hookRunCommand(
         hook: event,
         outcome: 'failed',
         reason: 'config-failed',
-        ...(promptActivationStdout === undefined ? {} : { activation: 'context-added' }),
         ...failureData(err),
       })
       for (const line of describeHookFailure(err)) deps.io.err(`notifai: ${line}`)
@@ -547,10 +502,7 @@ export async function hookRunCommand(
     const notes = outcome.notes.filter((note) => !/^(?:late )?answer from /.test(note))
     logger.info('hook.end', {
       hook: event,
-      // Stop stdout takes over the turn. UserPromptSubmit stdout may instead
-      // add context to the user's own turn, which is explicitly non-decisive.
       decided: outcome.decided ?? outcome.stdout !== undefined,
-      ...(promptActivationStdout === undefined ? {} : { activation: 'context-added' }),
       ...(notes.length === 0 ? {} : { notes }),
       ...outcome.log,
     })

package/src/commands.test.ts

@@ -3277,13 +3277,13 @@ describe('stable hook installation', () => {
     ).toBe(EXIT.ok)
     const globalFile = settingsFile('opencode', true, cwd, env)
     const current = readFileSync(globalFile, 'utf8')
-    writeFileSync(globalFile, current.replace('const ADAPTER_VERSION = 11', 'const ADAPTER_VERSION = 10'))
+    writeFileSync(globalFile, current.replace('const ADAPTER_VERSION = 12', 'const ADAPTER_VERSION = 11'))
 
     io.outLines = []
     expect(hooksInstallCommand(deps, { harness: 'opencode', execPath, scriptPath })).toBe(EXIT.ok)
     expect(existsSync(path.join(cwd, '.opencode', 'plugins', 'notifai.js'))).toBe(false)
     const refreshed = readFileSync(globalFile, 'utf8')
-    expect(refreshed).toContain('const ADAPTER_VERSION = 11')
+    expect(refreshed).toContain('const ADAPTER_VERSION = 12')
     expect(refreshed).toContain('experimental.chat.system.transform')
     expect(io.outLines.join('\n')).toMatch(/Installed opencode hooks/)
   })

package/src/hooks.test.ts

@@ -2855,7 +2855,7 @@ describe('session-start hook', () => {
 })
 
 describe('user-prompt-submit hook', () => {
-  it('activates once as a compatibility fallback when SessionStart was absent', async () => {
+  it('stays silent when SessionStart was absent while preserving prompt lifecycle', async () => {
     const h = harness()
 
     await hookRunCommand(
@@ -2865,136 +2865,10 @@ describe('user-prompt-submit hook', () => {
       'claude-code',
     )
 
-    expect(h.io.outLines).toHaveLength(1)
-    expect(JSON.parse(h.io.outLines[0] ?? '{}')).toMatchObject({
-      hookSpecificOutput: {
-        hookEventName: 'UserPromptSubmit',
-        additionalContext: expect.stringMatching(/Notifai.*session/i),
-      },
-    })
-    expect(readSessionState('presence-only', h.env).last_prompt_at).toBe(NOW)
-
-    await hookRunCommand(
-      h.deps,
-      'user-prompt-submit',
-      stdin({ session_id: 'presence-only' }),
-      'claude-code',
-    )
-    expect(h.io.outLines).toHaveLength(1)
-  })
-
-  it('stays silent when SessionStart already delivered activation', async () => {
-    const h = harness()
-    h.deps.codexSourcePid = 4242
-
-    await hookRunCommand(
-      h.deps,
-      'session-start',
-      stdin({ session_id: 'lifecycle-owned' }),
-      'codex',
-    )
-    h.io.outLines = []
-
-    await hookRunCommand(
-      h.deps,
-      'user-prompt-submit',
-      stdin({ session_id: 'lifecycle-owned' }),
-      'codex',
-    )
-
     expect(h.io.outLines).toEqual([])
-  })
-
-  it('reactivates a resumed session owned by a new harness process', async () => {
-    const h = harness()
-    h.deps.codexSourcePid = 4242
-    await hookRunCommand(
-      h.deps,
-      'session-start',
-      stdin({ session_id: 'resumed-owner' }),
-      'codex',
-    )
-    h.io.outLines = []
-    h.deps.codexSourcePid = 4343
-
-    await hookRunCommand(
-      h.deps,
-      'user-prompt-submit',
-      stdin({ session_id: 'resumed-owner' }),
-      'codex',
-    )
-
-    expect(JSON.parse(h.io.outLines[0] ?? '{}')).toMatchObject({
-      hookSpecificOutput: { hookEventName: 'UserPromptSubmit' },
-    })
-  })
-
-  it('uses the adapter-propagated harness owner across per-hook CLI processes', async () => {
-    const h = harness()
-    h.env['NOTIFAI_HOOK_SOURCE_PID'] = '5252'
-
-    await hookRunCommand(
-      h.deps,
-      'user-prompt-submit',
-      stdin({ session_id: 'adapter-owned' }),
-      'codex',
-    )
-    h.io.outLines = []
-    await hookRunCommand(
-      h.deps,
-      'user-prompt-submit',
-      stdin({ session_id: 'adapter-owned' }),
-      'codex',
-    )
-    expect(h.io.outLines).toEqual([])
-
-    h.env['NOTIFAI_HOOK_SOURCE_PID'] = '5353'
-    await hookRunCommand(
-      h.deps,
-      'user-prompt-submit',
-      stdin({ session_id: 'adapter-owned' }),
-      'codex',
-    )
-    expect(h.io.outLines).toHaveLength(1)
-  })
-
-  it('does not let a worker lifecycle suppress parent prompt activation', async () => {
-    const h = harness()
-    h.deps.codexSourcePid = 4242
-    await hookRunCommand(
-      h.deps,
-      'subagent-start',
-      stdin({ session_id: 'shared-parent-worker' }),
-      'codex',
-    )
-    h.io.outLines = []
-
-    await hookRunCommand(
-      h.deps,
-      'user-prompt-submit',
-      stdin({ session_id: 'shared-parent-worker' }),
-      'codex',
-    )
-
-    expect(JSON.parse(h.io.outLines[0] ?? '{}')).toMatchObject({
-      hookSpecificOutput: { hookEventName: 'UserPromptSubmit' },
-    })
-  })
-
-  it('activates before config and authentication readiness', async () => {
-    const h = harness()
-    h.deps.cwd = path.join(h.deps.cwd, 'missing-project')
-    h.deps.store.load = () => null
-
-    await hookRunCommand(
-      h.deps,
-      'user-prompt-submit',
-      stdin({ session_id: 'first-run', cwd: h.deps.cwd }),
-      'codex',
-    )
-
-    expect(JSON.parse(h.io.outLines[0] ?? '{}')).toMatchObject({
-      hookSpecificOutput: { hookEventName: 'UserPromptSubmit' },
+    expect(readSessionState('presence-only', h.env)).toEqual({
+      harness: 'claude-code',
+      last_prompt_at: NOW,
     })
   })
 

package/src/hooks.ts

@@ -90,10 +90,6 @@ export interface SessionState {
   harness?: HookHarness
   /** Checkout whose hook definition activated this session; lifecycle diagnostics only. */
   activation_cwd?: string
-  /** Model-visible proactive context already emitted for this harness session. */
-  activation_context_emitted_at?: number
-  /** Harness process that received it; a resumed session has a new owner. */
-  activation_context_owner_pid?: number
   /** Cursor's documented session context path is lossy; bounded first-Stop fallback journal. */
   cursor_activation_claimed_at?: number
   cursor_activation_confirmed_at?: number
@@ -547,12 +543,10 @@ function updateSessionState(
   })
 }
 
-/** Record a lifecycle activation so the first-prompt compatibility path stays silent. */
-export function markSessionActivation(
+/** Record the current installation when an owner session starts. */
+export function recordSessionStart(
   sessionId: string,
   env: NodeJS.ProcessEnv,
-  now: number,
-  ownerPid: number,
   harness?: HookHarness,
   cwd?: string,
 ): void {
@@ -560,46 +554,9 @@ export function markSessionActivation(
     ...current,
     ...(harness === undefined ? {} : { harness }),
     ...(cwd === undefined ? {} : { activation_cwd: current.activation_cwd ?? cwd }),
-    activation_context_emitted_at: now,
-    activation_context_owner_pid: ownerPid,
   }))
 }
 
-/**
- * Atomically own first-prompt activation only when no lifecycle hook did.
- *
- * Some managed hosts preserve UserPromptSubmit while regenerating away newer
- * SessionStart definitions. This is a compatibility seam, not the primary
- * lifecycle: one session gets at most one model-visible activation from it.
- */
-export function claimPromptActivation(
-  sessionId: string,
-  env: NodeJS.ProcessEnv,
-  now: number,
-  ownerPid: number,
-  harness?: HookHarness,
-  cwd?: string,
-): boolean {
-  let claimed = false
-  updateSessionState(sessionId, env, (current) => {
-    if (
-      current.activation_context_emitted_at !== undefined &&
-      current.activation_context_owner_pid === ownerPid
-    ) {
-      return current
-    }
-    claimed = true
-    return {
-      ...current,
-      ...(harness === undefined ? {} : { harness }),
-      ...(cwd === undefined ? {} : { activation_cwd: current.activation_cwd ?? cwd }),
-      activation_context_emitted_at: now,
-      activation_context_owner_pid: ownerPid,
-    }
-  })
-  return claimed
-}
-
 /** Atomically claim Cursor's first-Stop activation fallback once per conversation. */
 export function claimCursorStopActivation(
   sessionId: string,

package/src/install-hooks.test.ts

@@ -21,7 +21,10 @@ import {
   opencodePluginSource,
   opencodePluginTarget,
 } from './opencode-plugin.js'
-import { MISSING_LIFECYCLE_GUIDANCE_CONTEXT } from './session-activation.js'
+import {
+  MISSING_LIFECYCLE_GUIDANCE_CONTEXT,
+  WORKER_ACTIVATION_CONTEXT,
+} from './session-activation.js'
 import { hookAdapterPath, installHookAdapter } from './hook-adapter.js'
 import {
   BLOCKING_STOP_TIMEOUT_SECONDS,
@@ -196,8 +199,9 @@ describe('hook config', () => {
     })
   })
 
-  it('leaves exactly one handler per event when an old blocking shape is reinstalled over', () => {
+  it('restores missing SessionStart exactly once when an old owned shape is reinstalled over', () => {
     const old = mergeHooks({}, buildHookConfig({ adapterPath: ADAPTER }), SCRIPT)
+    delete old.document.hooks?.['SessionStart']
     const migrated = mergeHooks(
       old.document,
       buildHookConfig({ adapterPath: ADAPTER, harness: 'claude-code' }),
@@ -214,7 +218,6 @@ describe('hook config', () => {
     })
     expect(migrated.replaced.sort()).toEqual([
       'SessionEnd',
-      'SessionStart',
       'Stop',
       'SubagentStart',
       'UserPromptSubmit',
@@ -882,32 +885,54 @@ describe('the OpenCode adapter', () => {
     expect(source).not.toContain('"permission.ask"')
   })
 
-  it('adds session activation through OpenCode system context without setup or network', async () => {
+  it('classifies OpenCode parent, child, lookup failure, and missing identity safely', async () => {
     expect(source).toContain('"experimental.chat.system.transform"')
     const generated = (await import(
       `data:text/javascript;base64,${Buffer.from(source).toString('base64')}`
     )) as {
-      NotifAIPlugin(input: { directory: string; client: object }): Promise<{
+      NotifAIPlugin(input: {
+        directory: string
+        client: {
+          session: {
+            get(input: { path: { id: string } }): Promise<{ data: object }>
+          }
+        }
+      }): Promise<{
         'experimental.chat.system.transform'?: (
-          input: object,
+          input: { sessionID?: string },
           output: { system: string[] },
         ) => Promise<void>
       }>
     }
-    const plugin = await generated.NotifAIPlugin({ directory: '/repo', client: {} })
-    const output = { system: ['existing context'] }
+    const plugin = await generated.NotifAIPlugin({
+      directory: '/repo',
+      client: {
+        session: {
+          get: async ({ path: { id } }) => {
+            if (id === 'ses_parent') return { data: { id } }
+            if (id === 'ses_child') return { data: { id, parentID: 'ses_parent' } }
+            throw new Error('relationship lookup unavailable')
+          },
+        },
+      },
+    })
+    const parent = { system: ['existing context'] }
+
+    await plugin['experimental.chat.system.transform']?.({ sessionID: 'ses_parent' }, parent)
 
-    await plugin['experimental.chat.system.transform']?.({ sessionID: 'ses_1' }, output)
+    expect(parent.system).toEqual([`existing context\n\n${MISSING_LIFECYCLE_GUIDANCE_CONTEXT}`])
 
-    expect(output.system).toEqual([`existing context\n\n${MISSING_LIFECYCLE_GUIDANCE_CONTEXT}`])
+    const child = { system: [] as string[] }
+    await plugin['experimental.chat.system.transform']?.({ sessionID: 'ses_child' }, child)
+    expect(child.system).toEqual([WORKER_ACTIVATION_CONTEXT])
 
-    const internal = { system: ['internal agent-generation context'] }
-    await plugin['experimental.chat.system.transform']?.({}, internal)
-    expect(internal.system).toEqual(['internal agent-generation context'])
+    const lookupFailure = { system: [] as string[] }
+    await plugin['experimental.chat.system.transform']?.({ sessionID: 'ses_unknown' }, lookupFailure)
+    expect(lookupFailure.system).toEqual([WORKER_ACTIVATION_CONTEXT])
 
-    const empty = { system: [] as string[] }
-    await plugin['experimental.chat.system.transform']?.({ sessionID: 'ses_2' }, empty)
-    expect(empty.system).toEqual([MISSING_LIFECYCLE_GUIDANCE_CONTEXT])
+    const missingIdentity = { system: ['internal agent-generation context'] }
+    await plugin['experimental.chat.system.transform']?.({}, missingIdentity)
+    expect(missingIdentity.system).toEqual(['internal agent-generation context'])
   })
 
   it('publishes the session pointer on a user message without injecting content', () => {

package/src/opencode-plugin.ts

@@ -1,7 +1,10 @@
 import path from 'node:path'
 import { hookHostPlatform, type HookHostPlatform } from './hook-adapter.js'
 import { configHome } from './install-hooks.js'
-import { MISSING_LIFECYCLE_GUIDANCE_CONTEXT } from './session-activation.js'
+import {
+  MISSING_LIFECYCLE_GUIDANCE_CONTEXT,
+  WORKER_ACTIVATION_CONTEXT,
+} from './session-activation.js'
 
 /**
  * The OpenCode adapter.
@@ -32,7 +35,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 = 11
+const OPENCODE_ADAPTER_VERSION = 12
 
 export function opencodePluginDir(
   global: boolean,
@@ -105,6 +108,7 @@ ${nodeConstant}const ADAPTER = ${JSON.stringify(adapterPath)}
 const TIMEOUT_MS = ${timeoutSeconds * 1000}
 const ADAPTER_VERSION = ${OPENCODE_ADAPTER_VERSION}
 const MISSING_LIFECYCLE_GUIDANCE_CONTEXT = ${JSON.stringify(MISSING_LIFECYCLE_GUIDANCE_CONTEXT)}
+const WORKER_ACTIVATION_CONTEXT = ${JSON.stringify(WORKER_ACTIVATION_CONTEXT)}
 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
 
@@ -166,14 +170,29 @@ export const NotifAIPlugin = async ({ directory, client }) => {
       const sessionID = input?.sessionID
       if (typeof sessionID !== "string" || sessionID.length === 0) return
       if (activated.has(sessionID)) return
-      const resolved = await runHook("session-start", {
+      // OpenCode represents delegated work as child sessions. Missing or
+      // malformed relationship data must fail closed as worker context: it is
+      // safe to suppress a notification, never safe to let a child duplicate
+      // its parent's User-visible request.
+      let worker = true
+      try {
+        const response = await client.session.get({ path: { id: sessionID } })
+        const session = response?.data
+        if (session !== null && typeof session === "object") {
+          worker = typeof session.parentID === "string" && session.parentID.length > 0
+        }
+      } catch {
+        // Keep the safe worker classification.
+      }
+      const hookEventName = worker ? "SubagentStart" : "SessionStart"
+      const resolved = await runHook(worker ? "subagent-start" : "session-start", {
         session_id: sessionID,
         cwd,
-        hook_event_name: "SessionStart",
+        hook_event_name: hookEventName,
       })
       const context = typeof resolved === "string" && resolved.trim().length > 0
         ? resolved.trim()
-        : MISSING_LIFECYCLE_GUIDANCE_CONTEXT
+        : worker ? WORKER_ACTIVATION_CONTEXT : MISSING_LIFECYCLE_GUIDANCE_CONTEXT
       if (output.system.length === 0) {
         output.system.push(context)
       } else {

package/src/session-activation.ts

@@ -8,7 +8,7 @@ const ROOT_OWNERSHIP =
   'The root agent owns User-visible Notification Requests unless it explicitly delegates that ownership; workers report Agent Events to the parent.'
 
 export const WORKER_ACTIVATION_CONTEXT =
-  'Notifai worker context: report Agent Events to the parent; do not send User-visible Notification Requests unless the parent explicitly delegated that ownership. If delegated, run `notifai guidance` before composing one.'
+  'Notifai worker context: report Agent Events to the parent; do not send User-visible Notification Requests unless the parent explicitly delegated that ownership. If delegated, load the Notifai skill and run `notifai guidance` before composing one.'
 
 export const MISSING_LIFECYCLE_GUIDANCE_CONTEXT =
   'Notifai is active, but lifecycle guidance could not be loaded. Run `notifai guidance` once before deciding whether or how to send a Notification Request.'
@@ -25,7 +25,7 @@ function rootActivationContext(cwd: string, env: NodeJS.ProcessEnv): string {
 /** One lifecycle meaning, encoded for each harness output contract. */
 export function sessionActivationOutput(
   harness: HookHarness | undefined,
-  hookEventName: 'SessionStart' | 'SubagentStart' | 'UserPromptSubmit',
+  hookEventName: 'SessionStart' | 'SubagentStart',
   cwd: string = process.cwd(),
   env: NodeJS.ProcessEnv = process.env,
 ): string | undefined {

package/src/skill.test.ts

@@ -47,21 +47,22 @@ const section = (heading: string): string => {
 }
 
 describe('Notifai agent skill', () => {
-  it('routes proactively in ordinary sessions without waiting for the user to name Notifai', () => {
+  it('routes proactively in owner sessions without turning ordinary workers into senders', () => {
     // The frontmatter description is the only skill text available during
-    // automatic selection. If the ordinary-session trigger lives only in the
-    // body, agents doing unrelated work never load it and therefore never see
-    // the completion rule.
-    expect(description).toMatch(/every agent session/i)
-    expect(description).toMatch(/even when the user does not mention Notifai/i)
+    // automatic selection. It must select parent owners and workers given
+    // explicit delegation without selecting every ordinary worker.
+    expect(description).toMatch(/every agent session that owns User-visible Notification Requests/i)
+    expect(description).toMatch(/parent owns by default/i)
+    expect(description).toMatch(/worker only when ownership is explicitly delegated/i)
+    expect(description).toMatch(/even when the user does not mention (?:Notifai|it)/i)
     expect(description).toMatch(/guidance/i)
 
     const decide = section('## Decide whether to notify')
-    expect(decide).toMatch(/lifecycle context normally includes.*effective guidance/is)
+    expect(decide).toMatch(/owner session lifecycle context normally includes.*effective\s+guidance/is)
     expect(decide).toMatch(/context is absent.*read it once before judging an Agent\s+Event/is)
-    expect(decide).toMatch(/parent owns User-visible Notification Requests/i)
-    expect(decide).toMatch(/unless\s+it explicitly delegates/i)
-    expect(decide).toMatch(/workers[\s\S]{0,100}do not send independently/i)
+    expect(decide).toMatch(/parent owns by default/i)
+    expect(decide).toMatch(/explicit textual\s+delegation makes a worker the owner/i)
+    expect(decide).toMatch(/ordinary workers[\s\S]{0,100}do not load or send/i)
   })
 
   it('preserves the original Agent Event across setup and ambiguous delivery', () => {