@raidiant/notifai 10.0.0 → 10.1.1

package/src/commands-doctor.ts

@@ -11,7 +11,11 @@ import {
   HERMES_QUESTION_ROUTING_UNAVAILABLE,
   isHookInstallableHarness,
 } from './harnesses.js'
-import { inspectHookAdapter } from './hook-adapter.js'
+import {
+  hookAdapterTargetsArtifact,
+  inspectHookAdapter,
+  isNpxAdapterTarget,
+} from './hook-adapter.js'
 import {
   readLiveProjectSessionPointers,
   readProjectSessionPointer,
@@ -48,14 +52,16 @@ import type { Tone } from './ui/theme.js'
 import type { MachineCredential } from './credentials.js'
 import {
   EXIT,
-  UPDATE_CLI_COMMAND,
+  SETUP_COMMAND,
   diagnoseIgnoredOriginOverride,
   loadLoggedConfig,
   makeClient,
   resolvedBaseUrl,
+  updateCliCommand,
   type CommandDeps,
 } from './commands-core.js'
-import { deviceInstallRemedy, readyCompanionDevices, supportPageUrl } from './commands-devices.js'
+import { deviceInstallRemedy, readyCompanionDevices } from './commands-devices.js'
+import { setupAccessUrl } from './setup-destinations.js'
 import {
   claudeSessionPid,
   resolveActiveHarness,
@@ -68,7 +74,7 @@ import {
   hookActivationAdvice,
   requiredHookEvents,
 } from './commands-hooks.js'
-import { cliBinReadiness } from './cli-bin.js'
+import { cliBinReadiness, inspectCliInstallations } from './cli-bin.js'
 import {
   latestPublishedCliVersion,
   newerPublishedCli,
@@ -95,7 +101,7 @@ import { projectBinding, projectEnabled } from './project-enablement.js'
  * versions and document integers are structured inventory, never routing or a
  * definition of "up to date".
  */
-async function compatibilityCheck(client: ApiClient): Promise<ReadinessState> {
+async function compatibilityCheck(client: ApiClient, deps: CommandDeps): Promise<ReadinessState> {
   try {
     const [compatibility, documents] = await Promise.all([
       client.compatibility(),
@@ -130,7 +136,7 @@ async function compatibilityCheck(client: ApiClient): Promise<ReadinessState> {
         remedy: {
           by: 'user-here',
           summary: 'update Notifai',
-          command: UPDATE_CLI_COMMAND,
+          command: updateCliCommand(deps),
         },
       }
     }
@@ -147,7 +153,7 @@ async function compatibilityCheck(client: ApiClient): Promise<ReadinessState> {
         remedy: {
           by: 'user-here',
           summary: 'update Notifai',
-          command: UPDATE_CLI_COMMAND,
+          command: updateCliCommand(deps),
         },
       }
     }
@@ -303,6 +309,110 @@ function remoteInvalidatedByConfig(
   return server === undefined || !server.detail.includes(origin)
 }
 
+function isNoActivePlanError(err: unknown): err is ApiCallError {
+  return err instanceof ApiCallError && err.code === 'no_active_plan'
+}
+
+/**
+ * Device listing is grant-gated; access status is not. A paired Account whose
+ * plan lapsed must not be diagnosed as a revoked machine.
+ */
+async function probeAccount(
+  client: ApiClient,
+  credential: MachineCredential,
+  baseUrl: string,
+): Promise<{
+  email: string | null
+  devices: RoutableDevice[] | null
+  lookupFailed: boolean
+  auth: ReadinessState
+}> {
+  const [devicesOutcome, accessOutcome, requestOutcome] = await Promise.allSettled([
+    Promise.resolve().then(() => client.listDevices()),
+    Promise.resolve().then(() => client.accessStatus()),
+    Promise.resolve().then(() => client.accessRequest()),
+  ])
+  const access = accessOutcome.status === 'fulfilled' ? accessOutcome.value : null
+  const pendingRequest =
+    requestOutcome.status === 'fulfilled' ? requestOutcome.value.request : null
+  const devices = devicesOutcome.status === 'fulfilled' ? devicesOutcome.value.devices : null
+  const email = access?.email ?? null
+  const devicesErr = devicesOutcome.status === 'rejected' ? devicesOutcome.reason : null
+  const noActivePlan =
+    access?.status === 'no_active_plan' || isNoActivePlanError(devicesErr)
+
+  if (noActivePlan) {
+    const next =
+      (isNoActivePlanError(devicesErr) ? devicesErr.nextAction : null) ??
+      `Open ${setupAccessUrl(baseUrl)} to set up access, then retry.`
+    const who = email ? ` (${email})` : ''
+    // Three values, not two. Someone who asked yesterday is waiting on a person,
+    // not on an action of theirs, and telling them to ask again — every run,
+    // forever — is the only thing this terminal could get wrong about a wait it
+    // cannot shorten.
+    return {
+      email,
+      devices: null,
+      lookupFailed: true,
+      auth:
+        pendingRequest === null
+          ? {
+              id: 'auth',
+              title: 'Account',
+              status: 'gap',
+              detail: `this account does not have access to Notifai yet${who}`,
+              remedy: { by: 'user-elsewhere', summary: next },
+            }
+          : {
+              id: 'auth',
+              title: 'Account',
+              status: 'gap',
+              detail: `access requested on ${pendingRequest.requested_at.slice(0, 10)}${who} — waiting to be granted`,
+              remedy: {
+                by: 'user-elsewhere',
+                summary:
+                  'nothing is needed from you; this resumes on the next run once access is granted',
+              },
+            },
+    }
+  }
+
+  if (devices !== null) {
+    return {
+      email,
+      devices,
+      lookupFailed: false,
+      auth: {
+        id: 'auth',
+        title: 'Account',
+        status: 'ready',
+        detail: email
+          ? `machine ${credential.machineId} accepted (${email})`
+          : `machine ${credential.machineId} accepted`,
+      },
+    }
+  }
+
+  const err = devicesErr ?? (accessOutcome.status === 'rejected' ? accessOutcome.reason : null)
+  return {
+    email: null,
+    devices: null,
+    lookupFailed: true,
+    auth: {
+      id: 'auth',
+      title: 'Account',
+      status: 'gap',
+      detail: err instanceof ApiCallError ? `${err.code}: ${err.message}` : String(err),
+      remedy: {
+        by: 'user-here',
+        summary: 'this machine is no longer recognised; pair it again',
+        command: SETUP_COMMAND,
+        interactive: true,
+      },
+    },
+  }
+}
+
 /**
  * Read the whole setup once, in dependency order.
  *
@@ -378,7 +488,7 @@ export async function assessReadiness(
           remedy: {
             by: 'user-here',
             summary: 'sign in — this opens your browser to approve the machine',
-            command: 'notifai login',
+            command: SETUP_COMMAND,
             interactive: true,
           },
         },
@@ -426,7 +536,7 @@ export async function assessReadiness(
       baseUrl,
       `Bearer nfm_${credential.machineId}.${credential.secret}`,
     )
-    states.push(await compatibilityCheck(compatibilityClient))
+    states.push(await compatibilityCheck(compatibilityClient, deps))
   }
 
   let accountEmail: string | null = null
@@ -437,39 +547,11 @@ export async function assessReadiness(
   } else {
     const client = makeClient(deps, baseUrl, `Bearer nfm_${credential.machineId}.${credential.secret}`)
     accountClient = client
-    try {
-      const [{ devices }, email] = await Promise.all([
-        client.listDevices(),
-        Promise.resolve()
-          .then(async () => (await client.accessStatus()).email)
-          .catch(() => null as string | null),
-      ])
-      accountDevices = devices
-      accountEmail = email
-      states.push({
-        id: 'auth',
-        title: 'Account',
-        status: 'ready',
-        detail: accountEmail
-          ? `machine ${credential.machineId} accepted (${accountEmail})`
-          : `machine ${credential.machineId} accepted`,
-      })
-    } catch (err) {
-      // A credential the server rejects is revocation, not absence, and the
-      // remedy is the same sign-in either way.
-      accountLookupFailed = true
-      states.push({
-        id: 'auth',
-        title: 'Account',
-        status: 'gap',
-        detail: err instanceof ApiCallError ? `${err.code}: ${err.message}` : String(err),
-        remedy: {
-          by: 'user-here',
-          summary: 'this machine is no longer recognised; pair it again',
-          command: 'notifai login',
-        },
-      })
-    }
+    const probed = await probeAccount(client, credential, baseUrl)
+    accountDevices = probed.devices
+    accountEmail = probed.email
+    accountLookupFailed = probed.lookupFailed
+    states.push(probed.auth)
   }
 
   // Optional setup that works without a companion device must appear before the
@@ -509,7 +591,7 @@ export async function assessReadiness(
             // dashboard origin — not a placeholder, and not typed by hand.
             detail:
               companionDevices.length === 0
-                ? `no active Companion device registered yet; install Notifai via ${supportPageUrl(baseUrl)}`
+                ? 'no active Companion App registered yet'
                 : `${companionDevices.map((d) => `${d.display_name} (${d.platform}, ${d.permission_status})`).join(', ')} — registered but not able to receive`,
             remedy: {
               by: 'user-elsewhere',
@@ -553,7 +635,7 @@ async function applyRegistryRecommendation(
   contract.remedy = {
     by: 'user-here',
     summary: 'update Notifai',
-    command: UPDATE_CLI_COMMAND,
+    command: updateCliCommand(deps),
   }
 }
 
@@ -684,8 +766,12 @@ export async function doctorCommand(
     if (s.id === 'contract') {
       if (s.status === 'ready' || s.status === 'unknown') continue
       deps.io.out(s.detail)
-      if (s.remedy?.by !== 'user-elsewhere' && s.remedy?.command === UPDATE_CLI_COMMAND) {
-        deps.io.out(UPDATE_CLI_COMMAND)
+      if (
+        s.remedy?.by !== 'user-elsewhere' &&
+        s.remedy?.summary === 'update Notifai' &&
+        s.remedy.command !== undefined
+      ) {
+        deps.io.out(s.remedy.command)
       }
       continue
     }
@@ -754,14 +840,15 @@ export function remedyLine(state: ReadinessState): string {
  * way and is not worth re-deriving. The judgment added here is which failures
  * actually stand in the way.
  *
- * Not everything failed is in the way. A pointer that has never been
- * published is the normal condition of an install thirty seconds old — the
- * next prompt fixes it and no command can. Treating that as blocking would
- * mean `init` could only finish after a session had already run — so it
- * reports as something worth knowing rather than something to
- * fix, and `init` walks on to the states it can actually close, delivery
- * proof included. Which failures are informational, and what the true remedy
- * is, is each check's own call (`HookCheck`).
+ * `doctor` is a report and keeps its strict verdict here: a Codex Stop handler
+ * that would swallow an answer is a real failure and reads as one. `init` is
+ * the other consumer, and it treats every state in this group as a report line
+ * rather than a blocker — Question Routing is optional automation, and nothing
+ * optional may stand between a send-capable setup and its delivery proof.
+ *
+ * `reportOnly` marks the checks that no command can close, only the passage of
+ * a turn. Those are report lines even in `doctor`, because "look again" is not
+ * a remedy.
  */
 function hookStates(deps: CommandDeps): ReadinessState[] {
   const installations = findInstallations(deps.cwd, deps.env, deps.hookAdapterHome, deps.hookPlatform)
@@ -863,23 +950,21 @@ function checkTitle(name: string): string {
   return CHECK_TITLES[name] ?? name
 }
 
-  /** Real but not in the way; see the note above. */
-  const informational = new Set<string>()
   return [
     ...hookChecks(deps).map((check) => ({
       id: check.name.replace(/[ ()]+/g, '-').replace(/-$/, ''),
       title: checkTitle(check.name),
       status: check.ok
-        ? 'ready' as const
-        : check.informational === true || informational.has(check.name)
-          ? 'optional-gap' as const
-          : 'gap' as const,
+        ? ('ready' as const)
+        : check.reportOnly === true
+          ? ('optional-gap' as const)
+          : ('gap' as const),
       detail: check.detail,
+      ...(check.technical === undefined ? {} : { technical: check.technical }),
       ...(check.ok
         ? {}
         : {
             remedy: {
-              by: 'user-here' as const,
               // The check's own remedy when it has one; the generic reinstall
               // line was wrong exactly where it mattered (an unfired pointer
               // needs a prompt, not `hooks install`).
@@ -887,6 +972,7 @@ function checkTitle(name: string): string {
                 summary: 'the detail above names what to change',
                 command: 'notifai hooks install',
               }),
+              by: check.remedy?.by ?? ('user-here' as const),
             },
           }),
     })),
@@ -896,13 +982,15 @@ function checkTitle(name: string): string {
 
 
 interface HookCheck {
+  /** No command closes this; only a turn that has not happened yet. */
+  reportOnly?: boolean
   name: string
   ok: boolean
   detail: string
-  /** Real but not in the way: worth a line, never a blocker. */
-  informational?: boolean
+  technical?: unknown
   /** A remedy truer than the generic `notifai hooks install`. */
   remedy?: {
+    by?: 'cli' | 'user-here'
     summary: string
     command: string
     user_action?: { code: string; harness: string; action: string; message: string }
@@ -937,7 +1025,7 @@ function hookChecks(deps: CommandDeps): HookCheck[] {
     checks.push({
       name: 'hooks (detected)',
       ok: false,
-      informational: true,
+      reportOnly: true,
       detail: `${unwired.map((harness) => HARNESS_LABELS[harness]).join(', ')} detected on this machine but not wired`,
       remedy: {
         summary: 'install hooks for every detected harness',
@@ -959,14 +1047,14 @@ function hookChecks(deps: CommandDeps): HookCheck[] {
     checks.push({
       name: 'hooks (active harness)',
       ok: false,
-      informational: true,
+      reportOnly: true,
       detail: `Several harness sessions could own this shell (${contested.map((candidate) => candidate.label).join(', ')}); routing readiness is intentionally not attributed to either one`,
     })
   } else if (active !== null && !isHookInstallableHarness(active.harness)) {
     checks.push({
       name: 'hooks (active harness)',
       ok: true,
-      informational: true,
+      reportOnly: true,
       detail: `${active.label}: ${HERMES_QUESTION_ROUTING_UNAVAILABLE.deliveryContract}`,
     })
   } else if (active !== null) {
@@ -999,7 +1087,7 @@ function hookChecks(deps: CommandDeps): HookCheck[] {
         checks.push({
           name: 'hooks (active session)',
           ok: false,
-          informational: true,
+          reportOnly: true,
           detail: `active ${active.label} session has not published exact lifecycle state — send one ${active.label} prompt, then check again`,
           remedy: {
             summary: `send one ${active.label} prompt — its hook publishes the routing pointer`,
@@ -1052,14 +1140,47 @@ function hookChecks(deps: CommandDeps): HookCheck[] {
   )
   const sharedAdapter = inspectHookAdapter(deps.hookAdapterHome, deps.hookPlatform)
   adapterProblems.push(...sharedAdapter.problems)
+  const runningTarget = deps.hookInstallTarget
+  const runningArtifact =
+    runningTarget !== undefined && !isNpxAdapterTarget(runningTarget)
+      ? runningTarget.scriptPath
+      : process.argv[1]
+  const cliInstallations = inspectCliInstallations(
+    deps.env,
+    deps.hookPlatform ?? process.platform,
+    {
+      ...(runningArtifact === undefined ? {} : { runningArtifactPath: runningArtifact }),
+      currentVersion: packageVersion(),
+    },
+  )
+  const effectiveArtifact = cliInstallations.effective?.artifact_path ?? null
+  const adapterMismatch =
+    sharedAdapter.problems.length === 0 &&
+    effectiveArtifact !== null &&
+    !hookAdapterTargetsArtifact(sharedAdapter.target, effectiveArtifact)
+  if (adapterMismatch) {
+    adapterProblems.push('the registered CLI does not match the effective notifai command')
+  }
   if (adapterProblems.length > 0) {
     checks.push({
       name: 'hooks (adapter)',
       ok: false,
       // A machine-global install for a harness that is not active in this
-      // project is useful diagnosis, but it must not block unrelated init.
-      informational: active === null && installations.every((installation) => installation.global),
+      // project is useful diagnosis, but it is not this project's failure.
+      reportOnly: active === null && installations.every((installation) => installation.global),
       detail: adapterProblems.join('; '),
+      ...(adapterMismatch
+        ? { technical: { effective_cli_artifact: effectiveArtifact, registered_target: sharedAdapter.target } }
+        : {}),
+      ...(adapterMismatch && adapterProblems.length === 1
+        ? {
+            remedy: {
+              by: 'cli' as const,
+              summary: 'retarget Question Routing to the effective notifai command',
+              command: 'notifai init',
+            },
+          }
+        : {}),
     })
   }
 
@@ -1215,9 +1336,10 @@ function hookChecks(deps: CommandDeps): HookCheck[] {
   checks.push({
     name: 'hooks (fired)',
     ok: fired,
-    // A wholly fresh install is informational. Once UserPromptSubmit has fired,
-    // a missing Stop is a broken route, not missing historical evidence.
-    informational: firedPointer === null,
+    // Nothing here is a command. Whether the pointer is absent or the turn is
+    // half-finished, the only thing that closes this is a turn ending — which
+    // an agent running `init` inside that very turn cannot supply.
+    reportOnly: true,
     detail: fired
       ? active === null
         ? 'a session in this directory has run UserPromptSubmit and Stop'
@@ -1258,7 +1380,7 @@ function hookChecks(deps: CommandDeps): HookCheck[] {
       continuationHarnesses.every(
         (harness) => HARNESS_CAPABILITIES[harness].stopContinuation !== 'unsupported',
       ),
-    informational: active === null,
+    reportOnly: active === null,
     detail:
       continuationHarnesses.length === 0
         ? active === null
@@ -1315,7 +1437,7 @@ function wakeRouteCheck(
     return {
       name: 'hooks (wake route)',
       ok: readiness.state === 'ready',
-      informational: true,
+      reportOnly: true,
       detail:
         readiness.state === 'ready'
           ? `this Claude Code ${readiness.version} session is listening on ${readiness.socketPath}, so an answer can start a turn here without you`
@@ -1330,7 +1452,7 @@ function wakeRouteCheck(
     return {
       name: 'hooks (wake route)',
       ok: readiness.state === 'ready',
-      informational: true,
+      reportOnly: true,
       detail:
         readiness.state === 'ready'
           ? `the held Codex turn continues from its own hook, and after it returns ${readiness.lockDirectory} can prove a stopped thread unowned before resuming it`

package/src/commands-harness-context.ts

@@ -51,6 +51,14 @@ function harnessEnvCandidates(env: NodeJS.ProcessEnv): ActiveHarnessSession[] {
       ...(sessionLabelPending ? { sessionLabelPending: true } : {}),
     })
   }
+  if (env['NOTIFAI_ACTIVE_HARNESS'] === 'openclaw') {
+    const sessionId = env['NOTIFAI_ACTIVE_SESSION_ID']
+    candidates.push({
+      harness: 'openclaw',
+      label: 'OpenClaw',
+      ...(sessionId === undefined || sessionId === '' ? {} : { sessionId }),
+    })
+  }
   if (env['CLAUDECODE'] === '1') {
     const sessionId = env['CLAUDE_CODE_SESSION_ID']
     candidates.push({