@raidiant/notifai 10.0.0 → 10.1.1

package/src/commands.ts

@@ -1,6 +1,7 @@
 export {
   EXIT,
   log,
+  updateCliCommand,
   type CommandDeps,
   type CommandIo,
   type CommandSpinner,
@@ -63,6 +64,7 @@ export {
   type SetupScope,
 } from './commands-init.js'
 export { assessReadiness, doctorCommand } from './commands-doctor.js'
+export { cliUpdateCommand, type CliUpdateFlags } from './commands-update.js'
 export {
   projectDisableCommand,
   projectEnableCommand,

package/src/fixtures/openclaw-2026.7.1-2-agent-local.json

@@ -0,0 +1,57 @@
+{
+  "vendor": "openclaw/openclaw",
+  "release": "2026.7.1-2",
+  "commit": "0790d9f",
+  "instance": {
+    "harness": "openclaw",
+    "surface": "agent-local",
+    "execHost": "gateway"
+  },
+  "durableSessionKey": "agent:main:probe-owner",
+  "rotatingSessionId": "ae6686a4-d632-4750-b73b-56faec5fff9a",
+  "observedPluginEnv": {
+    "NOTIFAI_ACTIVE_HARNESS": "openclaw",
+    "NOTIFAI_ACTIVE_SESSION_ID": "agent:main:probe-owner"
+  },
+  "worker": {
+    "sessionKeySubstring": ":subagent:",
+    "provedSessionKey": "agent:main:subagent:probe-worker",
+    "missingIdentity": "fail-closed-worker"
+  },
+  "hooks": {
+    "proven": {
+      "activation": "before_prompt_build",
+      "stop": "agent_end",
+      "execMarkers": "resolve_exec_env"
+    },
+    "unprovenOnThisSurface": {
+      "presence": "message_received",
+      "sessionEnd": "session_end"
+    }
+  },
+  "evidence": {
+    "nativeHostOs": "macos",
+    "command": "openclaw agent --local",
+    "nativeOsUnrun": ["linux", "windows"]
+  },
+  "supported": [
+    "managed-setup",
+    "lifecycle-activation",
+    "source-context-from-session-key"
+  ],
+  "unsupported": [
+    "question-routing",
+    "command-stop-as-turn-end",
+    "2026.2.26-cli"
+  ],
+  "deferred": [
+    "gateway-embedded",
+    "gateway-remote",
+    "agent-exec",
+    "acp-nested",
+    "exec-sandbox",
+    "exec-node",
+    "native-linux",
+    "native-windows"
+  ]
+}

package/src/harness-integration.test.ts

@@ -210,3 +210,85 @@ describe('Hermes classic CLI/local Source Context seam', () => {
     )
   })
 })
