@raidiant/notifai 1.0.1 → 1.1.0

package/src/hook-adapter.ts

@@ -12,8 +12,11 @@ import { atomicWriteFileSync } from './atomic-file.js'
 import { withTargetFileLock } from './file-lock.js'
 
 const ADAPTER_MARKER = '# notifai managed hook adapter'
+const WIN32_ADAPTER_MARKER = '// notifai managed hook adapter'
 const ADAPTER_VERSION = 1
 
+export type HookHostPlatform = 'posix' | 'win32'
+
 export interface HookAdapterFileTarget {
   kind?: 'file'
   execPath: string
@@ -39,6 +42,12 @@ export interface HookAdapterInspection {
   problems: string[]
 }
 
+export function hookHostPlatform(
+  platform: NodeJS.Platform | HookHostPlatform = process.platform,
+): HookHostPlatform {
+  return platform === 'win32' ? 'win32' : 'posix'
+}
+
 /**
  * One user-level identity for every harness and every project/global install.
  *
@@ -57,18 +66,21 @@ export function hookAdapterPath(homeDir: string = os.userInfo().homedir): string
 export function installHookAdapter(
   target: HookAdapterTarget,
   homeDir?: string,
+  platform: NodeJS.Platform | HookHostPlatform = process.platform,
 ): { path: string; changed: boolean } {
-  assertUsableTarget(target)
+  const host = hookHostPlatform(platform)
+  assertUsableTarget(target, host)
   const file = hookAdapterPath(homeDir)
-  ensureManagedDirectories(homeDir ?? os.userInfo().homedir)
-  const source = hookAdapterSource(target)
+  ensureManagedDirectories(homeDir ?? os.userInfo().homedir, host)
+  const source = hookAdapterSource(target, host)
   return withTargetFileLock(file, () => {
     const existing = existsSync(file) ? readSafeManagedFile(file) : null
-    const changed =
-      existing === null || existing.contents !== source || (existing.mode & 0o777) !== 0o700
+    const modeDrift =
+      host === 'posix' && existing !== null && (existing.mode & 0o777) !== 0o700
+    const changed = existing === null || existing.contents !== source || modeDrift
     if (changed) {
       atomicWriteFileSync(file, source, {
-        mode: 0o700,
+        mode: host === 'posix' ? 0o700 : 0o600,
         preserveMode: false,
         requireCurrentUserOwner: true,
       })
@@ -77,14 +89,14 @@ export function installHookAdapter(
   })
 }
 
-function assertUsableTarget(target: HookAdapterTarget): void {
+function assertUsableTarget(target: HookAdapterTarget, host: HookHostPlatform): void {
   let exec
   try {
     exec = statSync(target.execPath)
   } catch {
     throw new Error(`Hook adapter runtime ${target.execPath} does not exist.`)
   }
-  if (!exec.isFile() || (exec.mode & 0o111) === 0) {
+  if (!exec.isFile() || (host === 'posix' && (exec.mode & 0o111) === 0)) {
     throw new Error(`Hook adapter runtime ${target.execPath} is not executable.`)
   }
   if (isNpxAdapterTarget(target)) {
@@ -114,7 +126,9 @@ function assertUsableTarget(target: HookAdapterTarget): void {
 /** Inspect the shared adapter without executing either it or its registered CLI. */
 export function inspectHookAdapter(
   homeDir?: string,
+  platform: NodeJS.Platform | HookHostPlatform = process.platform,
 ): HookAdapterInspection {
+  const host = hookHostPlatform(platform)
   const file = hookAdapterPath(homeDir)
   if (!existsSync(file)) {
     return { path: file, target: null, problems: [`${file} is missing; rerun \`notifai hooks install\``] }
@@ -135,19 +149,24 @@ export function inspectHookAdapter(
   }
 
   const problems: string[] = []
-  const uid = typeof process.getuid === 'function' ? process.getuid() : undefined
-  if (uid !== undefined && stat.uid !== uid) {
-    problems.push(`${file} is owned by uid ${stat.uid}, not the current user`)
-  }
-  if ((stat.mode & 0o077) !== 0 || (stat.mode & 0o700) !== 0o700) {
-    problems.push(`${file} permissions are ${(stat.mode & 0o777).toString(8)}, expected 700`)
+  if (host === 'posix') {
+    const uid = typeof process.getuid === 'function' ? process.getuid() : undefined
+    if (uid !== undefined && stat.uid !== uid) {
+      problems.push(`${file} is owned by uid ${stat.uid}, not the current user`)
+    }
+    if ((stat.mode & 0o077) !== 0 || (stat.mode & 0o700) !== 0o700) {
+      problems.push(`${file} permissions are ${(stat.mode & 0o777).toString(8)}, expected 700`)
+    }
   }
 
   const contents = readFileSync(file, 'utf8')
-  if (!contents.startsWith(`#!/bin/sh\n${ADAPTER_MARKER}\n`)) {
+  const format = adapterFormat(contents)
+  if (format === null) {
     problems.push(`${file} has no managed adapter marker`)
+  } else if (format !== host) {
+    problems.push(`${file} is not a ${host} managed adapter; rerun \`notifai hooks install\``)
   }
-  const version = Number(/^# adapter-version: (\d+)$/m.exec(contents)?.[1] ?? Number.NaN)
+  const version = Number(meta(contents, 'adapter-version') ?? Number.NaN)
   if (version !== ADAPTER_VERSION) problems.push(`${file} uses obsolete adapter version ${version}`)
   const target = parseTarget(contents)
   if (target === null) {
@@ -155,7 +174,7 @@ export function inspectHookAdapter(
   } else {
     try {
       const exec = statSync(target.execPath)
-      if (!exec.isFile() || (exec.mode & 0o111) === 0) {
+      if (!exec.isFile() || (host === 'posix' && (exec.mode & 0o111) === 0)) {
         problems.push(`registered runtime ${target.execPath} is not executable`)
       }
     } catch {
@@ -183,7 +202,17 @@ export function inspectHookAdapter(
   return { path: file, target, problems }
 }
 
-function hookAdapterSource(target: HookAdapterTarget): string {
+/** Generate the managed adapter source for one host. Exported so tests can pin bytes. */
+export function hookAdapterSource(
+  target: HookAdapterTarget,
+  platform: NodeJS.Platform | HookHostPlatform = process.platform,
+): string {
+  return hookHostPlatform(platform) === 'win32'
+    ? win32HookAdapterSource(target)
+    : posixHookAdapterSource(target)
+}
+
+function posixHookAdapterSource(target: HookAdapterTarget): string {
   if (isNpxAdapterTarget(target)) {
     return `#!/bin/sh
 ${ADAPTER_MARKER}
@@ -225,16 +254,77 @@ exit 127
 `
 }
 
+function win32HookAdapterSource(target: HookAdapterTarget): string {
+  const header = isNpxAdapterTarget(target)
+    ? `${WIN32_ADAPTER_MARKER}
+// adapter-version: ${ADAPTER_VERSION}
+// target-kind: npx
+// target-exec-json: ${JSON.stringify(target.execPath)}
+// target-npm-cli-json: ${JSON.stringify(target.npmCli)}
+// target-spec-json: ${JSON.stringify(target.spec)}
+`
+    : `${WIN32_ADAPTER_MARKER}
+// adapter-version: ${ADAPTER_VERSION}
+// target-exec-json: ${JSON.stringify(target.execPath)}
+// target-script-json: ${JSON.stringify(target.scriptPath)}
+`
+  const argv = isNpxAdapterTarget(target)
+    ? `[${JSON.stringify(target.npmCli)}, "exec", "--yes", "--package", ${JSON.stringify(target.spec)}, "--", "notifai", ...process.argv.slice(2)]`
+    : `[${JSON.stringify(target.scriptPath)}, ...process.argv.slice(2)]`
+  const companion = isNpxAdapterTarget(target)
+    ? JSON.stringify(target.npmCli)
+    : JSON.stringify(target.scriptPath)
+  return `${header}"use strict";
+const { spawnSync } = require("node:child_process");
+const { statSync } = require("node:fs");
+const registeredExec = ${JSON.stringify(target.execPath)};
+const registeredCompanion = ${companion};
+
+function isFile(file) {
+  try {
+    return statSync(file).isFile();
+  } catch {
+    return false;
+  }
+}
+
+if (isFile(registeredExec) && isFile(registeredCompanion)) {
+  const result = spawnSync(registeredExec, ${argv}, {
+    stdio: "inherit",
+    windowsHide: true,
+  });
+  if (result.error) {
+    process.stderr.write("Notifai hook adapter target is stale; run notifai hooks install.\\n");
+    process.exit(127);
+  }
+  process.exit(result.status === null ? 1 : result.status);
+}
+
+process.stderr.write("Notifai hook adapter target is stale; run notifai hooks install.\\n");
+process.exit(127);
+`
+}
+
+function adapterFormat(contents: string): HookHostPlatform | null {
+  if (contents.startsWith(`#!/bin/sh\n${ADAPTER_MARKER}\n`)) return 'posix'
+  if (contents.startsWith(`${WIN32_ADAPTER_MARKER}\n`)) return 'win32'
+  return null
+}
+
+function meta(contents: string, key: string): string | undefined {
+  return new RegExp(`^(?:#|//) ${key}: (.+)$`, 'm').exec(contents)?.[1]
+}
+
 function parseTarget(contents: string): HookAdapterTarget | null {
-  const kind = /^# target-kind: (.+)$/m.exec(contents)?.[1]
-  const exec = /^# target-exec-json: (.+)$/m.exec(contents)?.[1]
+  const kind = meta(contents, 'target-kind')
+  const exec = meta(contents, 'target-exec-json')
   if (exec === undefined) return null
   try {
     const execPath: unknown = JSON.parse(exec)
     if (typeof execPath !== 'string') return null
     if (kind === 'npx') {
-      const npmCliRaw = /^# target-npm-cli-json: (.+)$/m.exec(contents)?.[1]
-      const specRaw = /^# target-spec-json: (.+)$/m.exec(contents)?.[1]
+      const npmCliRaw = meta(contents, 'target-npm-cli-json')
+      const specRaw = meta(contents, 'target-spec-json')
       if (npmCliRaw === undefined || specRaw === undefined) return null
       const npmCli: unknown = JSON.parse(npmCliRaw)
       const spec: unknown = JSON.parse(specRaw)
@@ -242,7 +332,7 @@ function parseTarget(contents: string): HookAdapterTarget | null {
         ? { kind: 'npx', execPath, npmCli, spec }
         : null
     }
-    const script = /^# target-script-json: (.+)$/m.exec(contents)?.[1]
+    const script = meta(contents, 'target-script-json')
     if (script === undefined) return null
     const scriptPath: unknown = JSON.parse(script)
     return typeof scriptPath === 'string' ? { execPath, scriptPath } : null
@@ -255,7 +345,7 @@ function quote(value: string): string {
   return `'${value.replaceAll("'", `'\\''`)}'`
 }
 
-function ensureManagedDirectories(homeDir: string): void {
+function ensureManagedDirectories(homeDir: string, host: HookHostPlatform): void {
   if (!existsSync(homeDir)) mkdirSync(homeDir, { recursive: true, mode: 0o700 })
   for (const dir of [path.join(homeDir, '.notifai'), path.join(homeDir, '.notifai', 'bin')]) {
     if (!existsSync(dir)) mkdirSync(dir, { mode: 0o700 })
@@ -263,11 +353,13 @@ function ensureManagedDirectories(homeDir: string): void {
     if (stat.isSymbolicLink() || !stat.isDirectory()) {
       throw new Error(`${dir} is not a regular directory; refusing to install the hook adapter.`)
     }
-    const uid = typeof process.getuid === 'function' ? process.getuid() : undefined
-    if (uid !== undefined && stat.uid !== uid) {
-      throw new Error(`${dir} is owned by uid ${stat.uid}, not the current user.`)
+    if (host === 'posix') {
+      const uid = typeof process.getuid === 'function' ? process.getuid() : undefined
+      if (uid !== undefined && stat.uid !== uid) {
+        throw new Error(`${dir} is owned by uid ${stat.uid}, not the current user.`)
+      }
+      chmodSync(dir, 0o700)
     }
-    chmodSync(dir, 0o700)
   }
 }
 

package/src/hooks.test.ts

@@ -115,6 +115,7 @@ function fakeClient(recorder: Recorder, replies: ReplyView[]): ApiClient {
           platform: 'ios' as const,
           permission_status: 'authorized',
           registration_healthy: true,
+          reply_protocol_version: 1,
           last_seen_at: null,
         },
         {
@@ -123,6 +124,7 @@ function fakeClient(recorder: Recorder, replies: ReplyView[]): ApiClient {
           platform: 'macos' as const,
           permission_status: 'authorized',
           registration_healthy: true,
+          reply_protocol_version: 1,
           last_seen_at: null,
         },
       ],
@@ -716,6 +718,30 @@ describe('terminal-first grace window', () => {
     ).toBeGreaterThanOrEqual(60)
   })
 
+  it('never pushes a question to a Companion without the current reply protocol', async () => {
+    const h = harness([])
+    const factory = h.deps.clientFactory
+    h.deps.clientFactory = () => {
+      const client = factory!()
+      return {
+        ...client,
+        listDevices: async () => ({
+          devices: (await client.listDevices()).devices.map((device) => ({
+            ...device,
+            reply_protocol_version: null,
+          })),
+        }),
+      } as ApiClient
+    }
+    writeSessionState('old-companion', h.env, { last_prompt_at: AWAY })
+    registerQuestion('old-companion', h.env, { question: 'Ship it?' }, NOW)
+
+    await hookRunCommand(h.deps, 'stop', stdin({ session_id: 'old-companion' }))
+
+    expect(h.recorder.submitted).toHaveLength(0)
+    expect(h.io.errLines.join('\n')).toContain('no device can answer a question yet')
+  })
+
   it('charges transport overrun and close time to the one waiter ceiling', async () => {
     const h = harness([])
     const factory = h.deps.clientFactory
@@ -2247,7 +2273,7 @@ describe('session-end hook', () => {
       await waitUntil(
         () =>
           readdirSync(logLock).filter((name) => name.startsWith('ticket-')).length >= 2,
-        700,
+        5_000,
         'the real Codex hook did not reach contended diagnostics before its deadline',
       )
 

package/src/hooks.ts

@@ -976,7 +976,8 @@ async function answerableDevices(ctx: HookContext): Promise<string[]> {
     .filter(
       (device) =>
         (device.platform === 'ios' || device.platform === 'macos') &&
-        device.registration_healthy,
+        device.registration_healthy &&
+        device.reply_protocol_version === 1,
     )
     .filter((device) => configured === null || configured.includes(device.device_id))
     .map((device) => device.device_id)

package/src/install-hooks.test.ts

@@ -10,6 +10,7 @@ import {
 } from 'node:fs'
 import os from 'node:os'
 import path from 'node:path'
+import { parse as parseToml, stringify as stringifyToml } from 'smol-toml'
 import { describe, expect, it } from 'vitest'
 import { parseChoices } from './send.js'
 import {
@@ -19,7 +20,9 @@ import {
   opencodePluginSource,
   opencodePluginTarget,
 } from './opencode-plugin.js'
+import { hookAdapterPath, installHookAdapter } from './hook-adapter.js'
 import {
+  BLOCKING_STOP_TIMEOUT_SECONDS,
   HARNESSES,
   applyPlan,
   detectHarness,
@@ -33,7 +36,9 @@ import {
   codexTrustKey,
   codexTrustProblems,
   handlerEvent,
+  harnessAccountHome,
   hookCommand,
+  quoteWindowsArg,
   loadSettings,
   mergeHooks,
   removeHooks,
@@ -126,7 +131,7 @@ describe('hook config', () => {
     })
   })
 
-  it('gives Claude Code an asynchronous Stop with an explicit waiter budget', () => {
+  it('gives Claude Code an asynchronous Stop with an explicit waiter budget on POSIX', () => {
     const claude = buildHookConfig({ adapterPath: ADAPTER, harness: 'claude-code' })
 
     // `async: true` is what frees the turn: the handler returns at once and the
@@ -143,6 +148,22 @@ describe('hook config', () => {
     expect(claude['SessionEnd']?.[0]?.hooks[0]?.async).toBeUndefined()
   })
 
+  it('gives Claude Code a blocking Stop continuation on Windows', () => {
+    const options = {
+      adapterPath: 'C:\\Users\\Ada\\.notifai\\bin\\hook-adapter',
+      harness: 'claude-code' as const,
+      platform: 'win32' as const,
+      nodePath: 'C:\\Program Files\\nodejs\\node.exe',
+    }
+    const claude = buildHookConfig(options)
+
+    expect(claude['Stop']?.[0]?.hooks[0]).toEqual({
+      type: 'command',
+      command: hookCommand(options.adapterPath, 'stop', 'claude-code', options),
+      timeout: BLOCKING_STOP_TIMEOUT_SECONDS,
+    })
+  })
+
   it('leaves exactly one handler per event when an old blocking shape is reinstalled over', () => {
     const old = mergeHooks({}, buildHookConfig({ adapterPath: ADAPTER }), SCRIPT)
     const migrated = mergeHooks(
@@ -226,18 +247,37 @@ describe('settings locations', () => {
     )
   })
 
-  it('uses config.toml for Codex, not the legacy hooks.json', () => {
-    expect(settingsFile('codex', false, '/repo', {})).toBe('/repo/.codex/config.toml')
+  it('keeps ambient global settings inside the test account', () => {
+    expect(os.homedir()).toBe(process.env['HOME'])
+    expect(os.homedir()).toBe(process.env['NOTIFAI_TEST_HOME'])
+    expect(settingsFile('claude-code', true, '/repo', {})).toBe(
+      path.join(process.env['HOME']!, '.claude', 'settings.json'),
+    )
     expect(settingsFile('codex', true, '/repo', {})).toBe(
-      path.join(os.homedir(), '.codex', 'config.toml'),
+      path.join(process.env['HOME']!, '.codex', 'hooks.json'),
     )
   })
 
-  it('migrates a leftover Notifai-only hooks.json onto config.toml', () => {
-    const repo = mkdtempSync(path.join(os.tmpdir(), 'notifai-codex-migrate-json-'))
+  it('uses the dedicated Codex hooks file for a new layer', () => {
+    expect(settingsFile('codex', false, '/repo', {})).toBe('/repo/.codex/hooks.json')
+    expect(settingsFile('codex', true, '/repo', {})).toBe(
+      path.join(os.homedir(), '.codex', 'hooks.json'),
+    )
+  })
+
+  it('keeps a Notifai-only hooks.json instead of rewriting config.toml', () => {
+    const repo = mkdtempSync(path.join(os.tmpdir(), 'notifai-codex-json-'))
     mkdirSync(path.join(repo, '.codex'), { recursive: true })
     applyPlan(path.join(repo, '.codex', 'hooks.json'), { hooks: ours() })
 
+    expect(settingsFile('codex', false, repo, {})).toBe(path.join(repo, '.codex', 'hooks.json'))
+  })
+
+  it('keeps a Notifai-only inline representation so existing trust remains valid', () => {
+    const repo = mkdtempSync(path.join(os.tmpdir(), 'notifai-codex-ours-toml-'))
+    mkdirSync(path.join(repo, '.codex'), { recursive: true })
+    applyPlan(path.join(repo, '.codex', 'config.toml'), { hooks: ours() })
+
     expect(settingsFile('codex', false, repo, {})).toBe(path.join(repo, '.codex', 'config.toml'))
   })
 
@@ -282,17 +322,18 @@ describe('settings locations', () => {
 
   it('does not treat the Codex trust store as an inline hook representation', () => {
     const home = mkdtempSync(path.join(os.tmpdir(), 'notifai-codex-trust-only-'))
+    mkdirSync(path.join(home, '.codex'), { recursive: true })
     writeFileSync(
-      path.join(home, 'config.toml'),
-      `[hooks.state."${home}/hooks.json:stop:0:0"]\ntrusted_hash = "sha256:abc"\n`,
+      path.join(home, '.codex', 'config.toml'),
+      `[hooks.state."${home}/.codex/hooks.json:stop:0:0"]\ntrusted_hash = "sha256:abc"\n`,
     )
 
-    expect(settingsFile('codex', true, '/repo', { CODEX_HOME: home })).toBe(
-      path.join(home, 'config.toml'),
+    expect(settingsFile('codex', true, '/repo', { HOME: home, CODEX_HOME: path.join(home, '.codex') })).toBe(
+      path.join(home, '.codex', 'hooks.json'),
     )
   })
 
-  it('keeps writing to inline [hooks] when a leftover hooks.json only holds Notifai', () => {
+  it('preserves foreign inline hooks when both representations exist', () => {
     const repo = mkdtempSync(path.join(os.tmpdir(), 'notifai-codex-both-'))
     const layer = path.join(repo, '.codex')
     mkdirSync(layer, { recursive: true })
@@ -330,7 +371,7 @@ describe('a Codex install run inside a git worktree', () => {
   it('targets the main repository, which is the file Codex actually reads', () => {
     const { main, worktree } = repoWithWorktree()
 
-    expect(settingsFile('codex', false, worktree, {})).toBe(path.join(main, '.codex', 'config.toml'))
+    expect(settingsFile('codex', false, worktree, {})).toBe(path.join(main, '.codex', 'hooks.json'))
     expect(codexProjectRoot(worktree)).toBe(main)
   })
 
@@ -395,19 +436,13 @@ describe('a Codex install run inside a git worktree', () => {
     )
   })
 
-  it('follows a relocated config home rather than installing where nothing reads', () => {
-    // Orca points CODEX_HOME at a per-account home; writing to ~/.codex there
-    // produced hooks Codex never loaded, and nothing reported a problem.
-    expect(settingsFile('codex', true, '/repo', { CODEX_HOME: '/managed/codex' })).toBe(
-      '/managed/codex/config.toml',
+  it('follows the active harness home for global hook install', () => {
+    expect(settingsFile('codex', true, '/repo', { HOME: '/user', CODEX_HOME: '/managed/codex' })).toBe(
+      '/managed/codex/hooks.json',
     )
     expect(settingsFile('claude-code', true, '/repo', { CLAUDE_CONFIG_DIR: '/managed/claude' })).toBe(
       '/managed/claude/settings.json',
     )
-    // An empty value is not a relocation.
-    expect(settingsFile('codex', true, '/repo', { CODEX_HOME: '' })).toBe(
-      path.join(os.homedir(), '.codex', 'config.toml'),
-    )
   })
 })
 
@@ -560,7 +595,7 @@ describe('finding what is installed', () => {
       ].join('\n'),
     )
 
-    const found = findInstallations(cwd, { CODEX_HOME: path.join(cwd, 'no-codex-here') })
+    const found = findInstallations(cwd, { HOME: path.join(cwd, 'isolated-home') })
     const codex = found.find((installation) => installation.harness === 'codex' && !installation.global)
     expect(codex?.file).toBe(file)
     expect(codex?.handlers.map((handler) => handler.event)).toEqual(['Stop'])
@@ -580,7 +615,7 @@ describe('finding what is installed', () => {
       ),
     )
 
-    const problems = codexRepresentationProblems(cwd, { CODEX_HOME: path.join(cwd, 'no-codex-here') })
+    const problems = codexRepresentationProblems(cwd, { HOME: path.join(cwd, 'isolated-home') })
     expect(problems).toHaveLength(1)
     expect(problems[0]).toContain('loading hooks from both')
     expect(problems[0]).toContain(path.join(layer, 'hooks.json'))
@@ -594,7 +629,7 @@ describe('finding what is installed', () => {
     mkdirSync(path.join(cwd, '.claude'), { recursive: true })
     applyPlan(path.join(cwd, '.claude', 'settings.local.json'), { hooks: ours() })
 
-    const found = findInstallations(cwd, { CODEX_HOME: path.join(cwd, 'no-codex-here') })
+    const found = findInstallations(cwd, { HOME: path.join(cwd, 'isolated-home') })
     const claude = found.find((i) => i.harness === 'claude-code' && !i.global)
 
     expect(claude).toBeDefined()
@@ -615,39 +650,41 @@ describe('finding what is installed', () => {
 
   it('detects when Codex still trusts an older definition of an installed hook', () => {
     const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-codex-trust-'))
-    const codexHome = path.join(cwd, 'codex-home')
+    const home = path.join(cwd, 'home')
+    const env = { HOME: home }
     const hookFile = path.join(cwd, '.codex', 'hooks.json')
     mkdirSync(path.dirname(hookFile), { recursive: true })
     applyPlan(hookFile, { hooks: ours() })
-    const installations = findInstallations(cwd, { CODEX_HOME: codexHome })
+    const installations = findInstallations(cwd, env)
     const codex = installations.find((installation) => installation.harness === 'codex')
     const stop = codex?.handlers.find((handler) => handler.event === 'Stop')
     expect(stop).toBeDefined()
 
-    mkdirSync(codexHome, { recursive: true })
+    const trustFile = path.join(home, '.codex', 'config.toml')
+    mkdirSync(path.dirname(trustFile), { recursive: true })
     writeFileSync(
-      path.join(codexHome, 'config.toml'),
+      trustFile,
       `[hooks.state.${JSON.stringify(codexTrustKey(codex!, stop!))}]\ntrusted_hash = "sha256:obsolete"\n`,
     )
 
-    const stale = codexTrustProblems(installations, { CODEX_HOME: codexHome })
+    const stale = codexTrustProblems(installations, env)
     expect(stale).toHaveLength(3)
     expect(stale).toEqual(expect.arrayContaining([expect.stringMatching(/Stop.*changed.*\/hooks/i)]))
 
     writeFileSync(
-      path.join(codexHome, 'config.toml'),
+      trustFile,
       `[hooks.state.${JSON.stringify(codexTrustKey(codex!, stop!))}]\ntrusted_hash = "${codexHookIdentityHash(stop!)}"\n`,
     )
-    expect(codexTrustProblems(installations, { CODEX_HOME: codexHome })).toEqual([
+    expect(codexTrustProblems(installations, env)).toEqual([
       expect.stringMatching(/UserPromptSubmit.*not trusted.*\/hooks/i),
       expect.stringMatching(/SessionEnd.*not trusted.*\/hooks/i),
     ])
 
     writeFileSync(
-      path.join(codexHome, 'config.toml'),
+      trustFile,
       `[hooks.state.${JSON.stringify(codexTrustKey(codex!, stop!))}]\ntrusted_hash = "${codexHookIdentityHash(stop!)}"\nenabled = false\n`,
     )
-    expect(codexTrustProblems(installations, { CODEX_HOME: codexHome })).toEqual(
+    expect(codexTrustProblems(installations, env)).toEqual(
       expect.arrayContaining([expect.stringMatching(/Stop.*disabled.*\/hooks/i)]),
     )
   })
@@ -843,6 +880,14 @@ describe('detectHarness', () => {
     ])
   })
 
+  it('detects Codex from the active custom CODEX_HOME', () => {
+    const home = mkdtempSync(path.join(os.tmpdir(), 'notifai-detect-home-'))
+    const codexHome = path.join(home, 'managed', 'codex')
+    mkdirSync(codexHome, { recursive: true })
+
+    expect(detectedHarnesses(project(), { HOME: home, CODEX_HOME: codexHome })).toEqual(['codex'])
+  })
+
   it('prefers project evidence over anything installed on the machine', () => {
     // The regression. Machine-global markers used to be OR-ed in per harness,
     // so a developer with several agent tools installed got a candidate for
@@ -865,3 +910,99 @@ describe('detectHarness', () => {
     expect(answer === null || HARNESSES.includes(answer)).toBe(true)
   })
 })
+
+describe('Windows hook commands and discovery', () => {
+  const winNode = 'C:\\Program Files\\nodejs\\node.exe'
+  const winAdapter = 'C:\\Users\\Ada Lovelace\\.notifai\\bin\\hook-adapter'
+  const winOpts = { platform: 'win32' as const, nodePath: winNode }
+
+  it('keeps POSIX command bytes unchanged', () => {
+    expect(hookCommand(ADAPTER, 'stop', undefined, { platform: 'posix' })).toBe(
+      `'${ADAPTER}' hook stop --owner notifai`,
+    )
+    expect(hookCommand(ADAPTER, 'stop', 'codex', { platform: 'posix' })).toBe(
+      `'${ADAPTER}' hook stop --owner notifai --harness codex`,
+    )
+  })
+
+  it('emits a Windows-safe command with no POSIX single quotes', () => {
+    const command = hookCommand(winAdapter, 'stop', 'codex', winOpts)
+    expect(command).toBe(
+      `"${winNode}" "${winAdapter}" hook stop --owner notifai --harness codex`,
+    )
+    expect(command).not.toContain("'")
+    expect(quoteWindowsArg('C:\\ends\\with\\')).toBe('"C:\\ends\\with\\\\"')
+    expect(quoteWindowsArg('say "hi"')).toBe('"say \\"hi\\""')
+  })
+
+  it('round-trips the Windows command through JSON and TOML documents', () => {
+    const command = hookCommand(winAdapter, 'stop', 'cursor', winOpts)
+    expect(JSON.parse(JSON.stringify({ command }))).toEqual({ command })
+    expect(parseToml(stringifyToml({ command }))).toEqual({ command })
+  })
+
+  it('discovers a Windows-quoted installation as the stable adapter', () => {
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-win-discover-'))
+    const homeDir = path.join(cwd, 'home')
+    const script = path.join(cwd, 'cli.js')
+    writeFileSync(script, '')
+    installHookAdapter({ execPath: process.execPath, scriptPath: script }, homeDir, 'win32')
+    const adapter = hookAdapterPath(homeDir)
+    mkdirSync(path.join(cwd, '.claude'), { recursive: true })
+    applyPlan(path.join(cwd, '.claude', 'settings.local.json'), {
+      hooks: buildHookConfig({
+        adapterPath: adapter,
+        harness: 'claude-code',
+        platform: 'win32',
+        nodePath: process.execPath,
+      }),
+    })
+
+    const found = findInstallations(
+      cwd,
+      { HOME: homeDir, USERPROFILE: 'C:\\Users\\Ada' },
+      homeDir,
+      'win32',
+    )
+    expect(found).toHaveLength(1)
+    expect(found[0]?.harness).toBe('claude-code')
+    expect(found[0]?.problems ?? []).toEqual([])
+    expect(found[0]?.handlers[0]?.command.startsWith(`${quoteWindowsArg(process.execPath)} `)).toBe(
+      true,
+    )
+  })
+
+  it('prefers a Windows-absolute USERPROFILE over an MSYS HOME', () => {
+    const env = { HOME: '/c/Users/msys', USERPROFILE: 'C:\\Users\\Ada' }
+    expect(harnessAccountHome(env, 'win32')).toBe('C:\\Users\\Ada')
+    expect(settingsFile('cursor', true, '/repo', env, 'win32')).toBe(
+      path.join('C:\\Users\\Ada', '.cursor', 'hooks.json'),
+    )
+    expect(settingsFile('claude-code', true, '/repo', env, 'win32')).toBe(
+      path.join('C:\\Users\\Ada', '.claude', 'settings.json'),
+    )
+    expect(opencodePluginPath(true, '/repo', env, 'win32')).toBe(
+      path.join('C:\\Users\\Ada', '.config', 'opencode', 'plugins', 'notifai.js'),
+    )
+  })
+
+  it('makes OpenCode spawn the adapter through Node on Windows with shell:false', () => {
+    const source = opencodePluginSource({
+      adapterPath: winAdapter,
+      timeoutSeconds: 240,
+      platform: 'win32',
+      nodePath: winNode,
+    })
+    expect(source).toContain(`const NODE = ${JSON.stringify(winNode)}`)
+    expect(source).toContain('spawn(NODE, [ADAPTER, "hook", event, "--owner", "notifai", "--harness", "opencode"]')
+    expect(source).toContain('shell: false')
+    expect(source).toContain('windowsHide: true')
+    expect(source).not.toContain('spawn(ADAPTER,')
+    expect(opencodePluginTarget(source)).toEqual({
+      adapter: winAdapter,
+      current: true,
+      timeoutSeconds: 240,
+      nodePath: winNode,
+    })
+  })
+})