@raidiant/notifai 1.0.1 → 1.1.0

package/dist/install-hooks.d.ts

@@ -1,3 +1,4 @@
+import { type HookHostPlatform } from './hook-adapter.js';
 import { type Harness } from './harnesses.js';
 export { HARNESSES, type Harness } from './harnesses.js';
 /**
@@ -6,10 +7,10 @@ export { HARNESSES, type Harness } from './harnesses.js';
  * Claude Code's `settings.json` and Codex's hook files use the same shape —
  * `hooks` maps an event name to matcher groups, each holding command handlers
  * with an optional timeout — so one generator serves both. Only the file
- * location and the event set differ. Codex still loads a leftover
- * `hooks.json`, but that file is the legacy representation. We write inline
- * `[hooks]` tables in the same layer's `config.toml`. One representation per
- * layer, never both.
+ * location and the event set differ. Codex supports either a dedicated
+ * `hooks.json` or inline `[hooks]` tables in the same layer's `config.toml`.
+ * We default to the dedicated file so installing hooks never rewrites Codex's
+ * main configuration and trust store. One representation per layer, never both.
  *
  * Cursor's native format is flat and lower-camel-cased, while OpenCode's
  * extension point is a JavaScript plugin module. Each therefore has a bounded
@@ -35,12 +36,21 @@ export interface InstallPlan {
     global: boolean;
     config: HookConfig;
 }
+export interface HookCommandOptions {
+    platform?: NodeJS.Platform | HookHostPlatform;
+    /** Registered Node used to interpret the Windows adapter. Ignored on POSIX. */
+    nodePath?: string;
+}
 /**
  * The command each hook runs. Harness definitions know only the stable
  * user-level adapter. Mutable Node, package-manager, version, and checkout
- * paths live behind that seam and never enter a trusted hook identity.
+ * paths live behind that seam and never enter a trusted hook identity —
+ * except on Windows, where CreateProcess cannot run the adapter without an
+ * explicit Node executable, so the registered interpreter is named first.
  */
-export declare function hookCommand(adapterPath: string, event: string, harness?: Harness): string;
+export declare function hookCommand(adapterPath: string, event: string, harness?: Harness, options?: HookCommandOptions): string;
+/** The leading argv that every Notifai handler must start with. */
+export declare function hookCommandPrefix(adapterPath: string, options?: HookCommandOptions): string;
 /**
  * Says "Notifai installed this" without saying which checkout did.
  *
@@ -56,11 +66,21 @@ export declare function hookCommand(adapterPath: string, event: string, harness?
  * harness runs the command through a shell.
  */
 export declare const OWNER_MARKER = "--owner notifai";
+/**
+ * Quote one Windows argv element so CommandLineToArgvW / CreateProcess keep
+ * it as a single argument. Always used for the Node and adapter paths, which
+ * routinely contain spaces (`Program Files`) and must not use POSIX quotes
+ * inside JSON or TOML harness documents.
+ */
+export declare function quoteWindowsArg(value: string): string;
 export interface BuildOptions {
     /** Stable user-level executable installed by the hook adapter module. */
     adapterPath: string;
     /** The installed adapter stamps its exact harness into project pointers. */
     harness?: Harness;
+    platform?: NodeJS.Platform | HookHostPlatform;
+    /** Registered Node named first in Windows hook commands. */
+    nodePath?: string;
 }
 /**
  * Claude Code's Stop handler returns instantly and the same process lives on
@@ -106,7 +126,14 @@ export declare function buildCursorHookConfig(options: BuildOptions): CursorHook
  * gitignored file where one exists: which devices a person wants their
  * questions pushed to is not a property of the repository.
  */