+
+describe('OpenClaw agent-local Source Context seam', () => {
+  const PINNED_OPENCLAW = JSON.parse(
+    readFileSync(new URL('./fixtures/openclaw-2026.7.1-2-agent-local.json', import.meta.url), 'utf8'),
+  ) as {
+    durableSessionKey: string
+    rotatingSessionId: string
+    observedPluginEnv: { NOTIFAI_ACTIVE_HARNESS: 'openclaw'; NOTIFAI_ACTIVE_SESSION_ID: string }
+    instance: { harness: 'openclaw'; surface: 'agent-local'; execHost: 'gateway' }
+    hooks: {
+      proven: { activation: string; stop: string; execMarkers: string }
+      unprovenOnThisSurface: { presence: string; sessionEnd: string }
+    }
+    deferred: string[]
+  }
+
+  it('pins only the probed agent-local surface, not Gateway-embedded', () => {
+    expect(PINNED_OPENCLAW.instance).toEqual({
+      harness: 'openclaw',
+      surface: 'agent-local',
+      execHost: 'gateway',
+    })
+    expect(PINNED_OPENCLAW.durableSessionKey).toBe('agent:main:probe-owner')
+    expect(PINNED_OPENCLAW.observedPluginEnv.NOTIFAI_ACTIVE_SESSION_ID).toBe(
+      PINNED_OPENCLAW.durableSessionKey,
+    )
+    expect(PINNED_OPENCLAW.hooks.proven).toEqual({
+      activation: 'before_prompt_build',
+      stop: 'agent_end',
+      execMarkers: 'resolve_exec_env',
+    })
+    expect(PINNED_OPENCLAW.hooks.unprovenOnThisSurface).toEqual({
+      presence: 'message_received',
+      sessionEnd: 'session_end',
+    })
+    expect(PINNED_OPENCLAW.deferred).toContain('gateway-embedded')
+  })
+
+  it('attributes Source Context to the plugin-injected sessionKey', () => {
+    const env = stateEnv(PINNED_OPENCLAW.observedPluginEnv)
+    const cwd = '/workspace'
+    const active = resolveActiveHarness(env, cwd, Date.now()).active
+    expect(active).toMatchObject({
+      harness: 'openclaw',
+      sessionId: PINNED_OPENCLAW.durableSessionKey,
+    })
+    const built = buildSourceContext({
+      env,
+      invocation: inferInvocationContext(cwd, fixtureGit({})),
+      ...(active === null ? {} : { activeHarness: active }),
+      now: Date.now(),
+    })
+    expect(built).toMatchObject({
+      ok: true,
+      source: {
+        harness: 'openclaw',
+        session_id: PINNED_OPENCLAW.durableSessionKey,
+      },
+    })
+    if (built.ok) {
+      expect(JSON.stringify(built.source)).not.toContain(PINNED_OPENCLAW.rotatingSessionId)
+    }
+  })
+
+  it('treats nested OpenClaw and Claude markers as contested until live evidence exists', () => {
+    const env = stateEnv({
+      ...PINNED_OPENCLAW.observedPluginEnv,
+      CLAUDECODE: '1',
+      CLAUDE_CODE_SESSION_ID: 'claude-orchestrator',
+    })
+    const resolution = resolveActiveHarness(env, '/workspace', 1)
+    expect(resolution.contested.map((candidate) => candidate.harness).sort()).toEqual([
+      'claude-code',
+      'openclaw',
+    ])
+  })
+
+  it('keeps OpenClaw Question Routing unsupported', () => {
+    expect(HARNESS_CAPABILITIES.openclaw.stopContinuation).toBe('unsupported')
+    expect(HARNESS_CAPABILITIES.openclaw.deliveryRoutes).toEqual(['unsupported'])
+  })
+})

package/src/harnesses.test.ts

