@raidiant/notifai 11.7.1 → 12.0.0-beta.13

package/dist/install-hooks.js

@@ -1,1622 +0,0 @@
-import { existsSync, lstatSync, readFileSync, readdirSync, realpathSync, rmdirSync, rmSync, statSync, } from 'node:fs';
-import { createHash } from 'node:crypto';
-import path from 'node:path';
-import { parse as parseToml, stringify as stringifyToml } from 'smol-toml';
-import { atomicWriteFileSync } from './atomic-file.js';
-import { withTargetFileLock } from './file-lock.js';
-import { hookAdapterPath, hookHostPlatform, inspectHookAdapter, } from './hook-adapter.js';
-import { OPENCODE_PLUGIN_FILENAME, opencodeConfigDir, opencodePluginPath, opencodePluginTarget, } from './opencode-plugin.js';
-import { legacyOpenclawProjectPluginPath, openclawHasGlobalEvidence, openclawPluginPath, openclawPluginTarget, } from './openclaw-plugin.js';
-import { HOOK_INSTALLABLE_HARNESSES } from './harnesses.js';
-import { hermesPluginCurrent, hermesPluginDir, isOurHermesPlugin } from './hermes-plugin.js';
-import { attendDocumentEvents, HOOK_EVENT_COMMAND_RE, HOOK_EVENT_PATTERN, HOOK_EVENT_TABLE, OPENCLAW_EVENTS, OPENCODE_EVENTS, installsSessionAttendant, } from './hook-events.js';
-import { accountHome } from './platform.js';
-import { sameLocalPath } from './local-path.js';
-import { NON_ROUTING_STOP_TIMEOUT_SECONDS, QUESTION_STOP_TIMEOUT_SECONDS, } from './question-timing.js';
-/**
- * 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 —
- * 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, 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.
- *
- * Ownership used to be matched on the absolute script path, so installing from
- * a second checkout did not recognise the first one's handlers as ours. Both
- * stayed, the harness ran both, and one question produced two notifications;
- * uninstalling the second silently left the first running. A marker that every
- * Notifai build writes and no build's path appears in fixes that by making
- * ownership a property of the handler rather than of the machine it was
- * installed from.
- *
- * It is a real (ignored) CLI flag rather than a comment because not every
- * harness runs the command through a shell.
- */
-export const OWNER_MARKER = '--owner notifai';
-/**
- * POSIX single-quoting. Double quotes were wrong: they still expand `$(...)`
- * and backticks, so a checkout path containing shell syntax became command
- * execution on every hook event. Single quotes suppress all expansion; the
- * only escape needed is for a literal single quote.
- */
-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)}"`;
-}
-/**
- * Harnesses without asynchronous Question Routing use this short Stop budget.
- * Claude Code and Codex use `QUESTION_STOP_TIMEOUT_SECONDS` instead.
- */
-export const NON_ROUTING_BLOCKING_STOP_TIMEOUT_SECONDS = NON_ROUTING_STOP_TIMEOUT_SECONDS;
-export { QUESTION_STOP_TIMEOUT_SECONDS } from './question-timing.js';
-/**
- * Codex's Session Attendant lifetime. Codex kills an async hook at its
- * declared timeout, so the attendant declares the same complete window a
- * question owner does; the next prompt or turn end starts another.
- */
-export const CODEX_ATTEND_TIMEOUT_SECONDS = QUESTION_STOP_TIMEOUT_SECONDS;
-/** Codex clamps an Interrupt hook to three seconds; declaring it keeps the definition honest. */
-export const CODEX_INTERRUPT_TIMEOUT_SECONDS = 3;
-/**
- * Whether this harness's Stop handler runs detached from the turn.
- *
- * The installer and doctor share this predicate so they agree which harnesses
- * run out of band. Owner lifetime is route-neutral and lives in
- * `question-timing.ts`.
- *
- * Codex is detached on every platform because its delivery route is a write to
- * the thread's own durable inbox rather than this hook's stdout: there is no
- * continuation to keep a turn open for, and the queue has no platform
- * dependency to gate on. Claude Code still needs its turn held on Windows,
- * where no inbox socket exists.
- */
-export function stopHandlerIsDetached(harness, platform) {
-    if (harness === 'codex')
-        return true;
-    return harness === 'claude-code' && hookHostPlatform(platform) === 'posix';
-}
-/**
- * The turn-end handler, whose shape is the whole per-harness difference.
- *
- * Claude Code takes the answer over its own inbox socket and Codex takes it
- * through its thread's durable inbox, so both Stop hooks are `async: true`:
- * they return immediately, the terminal is never held, and the waiter finishes
- * out of band. Only Claude on Windows still blocks and prints a continuation to
- * stdout, because no inbox socket exists there. Every Question Routing owner
- * declares the same complete-window timeout, because the detached waiter must
- * outlive the answer window in every case; what changed for Codex is that a
- * short or missing timeout no longer truncates a held *turn*. Blocking hosts
- * also set `statusMessage` so the held turn is not mistaken for a hang.
- */
-export const BLOCKING_STOP_STATUS_MESSAGE = 'Notifai: waiting for your answer';
-function stopHandler(adapterPath, harness, options) {
-    const command = hookCommand(adapterPath, 'stop', harness, options);
-    if (stopHandlerIsDetached(harness, options.platform)) {
-        return { type: 'command', command, timeout: QUESTION_STOP_TIMEOUT_SECONDS, async: true };
-    }
-    if (harness === 'grok') {
-        return { type: 'command', command, timeout: QUESTION_STOP_TIMEOUT_SECONDS };
-    }
-    if (harness === 'codex' || harness === 'claude-code') {
-        return {
-            type: 'command',
-            command,
-            timeout: QUESTION_STOP_TIMEOUT_SECONDS,
-            statusMessage: BLOCKING_STOP_STATUS_MESSAGE,
-        };
-    }
-    return { type: 'command', command, timeout: NON_ROUTING_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);
-    const hooks = Object.create(null);
-    for (const row of HOOK_EVENT_TABLE) {
-        if (row.document === null)
-            continue;
-        if (row.notifai === 'post-tool-use' &&
-            (options.harness !== 'codex' || !installsSessionAttendant(options.harness, options.platform)))
-            continue;
-        if (row.notifai === 'stop') {
-            hooks[row.document] = [{ hooks: [stopHandler(adapterPath, options.harness, commandOptions)] }];
-            continue;
-        }
-        hooks[row.document] = [
-            {
-                hooks: [
-                    {
-                        type: 'command',
-                        command: hookCommand(adapterPath, row.notifai, options.harness, commandOptions),
-                        timeout: row.timeoutSeconds,
-                    },
-                ],
-            },
-        ];
-    }
-    if (installsSessionAttendant(options.harness, options.platform)) {
-        // A second handler in the same group, never folded into the first: the
-        // harness runs the activation handler's context back promptly and does
-        // not wait for an async handler. Claude Code does not time out a
-        // backgrounded hook, so its attendant declares none and ends itself with
-        // its session. Codex enforces every async timeout, and its 600-second
-        // default would kill the attendant: it declares the complete answer window
-        // and a later prompt or turn end re-arms it after that. Codex caps
-        // Interrupt at three seconds; that copy only records the turn's end.
-        for (const event of attendDocumentEvents(options.harness)) {
-            const attend = {
-                type: 'command',
-                command: hookCommand(adapterPath, 'attend', options.harness, commandOptions),
-                async: true,
-                ...(options.harness !== 'codex'
-                    ? {}
-                    : { timeout: event === 'Interrupt' ? CODEX_INTERRUPT_TIMEOUT_SECONDS : CODEX_ATTEND_TIMEOUT_SECONDS }),
-            };
-            const group = hooks[event]?.[0];
-            if (group === undefined)
-                hooks[event] = [{ hooks: [attend] }];
-            else
-                group.hooks.push(attend);
-        }
-    }
-    return hooks;
-}
-/** Cursor's native schema is flat and uses lower-camel lifecycle event names. */
-export function buildCursorHookConfig(options) {
-    const commandOptions = commandOptionsFrom(options);
-    const hooks = Object.create(null);
-    for (const row of HOOK_EVENT_TABLE) {
-        if (row.cursor === null)
-            continue;
-        const handler = {
-            command: hookCommand(options.adapterPath, row.notifai, 'cursor', commandOptions),
-            timeout: row.notifai === 'stop' ? NON_ROUTING_BLOCKING_STOP_TIMEOUT_SECONDS : row.timeoutSeconds,
-        };
-        if ('cursorLoopLimit' in row)
-            handler.loop_limit = row.cursorLoopLimit;
-        hooks[row.cursor] = [...(hooks[row.cursor] ?? []), handler];
-    }
-    return hooks;
-}
-/**
- * The one file each harness reads Notifai's lifecycle wiring from: the current
- * User's account, in that harness's active home.
- */
-export function settingsFile(harness, 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(env, platform);
-        case 'openclaw':
-            return openclawPluginPath(env, platform);
-        case 'hermes':
-            return path.join(hermesPluginDir(env), '__init__.py');
-        case 'cursor':
-            return path.join(harnessAccountHome(env, platform), '.cursor', 'hooks.json');
-        case 'claude-code':
-            return path.join(configHome(env, 'CLAUDE_CONFIG_DIR', '.claude', platform), 'settings.json');
-        case 'grok':
-            return path.join(configHome(env, 'GROK_HOME', '.grok', platform), 'hooks', 'notifai.json');
-        case 'codex':
-            return inspectCodexLayer(codexMachineLayerPaths(env, platform)).writeTarget;
-        default:
-            return assertNeverHarness(harness);
-    }
-}
-/**
- * Files an older build may have left inside this Project, which Notifai now
- * only ever reads in order to remove.
- *
- * Nothing installs here any more. Every path is still enumerated because a
- * leftover Project-scoped handler keeps firing beside the Machine one, and
- * silently leaving it would be exactly the duplicate-routing defect dropping
- * the second scope was meant to end.
- */
-export function legacyProjectHookFiles(harness, cwd) {
-    switch (harness) {
-        case 'opencode':
-            return [path.join(cwd, '.opencode', 'plugins', OPENCODE_PLUGIN_FILENAME)];
-        case 'openclaw':
-            return [legacyOpenclawProjectPluginPath(cwd)];
-        case 'cursor':
-            return [path.join(cwd, '.cursor', 'hooks.json')];
-        case 'claude-code':
-            return [path.join(cwd, '.claude', 'settings.local.json')];
-        case 'grok':
-            return [];
-        case 'hermes':
-            return [];
-        case 'codex':
-            return codexLegacyProjectLayers(cwd).flatMap((paths) => [paths.hooksJson, paths.configToml]);
-        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)}`);
-}
-/**
- * Where Codex looks for a project's hooks — the **main** repository, not the
- * working directory.
- *
- * Run from a linked git worktree, Codex reads `<main repo>/.codex/config.toml`
- * (or a leftover `hooks.json`) and never looks at the worktree's own. Proven 2026-08-03 in an isolated
- * `CODEX_HOME`: with cwd set to a worktree, a handler at the main repo root
- * fired and an identical one at the worktree root did not; removing the main
- * one left nothing firing at all. Writing to cwd therefore produces a silent
- * no-op for anyone whose agent runs in a worktree, which is the normal case
- * under tooling like Orca.
- *
- * Claude Code does not share this behaviour — it reads the worktree's own
- * `.claude/settings.local.json` — so this deliberately applies to Codex only.
- */
-export function codexProjectRoot(cwd) {
-    const entry = findGitEntry(cwd);
-    if (entry === null)
-        return cwd;
-    try {
-        if (statSync(entry).isDirectory())
-            return path.dirname(entry);
-        return linkedWorktreeMainRoot(entry) ?? cwd;
-    }
-    catch {
-        // An unreadable or exotic checkout is not worth failing an install over;
-        // cwd is what we used to do and is right for every non-worktree case.
-        return cwd;
-    }
-}
-/** The nearest `.git` at or above `from`, or null outside a repository. */
-function findGitEntry(from) {
-    let dir = path.resolve(from);
-    for (;;) {
-        const entry = path.join(dir, '.git');
-        if (existsSync(entry))
-            return entry;
-        const parent = path.dirname(dir);
-        if (parent === dir)
-            return null;
-        dir = parent;
-    }
-}
-/**
- * Resolve the main checkout only from Git's reciprocal linked-worktree
- * metadata. A repository can contain an arbitrary `.git` file, so its one-way
- * `gitdir`/`commondir` claims are not authority to write outside the Project.
- */
-function linkedWorktreeMainRoot(gitFile) {
-    if (!isOwnedRegularFile(gitFile))
-        return null;
-    const gitdirClaim = readPathMarker(gitFile, /^gitdir:[ \t]+([^\r\n]+)\r?\n?$/);
-    if (gitdirClaim === null)
-        return null;
-    const gitDir = path.resolve(path.dirname(gitFile), gitdirClaim);
-    if (!isOwnedDirectory(gitDir))
-        return null;
-    const commonClaim = readPathMarker(path.join(gitDir, 'commondir'), /^([^\r\n]+)\r?\n?$/);
-    const backlinkClaim = readPathMarker(path.join(gitDir, 'gitdir'), /^([^\r\n]+)\r?\n?$/);
-    if (commonClaim === null || backlinkClaim === null)
-        return null;
-    const commonDir = path.resolve(gitDir, commonClaim);
-    const backlink = path.resolve(gitDir, backlinkClaim);
-    const worktreesDir = path.join(commonDir, 'worktrees');
-    if (path.basename(commonDir).toLowerCase() !== '.git' ||
-        !isOwnedDirectory(commonDir) ||
-        !isOwnedDirectory(worktreesDir) ||
-        !sameLocalPath(path.dirname(realpathSync(gitDir)), realpathSync(worktreesDir)) ||
-        !sameLocalPath(backlink, gitFile)) {
-        return null;
-    }
-    const mainRoot = path.dirname(commonDir);
-    return isOwnedDirectory(mainRoot) ? mainRoot : null;
-}
-function readPathMarker(file, pattern) {
-    if (!isOwnedRegularFile(file))
-        return null;
-    const match = pattern.exec(readFileSync(file, 'utf8'));
-    const claim = match?.[1]?.trim();
-    return claim === undefined || claim === '' ? null : claim;
-}
-function isOwnedRegularFile(file) {
-    return isOwnedEntry(file, 'file');
-}
-function isOwnedDirectory(file) {
-    return isOwnedEntry(file, 'directory');
-}
-function isOwnedEntry(file, kind) {
-    const metadata = lstatSync(file);
-    if (metadata.isSymbolicLink())
-        return false;
-    if (kind === 'file' ? !metadata.isFile() : !metadata.isDirectory())
-        return false;
-    const uid = process.getuid?.();
-    return uid === undefined || metadata.uid === uid;
-}
-/**
- * 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, platform = process.platform) {
-    const override = env[variable];
-    if (override !== undefined && override !== '')
-        return override;
-    const home = harnessAccountHome(env, platform);
-    return path.join(home, fallback);
-}
-/**
- * User-global Codex config directory for the *running* Codex installation.
- *
- * `CODEX_HOME` replaces the home; it does not shadow it. `codex doctor` with
- * the variable set reports that directory for every path it resolves and never
- * consults `~/.codex` at all. So a session manager that points Codex at its own
- * home makes `~/.codex` inert for those sessions, and installing there would
- * write hooks the running agent never reads while reporting success.
- *
- * Following the variable is therefore correct even though it means install and
- * doctor resolve different homes when run from different shells. Doctor names
- * the home it inspected for exactly that reason — see `codexHomeNote`.
- */
-export function codexGlobalDir(env = process.env, platform = process.platform) {
-    return configHome(env, 'CODEX_HOME', '.codex', platform);
-}
-function codexLayerPathsIn(dir) {
-    return {
-        dir,
-        hooksJson: path.join(dir, 'hooks.json'),
-        configToml: path.join(dir, 'config.toml'),
-    };
-}
-/** The two files Codex will look at in the Machine layer Notifai installs into. */
-export function codexMachineLayerPaths(env = process.env, platform = process.platform) {
-    return codexLayerPathsIn(codexGlobalDir(env, platform));
-}
-/**
- * Project layers an older build may have written into, for removal only.
- *
- * Codex resolves a project hook file against the main repository, so a linked
- * worktree has two candidate directories: the main checkout's `.codex`, which
- * Codex reads, and the worktree's own, which older builds sometimes created and
- * Codex never reads. Both are legacy residue and both are enumerated here.
- */
-export function codexLegacyProjectLayers(cwd) {
-    const dirs = [path.join(codexProjectRoot(cwd), '.codex')];
-    const entry = findGitEntry(cwd);
-    if (entry !== null) {
-        const worktreeLayer = path.join(path.dirname(entry), '.codex');
-        if (!dirs.some((dir) => path.resolve(dir) === path.resolve(worktreeLayer))) {
-            dirs.push(worktreeLayer);
-        }
-    }
-    return dirs.map(codexLayerPathsIn);
-}
-/**
- * Where Notifai writes in this Codex layer.
- *
- * `config.toml` is the User's whole Codex configuration and Codex rewrites it
- * itself for `[hooks.state]`; keeping Notifai out of it bounds the blast radius
- * to hooks, removes a second writer racing those trust records, and replaces
- * TOML splicing with the same JSON merge Claude Code uses. Joining an inline
- * layer that already has the User's handlers is the one exception, and it
- * exists only so Codex never prints its dual-representation warning.
- *
- * A fresh installation uses `hooks.json` unless foreign inline handlers make
- * `config.toml` the layer's established representation. Notifai-owned inline
- * handlers with no foreign inline neighbours are moved to `hooks.json`. Codex
- * keys approval by source path, so that move is a User-owned `/hooks` review,
- * not a silent identity-preserving refresh. `[hooks.state]` is the trust store
- * rather than a hook definition, so it never counts as a representation and is
- * preserved through every write.
- */
-export function inspectCodexLayer(paths) {
-    const jsonDocument = tryLoadSettings(paths.hooksJson);
-    const tomlDocument = tryLoadSettings(paths.configToml);
-    const ourJsonEvents = ourHandlerEvents(jsonDocument);
-    const ourTomlEvents = ourHandlerEvents(tomlDocument);
-    const foreignTomlHooks = tomlDocument !== null &&
-        locateAllHandlers(tomlDocument).some((handler) => !isNotifaiCommand(handler.command));
-    return {
-        paths,
-        jsonEvents: hookEventNames(jsonDocument?.hooks),
-        tomlEvents: hookEventNames(tomlDocument?.hooks),
-        ourJsonEvents,
-        ourTomlEvents,
-        foreignTomlHooks,
-        writeTarget: foreignTomlHooks && !(ourJsonEvents.length > 0 && ourTomlEvents.length === 0)
-            ? paths.configToml
-            : paths.hooksJson,
-    };
-}
-/**
- * Serialize one Notifai transaction across both representations in a Codex
- * layer, then inspect that layer only after acquiring the shared anchor.
- */
-export function withCodexLayerTransaction(paths, action) {
-    return withTargetFileLock(paths.configToml, () => action(inspectCodexLayer(paths)));
-}
-/** Every Machine-layer file this harness might already be reading hooks from. */
-export function machineHookFiles(harness, env = process.env, platform = process.platform) {
-    if (harness === 'grok') {
-        const target = settingsFile('grok', env, platform);
-        const directory = path.dirname(target);
-        let names;
-        try {
-            names = readdirSync(directory).filter((name) => name.endsWith('.json')).sort();
-        }
-        catch {
-            return [target];
-        }
-        return [target, ...names.map((name) => path.join(directory, name)).filter((file) => file !== target)];
-    }
-    if (harness !== 'codex')
-        return [settingsFile(harness, env, platform)];
-    const paths = codexMachineLayerPaths(env, platform);
-    return [paths.hooksJson, paths.configToml];
-}
-/**
- * The Machine layer with *Notifai* installed in both Codex representations.
- *
- * A layer that uses `hooks.json` and inline `[hooks]` at once is not by itself
- * a Notifai fault: Codex supports both, loads both, runs every matching
- * handler, and already prints its own "prefer a single representation" warning
- * at startup. Foreign handlers in the other file are the user's — often written
- * by another tool that manages that file — and repeating Codex's warning as a
- * Notifai failure demanded an edit to configuration Notifai does not own, for a
- * condition where every handler still fires exactly once.
- *
- * What is ours to diagnose is Notifai in both files. Then one event really does
- * send two Notification Requests per turn, and the copy outside the write
- * target keeps firing an older definition after the next install refreshes only
- * the other one. Uninstall strips Notifai from both files, so the remedy is
- * exact — and it never touches a foreign handler.
- */
-export function codexRepresentationProblems(env = process.env, platform = process.platform) {
-    const layer = inspectCodexLayer(codexMachineLayerPaths(env, platform));
-    if (layer.ourJsonEvents.length === 0 || layer.ourTomlEvents.length === 0)
-        return [];
-    const doubled = layer.ourJsonEvents.filter((event) => layer.ourTomlEvents.includes(event));
-    const consequence = doubled.length > 0
-        ? `Codex runs every matching handler, so this layer notifies twice per turn for ${doubled.join(', ')}`
-        : `Codex runs both files, so this layer's Notifai handlers are split between them (${[...new Set([...layer.ourJsonEvents, ...layer.ourTomlEvents])].join(', ')}) and the next install refreshes only one file`;
-    return [
-        `Notifai hooks are installed in both ${layer.paths.hooksJson} and ${layer.paths.configToml}; ${consequence}. Run \`notifai hooks uninstall --harness codex\` and then \`notifai hooks install --harness codex\` to leave exactly one copy; foreign hooks in either file are left alone.`,
-    ];
-}
-/**
- * The Machine layer where Notifai and someone else each own one Codex
- * representation.
- *
- * This is not a fault and never fails a check. Codex loads `hooks.json` and
- * inline `[hooks]` together and runs every matching handler, so both sets fire
- * exactly once — but Codex also prints "prefer one representation per layer"
- * at startup, and a user who sees that warning deserves to know which file is
- * Notifai's, which is not, and that Notifai will not touch the one it does not
- * own. Saying nothing here is what made the warning look like Notifai's bug.
- */
-export function codexCoexistenceNotes(env = process.env, platform = process.platform) {
-    const layer = inspectCodexLayer(codexMachineLayerPaths(env, platform));
-    const inJson = layer.ourJsonEvents.length > 0;
-    const inToml = layer.ourTomlEvents.length > 0;
-    if (inJson === inToml)
-        return [];
-    const ours = inJson ? layer.paths.hooksJson : layer.paths.configToml;
-    const theirs = inJson ? layer.paths.configToml : layer.paths.hooksJson;
-    const theirEvents = inJson ? layer.tomlEvents : layer.jsonEvents;
-    if (theirEvents.length === 0)
-        return [];
-    return [
-        `Notifai's Codex hooks are in ${ours}. ${theirs} defines hooks Notifai does not own (${theirEvents.join(', ')}) and Notifai will not modify it. Codex loads both files and runs every matching handler, so each set fires exactly once; its "prefer one representation per layer" startup warning is reporting that, not a Notifai fault.`,
-    ];
-}
-/**
- * What `CODEX_HOME` is doing to this shell, when it is doing anything.
- *
- * Codex replaces its whole home when the variable is set, so hooks installed
- * from a shell without it are simply absent here, and its trust store is keyed
- * by absolute file path — a config copied between homes arrives untrusted.
- * Both facts turn into "Notifai is not wired" reports that look like a bug in
- * the installer, so doctor names the home it actually inspected.
- */
-export function codexHomeNote(env = process.env, platform = process.platform) {
-    const effective = codexGlobalDir(env, platform);
-    const accountDefault = path.join(harnessAccountHome(env, platform), '.codex');
-    if (effective === accountDefault)
-        return null;
-    return `CODEX_HOME points Codex at ${effective}, so ${accountDefault} is not read by Codex in this shell at all. Global hooks installed from a shell without CODEX_HOME live there and are invisible here; Codex also keys hook trust by absolute file path, so hooks copied between homes need approving again in each one.`;
-}
-function tryLoadSettings(file) {
-    if (!existsSync(file))
-        return null;
-    try {
-        return loadSettings(file);
-    }
-    catch {
-        return null;
-    }
-}
-function hookEventNames(hooks) {
-    return Object.entries(hooks ?? {})
-        .filter(([, value]) => Array.isArray(value))
-        .map(([event]) => event);
-}
-/** Events this document defines a Notifai handler for, by their event key. */
-function ourHandlerEvents(document) {
-    if (document === null)
-        return [];
-    return [...new Set(locateHandlers(document).map((handler) => handler.event))];
-}
-/** Best-effort detection so `hooks install` usually needs no flags. */
-/**
- * Harnesses this *project* shows evidence of, in the working directory only.
- *
- * `CLAUDE.md` counts because it is Claude Code's own project file and is
- * frequently the only marker: a repository can be worked in daily through
- * Claude Code and never accumulate a `.claude/` directory.
- *
- * `AGENTS.md` deliberately counts for nothing. It began as a Codex
- * convention and is now read by most agent tooling — including Claude Code,
- * and including this repository, where the two filenames are the same
- * document. Treating it as evidence of any one harness would be a guess
- * dressed up as detection.
- */
-function localHarnessEvidence(cwd) {
-    const found = [];
-    if (existsSync(path.join(cwd, '.claude')) || existsSync(path.join(cwd, 'CLAUDE.md'))) {
-        found.push('claude-code');
-    }
-    if (existsSync(path.join(cwd, '.codex')))
-        found.push('codex');
-    if (existsSync(path.join(cwd, '.cursor')))
-        found.push('cursor');
-    if (existsSync(path.join(cwd, '.opencode')))
-        found.push('opencode');
-    if (existsSync(path.join(cwd, '.openclaw')))
-        found.push('openclaw');
-    if (existsSync(path.join(cwd, '.grok')))
-        found.push('grok');
-    return found;
-}
-/** Harnesses installed anywhere on this machine — a much weaker signal. */
-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(codexGlobalDir(env, platform)))
-        found.push('codex');
-    if (existsSync(path.join(home, '.cursor')))
-        found.push('cursor');
-    if (existsSync(opencodeConfigDir(env, platform)))
-        found.push('opencode');
-    if (openclawHasGlobalEvidence(existsSync, env, platform))
-        found.push('openclaw');
-    if (env['HERMES_SESSION_ID'] || (env['HERMES_HOME']?.trim() && existsSync(env['HERMES_HOME']))) {
-        found.push('hermes');
-    }
-    if (existsSync(configHome(env, 'GROK_HOME', '.grok', platform)))
-        found.push('grok');
-    return found;
-}
-/**
- * Every supported harness this project or machine shows evidence of, in
- * declared order. Project markers come first, then machine installs that the
- * project did not already name.
- *
- * `AGENTS.md` still counts for nothing — see `localHarnessEvidence`.
- */
-export function detectedHarnesses(cwd, env = process.env, platform = process.platform) {
-    const seen = new Set([
-        ...localHarnessEvidence(cwd),
-        ...globalHarnessEvidence(env, platform),
-    ]);
-    return HOOK_INSTALLABLE_HARNESSES.filter((harness) => seen.has(harness));
-}
-/**
- * Which *single* harness to wire when a caller still needs exactly one, or
- * null when it is genuinely unclear.
- *
- * Project evidence decides, and machine evidence is consulted only when the
- * project offers none. Several markers are not a failure of detection — they
- * 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, platform = process.platform) {
-    const local = localHarnessEvidence(cwd);
-    if (local.length > 0)
-        return local.length === 1 ? local[0] : null;
-    const global = globalHarnessEvidence(env, platform);
-    return global.length === 1 ? global[0] : null;
-}
-function readCursorSettings(file) {
-    if (!existsSync(file))
-        return { version: 1 };
-    const source = readOwnedRegularFile(file);
-    try {
-        const parsed = JSON.parse(source);
-        return typeof parsed === 'object' && parsed !== null
-            ? parsed
-            : { version: 1 };
-    }
-    catch {
-        throw new Error(`Could not parse ${file}; fix or move it before installing hooks.`);
-    }
-}
-function isOurCommand(command, scriptPath) {
-    if (command.includes(OWNER_MARKER))
-        return true;
-    return (command.includes(`${scriptPath}' hook `) ||
-        command.includes(`${scriptPath}" hook `) ||
-        command.includes(`${scriptPath} hook `) ||
-        isLegacyNotifaiCommand(command));
-}
-/** Cleanup-only recognition for unmistakable pre-marker Notifai commands. */
-function isLegacyNotifaiCommand(command) {
-    const hook = `['"]?\\s+hook (?:${HOOK_EVENT_PATTERN})\\b`;
-    return (new RegExp(`(?:^|[\\s'"])notifai(?:\\.cmd)?${hook}`).test(command) ||
-        new RegExp(`(?:^|[/\\\\])(?:notifai-public|notifai)[/\\\\]apps[/\\\\]cli[/\\\\]dist[/\\\\]main\\.js${hook}`, 'i').test(command) ||
-        new RegExp(`[/\\\\]node_modules[/\\\\]@raidiant[/\\\\]notifai[/\\\\]dist[/\\\\]main\\.js${hook}`, 'i').test(command));
-}
-export function mergeCursorHooks(existing, incoming, scriptPath) {
-    const hooks = Object.create(null);
-    const added = [];
-    const replaced = [];
-    const removed = [];
-    for (const [event, handlers] of Object.entries(existing.hooks ?? {})) {
-        const foreign = handlers.filter((handler) => !isOurCommand(handler.command, scriptPath));
-        if (foreign.length !== handlers.length) {
-            if (event in incoming)
-                replaced.push(event);
-            else
-                removed.push(event);
-        }
-        if (foreign.length > 0)
-            hooks[event] = foreign;
-    }
-    for (const [event, handlers] of Object.entries(incoming)) {
-        if (!replaced.includes(event))
-            added.push(event);
-        hooks[event] = [...(hooks[event] ?? []), ...handlers];
-    }
-    return { document: { ...existing, version: 1, hooks }, added, replaced, removed };
-}
-export function removeCursorHooks(existing, scriptPath) {
-    const hooks = Object.create(null);
-    const replaced = [];
-    for (const [event, handlers] of Object.entries(existing.hooks ?? {})) {
-        const foreign = handlers.filter((handler) => !isOurCommand(handler.command, scriptPath));
-        if (foreign.length !== handlers.length)
-            replaced.push(event);
-        if (foreign.length > 0)
-            hooks[event] = foreign;
-    }
-    const document = { ...existing };
-    if (Object.keys(hooks).length > 0)
-        document.hooks = hooks;
-    else
-        delete document.hooks;
-    // `version` is Cursor's schema marker, which Notifai writes only because it
-    // is writing hooks. Alone it is residue, not settings.
-    if (Object.keys(document).length === 1 && document.version !== undefined)
-        delete document.version;
-    return { document, added: [], replaced, removed: [] };
-}
-function readSettings(file) {
-    if (!existsSync(file))
-        return {};
-    const source = readOwnedRegularFile(file);
-    try {
-        const parsed = JSON.parse(source);
-        return typeof parsed === 'object' && parsed !== null ? parsed : {};
-    }
-    catch {
-        throw new Error(`Could not parse ${file}; fix or move it before installing hooks.`);
-    }
-}
-/**
- * True when a single handler is ours. Deliberately per-handler, not per-group:
- * removing a whole group destroyed a user's own handler if they had added one
- * beside ours inside the same matcher group.
- */
-function isOurHandler(handler, scriptPath) {
-    return isOurCommand(handler.command, scriptPath);
-}
-/** Drops only our handlers, keeping the group and anyone else's handlers. */
-function withoutOurs(groups, scriptPath) {
-    let removed = false;
-    const kept = [];
-    for (const group of groups) {
-        const hooks = group.hooks.filter((handler) => {
-            const ours = isOurHandler(handler, scriptPath);
-            if (ours)
-                removed = true;
-            return !ours;
-        });
-        if (hooks.length > 0)
-            kept.push({ ...group, hooks });
-    }
-    return { groups: kept, removed };
-}
-/**
- * Refresh owned handlers in their existing slots. Codex's approval identity
- * includes group and handler indices, so stripping then appending an unchanged
- * handler can revoke its approval and stale an active session's Stop definition.
- * Missing handlers append after existing slots; foreign handlers and matcher
- * metadata stay in place.
- *
- * Retired handlers are considered in every event. Hosts without index-based
- * approval can remove them; strict Codex repair refuses ambiguous removal so
- * an explicit migration can account for native trust and active sessions.
- */
-export function mergeHooks(existing, incoming, scriptPath, options = {}) {
-    const hooks = Object.create(null);
-    const added = [];
-    const replaced = [];
-    const removed = [];
-    for (const [event, groups] of Object.entries(existing.hooks ?? {})) {
-        if (!Array.isArray(groups)) {
-            // Codex keeps `[hooks.state]` beside event tables. It is not a matcher list.
-            ;
-            hooks[event] = groups;
-            continue;
-        }
-        const desired = (incoming[event] ?? []).map(group => ({ ...group, hooks: [...group.hooks] }));
-        const refreshed = [];
-        let hadOurs = false;
-        for (const group of groups) {
-            const next = [];
-            for (const handler of group.hooks) {
-                if (!isOurHandler(handler, scriptPath)) {
-                    next.push(handler);
-                    continue;
-                }
-                hadOurs = true;
-                const replacementGroup = desired.find(candidate => candidate.hooks.some(replacement => handlerEvent(replacement.command) === handlerEvent(handler.command)));
-                const index = replacementGroup?.hooks.findIndex(replacement => handlerEvent(replacement.command) === handlerEvent(handler.command)) ?? -1;
-                if (replacementGroup !== undefined && index >= 0) {
-                    next.push(replacementGroup.hooks.splice(index, 1)[0]);
-                }
-                else if (options.preserveIdentities === true) {
-                    throw new Error(`Cannot preserve Codex hook identities for ${event}: duplicate or retired owned handlers require explicit migration. Review the existing hooks before retrying; the hook document was not changed.`);
-                }
-            }
-            // Empty native groups also occupy an approval index.
-            if (next.length > 0 || options.preserveIdentities === true)
-                refreshed.push({ ...group, hooks: next });
-        }
-        for (const group of desired.filter(candidate => candidate.hooks.length > 0)) {
-            // Append to a matching owned group without inserting before a foreign
-            // handler. An omitted matcher and '*' both cover the complete event.
-            const target = refreshed.find(candidate => (candidate.matcher ?? '*') === (group.matcher ?? '*') &&
-                candidate.hooks.some(handler => isOurHandler(handler, scriptPath)));
-            if (target === undefined)
-                refreshed.push(group);
-            else
-                target.hooks.push(...group.hooks);
-        }
-        if (hadOurs) {
-            if (event in incoming)
-                replaced.push(event);
-            else
-                removed.push(event);
-        }
-        if (refreshed.length > 0)
-            hooks[event] = refreshed;
-    }
-    for (const [event, groups] of Object.entries(incoming)) {
-        if (!replaced.includes(event))
-            added.push(event);
-        if (!(event in (existing.hooks ?? {})))
-            hooks[event] = groups;
-    }
-    return { document: { ...existing, hooks }, added, replaced, removed };
-}
-export function removeHooks(existing, scriptPath) {
-    const hooks = Object.create(null);
-    const replaced = [];
-    for (const [event, groups] of Object.entries(existing.hooks ?? {})) {
-        if (!Array.isArray(groups)) {
-            ;
-            hooks[event] = groups;
-            continue;
-        }
-        const { groups: foreign, removed } = withoutOurs(groups, scriptPath);
-        if (removed)
-            replaced.push(event);
-        if (foreign.length > 0)
-            hooks[event] = foreign;
-    }
-    const remaining = Object.keys(hooks).length > 0 ? hooks : undefined;
-    const document = { ...existing };
-    if (remaining === undefined)
-        delete document.hooks;
-    else
-        document.hooks = remaining;
-    return { document, added: [], replaced, removed: [] };
-}
-/**
- * Writes the settings file the way a tool that does not own it should.
- *
- * Truncating in place lost the user's whole harness configuration if the write
- * failed halfway, and clobbered a concurrent editor's changes; following a
- * symlink wrote through to a target they never named. So: refuse
- * anything that is not a regular file, write a sibling temp file, fsync it, and
- * rename over the original — atomic within a directory on every platform we
- * support.
- */
-export function applyPlan(file, document) {
-    preparePlan(file, document)();
-}
-/** Validate a proposed document before any file in a multi-file edit changes. */
-export function preparePlan(file, document, previous = readOptionalOwnedRegularFile(file)) {
-    const body = isTomlSettingsPath(file)
-        ? tomlBody(file, document, previous)
-        : `${JSON.stringify(document, null, 2)}\n`;
-    const empty = isTomlSettingsPath(file) ? body.trim() === '' : isEmptyJsonDocument(body);
-    return prepareFileWrite(file, previous, empty ? null : body);
-}
-function readOptionalOwnedRegularFile(file) {
-    try {
-        return readOwnedRegularFile(file);
-    }
-    catch (err) {
-        if (err.code === 'ENOENT')
-            return null;
-        throw err;
-    }
-}
-function prepareFileWrite(file, previous, next) {
-    return () => {
-        const current = readOptionalOwnedRegularFile(file);
-        if (current !== previous)
-            throw new Error(`Configuration changed while preparing ${file}; retry.`);
-        if (current === next)
-            return;
-        if (next === null)
-            rmSync(file, { force: true });
-        else
-            atomicWriteFileSync(file, next, { requireCurrentUserOwner: true });
-    };
-}
-function isEmptyJsonDocument(body) {
-    try {
-        const parsed = JSON.parse(body);
-        return typeof parsed === 'object' && parsed !== null && !Array.isArray(parsed) && Object.keys(parsed).length === 0;
-    }
-    catch {
-        return false;
-    }
-}
-/** Delete an emptied Codex hooks.json and a now-empty layer directory. */
-export function cleanupEmptiedCodexLayer(paths) {
-    if (existsSync(paths.hooksJson)) {
-        try {
-            const document = loadSettings(paths.hooksJson);
-            const keys = Object.keys(document);
-            const hooksEmpty = document.hooks === undefined || Object.keys(document.hooks).length === 0;
-            if (keys.every((key) => key === 'hooks') && hooksEmpty) {
-                rmSync(paths.hooksJson, { force: true });
-            }
-        }
-        catch {
-            // Leave a file uninstall could not parse; the caller already reported it.
-        }
-    }
-    if (!existsSync(paths.dir))
-        return;
-    try {
-        if (readdirSync(paths.dir).length === 0)
-            rmdirSync(paths.dir);
-    }
-    catch {
-        // A concurrently replaced directory is not ours to fight.
-    }
-}
-/**
- * A TOML file rewritten around its `[hooks]` tables, not over them.
- *
- * `config.toml` is the user's, and for most of them it is hand-written: model
- * choices, sandbox settings, MCP servers, and the comments explaining why. A
- * parse-and-restringify write returns all of that as data and none of it as
- * the document they wrote — comments gone, order normalized, spacing theirs no
- * longer. Notifai adds three hook handlers; it has no business reflowing the
- * rest.
- *
- * So everything outside `[hooks...]` is carried across as the exact bytes it
- * came in as, and only the hooks tables are regenerated — re-emitted at the end
- * of the file, because TOML does not care where a table sits and splicing into
- * the middle would mean reasoning about a region line by line. If the result
- * cannot be proven to parse back to the document asked for, refuse the write.
- */
-function tomlBody(file, document, previous) {
-    if (previous === null)
-        return `${stringifyToml(document)}\n`;
-    if (sameTomlValue(parseToml(previous), document))
-        return previous;
-    const next = spliceTomlHooks(previous, document);
-    if (next === null)
-        throw new Error(`Cannot preserve unrelated TOML configuration in ${file}; no changes written.`);
-    return next;
-}
-/** Only locate syntax; smol-toml owns validity and decoded key identity. */
-function tomlStatements(source) {
-    parseToml(source);
-    const statements = [];
-    let offset = 0;
-    while (offset < source.length) {
-        if (/\s/.test(source[offset])) {
-            offset++;
-            continue;
-        }
-        if (source[offset] === '#') {
-            while (offset < source.length && source[offset] !== '\n')
-                offset++;
-            continue;
-        }
-        const start = offset;
-        let depth = 0;
-        let equals = -1;
-        const comments = [];
-        while (offset < source.length) {
-            const char = source[offset];
-            if (char === '"' || char === "'") {
-                const multiline = source.slice(offset, offset + 3) === char.repeat(3);
-                offset += multiline ? 3 : 1;
-                while (offset < source.length) {
-                    if (char === '"' && source[offset] === '\\') {
-                        offset += 2;
-                        continue;
-                    }
-                    if (source[offset] === char) {
-                        let count = 1;
-                        while (source[offset + count] === char)
-                            count++;
-                        if (!multiline || count >= 3) {
-                            offset += multiline ? count : 1;
-                            break;
-                        }
-                        offset += count;
-                    }
-                    else
-                        offset++;
-                }
-                continue;
-            }
-            if (char === '#') {
-                if (depth === 0)
-                    break;
-                const commentStart = offset;
-                while (offset < source.length && source[offset] !== '\n')
-                    offset++;
-                comments.push({ start: commentStart, end: offset });
-                continue;
-            }
-            if (char === '\n' && depth === 0)
-                break;
-            if (char === '[' || char === '{')
-                depth++;
-            if (char === ']' || char === '}')
-                depth--;
-            if (char === '=' && depth === 0 && equals === -1)
-                equals = offset;
-            offset++;
-        }
-        const table = source[start] === '[';
-        const syntax = source.slice(start, offset).trim();
-        // A standalone table or a dummy assignment decodes dotted/quoted/escaped
-        // keys without interpreting brackets, dots or quotes inside a key as syntax.
-        let decoded = parseToml(table ? syntax : `${source.slice(start, equals)} = 0`);
-        const keys = [];
-        while (decoded !== null && typeof decoded === 'object') {
-            if (Array.isArray(decoded)) {
-                decoded = decoded[0];
-                continue;
-            }
-            const entries = Object.entries(decoded);
-            if (entries.length !== 1)
-                break;
-            const [key, value] = entries[0];
-            keys.push(key);
-            decoded = value;
-        }
-        statements.push({ start, end: offset, table, path: keys, comments });
-    }
-    return statements;
-}
-/** Splice syntax spans only; even comments inside removed arrays survive. */
-function omitTomlStatements(source, removed) {
-    let next = '';
-    let offset = 0;
-    for (const statement of removed) {
-        next += source.slice(offset, statement.start);
-        for (const comment of statement.comments)
-            next += `${source.slice(comment.start, comment.end)}\n`;
-        offset = statement.end;
-    }
-    return next + source.slice(offset);
-}
-/** Replace hook syntax only, validating all unrelated parsed values. */
-function spliceTomlHooks(source, document) {
-    try {
-        let table = [];
-        const removed = tomlStatements(source).filter((statement) => {
-            if (statement.table)
-                table = statement.path;
-            return (statement.table ? table : [...table, ...statement.path])[0] === 'hooks';
-        });
-        const head = omitTomlStatements(source, removed);
-        const body = document.hooks === undefined ? '' : stringifyToml({ hooks: document.hooks });
-        const spliced = body === '' ? head : `${head}${head === '' || head.endsWith('\n') ? '' : '\n'}${body}\n`;
-        return sameTomlValue(parseToml(spliced), document) ? spliced : null;
-    }
-    catch {
-        return null;
-    }
-}
-/** Structural equality for parsed TOML, which carries dates as well as data. */
-function sameTomlValue(a, b) {
-    if (Object.is(a, b))
-        return true;
-    if (a instanceof Date && b instanceof Date)
-        return a.getTime() === b.getTime();
-    if (Array.isArray(a) || Array.isArray(b)) {
-        if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length)
-            return false;
-        return a.every((item, index) => sameTomlValue(item, b[index]));
-    }
-    if (typeof a !== 'object' || typeof b !== 'object' || a === null || b === null)
-        return false;
-    const left = a;
-    const right = b;
-    const keys = Object.keys(left);
-    if (keys.length !== Object.keys(right).length)
-        return false;
-    return keys.every((key) => Object.hasOwn(right, key) && sameTomlValue(left[key], right[key]));
-}
-export function loadSettings(file) {
-    return isTomlSettingsPath(file) ? readTomlSettings(file) : readSettings(file);
-}
-export function isTomlSettingsPath(file) {
-    return file.endsWith('.toml');
-}
-function readTomlSettings(file) {
-    if (!existsSync(file))
-        return {};
-    const source = readOwnedRegularFile(file);
-    try {
-        const parsed = parseToml(source);
-        return typeof parsed === 'object' && parsed !== null ? parsed : {};
-    }
-    catch {
-        throw new Error(`Could not parse ${file}; fix or move it before installing hooks.`);
-    }
-}
-export function loadCursorSettings(file) {
-    return readCursorSettings(file);
-}
-/** Codex's canonical event spelling inside its persisted trust keys. */
-function codexEventName(event) {
-    return event.replace(/([a-z0-9])([A-Z])/g, '$1_$2').toLowerCase();
-}
-/** Recursively sort object keys before hashing, matching Codex's canonical JSON. */
-function canonicalValue(value) {
-    if (Array.isArray(value))
-        return value.map(canonicalValue);
-    if (typeof value !== 'object' || value === null)
-        return value;
-    return Object.fromEntries(Object.entries(value)
-        .sort(([left], [right]) => left.localeCompare(right))
-        .map(([key, child]) => [key, canonicalValue(child)]));
-}
-/**
- * Best-effort mirror of the identity current Codex builds compare with
- * `hooks.state.*.trusted_hash`. Codex hashes `type`, `command`, `timeout`,
- * `async`, `statusMessage`, and `additionalContextLimit` (omitting the 2,500
- * default). This persisted format is diagnostic evidence, not an API: Codex's
- * `/hooks` UI remains authoritative and Notifai never writes the trust store.
- */
-/**
- * Codex's default additionalContext spill threshold, in approximate tokens.
- * Codex strips this value before hashing, so an explicit 2,500 matches omit.
- */
-const CODEX_DEFAULT_ADDITIONAL_CONTEXT_LIMIT = 2_500;
-export function codexHookIdentityHash(handler) {
-    const command = {
-        type: 'command',
-        command: handler.command,
-        timeout: Math.max(1, handler.timeout ?? 600),
-        async: handler.async ?? false,
-        ...(handler.statusMessage === undefined ? {} : { statusMessage: handler.statusMessage }),
-        ...(handler.additionalContextLimit === undefined
-            || handler.additionalContextLimit === CODEX_DEFAULT_ADDITIONAL_CONTEXT_LIMIT
-            ? {}
-            : { additionalContextLimit: handler.additionalContextLimit }),
-    };
-    const normalized = canonicalValue({
-        event_name: codexEventName(handler.event),
-        hooks: [command],
-    });
-    return `sha256:${createHash('sha256').update(JSON.stringify(normalized)).digest('hex')}`;
-}
-function codexTrustState(env) {
-    const file = path.join(codexGlobalDir(env), 'config.toml');
-    if (!existsSync(file))
-        return {};
-    try {
-        const parsed = parseToml(readFileSync(file, 'utf8'));
-        const hooks = parsed['hooks'];
-        if (typeof hooks !== 'object' || hooks === null)
-            return {};
-        const state = hooks['state'];
-        return typeof state === 'object' && state !== null ? state : {};
-    }
-    catch {
-        return {};
-    }
-}
-/** Best-effort mirror of current Codex's persisted key for one handler. */
-export function codexTrustKey(installation, handler) {
-    let source = installation.file;
-    try {
-        source = path.join(realpathSync(path.dirname(source)), path.basename(source));
-    }
-    catch {
-        // Codex falls back to the logical source path when canonicalization fails,
-        // so the diagnostic must do the same.
-    }
-    return `${source}:${codexEventName(handler.event)}:${handler.groupIndex}:${handler.handlerIndex}`;
-}
-/**
- * Stable identity of the one Codex Stop definition an Agent Session loaded.
- *
- * Codex materializes hook handlers into the session runtime. A later config
- * change can therefore make the file on disk current while an older session
- * keeps executing the definition it loaded at activation. Include Codex's
- * source key as well as the normalized handler identity so moving an otherwise
- * byte-identical definition between project and global layers also requires a
- * fresh session.
- */
-export function codexStopDefinitionFingerprint(installations) {
-    const candidates = installations
-        .filter((installation) => installation.harness === 'codex')
-        .flatMap((installation) => installation.handlers
-        // The attend handler shares the Stop group; it is not the Stop definition.
-        .filter((handler) => handler.event === 'Stop' && handlerEvent(handler.command) !== 'attend')
-        .map((handler) => ({ installation, handler })));
-    if (candidates.length !== 1)
-        return undefined;
-    const candidate = candidates[0];
-    if (candidate === undefined)
-        return undefined;
-    const { installation, handler } = candidate;
-    return createHash('sha256')
-        .update(`${codexTrustKey(installation, handler)}\0${codexHookIdentityHash(handler)}`)
-        .digest('hex');
-}
-/**
- * Trust defects that make installed Codex handlers look present while Codex
- * skips them. Trust is user-owned; the supported repair is Codex's `/hooks`
- * review UI, never writing the trust store on the user's behalf. Because the
- * persisted shape is not a public Codex contract, this diagnosis can drift;
- * `/hooks` remains the source of truth.
- */
-export function codexTrustProblems(installations, env = process.env) {
-    const state = codexTrustState(env);
-    return installations
-        .filter((installation) => installation.harness === 'codex')
-        .flatMap((installation) => installation.handlers.flatMap((handler) => {
-        const key = codexTrustKey(installation, handler);
-        const entry = state[key];
-        const trustedHash = typeof entry === 'object' && entry !== null
-            ? entry['trusted_hash']
-            : undefined;
-        const currentHash = codexHookIdentityHash(handler);
-        if (typeof entry === 'object' &&
-            entry !== null &&
-            entry['enabled'] === false) {
-            return [
-                `${handler.event} in ${installation.file} is disabled in Codex; open \`/hooks\` and enable the Notifai handler`,
-            ];
-        }
-        if (trustedHash === currentHash)
-            return [];
-        return [
-            `${handler.event} in ${installation.file} is ${typeof trustedHash === 'string' ? 'changed since it was trusted' : 'not trusted'}; open \`/hooks\` in Codex and approve the Notifai handler`,
-        ];
-    }));
-}
-/**
- * Trust defects in the handlers Question Routing runs. The Session Attendant
- * is presence, never a routing gate: an attend handler still awaiting
- * approval is reported by doctor and init and never refuses a question.
- */
-export function codexRoutingTrustProblems(installations, env = process.env) {
-    return codexTrustProblems(installations.map((installation) => ({
-        ...installation,
-        handlers: installation.handlers.filter((handler) => !['attend', 'post-tool-use'].includes(handlerEvent(handler.command) ?? '')),
-    })), env);
-}
-/**
- * Any Notifai handler, whatever checkout wrote it.
- *
- * Deliberately looser than `isOurHandler`: this answers "has Notifai been set
- * up here at all", and a handler installed from a second checkout is still
- * evidence that it has (and is itself worth reporting).
- */
-function isNotifaiCommand(command) {
-    return HOOK_EVENT_COMMAND_RE.test(command);
-}
-/**
- * Native plugin ids that would fire beside document hooks if left enabled.
- *
- * Notifai no longer wires through harness plugins. A leftover enablement from
- * a trial or an older experiment still runs the same adapter command, so
- * document handlers plus that plugin fire every event twice. Matching is the
- * plugin name `notifai` with an optional `@marketplace` suffix — never a
- * substring of someone else's plugin id.
- */
-function isNotifaiNativePluginKey(key) {
-    const id = key.split('@')[0]?.trim() ?? '';
-    return id.toLowerCase() === 'notifai';
-}
-function pluginEntryIsEnabled(value) {
-    if (value === false)
-        return false;
-    if (value !== null && typeof value === 'object' && !Array.isArray(value)) {
-        return value['enabled'] !== false;
-    }
-    return true;
-}
-export function notifaiNativePluginEnablementKeys(value) {
-    if (value === null || typeof value !== 'object' || Array.isArray(value))
-        return [];
-    return Object.entries(value)
-        .filter(([key, enabled]) => isNotifaiNativePluginKey(key) && pluginEntryIsEnabled(enabled))
-        .map(([key]) => key);
-}
-export function stripObsoleteNotifaiPluginEnablement(document) {
-    const next = { ...document };
-    const removed = [];
-    for (const field of ['enabledPlugins', 'plugins']) {
-        const value = next[field];
-        if (value === null || typeof value !== 'object' || Array.isArray(value))
-            continue;
-        const record = { ...value };
-        let changed = false;
-        for (const key of Object.keys(record)) {
-            if (!isNotifaiNativePluginKey(key) || !pluginEntryIsEnabled(record[key]))
-                continue;
-            delete record[key];
-            removed.push(key);
-            changed = true;
-        }
-        if (!changed)
-            continue;
-        if (Object.keys(record).length === 0)
-            delete next[field];
-        else
-            next[field] = record;
-    }
-    return { document: next, removed };
-}
-/**
- * Remove enabled Notifai plugin tables only after lexical ownership and full
- * semantic preservation are proven. Unsupported dotted/inline definitions
- * fail before mutation, rather than silently leaving a second firing path.
- */
-export function spliceOutNotifaiPluginTables(source) {
-    const expected = parseToml(source);
-    const plugins = expected['plugins'];
-    const removed = notifaiNativePluginEnablementKeys(plugins);
-    if (removed.length === 0)
-        return { next: source, removed };
-    const remaining = { ...plugins };
-    for (const key of removed)
-        delete remaining[key];
-    expected['plugins'] = remaining;
-    let dropping = false;
-    const omitted = tomlStatements(source).filter((statement) => {
-        if (statement.table) {
-            dropping = statement.path[0] === 'plugins' && removed.includes(statement.path[1] ?? '');
-        }
-        return dropping;
-    });
-    const next = omitTomlStatements(source, omitted);
-    const parsed = parseToml(next);
-    // Removing the last child table may also remove its implicit parent.
-    for (const value of [expected, parsed]) {
-        const entries = value['plugins'];
-        if (entries && typeof entries === 'object' && !Array.isArray(entries) && Object.keys(entries).length === 0) {
-            delete value['plugins'];
-        }
-    }
-    if (!sameTomlValue(parsed, expected)) {
-        throw new Error('Cannot safely remove obsolete native plugin wiring from this TOML form; disable the Notifai plugin or use [plugins."notifai"] table form and retry. No changes written.');
-    }
-    return { next, removed };
-}
-/**
- * Leftover native plugin enablement that would fire beside document hooks.
- *
- * Reads only harness settings files this installer already owns inspecting.
- * It never shells out to a plugin CLI and never writes a plugin.
- */
-export function findObsoleteNotifaiPluginWiring(env = process.env, platform = process.platform) {
-    const found = [];
-    const claudeFile = settingsFile('claude-code', env, platform);
-    if (existsSync(claudeFile)) {
-        try {
-            const keys = notifaiNativePluginEnablementKeys(loadSettings(claudeFile)['enabledPlugins']);
-            if (keys.length > 0)
-                found.push({ harness: 'claude-code', file: claudeFile, keys });
-        }
-        catch {
-            // Unreadable settings are reported by the ordinary install/doctor path.
-        }
-    }
-    const codexToml = codexMachineLayerPaths(env, platform).configToml;
-    if (existsSync(codexToml)) {
-        try {
-            const keys = notifaiNativePluginEnablementKeys(loadSettings(codexToml)['plugins']);
-            if (keys.length > 0)
-                found.push({ harness: 'codex', file: codexToml, keys });
-        }
-        catch {
-            // Same: leave diagnosis to the settings reader that already ran.
-        }
-    }
-    return found;
-}
-/**
- * Plan native plugin retirement without changing configuration. The caller
- * validates every destination before applying this plan under the layer lock.
- */
-export function prepareCodexPluginCleanup(file) {
-    const previous = readOptionalOwnedRegularFile(file);
-    if (previous === null)
-        return { source: null, removed: [], apply: prepareFileWrite(file, null, null) };
-    const { next, removed } = spliceOutNotifaiPluginTables(previous);
-    return { source: next, removed, apply: prepareFileWrite(file, previous, next) };
-}
-/**
- * The one Machine installation each harness would read a Notifai handler from.
- */
-export function findInstallations(env = process.env, adapterHome, platform = process.platform) {
-    return HOOK_INSTALLABLE_HARNESSES.flatMap((harness) => collectInstallations(harness, machineHookFiles(harness, env, platform), adapterHome, platform, env));
-}
-/**
- * Notifai handlers a previous build left in Project-scoped files.
- *
- * These are never an install target and never a fallback: they are residue to
- * report and remove once the Machine installation is proven current. Foreign
- * handlers sharing those files are not returned and are never touched.
- */
-export function findLegacyProjectInstallations(cwd, env = process.env, adapterHome, platform = process.platform) {
-    const machine = new Set(HOOK_INSTALLABLE_HARNESSES.flatMap((harness) => machineHookFiles(harness, env, platform).map((file) => path.resolve(file))));
-    return HOOK_INSTALLABLE_HARNESSES.flatMap((harness) => collectInstallations(harness, 
-    // A Project checkout that happens to be the harness home would otherwise
-    // report the Machine installation as legacy residue and delete it.
-    legacyProjectHookFiles(harness, cwd).filter((file) => !machine.has(path.resolve(file))), adapterHome, platform, env));
-}
-function collectInstallations(harness, files, adapterHome, platform, env) {
-    const nodePath = inspectHookAdapter(adapterHome, platform).target?.execPath;
-    const commandOptions = {
-        platform,
-        ...(nodePath === undefined ? {} : { nodePath }),
-    };
-    const found = [];
-    for (const file of files) {
-        if (!existsSync(file))
-            continue;
-        if (harness === 'hermes') {
-            if (!isOurHermesPlugin(path.dirname(file)))
-                continue;
-            found.push({
-                harness,
-                file,
-                handlers: [],
-                ...(hermesPluginCurrent(adapterHome, env) ? {} : {
-                    problems: ['Hermes plugin does not match the current Notifai adapter; rerun `notifai hooks install --harness hermes`'],
-                }),
-            });
-            continue;
-        }
-        // OpenCode's adapter is a plugin module, not a settings document, so it
-        // is reported as one installation covering all three events rather than
-        // parsed for handlers.
-        if (harness === 'opencode' || harness === 'openclaw') {
-            let source;
-            try {
-                source = readOwnedRegularFile(file);
-            }
-            catch {
-                continue;
-            }
-            const target = harness === 'openclaw' ? openclawPluginTarget(source) : opencodePluginTarget(source);
-            if (target === null)
-                continue;
-            const label = harness === 'openclaw' ? 'OpenClaw' : 'OpenCode';
-            const problems = [
-                ...(!target.current
-                    ? [`obsolete ${label} event wiring; rerun \`notifai hooks install --harness ${harness}\``]
-                    : []),
-                ...(target.adapter !== hookAdapterPath(adapterHome)
-                    ? [
-                        `${label} still names a mutable CLI or runtime path; rerun \`notifai hooks install --harness ${harness}\``,
-                    ]
-                    : []),
-            ];
-            const events = harness === 'openclaw' ? OPENCLAW_EVENTS : OPENCODE_EVENTS;
-            found.push({
-                harness,
-                file,
-                ...(problems.length > 0 ? { problems } : {}),
-                handlers: events.map(([event, hookEvent]) => ({
-                    event,
-                    groupIndex: 0,
-                    handlerIndex: 0,
-                    command: hookCommand(target.adapter, hookEvent, harness, {
-                        ...commandOptions,
-                        ...(target.nodePath === undefined ? {} : { nodePath: target.nodePath }),
-                    }),
-                    ...(target.timeoutSeconds === undefined ? {} : { timeout: target.timeoutSeconds }),
-                })),
-            });
-            continue;
-        }
-        if (harness === 'cursor') {
-            let document;
-            try {
-                document = readCursorSettings(file);
-            }
-            catch {
-                continue;
-            }
-            const handlers = locateCursorHandlers(document);
-            if (handlers.length > 0) {
-                const problems = harnessMarkerProblems(harness, handlers, adapterHome, commandOptions);
-                found.push({ harness, file, handlers, ...(problems.length > 0 ? { problems } : {}) });
-            }
-            continue;
-        }
-        let document;
-        try {
-            document = loadSettings(file);
-        }
-        catch {
-            continue;
-        }
-        const handlers = locateHandlers(document);
-        if (handlers.length > 0) {
-            const problems = harnessMarkerProblems(harness, handlers, adapterHome, commandOptions);
-            found.push({ harness, file, handlers, ...(problems.length > 0 ? { problems } : {}) });
-        }
-    }
-    return found;
-}
-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 = `${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');
-    }
-    return problems;
-}
-function locateCursorHandlers(document) {
-    const handlers = [];
-    for (const [event, eventHandlers] of Object.entries(document.hooks ?? {})) {
-        eventHandlers.forEach((handler, handlerIndex) => {
-            if (isNotifaiCommand(handler.command)) {
-                handlers.push({
-                    event,
-                    groupIndex: 0,
-                    handlerIndex,
-                    command: handler.command,
-                    ...(handler.timeout === undefined ? {} : { timeout: handler.timeout }),
-                });
-            }
-        });
-    }
-    return handlers;
-}
-function locateAllHandlers(document) {
-    const handlers = [];
-    for (const [event, groups] of Object.entries(document.hooks ?? {})) {
-        if (!Array.isArray(groups))
-            continue;
-        groups.forEach((group, groupIndex) => {
-            group.hooks?.forEach((handler, handlerIndex) => {
-                if (typeof handler?.command !== 'string')
-                    return;
-                handlers.push({
-                    event,
-                    groupIndex,
-                    handlerIndex,
-                    command: handler.command,
-                    ...(handler.timeout === undefined ? {} : { timeout: handler.timeout }),
-                    ...(handler.async === undefined ? {} : { async: handler.async }),
-                    ...(handler.asyncRewake === undefined ? {} : { asyncRewake: handler.asyncRewake }),
-                    ...(handler.statusMessage === undefined ? {} : { statusMessage: handler.statusMessage }),
-                    ...(typeof handler.additionalContextLimit === 'number'
-                        ? { additionalContextLimit: handler.additionalContextLimit }
-                        : {}),
-                });
-            });
-        });
-    }
-    return handlers;
-}
-function locateHandlers(document) {
-    return locateAllHandlers(document).filter((handler) => isNotifaiCommand(handler.command));
-}
-/** The hook event a handler's command actually invokes, e.g. `stop`. */
-export function handlerEvent(command) {
-    return / hook ([a-z-]+)/.exec(command)?.[1] ?? null;
-}
-function readOwnedRegularFile(file) {
-    const stat = lstatSync(file);
-    if (stat.isSymbolicLink() || !stat.isFile()) {
-        throw new Error(`${file} is not a regular file${stat.isSymbolicLink() ? ' (symlink)' : ''}; refusing to read it.`);
-    }
-    const uid = typeof process.getuid === 'function' ? process.getuid() : undefined;
-    if (uid !== undefined && stat.uid !== uid) {
-        throw new Error(`${file} is owned by uid ${stat.uid}, not the current user.`);
-    }
-    return readFileSync(file, 'utf8');
-}
-//# sourceMappingURL=install-hooks.js.map