-export declare function settingsFile(harness: Harness, global: boolean, cwd: string, env?: NodeJS.ProcessEnv): string;
+export declare function settingsFile(harness: Harness, global: boolean, cwd: string, env?: NodeJS.ProcessEnv, platform?: NodeJS.Platform | HookHostPlatform): string;
+/**
+ * The account home harness config roots are resolved against.
+ *
+ * Delegates to the shared process/path `accountHome` so Cursor, OpenCode,
+ * Claude, and Codex follow the same Windows USERPROFILE / MSYS HOME rules.
+ */
+export declare function harnessAccountHome(env?: NodeJS.ProcessEnv, platform?: NodeJS.Platform | HookHostPlatform): string;
 /**
  * Where Codex looks for a project's hooks — the **main** repository, not the
  * working directory.
@@ -139,19 +166,21 @@ export declare function codexProjectRoot(cwd: string): string;
  */
 export declare function codexLayerDir(cwd: string): string | null;
 /**
- * Both harnesses let an environment variable relocate their whole config
- * directory, and tooling that manages sessions does exactly that — Orca points
- * `CODEX_HOME` at a per-account home, so writing to `~/.codex` installs hooks
- * into a file Codex never reads and the failure is silent. Observed 2026-08-02.
+ * Harness-specific home variables relocate the whole active harness home.
+ * This matters under session managers that give each Codex account its own
+ * `CODEX_HOME`: writing to the OS account's ~/.codex would configure a
+ * different Codex installation than the one running the command.
  */
-export declare function configHome(env: NodeJS.ProcessEnv, variable: string, fallback: string): string;
+export declare function configHome(env: NodeJS.ProcessEnv, variable: string, fallback: string, platform?: NodeJS.Platform | HookHostPlatform): string;
+/** User-global Codex config directory for the active Codex installation. */
+export declare function codexGlobalDir(env?: NodeJS.ProcessEnv, platform?: NodeJS.Platform | HookHostPlatform): string;
 export interface CodexLayerPaths {
     dir: string;
     hooksJson: string;
     configToml: string;
 }
 /** The two files Codex will look at for one config layer. */
