@raidiant/notifai 10.0.0 → 10.1.0

package/src/commands-init.ts

@@ -25,6 +25,7 @@ import { buildDraft, formatReceipt } from './send.js'
 import { loginCommand } from './commands-auth.js'
 import {
   EXIT,
+  SETUP_COMMAND,
   UPDATE_CLI_COMMAND,
   authedClient,
   loadLoggedConfig,
@@ -848,8 +849,8 @@ async function printInitClose(
     await deps.io.note?.(`${blocker.title} — ${blocker.detail}\n${remedyLine(blocker)}`, 'Next')
     deps.io.out(`Next: ${blocker.title} — ${blocker.detail}`)
     deps.io.out(`  ${remedyLine(blocker)}`)
-    if (blocker.remedy?.by === 'user-elsewhere' || blocker.remedy?.by === 'user-here') {
-      deps.io.out('  Then re-run `notifai init` and it will pick up from here.')
+    if (shouldRestateInit(blocker)) {
+      deps.io.out(`  Then re-run \`${SETUP_COMMAND}\` and it will pick up from here.`)
     }
     await deps.io.outro?.('One step remains (above)')
     return
@@ -866,7 +867,12 @@ async function printInitClose(
   }
   deps.io.out(`Next: ${blocker.title} — ${blocker.detail}`)
   deps.io.out(`  ${remedyLine(blocker)}`)
-  if (blocker.remedy?.by === 'user-elsewhere' || blocker.remedy?.by === 'user-here') {
-    deps.io.out('  Then re-run `notifai init` and it will pick up from here.')
+  if (shouldRestateInit(blocker)) {
+    deps.io.out(`  Then re-run \`${SETUP_COMMAND}\` and it will pick up from here.`)
   }
 }
+
+function shouldRestateInit(blocker: ReadinessState): boolean {
+  if (blocker.remedy?.by !== 'user-elsewhere' && blocker.remedy?.by !== 'user-here') return false
+  return !('command' in blocker.remedy) || blocker.remedy.command !== SETUP_COMMAND
+}

package/src/commands.test.ts

@@ -34,6 +34,7 @@ import {
   acknowledgeCommand,
   askCommand,
   accessStatusCommand,
+  authStatusCommand,
   buildQuestions,
   assessReadiness,
   capabilitiesCommand,
@@ -446,6 +447,16 @@ describe('command contracts', () => {
     expect(submitted?.draft.project).toBeUndefined()
     expect(projectEnabled(projectBinding(cwd, env))).toBe(false)
   })
+  it('tells an unsigned machine to run init, not login', () => {
+    const io = new CapturedIo()
+    const deps = makeDeps(io, {} as ApiClient)
+    deps.store.load = () => null
+
+    expect(authStatusCommand(deps, {})).toBe(EXIT.auth)
+    expect(io.errLines.join('\n')).toMatch(/Not signed in\. Run `notifai init`/)
+    expect(io.errLines.join('\n')).not.toContain('notifai login')
+  })
+
   it('shows an actionable no-plan access state', async () => {
     const io = new CapturedIo()
     const client = {
@@ -2596,7 +2607,7 @@ describe('credential origin pinning', () => {
     expect(io.errLines).toEqual([
       'This account has no active plan or temporary Alpha access.',
       'next: Ask the account owner for Alpha access.',
-      'After access is granted, run `notifai login` again.',
+      'After access is granted, run `notifai init` again.',
     ])
   })
 
@@ -3277,6 +3288,71 @@ describe('harness activation guidance', () => {
     expect(inspectHookAdapter(deps.hookAdapterHome).problems).toEqual([])
     expect(inspectHookAdapter(deps.hookAdapterHome).target?.scriptPath).toBe(scriptPath)
   })
+
+  it('installs an owned OpenClaw plugin and reports unsupported continuation', async () => {
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-openclaw-activation-'))
+    const io = new CapturedIo()
+    const client = {
+      health: async () => true,
+      capabilities: async () => ({ schema_version: 1, platform: 'ios' }),
+      listDevices: async () => ({ devices: [] }),
+    } as unknown as ApiClient
+    const home = path.join(cwd, 'home')
+    const deps = {
+      ...makeDeps(io, client),
+      cwd,
+      env: {
+        HOME: home,
+        XDG_CONFIG_HOME: path.join(cwd, 'config'),
+        XDG_STATE_HOME: path.join(cwd, 'state'),
+        OPENCLAW_STATE_DIR: path.join(cwd, 'openclaw-home'),
+      },
+    }
+
+    expect(hooksInstallCommand(deps, { harness: 'openclaw', execPath, scriptPath })).toBe(EXIT.ok)
+    expect(io.outLines.join('\n')).toContain('Installed openclaw hooks in')
+    expect(io.outLines.join('\n')).toContain(
+      'Restart the OpenClaw Gateway, start one fresh Agent Session, send one prompt, then run `notifai doctor`.',
+    )
+    const pluginFile = path.join(cwd, '.openclaw', 'extensions', 'notifai', 'index.js')
+    const plugin = readFileSync(pluginFile, 'utf8')
+    expect(plugin).toContain('api.on("before_prompt_build"')
+    expect(plugin).toContain('api.on("resolve_exec_env"')
+    expect(plugin).not.toContain('command:stop')
+    const config = JSON.parse(
+      readFileSync(path.join(cwd, 'openclaw-home', 'openclaw.json'), 'utf8'),
+    ) as {
+      plugins: { entries: { notifai: { enabled: boolean; hooks: { allowConversationAccess: boolean } } } }
+    }
+    expect(config.plugins.entries.notifai).toEqual({
+      enabled: true,
+      hooks: { allowConversationAccess: true },
+    })
+
+    io.outLines = []
+    expect(await doctorCommand(deps, {})).toBe(EXIT.failed)
+    expect(io.outLines.join('\n')).toContain('no proven answer continuation')
+  })
+
+  it('refuses to overwrite a foreign OpenClaw plugin', () => {
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-openclaw-foreign-'))
+    const plugin = path.join(cwd, '.openclaw', 'extensions', 'notifai', 'index.js')
+    mkdirSync(path.dirname(plugin), { recursive: true })
+    writeFileSync(plugin, 'export default { id: "foreign" }\n')
+    const io = new CapturedIo()
+    const deps = {
+      ...makeDeps(io, {} as ApiClient),
+      cwd,
+      env: {
+        HOME: path.join(cwd, 'home'),
+        XDG_STATE_HOME: path.join(cwd, 'state'),
+        OPENCLAW_STATE_DIR: path.join(cwd, 'openclaw-home'),
+      },
+    }
+    expect(hooksInstallCommand(deps, { harness: 'openclaw', execPath, scriptPath })).toBe(EXIT.failed)
+    expect(io.errLines.join('\n')).toMatch(/was not written by Notifai/)
+    expect(readFileSync(plugin, 'utf8')).toBe('export default { id: "foreign" }\n')
+  })
 })
 
 describe('stable hook installation', () => {
@@ -4524,8 +4600,9 @@ describe('init', () => {
     expect(await initCommand(deps, {})).toBe(EXIT.failed)
     const out = io.outLines.join('\n')
     expect(out).toContain('Next: This machine')
-    expect(out).toContain('notifai login')
-    expect(out).toContain('Then re-run `notifai init` and it will pick up from here.')
+    expect(out).toContain('notifai init')
+    expect(out).not.toContain('notifai login')
+    expect(out).not.toContain('Then re-run')
     // The device gap is real and downstream; it must stay hidden until the
     // sign-in that would let anyone actually check it has happened.
     expect(out).not.toContain('companion app')
@@ -5071,7 +5148,8 @@ describe('init', () => {
     }
 
     expect(await initCommand(deps, { setupScope: 'project' })).toBe(EXIT.failed)
-    expect(io.outLines.join('\n')).toContain('notifai login')
+    expect(io.outLines.join('\n')).toContain('notifai init')
+    expect(io.outLines.join('\n')).not.toContain('notifai login')
   })
 
   it('announces sign-in for a present human without re-confirming', async () => {
@@ -5104,7 +5182,8 @@ describe('init', () => {
     const out = io.outLines.join('\n')
     expect(out).toContain('Opening your browser to approve this machine — Ctrl-C to stop.')
     expect(out).toContain('Next: This machine')
-    expect(out).toContain('Then re-run `notifai init` and it will pick up from here.')
+    expect(out).toContain('notifai init')
+    expect(out).not.toContain('notifai login')
   })
 
   it('never prompts or opens a browser when an agent runs it unattended', async () => {
@@ -5667,10 +5746,88 @@ describe('init', () => {
     const out = io.outLines.join('\n')
     expect(out).toContain('Next: Account')
     expect(out).toContain('pair it again')
-    expect(out).toContain('notifai login')
+    expect(out).toContain('notifai init')
+    expect(out).not.toContain('notifai login')
     expect(out.match(/^Next:/gm)).toHaveLength(1)
   })
 
+  it('names the support next action when a paired account has no active plan', async () => {
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'init-no-plan-'))
+    const io = new CapturedIo()
+    const nextAction = 'Open https://app.notifai.sh/support to request Alpha access, then retry.'
+    const client = {
+      health: async () => true,
+      capabilities: async () => ({ schema_version: 1, platform: 'ios' }),
+      listDevices: async () => {
+        throw new ApiCallError(403, 'no_active_plan', 'No active plan.', nextAction)
+      },
+      accessStatus: async () => ({
+        status: 'no_active_plan',
+        reason: 'no_active_grant',
+        expires_at: null,
+        email: 'rafael@example.test',
+      }),
+    } as unknown as ApiClient
+    const deps = {
+      ...makeDeps(io, client),
+      cwd,
+      env: isolatedEnv(cwd),
+    }
+
+    const readiness = await assessReadiness(deps)
+    const auth = readiness.states.find((state) => state.id === 'auth')
+    expect(auth).toMatchObject({
+      status: 'gap',
+      detail: 'no active plan or temporary Alpha access (rafael@example.test)',
+      remedy: { by: 'user-elsewhere', summary: nextAction },
+    })
+    expect(auth?.remedy && 'command' in auth.remedy ? auth.remedy.command : undefined).toBeUndefined()
+
+    expect(await initCommand(deps, { hooks: false, skills: false })).toBe(EXIT.failed)
+    const out = io.outLines.join('\n')
+    expect(out).toContain('Next: Account')
+    expect(out).toContain(nextAction)
+    expect(out).not.toContain('pair it again')
+    expect(out).not.toContain('notifai login')
+    expect(out.match(/^Next:/gm)).toHaveLength(1)
+
+    const doctorIo = new CapturedIo()
+    expect(await doctorCommand({ ...deps, io: doctorIo }, { json: true })).toBe(EXIT.failed)
+    const payload = JSON.parse(doctorIo.outLines[0] ?? '{}') as {
+      states: Array<{ id: string; remedy?: { summary?: string; command?: string } }>
+    }
+    const doctorAuth = payload.states.find((state) => state.id === 'auth')
+    expect(doctorAuth?.remedy?.summary).toBe(nextAction)
+    expect(doctorAuth?.remedy?.command).toBeUndefined()
+  })
+
+  it('does not treat a listDevices no-plan 403 as a revoked machine when accessStatus fails', async () => {
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'init-no-plan-devices-only-'))
+    const io = new CapturedIo()
+    const nextAction = 'Open https://app.notifai.sh/support to request Alpha access, then retry.'
+    const client = {
+      health: async () => true,
+      listDevices: async () => {
+        throw new ApiCallError(403, 'no_active_plan', 'No active plan.', nextAction)
+      },
+      accessStatus: async () => {
+        throw new ApiCallError(500, 'internal_error', 'access status unavailable')
+      },
+    } as unknown as ApiClient
+    const deps = {
+      ...makeDeps(io, client),
+      cwd,
+      env: isolatedEnv(cwd),
+    }
+
+    const readiness = await assessReadiness(deps)
+    const auth = readiness.states.find((state) => state.id === 'auth')
+    expect(auth?.status).toBe('gap')
+    expect(auth?.detail).toContain('no active plan')
+    expect(auth?.remedy).toMatchObject({ by: 'user-elsewhere', summary: nextAction })
+    expect(JSON.stringify(auth)).not.toContain('pair it again')
+  })
+
   it('reuses proof across worktrees of one Project on the same Approved Machine', async () => {
     const stateRoot = mkdtempSync(path.join(os.tmpdir(), 'init-worktrees-state-'))
     let submitCalls = 0
@@ -6723,6 +6880,28 @@ describe('asking before the hooks have ever run', () => {
     expect(readSessionState('opencode-current', env).pending).toBeUndefined()
   })
 
+  it('rejects OpenClaw before registration even with an exact matching pointer', () => {
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-active-openclaw-unsupported-'))
+    const io = new CapturedIo()
+    const env = {
+      HOME: path.join(cwd, 'home'),
+      XDG_CONFIG_HOME: path.join(cwd, 'config'),
+      XDG_STATE_HOME: path.join(cwd, 'state'),
+      OPENCLAW_STATE_DIR: path.join(cwd, 'openclaw-home'),
+      NOTIFAI_ACTIVE_HARNESS: 'openclaw',
+      NOTIFAI_ACTIVE_SESSION_ID: 'agent:main:main',
+    }
+    const deps = { ...makeDeps(io, {} as ApiClient), cwd, env, now: () => 42 }
+    expect(hooksInstallCommand(deps, { harness: 'openclaw', execPath, scriptPath })).toBe(EXIT.ok)
+    writeSessionState('agent:main:main', env, { harness: 'openclaw', last_prompt_at: 42, last_stop_at: 41 })
+    writeProjectSession(cwd, env, 'agent:main:main', 42, 'openclaw')
+    io.outLines = []
+
+    expect(askCommand(deps, 'Ship it?', {})).toBe(EXIT.usage)
+    expect(io.errLines.join('\n')).toMatch(/no proven answer continuation/i)
+    expect(readSessionState('agent:main:main', env).pending).toBeUndefined()
+  })
+
   it('refuses Hermes ask as unsupported rather than as missing hooks', () => {
     const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-hermes-ask-unsupported-'))
     const io = new CapturedIo()

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. */