@@ -34,7 +34,13 @@ describe('harness contract', () => {
   })
 
   it('keeps managed hook installation a strict subset of Source Context', () => {
-    expect(HOOK_INSTALLABLE_HARNESSES).toEqual(['claude-code', 'codex', 'cursor', 'opencode'])
+    expect(HOOK_INSTALLABLE_HARNESSES).toEqual([
+      'claude-code',
+      'codex',
+      'cursor',
+      'opencode',
+      'openclaw',
+    ])
     expect(SOURCE_CONTEXT_HARNESSES).toContain('hermes')
     expect(HOOK_INSTALLABLE_HARNESSES).not.toContain('hermes')
     expect(Object.keys(HARNESS_CAPABILITIES).sort()).toEqual([...HOOK_INSTALLABLE_HARNESSES].sort())
@@ -96,6 +102,8 @@ describe('harness contract', () => {
     })
     expect(HARNESS_CAPABILITIES.opencode.stopContinuation).toBe('unsupported')
     expect(HARNESS_CAPABILITIES.opencode.deliveryRoutes).toEqual(['unsupported'])
+    expect(HARNESS_CAPABILITIES.openclaw.stopContinuation).toBe('unsupported')
+    expect(HARNESS_CAPABILITIES.openclaw.deliveryRoutes).toEqual(['unsupported'])
   })
 
   it('treats the pinned Hermes classic CLI/local trace as send-only', () => {

package/src/harnesses.ts

@@ -1,5 +1,12 @@
 /** Every harness Notifai can name in Source Context when authoritatively known. */
-export const SOURCE_CONTEXT_HARNESSES = ['claude-code', 'codex', 'cursor', 'opencode', 'hermes'] as const
+export const SOURCE_CONTEXT_HARNESSES = [
+  'claude-code',
+  'codex',
+  'cursor',
+  'opencode',
+  'openclaw',
+  'hermes',
+] as const
 
 export type SourceContextHarness = (typeof SOURCE_CONTEXT_HARNESSES)[number]
 
@@ -10,7 +17,13 @@ export type SourceContextHarness = (typeof SOURCE_CONTEXT_HARNESSES)[number]
  * narrower, independently proven cell: Hermes can appear in Source Context
  * without being hook-installable.
  */
-export const HOOK_INSTALLABLE_HARNESSES = ['claude-code', 'codex', 'cursor', 'opencode'] as const
+export const HOOK_INSTALLABLE_HARNESSES = [
+  'claude-code',
+  'codex',
+  'cursor',
+  'opencode',
+  'openclaw',
+] as const
 
 export type HookInstallableHarness = (typeof HOOK_INSTALLABLE_HARNESSES)[number]
 
@@ -23,6 +36,7 @@ export const HARNESS_LABELS: Record<SourceContextHarness, string> = {
   codex: 'Codex',
   cursor: 'Cursor',
   opencode: 'OpenCode',
+  openclaw: 'OpenClaw',
   hermes: 'Hermes',
 }
 
@@ -73,6 +87,13 @@ const OPENCODE_CAPABILITY: HarnessCapability = {
     'no proven answer continuation after session.idle; use a blocking reply command',
 }
 
+const OPENCLAW_CAPABILITY: HarnessCapability = {
+  stopContinuation: 'unsupported',
+  deliveryRoutes: ['unsupported'],
+  deliveryContract:
+    'no proven answer continuation after agent_end; use a blocking reply command',
+}
+
 export const HERMES_QUESTION_ROUTING_UNAVAILABLE: HarnessCapability = {
   stopContinuation: 'unsupported',
   deliveryRoutes: ['unsupported'],
@@ -134,6 +155,7 @@ export const HARNESS_CAPABILITIES: Record<HookInstallableHarness, HarnessCapabil
   codex: CODEX_CAPABILITY,
   cursor: CURSOR_CAPABILITY,
   opencode: OPENCODE_CAPABILITY,
+  openclaw: OPENCLAW_CAPABILITY,
 }
 
 /** Question-routing capability for the active harness integration. */

package/src/hook-adapter.ts

@@ -4,6 +4,7 @@ import {
   lstatSync,
   mkdirSync,
   readFileSync,
+  realpathSync,
   statSync,
 } from 'node:fs'
 import os from 'node:os'
@@ -42,6 +43,19 @@ export interface HookAdapterInspection {
   problems: string[]
 }
 
+/** Whether a parsed adapter runs the same installed CLI artifact as PATH. */
+export function hookAdapterTargetsArtifact(
+  target: HookAdapterTarget | null,
+  artifactPath: string,
+): boolean {
+  if (target === null || isNpxAdapterTarget(target)) return false
+  try {
+    return realpathSync(target.scriptPath) === realpathSync(artifactPath)
+  } catch {
+    return false
+  }
+}
+
 export function hookHostPlatform(
   platform: NodeJS.Platform | HookHostPlatform = process.platform,
 ): HookHostPlatform {

package/src/hooks.test.ts

@@ -48,6 +48,7 @@ import {
   drainRetirements,
   drainOrphanRetirements,
   handleSessionEnd,
+  inspectQuestionState,
   runEscalationWaiter,
   MAX_CONTINUATION_COUNT,
   MAX_HELD_DELIVERIES,
@@ -355,6 +356,7 @@ function harness(replies: ReplyView[] = []): Harness {
       sleep: async (milliseconds: number) => {
         clock += milliseconds
       },
+      spawnQuestionSettlement: () => {},
     },
   }
 }
@@ -2219,6 +2221,7 @@ describe('several questions in flight', () => {
       pending: [
         {
           question: 'Ship it?',
+          question_id: 'q_answer_handoff',
           asked_at: NOW,
           request_id: 'req_existing',
           collapse_key: 'question-existing',
@@ -2231,6 +2234,10 @@ describe('several questions in flight', () => {
     await hookRunCommand(h.deps, 'stop', stdin({ session_id: 'answer-handoff' }))
     const staged = readSessionState('answer-handoff', h.env)
     expect(staged.accepted?.answers[0]?.reply.text).toBe('Ship it')
+    expect(inspectQuestionState('q_answer_handoff', h.env)).toMatchObject({
+      found: true,
+      question: { state: 'answered', submitted: true, request_id: 'req_existing' },
+    })
     expect(JSON.parse(h.io.outLines.at(-1)!).decision).toBe('block')
 
     h.io.outLines = []
@@ -3054,6 +3061,40 @@ describe('user-prompt-submit hook', () => {
     expect(readSessionState('s10', h.env).last_prompt_at).toBe(NOW)
   })
 
+  it('launches one settlement owner when a new prompt overtakes the asking turn Stop', async () => {
+    const h = harness([])
+    writeSessionState('pre-stop-prompt', h.env, { last_prompt_at: AWAY })
+    registerQuestion(
+      'pre-stop-prompt',
+      h.env,
+      { question: 'Ship the release?', body: 'Ship the release?' },
+      NOW,
+    )
+    let launches = 0
+    const deps = {
+      ...h.deps,
+      spawnQuestionSettlement: () => {
+        launches += 1
+      },
+    } as CommandDeps
+
+    await hookRunCommand(
+      deps,
+      'user-prompt-submit',
+      stdin({
+        session_id: 'pre-stop-prompt',
+        cwd: h.deps.cwd,
+        prompt: 'Keep working on the unrelated release notes.',
+      }),
+      'codex',
+    )
+
+    expect(launches).toBe(1)
+    const pending = readSessionState('pre-stop-prompt', h.env).pending?.[0]
+    expect(pending?.question).toBe('Ship the release?')
+    expect(pending?.request_id).toBeUndefined()
+  })
+
   it('records Stop separately so a prompt hook cannot impersonate turn-end routing', async () => {
     const h = harness()
     await hookRunCommand(h.deps, 'user-prompt-submit', stdin({ session_id: 'events' }))
@@ -3249,6 +3290,40 @@ describe('user-prompt-submit hook', () => {
     expect(readSessionState('prompt-match', h.env).pending).toBeUndefined()
   })
 
+  it('withdraws a matching unpushed registration without launching settlement', async () => {
+    const h = harness([])
+    registerQuestion('prompt-match-unpushed', h.env, {
+      question: 'Ship it?',
+      questions: [
+        {
+          id: 'q1',
+          text: 'Ship it?',
+          choices: [
+            { id: 'ship', label: 'Ship it' },
+            { id: 'wait', label: 'Wait' },
+          ],
+        },
+      ],
+    })
+    let launches = 0
+
+    await hookRunCommand(
+      {
+        ...h.deps,
+        spawnQuestionSettlement: () => {
+          launches += 1
+        },
+      },
+      'user-prompt-submit',
+      stdin({ session_id: 'prompt-match-unpushed', prompt: 'Ship it' }),
+      'codex',
+    )
+
+    expect(launches).toBe(0)
+    expect(h.recorder.submitted).toEqual([])
+    expect(readSessionState('prompt-match-unpushed', h.env).pending).toBeUndefined()
+  })
+
   it('leaves an unrelated prompt’s live question open for the reply window', async () => {
     const h = harness([])
     writeSessionState('prompt-unrelated', h.env, {
@@ -3446,6 +3521,26 @@ describe('session-end hook', () => {
     expect(records.at(-1)?.data).toMatchObject({ outcome: 'cleaned', queued_retirements: 0 })
   })
 
+  it('keeps only content-free terminal question state after SessionEnd', async () => {
+    const h = harness()
+    writeSessionState('ended-question', h.env, {
+      last_prompt_at: NOW,
+      pending: [{ question: 'Ship it?', question_id: 'q_ended_local' }],
+    })
+
+    expect(
+      await hookRunCommand(h.deps, 'session-end', stdin({ session_id: 'ended-question' })),
+    ).toBe(EXIT.ok)
+
+    expect(readSessionState('ended-question', h.env)).toEqual({
+      question_history: [{ question_id: 'q_ended_local', state: 'withdrawn' }],
+    })
+    expect(inspectQuestionState('q_ended_local', h.env)).toMatchObject({
+      found: true,
+      question: { state: 'withdrawn', submitted: false, request_id: null },
+    })
+  })
+
   it('round-trips future session-state fields when SessionEnd preserves an obligation', async () => {
     const h = harness()
     const sessionId = 'session-end-future-state'
@@ -4462,6 +4557,63 @@ describe('Claude Code Stop wake route', () => {
     }
   }
 
+  it('settles a pre-Stop registration through the detached Claude owner', async () => {
+    const h = harness([reply({ text: 'Ship it' })])
+    h.recorder.acknowledgementRequiredFor = () => false
+    writeGlobalConfig(h, 'ask_grace_seconds = 0\n')
+    registerQuestion('claude-route', h.env, { question: 'Ship it?' }, NOW)
+    const wake = claudeWake()
+    let settlementInput: { session_id?: string; cwd?: string } | undefined
+    const deps: CommandDeps = {
+      ...h.deps,
+      claudeWake: wake,
+      claudeSourcePid: 12345,
+      spawnQuestionSettlement: (launch) => {
+        settlementInput = launch.envelope
+      },
+    }
+
+    await hookRunCommand(
+      deps,
+      'user-prompt-submit',
+      stdin({
+        session_id: 'claude-route',
+        cwd: h.deps.cwd,
+        prompt: 'Keep working on the unrelated release notes.',
+      }),
+      'claude-code',
+    )
+    await hookRunCommand(
+      deps,
+      'question-settlement',
+      stdin(settlementInput),
+      'claude-code',
+    )
+
+    expect(h.recorder.submitted.filter((entry) => isQuestionSubmit(entry))).toHaveLength(1)
+    expect(wake.sent).toHaveLength(1)
+    expect(wake.resumed).toEqual([])
+    expect(h.io.outLines).toEqual([])
+
+    await hookRunCommand(
+      deps,
+      'stop',
+      stdin({ session_id: 'claude-route', cwd: h.deps.cwd }),
+      'claude-code',
+    )
+    await hookRunCommand(
+      deps,
+      'stop',
+      stdin({ session_id: 'claude-route', cwd: h.deps.cwd }),
+      'claude-code',
+    )
+
+    expect(h.recorder.submitted.filter((entry) => isQuestionSubmit(entry))).toHaveLength(1)
+    expect(wake.sent).toHaveLength(1)
+    expect(readSessionState('claude-route', h.env).pending).toBeUndefined()
+    expect(readSessionState('claude-route', h.env).accepted).toBeUndefined()
+  })
+
   it('routes an accepted answer through the Claude inbox instead of hook stdout', async () => {
     const h = harness([reply({ text: 'BETA' })])
     writeGlobalConfig(h, 'ask_grace_seconds = 0\n')
@@ -4877,6 +5029,129 @@ describe('Codex Stop wake route', () => {
     })
   }
 
+  it('settles once when UserPromptSubmit overtakes the asking turn Stop', async () => {
+    const h = harness([reply({ text: 'Ship it' })])
+    h.recorder.acknowledgementRequiredFor = () => false
+    writeGlobalConfig(h, 'ask_grace_seconds = 0\n')
+    writeSessionState(CODEX_THREAD, h.env, { last_prompt_at: AWAY })
+    registerQuestion(CODEX_THREAD, h.env, { question: 'Ship it?' }, NOW)
+    const wake = codexWake({ sourceAlive: true, probe: { state: 'live' } })
+    let launched:
+      | { envelope: { session_id?: string; cwd?: string }; harness: string }
+      | undefined
+    const deps: CommandDeps = {
+      ...h.deps,
+      codexWake: wake,
+      codexSourcePid: 12345,
+      spawnQuestionSettlement: (launch) => {
+        launched = launch
+      },
+    }
+
+    await hookRunCommand(
+      deps,
+      'user-prompt-submit',
+      stdin({
+        session_id: CODEX_THREAD,
+        cwd: h.deps.cwd,
+        prompt: 'Keep working on the unrelated release notes.',
+      }),
+      'codex',
+    )
+
+    expect(launched).toEqual({
+      envelope: { session_id: CODEX_THREAD, cwd: h.deps.cwd },
+      harness: 'codex',
+    })
+    expect(h.deps.now?.()).toBe(NOW)
+    expect(h.recorder.submitted).toEqual([])
+    expect(readSessionState(CODEX_THREAD, h.env).last_stop_at).toBeUndefined()
+
+    await hookRunCommand(
+      deps,
+      'question-settlement',
+      stdin(launched?.envelope),
+      'codex',
+    )
+
+    expect(h.recorder.submitted.filter((entry) => isQuestionSubmit(entry))).toHaveLength(1)
+    expect(h.io.outLines).toEqual([])
+    expect(wake.resumed).toEqual([])
+    expect(readSessionState(CODEX_THREAD, h.env).accepted).toBeDefined()
+    expect(readSessionState(CODEX_THREAD, h.env).last_stop_at).toBeUndefined()
+
+    await hookRunCommand(
+      deps,
+      'stop',
+      stdin({ session_id: CODEX_THREAD, cwd: h.deps.cwd }),
+      'codex',
+    )
+    expect(h.io.outLines.map((line) => JSON.parse(line))).toEqual([
+      expect.objectContaining({ decision: 'block' }),
+    ])
+
+    await hookRunCommand(
+      deps,
+      'stop',
+      stdin({
+        session_id: CODEX_THREAD,
+        cwd: h.deps.cwd,
+        stop_hook_active: true,
+      }),
+      'codex',
+    )
+    await hookRunCommand(
+      deps,
+      'stop',
+      stdin({ session_id: CODEX_THREAD, cwd: h.deps.cwd }),
+      'codex',
+    )
+
+    expect(h.recorder.submitted.filter((entry) => isQuestionSubmit(entry))).toHaveLength(1)
+    expect(h.io.outLines).toHaveLength(1)
+    expect(readSessionState(CODEX_THREAD, h.env).pending).toBeUndefined()
+    expect(readSessionState(CODEX_THREAD, h.env).accepted).toBeUndefined()
+  })
+
+  it('keeps the detached recovery owner through the complete reply window', async () => {
+    const h = harness([])
+    writeGlobalConfig(h, 'ask_grace_seconds = 0\n')
+    writeSessionState(CODEX_THREAD, h.env, { last_prompt_at: AWAY })
+    registerQuestion(CODEX_THREAD, h.env, { question: 'Ship it?' }, NOW)
+    let settlementInput: { session_id?: string; cwd?: string } | undefined
+    const deps: CommandDeps = {
+      ...h.deps,
+      codexWake: codexWake({ sourceAlive: true, probe: { state: 'live' } }),
+      codexSourcePid: 12345,
+      spawnQuestionSettlement: (launch) => {
+        settlementInput = launch.envelope
+      },
+    }
+
+    await hookRunCommand(
+      deps,
+      'user-prompt-submit',
+      stdin({
+        session_id: CODEX_THREAD,
+        cwd: h.deps.cwd,
+        prompt: 'Keep working on the unrelated release notes.',
+      }),
+      'codex',
+    )
+    expect(h.deps.now?.()).toBe(NOW)
+
+    await hookRunCommand(
+      deps,
+      'question-settlement',
+      stdin(settlementInput),
+      'codex',
+    )
+
+    expect(h.deps.now?.()).toBe(NOW + 480_000)
+    expect(h.recorder.closed).toEqual([h.recorder.receipts[0]])
+    expect(readSessionState(CODEX_THREAD, h.env).pending).toBeUndefined()
+  })
+
   it('continues the held turn with decision:block when the answer arrives during the hold', async () => {
     const h = harness([reply({ text: 'BETA' })])
     writeGlobalConfig(h, 'ask_grace_seconds = 0\n')