@raidiant/notifai 5.0.0 → 6.0.0

package/src/config-schema.ts

@@ -83,7 +83,7 @@ const INFO: Record<ConfigKey, Omit<ConfigKeyInfo, 'key'>> = {
     label: 'Send questions to my devices',
     group: 'questions',
     kind: 'boolean',
-    summary: 'Whether a registered question may reach your phone and Mac at all',
+    summary: 'Whether a registered question may reach your iPhone at all',
     detail:
       'The master switch for question routing. When this is off, a question an agent registers with `notifai ask` stays in the terminal and never leaves this machine, whatever else is configured. Turn it off to stop being reached for a while without uninstalling the harness hooks.',
     example: 'true',

package/src/config.test.ts

@@ -177,6 +177,15 @@ describe('config precedence', () => {
     expect(config.wait_seconds.value).toBe(2)
     expect(config.wait_seconds.source).toBe('flag')
   })
+
+  it('uses the prior default when a newer CLI wrote an unknown enum value', () => {
+    const { env, cwd } = setup({
+      globalToml: 'sound = "future-sound"\ninterruption_level = "future-level"\n',
+    })
+    const config = loadConfig({ cwd, env })
+    expect(config.sound).toEqual({ value: null, source: 'default' })
+    expect(config.interruption_level).toEqual({ value: null, source: 'default' })
+  })
 })
 
 describe('draft building', () => {

package/src/config.ts

@@ -1,9 +1,12 @@
-import { REPLY_MAX_WINDOW_SECONDS } from '@raidiant/notifai-protocol'
+import {
+  CLI_SOUNDS,
+  INTERRUPTION_LEVELS,
+  REPLY_MAX_WINDOW_SECONDS,
+} from '@raidiant/notifai-protocol'
 import { createHash } from 'node:crypto'
 import { existsSync, readFileSync, realpathSync } from 'node:fs'
 import path from 'node:path'
 import { parse as parseToml } from 'smol-toml'
-import type { CLI_SOUNDS, INTERRUPTION_LEVELS } from '@raidiant/notifai-protocol'
 import { configHome, stateHome } from './platform.js'
 
 /**
@@ -133,6 +136,8 @@ export const NUMERIC_CONFIG_KEYS: readonly ConfigKey[] = [
  * is the same discipline the numeric bounds follow.
  */
 export const ENUM_CONFIG_VALUES: Partial<Record<ConfigKey, readonly string[]>> = {
+  sound: CLI_SOUNDS,
+  interruption_level: INTERRUPTION_LEVELS,
   log_level: LOG_LEVELS,
 }
 

package/src/credentials.test.ts

@@ -168,7 +168,10 @@ describe('FileStore', () => {
     if (process.platform !== 'win32') {
       expect(statSync(file).mode & 0o777).toBe(0o600)
     }
-    expect(JSON.parse(readFileSync(file, 'utf8'))).toEqual(SAMPLE)
+    expect(JSON.parse(readFileSync(file, 'utf8'))).toEqual({
+      format: 'notifai.machine-credential.v1',
+      ...SAMPLE,
+    })
     expect(store.load()).toEqual(SAMPLE)
     store.save(OTHER)
     expect(store.load()).toEqual(OTHER)
@@ -190,6 +193,27 @@ describe('FileStore', () => {
     writeRaw(file, `${JSON.stringify({ machineId: 'mach_fixture' })}\n`)
     expect(new FileStore(env).load()).toBeNull()
   })
+
+  it('reads the unversioned v1 shape while making every new save explicit', () => {
+    const { env } = sandbox('file-unversioned-v1')
+    const file = path.join(env.XDG_CONFIG_HOME!, 'notifai', 'credentials.json')
+    writeRaw(file, `${JSON.stringify(SAMPLE)}\n`)
+    const store = new FileStore(env)
+    expect(store.load()).toEqual(SAMPLE)
+    store.save(SAMPLE)
+    expect(JSON.parse(readFileSync(file, 'utf8'))).toMatchObject({
+      format: 'notifai.machine-credential.v1',
+    })
+  })
+
+  it('does not interpret or erase a credential from a future format epoch', () => {
+    const { env } = sandbox('file-future-format')
+    const file = path.join(env.XDG_CONFIG_HOME!, 'notifai', 'credentials.json')
+    const future = `${JSON.stringify({ format: 'notifai.machine-credential.v2', ...SAMPLE })}\n`
+    writeRaw(file, future)
+    expect(new FileStore(env).load()).toBeNull()
+    expect(readFileSync(file, 'utf8')).toBe(future)
+  })
 })
 
 describe('WindowsDpapiStore', () => {

package/src/credentials.ts

@@ -44,6 +44,7 @@ export interface CredentialStoreOptions {
 }
 
 const SERVICE = 'io.notifai.cli'
+const CREDENTIAL_FORMAT = 'notifai.machine-credential.v1'
 const DPAPI_FORMAT = 'notifai.dpapi.current-user.v1'
 const DPAPI_ENTROPY = 'io.notifai.cli'
 const DPAPI_TIMEOUT_MS = 15_000
@@ -136,7 +137,7 @@ export class KeychainStore implements CredentialStore {
         '-a',
         'machine',
         '-w',
-        JSON.stringify(credential),
+        JSON.stringify(serializeCredential(credential)),
       ],
       { stdio: 'ignore' },
     )
@@ -189,7 +190,7 @@ export class FileStore implements CredentialStore {
   }
 
   save(credential: MachineCredential): void {
-    atomicWriteFileSync(this.filePath(), `${JSON.stringify(credential, null, 2)}\n`, {
+    atomicWriteFileSync(this.filePath(), `${JSON.stringify(serializeCredential(credential), null, 2)}\n`, {
       mode: 0o600,
       preserveMode: false,
       requireCurrentUserOwner: true,
@@ -251,7 +252,7 @@ export class WindowsDpapiStore implements CredentialStore {
     if (file === null) {
       throw new Error('Windows credential store path is not configured (LOCALAPPDATA is missing)')
     }
-    const blob = this.protect(Buffer.from(JSON.stringify(credential), 'utf8'))
+    const blob = this.protect(Buffer.from(JSON.stringify(serializeCredential(credential)), 'utf8'))
     atomicWriteFileSync(file, `${JSON.stringify({ format: DPAPI_FORMAT, data: blob })}\n`, {
       mode: 0o600,
       preserveMode: false,
@@ -302,6 +303,10 @@ export class WindowsDpapiStore implements CredentialStore {
   }
 }
 
+function serializeCredential(credential: MachineCredential): Record<string, string> {
+  return { format: CREDENTIAL_FORMAT, ...credential }
+}
+
 function parseCredentialJson(raw: string): MachineCredential | null {
   try {
     return parseCredential(JSON.parse(raw) as unknown)
@@ -313,6 +318,11 @@ function parseCredentialJson(raw: string): MachineCredential | null {
 function parseCredential(raw: unknown): MachineCredential | null {
   if (raw === null || typeof raw !== 'object') return null
   const value = raw as Record<string, unknown>
+  const format = value['format']
+  // Unversioned credentials are the pre-epoch v1 representation. A future
+  // format is left untouched on disk/keychain and treated as unavailable;
+  // interpreting it as v1 could silently change authentication meaning.
+  if (format !== undefined && format !== CREDENTIAL_FORMAT) return null
   const machineId = value['machineId']
   const secret = value['secret']
   const baseUrl = value['baseUrl']

package/src/hooks.test.ts

@@ -1,4 +1,4 @@
-import { spawn, type ChildProcess } from 'node:child_process'
+import { execFileSync, spawn, type ChildProcess } from 'node:child_process'
 import {
   existsSync,
   mkdirSync,
@@ -167,7 +167,8 @@ function fakeClient(recorder: Recorder, replies: ReplyView[]): ApiClient {
           platform: 'ios' as const,
           permission_status: 'authorized',
           registration_healthy: true,
-          reply_protocol_version: 2,
+          capabilities: ['answer'],
+          derived_status: 'working',
           last_seen_at: null,
         },
         {
@@ -176,7 +177,8 @@ function fakeClient(recorder: Recorder, replies: ReplyView[]): ApiClient {
           platform: 'macos' as const,
           permission_status: 'authorized',
           registration_healthy: true,
-          reply_protocol_version: 2,
+          capabilities: ['answer'],
+          derived_status: 'working',
           last_seen_at: null,
         },
       ],
@@ -337,6 +339,23 @@ function harness(replies: ReplyView[] = []): Harness {
   }
 }
 
+function runFixtureGit(cwd: string, ...args: string[]): string {
+  return execFileSync('git', ['-C', cwd, ...args], {
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'pipe'],
+  }).trim()
+}
+
+function initializeFixtureRepository(root: string, branch = 'branch-a'): void {
+  runFixtureGit(root, 'init')
+  runFixtureGit(root, 'config', 'user.email', 'notifai-tests@example.invalid')
+  runFixtureGit(root, 'config', 'user.name', 'Notifai Tests')
+  writeFileSync(path.join(root, 'tracked.txt'), 'fixture\n')
+  runFixtureGit(root, 'add', 'tracked.txt')
+  runFixtureGit(root, 'commit', '-m', 'fixture')
+  runFixtureGit(root, 'branch', '-M', branch)
+}
+
 function stdin(payload: unknown): () => Promise<string> {
   return async () => JSON.stringify(payload)
 }
@@ -494,6 +513,26 @@ describe('the waiter wall clock', () => {
 })
 
 describe('pushing a registered question', () => {
+  it('keeps unknown future session keys through an older read-modify-write', () => {
+    const h = harness([])
+    const sessionId = 'future-session-format'
+    const file = path.join(stateDir(h.env), 'sessions', `${sanitizeSessionId(sessionId)}.json`)
+    mkdirSync(path.dirname(file), { recursive: true })
+    writeFileSync(
+      file,
+      `${JSON.stringify({
+        last_prompt_at: NOW,
+        future_session_key: { nested: ['kept'] },
+      })}\n`,
+    )
+
+    registerQuestion(sessionId, h.env, { question: 'Still preserved?' }, NOW)
+
+    const rewritten = JSON.parse(readFileSync(file, 'utf8')) as Record<string, unknown>
+    expect(rewritten['future_session_key']).toEqual({ nested: ['kept'] })
+    expect(rewritten['pending']).toHaveLength(1)
+  })
+
   // Found by a live Claude Code session: a spawned agent always has a
   // just-set last_prompt_at, and the routing gate once read that as the user
   // being present — so its FIRST question could never escalate, which is the
@@ -864,7 +903,7 @@ describe('terminal-first grace window', () => {
     ).toBeGreaterThanOrEqual(60)
   })
 
-  it('never pushes a question to a Companion without the current reply protocol', async () => {
+  it('never pushes a question to a Companion that did not advertise answer', async () => {
     const h = harness([])
     const factory = h.deps.clientFactory
     h.deps.clientFactory = () => {
@@ -874,7 +913,7 @@ describe('terminal-first grace window', () => {
         listDevices: async () => ({
           devices: (await client.listDevices()).devices.map((device) => ({
             ...device,
-            reply_protocol_version: null,
+            capabilities: [],
           })),
         }),
       } as ApiClient
@@ -2638,6 +2677,58 @@ describe('user-prompt-submit hook', () => {
     clearSessionState('s14', h.env)
     expect(readProjectSession(project, h.env, NOW)).toBeNull()
   })
+
+  it('round-trips future project-pointer fields while publishing a session', () => {
+    const h = harness()
+    const pointer = projectSessionPointerPath(h.deps.cwd, h.env)
+    const futureEntry = {
+      format: 2,
+      session: { id: 'future-session', runtime: 'future-harness' },
+    }
+    mkdirSync(path.dirname(pointer), { recursive: true })
+    writeFileSync(
+      pointer,
+      `${JSON.stringify({
+        future_root: { retained: true },
+        sessions: [
+          {
+            session_id: 'still-running',
+            updated_at: NOW - 1,
+            harness: 'codex',
+            future_entry: { retained: true },
+          },
+          {
+            session_id: 'new-session',
+            updated_at: NOW - 2,
+            harness: 'claude-code',
+            future_current_entry: { retained: true },
+          },
+          futureEntry,
+        ],
+      })}\n`,
+    )
+
+    writeProjectSession(h.deps.cwd, h.env, 'new-session', NOW, 'claude-code')
+
+    expect(JSON.parse(readFileSync(pointer, 'utf8'))).toEqual({
+      future_root: { retained: true },
+      sessions: [
+        {
+          session_id: 'still-running',
+          updated_at: NOW - 1,
+          harness: 'codex',
+          future_entry: { retained: true },
+        },
+        futureEntry,
+        {
+          session_id: 'new-session',
+          updated_at: NOW,
+          harness: 'claude-code',
+          future_current_entry: { retained: true },
+        },
+      ],
+    })
+  })
 })
 
 describe('session-end hook', () => {
@@ -2656,6 +2747,36 @@ describe('session-end hook', () => {
     expect(records.at(-1)?.data).toMatchObject({ outcome: 'cleaned', queued_retirements: 0 })
   })
 
+  it('round-trips future session-state fields when SessionEnd preserves an obligation', async () => {
+    const h = harness()
+    const sessionId = 'session-end-future-state'
+    const stateFile = path.join(
+      stateDir(h.env),
+      'sessions',
+      `${sanitizeSessionId(sessionId)}.json`,
+    )
+    const acknowledgement = {
+      request_id: 'req_future_ack',
+      recorded_at: NOW,
+      future_entry: { retained: true },
+    }
+    mkdirSync(path.dirname(stateFile), { recursive: true })
+    writeFileSync(
+      stateFile,
+      `${JSON.stringify({
+        future_root: { retained: true },
+        acknowledgement_due: [acknowledgement],
+      })}\n`,
+    )
+
+    await hookRunCommand(h.deps, 'session-end', stdin({ session_id: sessionId }))
+
+    expect(JSON.parse(readFileSync(stateFile, 'utf8'))).toEqual({
+      future_root: { retained: true },
+      acknowledgement_due: [acknowledgement],
+    })
+  })
+
   it('runs the real Codex SessionEnd cleanup before contended diagnostics and exits fail-open', async () => {
     const h = harness()
     const sessionId = 'session-end-budget'
@@ -2772,6 +2893,54 @@ describe('session-end hook', () => {
     ).toEqual({ sessionId: 'still-running', harness: 'codex' })
   })
 
+  it('keeps future project-pointer data when clearing the ending session', async () => {
+    const h = harness()
+    const pointer = projectSessionPointerPath(h.deps.cwd, h.env)
+    const futureEntry = {
+      format: 2,
+      session: { id: 'future-session', runtime: 'future-harness' },
+    }
+    writeSessionState('still-running', h.env, { last_prompt_at: NOW })
+    writeSessionState('ending', h.env, { last_prompt_at: NOW })
+    mkdirSync(path.dirname(pointer), { recursive: true })
+    writeFileSync(
+      pointer,
+      `${JSON.stringify({
+        future_root: { retained: true },
+        sessions: [
+          {
+            session_id: 'still-running',
+            updated_at: NOW - 1,
+            harness: 'codex',
+            future_entry: { retained: true },
+          },
+          futureEntry,
+          { session_id: 'ending', updated_at: NOW, harness: 'claude-code' },
+        ],
+      })}\n`,
+    )
+
+    await hookRunCommand(
+      h.deps,
+      'session-end',
+      stdin({ session_id: 'ending', cwd: h.deps.cwd }),
+      'claude-code',
+    )
+
+    expect(JSON.parse(readFileSync(pointer, 'utf8'))).toEqual({
+      future_root: { retained: true },
+      sessions: [
+        {
+          session_id: 'still-running',
+          updated_at: NOW - 1,
+          harness: 'codex',
+          future_entry: { retained: true },
+        },
+        futureEntry,
+      ],
+    })
+  })
+
   it('preserves incomplete live state and reports why it cannot retire it', async () => {
     const h = harness()
     writeSessionState('s-incomplete', h.env, {
@@ -2803,6 +2972,164 @@ describe('malformed input', () => {
 })
 
 describe('telling concurrent agents apart', () => {
+  it('uses each hook event branch while keeping one immutable session identity', async () => {
+    const h = harness([reply({ text: 'Yes' })])
+    initializeFixtureRepository(h.deps.cwd)
+    registerQuestion(
+      'session-branch-transition',
+      h.env,
+      {
+        question: 'Ship it?',
+        source: {
+          session_id: 'session-branch-transition',
+          session_label: 'Branch transition',
+          harness: 'claude-code',
+          branch: 'branch-a',
+        },
+      },
+      NOW,
+    )
+
+    runFixtureGit(h.deps.cwd, 'checkout', '-b', 'branch-b')
+    await hookRunCommand(
+      h.deps,
+      'stop',
+      stdin({ session_id: 'session-branch-transition', cwd: h.deps.cwd }),
+      'claude-code',
+    )
+
+    const question = h.recorder.submitted.find((entry) => entry.draft.event === 'agent_question')
+    expect(question?.draft.source).toEqual({
+      session_id: 'session-branch-transition',
+      session_label: 'Branch transition',
+      harness: 'claude-code',
+      branch: 'branch-b',
+    })
+
+    runFixtureGit(h.deps.cwd, 'checkout', 'branch-a')
+    h.recorder.acknowledged ??= new Set()
+    h.recorder.acknowledged.add(h.recorder.receipts[0]!)
+    await hookRunCommand(
+      h.deps,
+      'stop',
+      stdin({
+        session_id: 'session-branch-transition',
+        cwd: h.deps.cwd,
+        stop_hook_active: true,
+      }),
+      'claude-code',
+    )
+
+    const retirement = h.recorder.submitted.find(
+      (entry) => entry.draft.event === 'question_retired',
+    )
+    expect(retirement?.draft.source).toEqual({
+      session_id: 'session-branch-transition',
+      session_label: 'Branch transition',
+      harness: 'claude-code',
+      branch: 'branch-a',
+    })
+  })
+
+  it('clears registration-time branch and worktree on a detached-HEAD hook event', async () => {
+    const h = harness([])
+    initializeFixtureRepository(h.deps.cwd)
+    registerQuestion(
+      'session-detached',
+      h.env,
+      {
+        question: 'Ship it?',
+        source: {
+          session_id: 'session-detached',
+          session_label: 'Detached review',
+          harness: 'claude-code',
+          branch: 'branch-a',
+          worktree: 'stale-worktree',
+        },
+      },
+      NOW,
+    )
+    runFixtureGit(h.deps.cwd, 'checkout', '--detach', 'HEAD')
+
+    await hookRunCommand(
+      h.deps,
+      'stop',
+      stdin({ session_id: 'session-detached', cwd: h.deps.cwd }),
+      'claude-code',
+    )
+
+    const question = h.recorder.submitted.find((entry) => entry.draft.event === 'agent_question')
+    expect(question?.draft.source).toEqual({
+      session_id: 'session-detached',
+      session_label: 'Detached review',
+      harness: 'claude-code',
+    })
+  })
+
+  it('captures entry into and exit from a linked worktree on the same session', async () => {
+    const h = harness([reply({ text: 'Yes' })])
+    initializeFixtureRepository(h.deps.cwd, 'main')
+    const linked = `${h.deps.cwd}-linked`
+    runFixtureGit(h.deps.cwd, 'worktree', 'add', '-b', 'worktree-branch', linked)
+    try {
+      registerQuestion(
+        'session-worktree-transition',
+        h.env,
+        {
+          question: 'Ship it?',
+          source: {
+            session_id: 'session-worktree-transition',
+            session_label: 'Worktree transition',
+            harness: 'claude-code',
+            branch: 'main',
+          },
+        },
+        NOW,
+      )
+
+      await hookRunCommand(
+        h.deps,
+        'stop',
+        stdin({ session_id: 'session-worktree-transition', cwd: linked }),
+        'claude-code',
+      )
+      const question = h.recorder.submitted.find(
+        (entry) => entry.draft.event === 'agent_question',
+      )
+      expect(question?.draft.source).toEqual({
+        session_id: 'session-worktree-transition',
+        session_label: 'Worktree transition',
+        harness: 'claude-code',
+        branch: 'worktree-branch',
+        worktree: path.basename(linked),
+      })
+
+      h.recorder.acknowledged ??= new Set()
+      h.recorder.acknowledged.add(h.recorder.receipts[0]!)
+      await hookRunCommand(
+        h.deps,
+        'stop',
+        stdin({
+          session_id: 'session-worktree-transition',
+          cwd: h.deps.cwd,
+          stop_hook_active: true,
+        }),
+        'claude-code',
+      )
+      const retirement = h.recorder.submitted.find(
+        (entry) => entry.draft.event === 'question_retired',
+      )
+      expect(retirement?.draft.source).toEqual({
+        session_id: 'session-worktree-transition',
+        session_label: 'Worktree transition',
+        harness: 'claude-code',
+        branch: 'main',
+      })
+    } finally {
+      runFixtureGit(h.deps.cwd, 'worktree', 'remove', '--force', linked)
+    }
+  })
+
   it('stamps structured Source Context on the question it pushes', async () => {
     const h = harness([])
     registerQuestion(
@@ -3881,11 +4208,9 @@ describe('escalation waiter delivery seam', () => {
 
 
 describe('session state across a prompt', () => {
-  it('carries every kind of session state across a typed prompt', async () => {
-    // The prompt handler rebuilds state from named fields, so a field nobody
-    // remembered to name is erased by the user typing. That is how an
-    // acknowledgement obligation once vanished. This fails if a future field is
-    // added to SessionState and not carried across.
+  it('carries known and future session state across a typed prompt', async () => {
+    // The prompt transition deliberately changes pending/retiring state and the
+    // continuation count, but fields introduced by a newer CLI remain opaque.
     const h = harness([])
     const before = {
       last_prompt_at: AWAY,
@@ -3903,7 +4228,11 @@ describe('session state across a prompt', () => {
       acknowledgement_due: [{ request_id: 'req_carry_ack', recorded_at: NOW }],
       acknowledgement_blocks: 2,
     }
-    writeSessionState('carry-all', h.env, before)
+    const futureSessionValue = { nested: ['kept'], revision: 2 }
+    writeSessionState('carry-all', h.env, {
+      ...before,
+      future_session_key: futureSessionValue,
+    } as SessionState & { future_session_key: typeof futureSessionValue })
 
     await hookRunCommand(
       h.deps,
@@ -3915,6 +4244,17 @@ describe('session state across a prompt', () => {
     for (const key of Object.keys(before) as (keyof typeof before)[]) {
       expect(after[key], `${key} did not survive the prompt`).toBeDefined()
     }
+    const persisted = JSON.parse(
+      readFileSync(
+        path.join(
+          stateDir(h.env),
+          'sessions',
+          `${sanitizeSessionId('carry-all')}.json`,
+        ),
+        'utf8',
+      ),
+    ) as Record<string, unknown>
+    expect(persisted['future_session_key']).toEqual(futureSessionValue)
     // The one field a prompt resets rather than carries.
     expect(after.continuation?.count).toBe(0)
     expect(after.acknowledgement_blocks).toBe(2)