@raidiant/notifai 3.0.1 → 5.0.0

package/src/main.ts

@@ -124,8 +124,6 @@ const program = new Command('notifai')
   // it. Without this, adding that default would silently break
   // `notifai help send` for everyone who reaches for it before `--help`.
   .helpCommand(true)
-  // Where the implicit help command lands; every other command names its own.
-  .commandsGroup(GROUP.help)
   .hook('preAction', (_program, actionCommand) => {
     logger.bind({ cmd: commandPath(actionCommand) })
     // SessionEnd uses the hook policy shared with commands.ts: local cleanup
@@ -156,7 +154,40 @@ const program = new Command('notifai')
  * interactive tree cost nothing to the paths that never draw them — `send`,
  * `ask`, and the hook that runs in front of every prompt the user types.
  */
-program.action(async () => {
+/**
+ * Commander exits 1 for every usage error it detects itself, which contradicts
+ * the exit vocabulary this CLI documents and every hand-written usage error it
+ * returns. A caller branching on exit codes should not have to know which layer
+ * rejected it. Help and version stay successful.
+ */
+program.exitOverride((err) => {
+  process.exit(err.exitCode === 0 ? 0 : 2)
+})
+
+/**
+ * An unrecognised subcommand reaches the root as an excess argument, and
+ * "expected 0 arguments but got 1" tells a caller nothing about what it typed
+ * or what exists. Naming it — with the nearest real command when there is one —
+ * turns a dead end into one more try.
+ */
+program.usage('[options] [command]')
+program.argument('[command]').action(async (command?: string) => {
+  if (command !== undefined) {
+    const names = program.commands.map((cmd) => cmd.name())
+    const near = names.filter(
+      (name) =>
+        name.startsWith(command.slice(0, 2)) ||
+        command.startsWith(name.slice(0, 2)) ||
+        name.includes(command) ||
+        command.includes(name),
+    )
+    deps.io.err(
+      `Unknown command "${command}".` +
+        (near.length > 0 ? ` Did you mean: ${near.slice(0, 3).join(', ')}?` : '') +
+        ' Run notifai --help for the full list.',
+    )
+    process.exit(2)
+  }
   if (deps.io.interactive !== true) {
     program.outputHelp()
     return
@@ -262,18 +293,27 @@ const send = program
   .summary('Send a notification')
   .description('Send a notification')
   .optionsGroup(SEND_GROUP.content)
-  .requiredOption('--title <title>', 'notification title')
-  .requiredOption('--body <body>', 'notification body')
-  .option('--subtitle <subtitle>', 'a line between the title and the body')
-  .option('--detail <markdown>', 'long-form markdown shown only in the app, never on the banner')
-  .option('--detail-file <path>', 'read --detail from a file (use - for stdin)')
-  .option('--image <path|url|media_id>', 'upload or attach an image')
+  .requiredOption('--title <title>', 'brief title whose substance is immediately understandable')
+  .option('--body <markdown>', 'canonical Markdown body')
+  .option('--body-file <path>', 'read the canonical Markdown body from a file (use - for stdin)')
+  .option('--subtitle <subtitle>', 'a plain-text line between the title and body')
+  .option(
+    '--image <path|url|media_id>',
+    'upload or attach an image in collection order (repeatable, maximum 8)',
+    (v: string, all: string[] = []) => [...all, v],
+  )
+  .option(
+    '--image-alt <text>',
+    'alt text paired with --image occurrences by position (repeatable)',
+    (v: string, all: string[] = []) => [...all, v],
+  )
   .optionsGroup(SEND_GROUP.routing)
-  .option('--kind <kind>', 'what this is: update (default) | done | question (requires --reply)')
-  .option('--project <id>', 'project identifier, e.g. my-app (lazily registered)')
-  .option('--device <id>', 'target a device id (repeatable)', (v: string, all: string[]) => [...all, v], [])
+  .option('--kind <kind>', 'what this is (required): update | done | failed | blocked — question is set by --reply')
+  .option('--project <id>', 'project identifier override (otherwise configured or inferred)')
+  .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>', 'session identity (env: NOTIFAI_SESSION); presentation varies by surface')
+  .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('--event <event>', 'agent event name, e.g. tests_passed')
   .optionsGroup(SEND_GROUP.presentation)
   .option('--collapse-key <key>', 'replace earlier notifications with the same key')
@@ -283,22 +323,26 @@ const send = program
   .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))
-  .option('--reply-window <seconds>', 'how long the server accepts a reply (default: 3600)', (v: string) => Number(v))
+  .option(
+    '--reply-window <seconds>',
+    'how long an answer is still accepted, 60-259200 (default: reply_window_seconds, a day)',
+    (v: string) => Number(v),
+  )
   .option(
     '--reply-choice <label>',
     'with --reply, ask a closed question; repeat the flag once per answer (2-6)',
-    (v: string, all: string[]) => [...all, v], [],
+    (v: string, all: string[] = []) => [...all, v],
   )
   .option('--reply-multi', 'with --reply-choice, several answers may be selected')
   // Kept registered, and always a usage error with --reply, so the caller gets
   // a message pointing at `ask` instead of "unknown option".
   .option('--no-block', 'rejected with --reply; use `notifai ask` to ask and end the turn')
   .optionsGroup(SEND_GROUP.advanced)
-  .option('--sound <sound>', 'override kind profile / saved config: default | done | attention | alert | none')
-  .option('--level <level>', 'override kind profile / saved config: passive | active | time_sensitive')
+  .option('--sound <sound>', 'override saved sound: default | done | attention | alert | none')
+  .option('--level <level>', 'override saved interruption level: passive | active | time_sensitive')
   .option('--wait <seconds>', 'how long to wait for provider outcomes', (v: string) => Number(v))
   .option('--no-wait', 'return immediately after acceptance')
-  .option('--data <key=value>', 'custom data (repeatable)', (v: string, all: string[]) => [...all, v], [])
+  .option('--data <key=value>', 'custom data (repeatable)', (v: string, all: string[] = []) => [...all, v])
   .option('--idempotency-key <key>', 'safe-retry key (default: random)')
   .option('--base-url <url>', 'developer override for the service origin (also NOTIFAI_BASE_URL)')
   .option('--json', 'print the full submission receipt as JSON')
@@ -308,24 +352,22 @@ const send = program
     const wait = typeof opts['wait'] === 'number' ? opts['wait'] : undefined
     const noBlock = opts['block'] === false
     const sendOpts = { ...opts }
-    // Same empty-collector normalisation as `ask`.
-    if (Array.isArray(sendOpts['replyChoice']) && sendOpts['replyChoice'].length === 0) {
-      delete sendOpts['replyChoice']
+    // Commander collectors default to []; an empty list means "not passed".
+    for (const key of ['replyChoice', 'image', 'imageAlt']) {
+      if (Array.isArray(sendOpts[key]) && sendOpts[key].length === 0) delete sendOpts[key]
     }
     delete sendOpts['block']
-    // Long-form detail is usually a build log or a diff summary, which nobody
-    // wants to shell-escape onto a command line.
-    const detailFile = sendOpts['detailFile']
-    delete sendOpts['detailFile']
-    if (typeof detailFile === 'string') {
-      if (sendOpts['detail'] !== undefined) {
-        deps.io.err('Pass either --detail or --detail-file, not both.')
+    const bodyFile = sendOpts['bodyFile']
+    delete sendOpts['bodyFile']
+    if (typeof bodyFile === 'string') {
+      if (sendOpts['body'] !== undefined) {
+        deps.io.err('Pass either --body or --body-file, not both.')
         process.exit(2)
       }
       try {
-        sendOpts['detail'] = readFileSync(detailFile === '-' ? 0 : detailFile, 'utf8')
+        sendOpts['body'] = readFileSync(bodyFile === '-' ? 0 : bodyFile, 'utf8')
       } catch (err) {
-        deps.io.err(`Could not read ${detailFile}: ${String(err)}`)
+        deps.io.err(`Could not read ${bodyFile}: ${String(err)}`)
         process.exit(2)
       }
     }
@@ -337,8 +379,8 @@ const send = program
 
 send.addHelpText(
   'after',
-  `\nKind profiles apply automatically. Pass --sound or --level only to override them or saved user config:\n  update    sound none       level passive\n  done      sound done       level passive\n  question  sound attention  level active (--reply)\n`,
-)
+  `\nKind is required, and it selects the sound the notification arrives with: done rings the completion chime, failed the most insistent tone, blocked and question a distinct attention tone, update the standard one.\nAn explicit --sound or --level, and the user's saved preference, both outrank that default.\n`,
+ )
 
 program
   .command('replies [request_id]')
@@ -360,9 +402,9 @@ program
   .description(
     'Record the required Agent Acknowledgement for a replied-to notification request; never prompts',
   )
-  .requiredOption('--text <text>', 'concrete work you will do because of the reply')
+  .option('--text <text>', 'concrete work you will do because of the reply')
   .option('--json', 'machine-readable output')
-  .action(async (requestId: string, opts: { text: string; json?: boolean }) => {
+  .action(async (requestId: string, opts: { text?: string; json?: boolean }) => {
     process.exit(await acknowledgeCommand(deps, requestId, opts))
   })
 
@@ -380,35 +422,53 @@ program
   .command('ask [question]')
   .helpGroup(GROUP.agent)
   .summary('Register a question, then end the turn')
-  .description('Register a question for the turn-end hook to route under your presence settings')
+  .description('Register a question for the turn-end hook to route to your devices, subject to your question-routing settings')
   .option(
     '--choice <label>',
     'answers to offer instead of free text; repeat the flag once per answer (2-6)',
-    (v: string, all: string[]) => [...all, v], [],
+    (v: string, all: string[] = []) => [...all, v],
   )
   .option('--multi', 'with --choice, several answers may be selected')
-  .option('--detail <markdown>', 'long-form context shown only in the app, never on the banner')
-  .option('--detail-file <path>', 'read --detail from a file (use - for stdin)')
+  .option('--json', 'machine-readable output')
+  .option('--body <markdown>', 'optional Markdown context appended after the question block')
+  .option('--body-file <path>', 'read optional Markdown context from a file (use - for stdin)')
   .option('--form <path>', 'ask several questions as one form; JSON file (use - for stdin)')
-  .option('--session <id>', 'session id (default: the session working in this directory, else $NOTIFAI_SESSION)')
-  .action((question: string | undefined, opts: {
+  .option(
+    '--image <path|url|media_id>',
+    'upload or attach an image in collection order (repeatable, maximum 8)',
+    (v: string, all: string[] = []) => [...all, v],
+  )
+  .option(
+    '--image-alt <text>',
+    'alt text paired with --image occurrences by position (repeatable)',
+    (v: string, all: string[] = []) => [...all, v],
+  )
+  .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)')
+  .action(async (question: string | undefined, opts: {
     choice?: string[]
     multi?: boolean
-    detail?: string
-    detailFile?: string
+    json?: boolean
+    body?: string
+    bodyFile?: string
     form?: string
-    session?: string
+    image?: string[]
+    imageAlt?: string[]
+    project?: string
+    sessionId?: string
+    sessionLabel?: string
   }) => {
-    let detail = opts.detail
-    if (typeof opts.detailFile === 'string') {
-      if (detail !== undefined) {
-        deps.io.err('Pass either --detail or --detail-file, not both.')
+    let body = opts.body
+    if (typeof opts.bodyFile === 'string') {
+      if (body !== undefined) {
+        deps.io.err('Pass either --body or --body-file, not both.')
         process.exit(2)
       }
       try {
-        detail = readFileSync(opts.detailFile === '-' ? 0 : opts.detailFile, 'utf8')
+        body = readFileSync(opts.bodyFile === '-' ? 0 : opts.bodyFile, 'utf8')
       } catch (err) {
-        deps.io.err(`Could not read ${opts.detailFile}: ${String(err)}`)
+        deps.io.err(`Could not read ${opts.bodyFile}: ${String(err)}`)
         process.exit(2)
       }
     }
@@ -421,15 +481,20 @@ program
         process.exit(2)
       }
     }
-    // commander's collector defaults to []; an empty list means "not asked".
+    // Commander collectors default to []; an empty list means "not passed".
     const flags: Parameters<typeof askCommand>[2] = {
-      ...(opts.session !== undefined ? { session: opts.session } : {}),
       ...(opts.choice?.length ? { choice: opts.choice } : {}),
       ...(opts.multi ? { multi: true } : {}),
-      ...(detail !== undefined ? { detail } : {}),
+      ...(body !== undefined ? { body } : {}),
       ...(form !== undefined ? { form } : {}),
+      ...(opts.image?.length ? { image: opts.image } : {}),
+      ...(opts.imageAlt?.length ? { imageAlt: opts.imageAlt } : {}),
+      ...(opts.project !== undefined ? { project: opts.project } : {}),
+      ...(opts.sessionId !== undefined ? { sessionId: opts.sessionId } : {}),
+      ...(opts.sessionLabel !== undefined ? { sessionLabel: opts.sessionLabel } : {}),
+      ...(opts.json === true ? { json: true } : {}),
     }
-    process.exit(askCommand(deps, question, flags))
+    process.exit(await askCommand(deps, question, flags))
   })
 
 program
@@ -497,7 +562,7 @@ program
   .option('--all', 'lift the default limit, up to a hard cap')
   .option('--since <when>', 'only records newer than this: 10m, 2h, 1d, or an ISO 8601 instant')
   .option('--level <level>', 'minimum severity: error | info | debug (error shows only failures)')
-  .option('--event <name>', 'only this event; repeatable', (v: string, all: string[]) => [...all, v], [])
+  .option('--event <name>', 'only this event; repeatable', (v: string, all: string[] = []) => [...all, v])
   .option('--run <id>', 'everything one command invocation did')
   .option('--request <id>', 'everything about one notification request')
   .option('--session <id>', 'only this harness session')

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 = 5
+const OPENCODE_ADAPTER_VERSION = 6
 
 export function opencodePluginDir(
   global: boolean,
@@ -75,150 +75,32 @@ export interface OpencodePluginOptions {
  * hand that to the CLI on stdin. It deliberately fails open: an adapter error
  * never changes OpenCode's own behavior.
  */
-export function opencodePluginSource(options: OpencodePluginOptions): string {
-  if (hookHostPlatform(options.platform) === 'win32') {
-    return win32OpencodePluginSource(options)
-  }
-  return posixOpencodePluginSource(options)
-}
-
-function posixOpencodePluginSource(options: OpencodePluginOptions): string {
-  const { adapterPath, timeoutSeconds } = options
-  return `${OPENCODE_PLUGIN_MARKER}
-// Generated by \`notifai hooks install --harness opencode\`. Edits are lost on
-// the next install; change the CLI instead, which is where the logic lives.
-import { spawn } from "node:child_process"
-
-const ADAPTER = ${JSON.stringify(adapterPath)}
-const TIMEOUT_MS = ${timeoutSeconds * 1000}
-const ADAPTER_VERSION = ${OPENCODE_ADAPTER_VERSION}
-
 /**
- * Runs \`notifai hook <event>\`, feeding it the same JSON envelope the other
- * harnesses send. Resolves to stdout, or null if anything at all went wrong.
+ * The plugin body, which is the same on every platform except for how it
+ * reaches the adapter.
+ *
+ * It was two near-identical copies — about a hundred and twenty lines each,
+ * differing only in the spawn call — so every fix to the plugin had to be made
+ * twice or silently apply to one platform.
  */
-function runHook(event, envelope) {
-  return new Promise((resolve) => {
-    let child
-    try {
-      child = spawn(ADAPTER, ["hook", event, "--owner", "notifai", "--harness", "opencode"], {
-        env: process.env,
-        shell: false,
-        stdio: ["pipe", "pipe", "pipe"],
-      })
-    } catch {
-      resolve(null)
-      return
-    }
-
-    let stdout = ""
-    let settled = false
-    const finish = (value) => {
-      if (settled) return
-      settled = true
-      clearTimeout(timer)
-      resolve(value)
-    }
-    const timer = setTimeout(() => {
-      child.kill("SIGTERM")
-      finish(null)
-    }, TIMEOUT_MS)
-
-    child.stdout?.setEncoding("utf-8")
-    child.stdout?.on("data", (chunk) => {
-      stdout += chunk
-    })
-    // Hook stderr is diagnostics, not plugin output; discard it here.
-    child.stderr?.resume()
-    child.on("error", () => finish(null))
-    child.on("close", () => finish(stdout))
-
-    try {
-      child.stdin?.end(JSON.stringify(envelope))
-    } catch {
-      finish(null)
-    }
-  })
-}
-
-function additionalContext(stdout) {
-  if (typeof stdout !== "string" || stdout.trim() === "") return null
-  try {
-    const parsed = JSON.parse(stdout)
-    const context = parsed?.hookSpecificOutput?.additionalContext
-    return typeof context === "string" && context.length > 0 ? context : null
-  } catch {
-    return null
-  }
-}
-
-export const NotifAIPlugin = async ({ directory }) => {
-  const cwd = typeof directory === "string" && directory.length > 0 ? directory : process.cwd()
-
-  return {
-    /** Exact active-harness identity for shell commands such as \`notifai ask\`. */
-    "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
-      }
-    },
-
-    /**
-     * Presence. The user typing is the signal every harness shares, and it is
-     * also what publishes the project -> session pointer \`notifai ask\` reads.
-     */
-    "chat.message": async (input, output) => {
-      const stdout = await runHook("user-prompt-submit", {
-        session_id: input?.sessionID ?? input?.info?.sessionID,
-        cwd,
-        hook_event_name: "UserPromptSubmit",
-      })
-      const context = additionalContext(stdout)
-      if (context !== null) {
-        output.parts.push({
-          id: "prt_notifai_" + Date.now(),
-          sessionID: input.sessionID,
-          messageID: output.message.id,
-          type: "text",
-          text: context,
-          synthetic: true,
-        })
-      }
-    },
-
-    /** Session lifecycle events are delivered through OpenCode's event bus. */
-    event: async ({ event }) => {
-      if (event?.type === "session.idle") {
-        await runHook("stop", {
-          session_id: event?.properties?.sessionID,
-          cwd,
-          hook_event_name: "Stop",
-        })
-      } else if (event?.type === "session.deleted") {
-        await runHook("session-end", {
-          session_id: event?.properties?.info?.id,
-          cwd,
-          hook_event_name: "SessionEnd",
-        })
-      }
-    },
-  }
-}
-`
-}
-
-function win32OpencodePluginSource(options: OpencodePluginOptions): string {
+export function opencodePluginSource(options: OpencodePluginOptions): string {
   const { adapterPath, timeoutSeconds } = options
-  const nodePath = options.nodePath ?? process.execPath
+  // Windows cannot execute the adapter script directly, so it goes through the
+  // registered Node executable and the console window is suppressed.
+  const win32 = hookHostPlatform(options.platform) === 'win32'
+  const nodeConstant = win32
+    ? `const NODE = ${JSON.stringify(options.nodePath ?? process.execPath)}\n`
+    : ''
+  const spawnArguments = win32
+    ? 'NODE, [ADAPTER, "hook", event, "--owner", "notifai", "--harness", "opencode"]'
+    : 'ADAPTER, ["hook", event, "--owner", "notifai", "--harness", "opencode"]'
+  const windowsHide = win32 ? '\n        windowsHide: true,' : ''
   return `${OPENCODE_PLUGIN_MARKER}
 // Generated by \`notifai hooks install --harness opencode\`. Edits are lost on
 // the next install; change the CLI instead, which is where the logic lives.
 import { spawn } from "node:child_process"
 
-const NODE = ${JSON.stringify(nodePath)}
-const ADAPTER = ${JSON.stringify(adapterPath)}
+${nodeConstant}const ADAPTER = ${JSON.stringify(adapterPath)}
 const TIMEOUT_MS = ${timeoutSeconds * 1000}
 const ADAPTER_VERSION = ${OPENCODE_ADAPTER_VERSION}
 
@@ -230,10 +112,9 @@ function runHook(event, envelope) {
   return new Promise((resolve) => {
     let child
     try {
-      child = spawn(NODE, [ADAPTER, "hook", event, "--owner", "notifai", "--harness", "opencode"], {
+      child = spawn(${spawnArguments}, {
         env: process.env,
-        shell: false,
-        windowsHide: true,
+        shell: false,${windowsHide}
         stdio: ["pipe", "pipe", "pipe"],
       })
     } catch {
@@ -271,17 +152,6 @@ function runHook(event, envelope) {
   })
 }
 
-function additionalContext(stdout) {
-  if (typeof stdout !== "string" || stdout.trim() === "") return null
-  try {
-    const parsed = JSON.parse(stdout)
-    const context = parsed?.hookSpecificOutput?.additionalContext
-    return typeof context === "string" && context.length > 0 ? context : null
-  } catch {
-    return null
-  }
-}
-
 export const NotifAIPlugin = async ({ directory }) => {
   const cwd = typeof directory === "string" && directory.length > 0 ? directory : process.cwd()
 
@@ -299,23 +169,13 @@ export const NotifAIPlugin = async ({ directory }) => {
      * Presence. The user typing is the signal every harness shares, and it is
      * also what publishes the project -> session pointer \`notifai ask\` reads.
      */
-    "chat.message": async (input, output) => {
-      const stdout = await runHook("user-prompt-submit", {
+    /** Publishes the session pointer; the CLI returns no content to inject. */
+    "chat.message": async (input) => {
+      await runHook("user-prompt-submit", {
         session_id: input?.sessionID ?? input?.info?.sessionID,
         cwd,
         hook_event_name: "UserPromptSubmit",
       })
-      const context = additionalContext(stdout)
-      if (context !== null) {
-        output.parts.push({
-          id: "prt_notifai_" + Date.now(),
-          sessionID: input.sessionID,
-          messageID: output.message.id,
-          type: "text",
-          text: context,
-          synthetic: true,
-        })
-      }
     },
 
     /** Session lifecycle events are delivered through OpenCode's event bus. */

package/src/question-caps.test.ts

@@ -0,0 +1,49 @@
+import { mkdtempSync } from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { describe, expect, it } from 'vitest'
+import { MAX_LIVE_QUESTIONS, MAX_PENDING_QUESTIONS, registerQuestion } from './hooks.js'
+
+/**
+ * `registerQuestion` decides how many questions one session may hold, and these
+ * exercise it directly against a bare state directory — no harness, no server,
+ * no clock. They live apart from `hooks.test.ts` because nothing here needs
+ * what that file spends its setup on.
+ */
+const state = (): NodeJS.ProcessEnv => {
+  const dir = mkdtempSync(path.join(os.tmpdir(), 'notifai-caps-'))
+  return { HOME: dir, XDG_STATE_HOME: path.join(dir, 'state') } as NodeJS.ProcessEnv
+}
+
+describe('how many questions one session may hold', () => {
+  it('stops an agent registering a fifth question nobody has asked yet', () => {
+    const env = state()
+    for (let i = 0; i < MAX_PENDING_QUESTIONS; i += 1) {
+      registerQuestion('loop', env, { question: `Q${i}?` })
+    }
+    expect(() => registerQuestion('loop', env, { question: 'One more?' })).toThrow(
+      /already waiting to be asked/,
+    )
+  })
+
+  it('does not count a question the user simply has not answered yet', () => {
+    // An answer stays accepted for a day. Counting questions already on the
+    // user's devices against the loop guard would let a patient user stop the
+    // agent from asking anything at all.
+    const env = state()
+    for (let i = 0; i < MAX_PENDING_QUESTIONS; i += 1) {
+      registerQuestion('live', env, { question: `Asked ${i}?`, request_id: `req_${i}` })
+    }
+    expect(() => registerQuestion('live', env, { question: 'A new one?' })).not.toThrow()
+  })
+
+  it('still bounds what one session can put on the lock screen', () => {
+    const env = state()
+    for (let i = 0; i < MAX_LIVE_QUESTIONS; i += 1) {
+      registerQuestion('flood', env, { question: `Asked ${i}?`, request_id: `req_${i}` })
+    }
+    expect(() => registerQuestion('flood', env, { question: 'One too many?' })).toThrow(
+      /already open/,
+    )
+  })
+})