-export declare function codexLayerPaths(global: boolean, cwd: string, env?: NodeJS.ProcessEnv): CodexLayerPaths;
+export declare function codexLayerPaths(global: boolean, cwd: string, env?: NodeJS.ProcessEnv, platform?: NodeJS.Platform | HookHostPlatform): CodexLayerPaths;
 export interface CodexLayerInspection {
     paths: CodexLayerPaths;
     jsonEvents: string[];
@@ -164,15 +193,15 @@ export interface CodexLayerInspection {
 /**
  * Which representation this Codex layer already uses.
  *
- * `hooks.json` is the legacy file. We write inline `[hooks]` in
- * `config.toml` unless this layer already has someone else's hooks only in
- * `hooks.json` — writing a second file would make Codex load both and run
- * every matching handler. `[hooks.state]` is the trust store, not a hook
+ * Codex supports `hooks.json` and inline `[hooks]` side by side, but loads both
+ * and runs every matching handler. Prefer the dedicated file for a new layer;
+ * preserve an existing single representation so installing Notifai never
+ * invents a dual layer. `[hooks.state]` is the trust store, not a hook
  * definition, so it does not count as a representation.
  */
 export declare function inspectCodexLayer(paths: CodexLayerPaths): CodexLayerInspection;
 /** Every file in this layer Codex might already be reading hooks from. */
-export declare function hookDefinitionFiles(harness: Harness, global: boolean, cwd: string, env?: NodeJS.ProcessEnv): string[];
+export declare function hookDefinitionFiles(harness: Harness, global: boolean, cwd: string, env?: NodeJS.ProcessEnv, platform?: NodeJS.Platform | HookHostPlatform): string[];
 /**
  * Drop the unused representation after writing the one this layer already had.
  *
@@ -189,7 +218,7 @@ export declare function codexRepresentationProblems(cwd: string, env?: NodeJS.Pr
  *
  * `AGENTS.md` still counts for nothing — see `localHarnessEvidence`.
  */
-export declare function detectedHarnesses(cwd: string, env?: NodeJS.ProcessEnv): Harness[];
+export declare function detectedHarnesses(cwd: string, env?: NodeJS.ProcessEnv, platform?: NodeJS.Platform | HookHostPlatform): Harness[];
 /**
  * Which *single* harness to wire when a caller still needs exactly one, or
  * null when it is genuinely unclear.
@@ -199,7 +228,7 @@ export declare function detectedHarnesses(cwd: string, env?: NodeJS.ProcessEnv):
  * are several harnesses. `detectedHarnesses` is the default for install;
  * this helper stays for uninstall and any caller that cannot take a list.
  */
-export declare function detectHarness(cwd: string, env?: NodeJS.ProcessEnv): Harness | null;
+export declare function detectHarness(cwd: string, env?: NodeJS.ProcessEnv, platform?: NodeJS.Platform | HookHostPlatform): Harness | null;
 export interface SettingsDocument {
     hooks?: HookConfig;
     [key: string]: unknown;
@@ -288,6 +317,6 @@ export declare function codexTrustKey(installation: Installation, handler: Insta
  */
 export declare function codexTrustProblems(installations: Installation[], env?: NodeJS.ProcessEnv): string[];
 /** Every place either harness would read a Notifai handler from. */
-export declare function findInstallations(cwd: string, env?: NodeJS.ProcessEnv, adapterHome?: string): Installation[];
+export declare function findInstallations(cwd: string, env?: NodeJS.ProcessEnv, adapterHome?: string, platform?: NodeJS.Platform | HookHostPlatform): Installation[];
 /** The hook event a handler's command actually invokes, e.g. `stop`. */
 export declare function handlerEvent(command: string): string | null;

package/dist/install-hooks.js

@@ -1,12 +1,12 @@
 import { existsSync, lstatSync, readFileSync, realpathSync, rmSync, statSync, } from 'node:fs';
 import { createHash } from 'node:crypto';
-import os from 'node:os';
 import path from 'node:path';
 import { parse as parseToml, stringify as stringifyToml } from 'smol-toml';
 import { atomicWriteFileSync } from './atomic-file.js';
-import { hookAdapterPath } from './hook-adapter.js';
+import { hookAdapterPath, hookHostPlatform, inspectHookAdapter, } from './hook-adapter.js';
 import { opencodePluginPath, opencodePluginTarget } from './opencode-plugin.js';
 import { HARNESSES } from './harnesses.js';
+import { accountHome } from './platform.js';
 export { HARNESSES } from './harnesses.js';
 /**
  * The three joints the OpenCode plugin hooks into, as (harness event, the
@@ -21,12 +21,23 @@ const OPENCODE_EVENTS = [
 /**
  * The command each hook runs. Harness definitions know only the stable
  * user-level adapter. Mutable Node, package-manager, version, and checkout
- * paths live behind that seam and never enter a trusted hook identity.
+ * paths live behind that seam and never enter a trusted hook identity —
+ * except on Windows, where CreateProcess cannot run the adapter without an
+ * explicit Node executable, so the registered interpreter is named first.
  */
-export function hookCommand(adapterPath, event, harness) {
-    return (`${quote(adapterPath)} hook ${event} ${OWNER_MARKER}` +
+export function hookCommand(adapterPath, event, harness, options = {}) {
+    return (`${hookCommandPrefix(adapterPath, options)}hook ${event} ${OWNER_MARKER}` +
         (harness === undefined ? '' : ` --harness ${harness}`));
 }
+/** The leading argv that every Notifai handler must start with. */
+export function hookCommandPrefix(adapterPath, options = {}) {
+    const host = hookHostPlatform(options.platform);
+    if (host === 'win32') {
+        const nodePath = options.nodePath ?? process.execPath;
+        return `${quoteWindowsArg(nodePath)} ${quoteWindowsArg(adapterPath)} `;
+    }
+    return `${quote(adapterPath)} `;
+}
 /**
  * Says "Notifai installed this" without saying which checkout did.
  *
@@ -51,6 +62,30 @@ export const OWNER_MARKER = '--owner notifai';
 function quote(value) {
     return `'${value.replaceAll("'", `'\\''`)}'`;
 }
+/**
+ * Quote one Windows argv element so CommandLineToArgvW / CreateProcess keep
+ * it as a single argument. Always used for the Node and adapter paths, which
+ * routinely contain spaces (`Program Files`) and must not use POSIX quotes
+ * inside JSON or TOML harness documents.
+ */
+export function quoteWindowsArg(value) {
+    let out = '"';
+    let slashes = 0;
+    for (const ch of value) {
+        if (ch === '\\') {
+            slashes += 1;
+            continue;
+        }
+        if (ch === '"') {
+            out += '\\'.repeat(slashes * 2 + 1) + '"';
+            slashes = 0;
+            continue;
+        }
+        out += '\\'.repeat(slashes) + ch;
+        slashes = 0;
+    }
+    return `${out}${'\\'.repeat(slashes * 2)}"`;
+}
 /**
  * Claude Code's Stop handler returns instantly and the same process lives on
  * out of band as the escalation waiter, so this `timeout` bounds a background
@@ -86,24 +121,31 @@ export const BLOCKING_STOP_TIMEOUT_SECONDS = 540;
  * declared ceiling above the wait — except Codex, which owns that number
  * itself and whose definition must stay byte-stable for its trust store.
  */
-function stopHandler(adapterPath, harness) {
-    const command = hookCommand(adapterPath, 'stop', harness);
-    if (harness === 'claude-code') {
+function stopHandler(adapterPath, harness, options) {
+    const command = hookCommand(adapterPath, 'stop', harness, options);
+    if (harness === 'claude-code' && hookHostPlatform(options.platform) === 'posix') {
         return { type: 'command', command, timeout: CLAUDE_ASYNC_STOP_TIMEOUT_SECONDS, async: true };
     }
     if (harness === 'codex')
         return { type: 'command', command };
     return { type: 'command', command, timeout: BLOCKING_STOP_TIMEOUT_SECONDS };
 }
+function commandOptionsFrom(options) {
+    return {
+        ...(options.platform === undefined ? {} : { platform: options.platform }),
+        ...(options.nodePath === undefined ? {} : { nodePath: options.nodePath }),
+    };
+}
 export function buildHookConfig(options) {
     const { adapterPath } = options;
+    const commandOptions = commandOptionsFrom(options);
     return {
         UserPromptSubmit: [
             {
                 hooks: [
                     {
                         type: 'command',
-                        command: hookCommand(adapterPath, 'user-prompt-submit', options.harness),
+                        command: hookCommand(adapterPath, 'user-prompt-submit', options.harness, commandOptions),
                         // Claude Code caps UserPromptSubmit at 30s; stay well inside it so
                         // a slow network can never delay the user's own prompt.
                         timeout: 15,
@@ -111,13 +153,13 @@ export function buildHookConfig(options) {
                 ],
             },
         ],
-        Stop: [{ hooks: [stopHandler(adapterPath, options.harness)] }],
+        Stop: [{ hooks: [stopHandler(adapterPath, options.harness, commandOptions)] }],
         SessionEnd: [
             {
                 hooks: [
                     {
                         type: 'command',
-                        command: hookCommand(adapterPath, 'session-end', options.harness),
+                        command: hookCommand(adapterPath, 'session-end', options.harness, commandOptions),
                         // Both harnesses give SessionEnd a ~1-3s budget, so this handler
                         // only touches local state.
                         timeout: 3,
@@ -129,16 +171,17 @@ export function buildHookConfig(options) {
 }
 /** Cursor's native schema is flat and uses lower-camel lifecycle event names. */
 export function buildCursorHookConfig(options) {
+    const commandOptions = commandOptionsFrom(options);
     return {
         beforeSubmitPrompt: [
             {
-                command: hookCommand(options.adapterPath, 'user-prompt-submit', 'cursor'),
+                command: hookCommand(options.adapterPath, 'user-prompt-submit', 'cursor', commandOptions),
                 timeout: 15,
             },
         ],
         stop: [
             {
-                command: hookCommand(options.adapterPath, 'stop', 'cursor'),
+                command: hookCommand(options.adapterPath, 'stop', 'cursor', commandOptions),
                 timeout: BLOCKING_STOP_TIMEOUT_SECONDS,
                 // A continuation may register a real follow-up question. Match the
                 // session-state cap so those chains are useful but never unbounded.
@@ -147,7 +190,7 @@ export function buildCursorHookConfig(options) {
         ],
         sessionEnd: [
             {
-                command: hookCommand(options.adapterPath, 'session-end', 'cursor'),
+                command: hookCommand(options.adapterPath, 'session-end', 'cursor', commandOptions),
                 timeout: 3,
             },
         ],
@@ -158,28 +201,37 @@ export function buildCursorHookConfig(options) {
  * gitignored file where one exists: which devices a person wants their
  * questions pushed to is not a property of the repository.
  */
-export function settingsFile(harness, global, cwd, env = process.env) {
+export function settingsFile(harness, global, cwd, env = process.env, platform = process.platform) {
     switch (harness) {
         // OpenCode has no settings document to merge into — its adapter is a
         // generated plugin module, so it owns a whole file instead.
         case 'opencode':
-            return opencodePluginPath(global, cwd, env);
+            return opencodePluginPath(global, cwd, env, platform);
         case 'cursor': {
-            const home = env['HOME'] !== undefined && env['HOME'] !== '' ? env['HOME'] : os.homedir();
+            const home = harnessAccountHome(env, platform);
             return global
                 ? path.join(home, '.cursor', 'hooks.json')
                 : path.join(cwd, '.cursor', 'hooks.json');
         }
         case 'claude-code':
             return global
-                ? path.join(configHome(env, 'CLAUDE_CONFIG_DIR', '.claude'), 'settings.json')
+                ? path.join(configHome(env, 'CLAUDE_CONFIG_DIR', '.claude', platform), 'settings.json')
                 : path.join(cwd, '.claude', 'settings.local.json');
         case 'codex':
-            return inspectCodexLayer(codexLayerPaths(global, cwd, env)).writeTarget;
+            return inspectCodexLayer(codexLayerPaths(global, cwd, env, platform)).writeTarget;
         default:
             return assertNeverHarness(harness);
     }
 }
+/**
+ * The account home harness config roots are resolved against.
+ *
+ * Delegates to the shared process/path `accountHome` so Cursor, OpenCode,
+ * Claude, and Codex follow the same Windows USERPROFILE / MSYS HOME rules.
+ */
+export function harnessAccountHome(env = process.env, platform = process.platform) {
+    return accountHome(env, hookHostPlatform(platform) === 'win32' ? 'win32' : 'linux');
+}
 function assertNeverHarness(harness) {
     throw new Error(`Unsupported harness: ${String(harness)}`);
 }
@@ -268,19 +320,26 @@ function commonGitDir(gitDir) {
     return path.resolve(gitDir, readFileSync(marker, 'utf8').trim());
 }
 /**
- * Both harnesses let an environment variable relocate their whole config
- * directory, and tooling that manages sessions does exactly that — Orca points
- * `CODEX_HOME` at a per-account home, so writing to `~/.codex` installs hooks
- * into a file Codex never reads and the failure is silent. Observed 2026-08-02.
+ * Harness-specific home variables relocate the whole active harness home.
+ * This matters under session managers that give each Codex account its own
+ * `CODEX_HOME`: writing to the OS account's ~/.codex would configure a
+ * different Codex installation than the one running the command.
  */
-export function configHome(env, variable, fallback) {
+export function configHome(env, variable, fallback, platform = process.platform) {
     const override = env[variable];
-    return override !== undefined && override !== '' ? override : path.join(os.homedir(), fallback);
+    if (override !== undefined && override !== '')
+        return override;
+    const home = harnessAccountHome(env, platform);
+    return path.join(home, fallback);
+}
+/** User-global Codex config directory for the active Codex installation. */
+export function codexGlobalDir(env = process.env, platform = process.platform) {
+    return configHome(env, 'CODEX_HOME', '.codex', platform);
 }
 /** The two files Codex will look at for one config layer. */
-export function codexLayerPaths(global, cwd, env = process.env) {
+export function codexLayerPaths(global, cwd, env = process.env, platform = process.platform) {
     const dir = global
-        ? configHome(env, 'CODEX_HOME', '.codex')
+        ? codexGlobalDir(env, platform)
         : path.join(codexProjectRoot(cwd), '.codex');
     return {
         dir,
@@ -291,10 +350,10 @@ export function codexLayerPaths(global, cwd, env = process.env) {
 /**
  * Which representation this Codex layer already uses.
  *
- * `hooks.json` is the legacy file. We write inline `[hooks]` in
- * `config.toml` unless this layer already has someone else's hooks only in
- * `hooks.json` — writing a second file would make Codex load both and run
- * every matching handler. `[hooks.state]` is the trust store, not a hook
+ * Codex supports `hooks.json` and inline `[hooks]` side by side, but loads both
+ * and runs every matching handler. Prefer the dedicated file for a new layer;
+ * preserve an existing single representation so installing Notifai never
+ * invents a dual layer. `[hooks.state]` is the trust store, not a hook
  * definition, so it does not count as a representation.
  */
 export function inspectCodexLayer(paths) {
@@ -304,15 +363,24 @@ export function inspectCodexLayer(paths) {
     const tomlEvents = hookEventNames(tomlDocument?.hooks);
     const jsonForeign = documentHasForeignHandlers(jsonDocument);
     const tomlForeign = documentHasForeignHandlers(tomlDocument);
+    const jsonOurs = documentHasOurHandlers(jsonDocument);
+    const tomlOurs = documentHasOurHandlers(tomlDocument);
     const dual = jsonEvents.length > 0 && tomlEvents.length > 0;
-    // Current representation. Stay on the legacy file only when that is
-    // already where someone else's hooks live and toml has none.
-    let writeTarget = paths.configToml;
-    if (jsonEvents.length > 0 && tomlEvents.length === 0 && jsonForeign) {
-        writeTarget = paths.hooksJson;
-    }
-    else if (dual && jsonForeign && !tomlForeign) {
-        writeTarget = paths.hooksJson;
+    let writeTarget = paths.hooksJson;
+    if (tomlEvents.length > 0 && jsonEvents.length === 0) {
+        writeTarget = paths.configToml;
+    }
+    else if (dual) {
+        if (tomlForeign && !jsonForeign)
+            writeTarget = paths.configToml;
+        else if (jsonForeign && !tomlForeign)
+            writeTarget = paths.hooksJson;
+        else if (!jsonForeign && !tomlForeign)
+            writeTarget = paths.hooksJson;
+        else if (tomlOurs && !jsonOurs)
+            writeTarget = paths.configToml;
+        else
+            writeTarget = paths.hooksJson;
     }
     return {
         paths,
@@ -325,10 +393,10 @@ export function inspectCodexLayer(paths) {
     };
 }
 /** Every file in this layer Codex might already be reading hooks from. */
-export function hookDefinitionFiles(harness, global, cwd, env = process.env) {
+export function hookDefinitionFiles(harness, global, cwd, env = process.env, platform = process.platform) {
     if (harness !== 'codex')
-        return [settingsFile(harness, global, cwd, env)];
-    const paths = codexLayerPaths(global, cwd, env);
+        return [settingsFile(harness, global, cwd, env, platform)];
+    const paths = codexLayerPaths(global, cwd, env, platform);
     return [paths.hooksJson, paths.configToml];
 }
 /**
@@ -389,6 +457,11 @@ function documentHasForeignHandlers(document) {
         return false;
     return locateAllHandlers(document).some((handler) => !isNotifaiCommand(handler.command));
 }
+function documentHasOurHandlers(document) {
+    if (document === null)
+        return false;
+    return locateHandlers(document).length > 0;
+}
 /** Best-effort detection so `hooks install` usually needs no flags. */
 /**
  * Harnesses this *project* shows evidence of, in the working directory only.
@@ -417,12 +490,12 @@ function localHarnessEvidence(cwd) {
     return found;
 }
 /** Harnesses installed anywhere on this machine — a much weaker signal. */
-function globalHarnessEvidence(env = process.env) {
-    const home = env['HOME'] !== undefined && env['HOME'] !== '' ? env['HOME'] : os.homedir();
+function globalHarnessEvidence(env = process.env, platform = process.platform) {
+    const home = harnessAccountHome(env, platform);
     const found = [];
     if (existsSync(path.join(home, '.claude')))
         found.push('claude-code');
-    if (existsSync(path.join(home, '.codex')))
+    if (existsSync(codexGlobalDir(env, platform)))
         found.push('codex');
     if (existsSync(path.join(home, '.cursor')))
         found.push('cursor');
@@ -437,8 +510,11 @@ function globalHarnessEvidence(env = process.env) {
  *
  * `AGENTS.md` still counts for nothing — see `localHarnessEvidence`.
  */
-export function detectedHarnesses(cwd, env = process.env) {
-    const seen = new Set([...localHarnessEvidence(cwd), ...globalHarnessEvidence(env)]);
+export function detectedHarnesses(cwd, env = process.env, platform = process.platform) {
+    const seen = new Set([
+        ...localHarnessEvidence(cwd),
+        ...globalHarnessEvidence(env, platform),
+    ]);
     return HARNESSES.filter((harness) => seen.has(harness));
 }
 /**
@@ -450,11 +526,11 @@ export function detectedHarnesses(cwd, env = process.env) {
  * are several harnesses. `detectedHarnesses` is the default for install;
  * this helper stays for uninstall and any caller that cannot take a list.
  */
-export function detectHarness(cwd, env = process.env) {
+export function detectHarness(cwd, env = process.env, platform = process.platform) {
     const local = localHarnessEvidence(cwd);
     if (local.length > 0)
         return local.length === 1 ? local[0] : null;
-    const global = globalHarnessEvidence(env);
+    const global = globalHarnessEvidence(env, platform);
     return global.length === 1 ? global[0] : null;
 }
 function readCursorSettings(file) {
@@ -688,7 +764,7 @@ export function codexHookIdentityHash(handler) {
     return `sha256:${createHash('sha256').update(JSON.stringify(normalized)).digest('hex')}`;
 }
 function codexTrustState(env) {
-    const file = path.join(configHome(env, 'CODEX_HOME', '.codex'), 'config.toml');
+    const file = path.join(codexGlobalDir(env), 'config.toml');
     if (!existsSync(file))
         return {};
     try {
@@ -758,11 +834,16 @@ function isNotifaiCommand(command) {
     return / hook (user-prompt-submit|stop|session-end)\b/.test(command);
 }
 /** Every place either harness would read a Notifai handler from. */
-export function findInstallations(cwd, env = process.env, adapterHome) {
+export function findInstallations(cwd, env = process.env, adapterHome, platform = process.platform) {
+    const nodePath = inspectHookAdapter(adapterHome, platform).target?.execPath;
+    const commandOptions = {
+        platform,
+        ...(nodePath === undefined ? {} : { nodePath }),
+    };
     const found = [];
     for (const harness of HARNESSES) {
         for (const global of [false, true]) {
-            const files = hookDefinitionFiles(harness, global, cwd, env);
+            const files = hookDefinitionFiles(harness, global, cwd, env, platform);
             for (const file of files) {
                 if (!existsSync(file))
                     continue;
@@ -802,7 +883,10 @@ export function findInstallations(cwd, env = process.env, adapterHome) {
                             event,
                             groupIndex: 0,
                             handlerIndex: 0,
-                            command: hookCommand(target.adapter, hookEvent, 'opencode'),
+                            command: hookCommand(target.adapter, hookEvent, 'opencode', {
+                                ...commandOptions,
+                                ...(target.nodePath === undefined ? {} : { nodePath: target.nodePath }),
+                            }),
                             ...(target.timeoutSeconds === undefined ? {} : { timeout: target.timeoutSeconds }),
                         })),
                     });
@@ -818,7 +902,7 @@ export function findInstallations(cwd, env = process.env, adapterHome) {
                     }
                     const handlers = locateCursorHandlers(document);
                     if (handlers.length > 0) {
-                        const problems = harnessMarkerProblems(harness, handlers, adapterHome);
+                        const problems = harnessMarkerProblems(harness, handlers, adapterHome, commandOptions);
                         found.push({ harness, file, global, handlers, ...(problems.length > 0 ? { problems } : {}) });
                     }
                     continue;
@@ -832,7 +916,7 @@ export function findInstallations(cwd, env = process.env, adapterHome) {
                 }
                 const handlers = locateHandlers(document);
                 if (handlers.length > 0) {
-                    const problems = harnessMarkerProblems(harness, handlers, adapterHome);
+                    const problems = harnessMarkerProblems(harness, handlers, adapterHome, commandOptions);
                     found.push({ harness, file, global, handlers, ...(problems.length > 0 ? { problems } : {}) });
                 }
             }
@@ -840,12 +924,12 @@ export function findInstallations(cwd, env = process.env, adapterHome) {
     }
     return found;
 }
-function harnessMarkerProblems(harness, handlers, adapterHome) {
+function harnessMarkerProblems(harness, handlers, adapterHome, options = {}) {
     const problems = [];
     if (!handlers.every((handler) => handler.command.includes(`--harness ${harness}`))) {
         problems.push(`installed commands do not stamp the ${harness} routing identity; rerun \`notifai hooks install --harness ${harness}\``);
     }
-    const expected = `${quote(hookAdapterPath(adapterHome))} hook `;
+    const expected = `${hookCommandPrefix(hookAdapterPath(adapterHome), options)}hook `;
     if (!handlers.every((handler) => handler.command.startsWith(expected))) {
         problems.push('installed commands still name a mutable CLI or runtime path; rerun `notifai hooks install` to migrate to the stable adapter');
     }