@raidiant/notifai 0.5.1 → 1.0.1

package/dist/commands.js

@@ -7,20 +7,20 @@ import { parse as parseToml, stringify as stringifyToml } from 'smol-toml';
 import { CAPABILITIES_V1, QUESTION_TEXT_MAX_LENGTH, REPLY_MAX_QUESTIONS, REPLY_MAX_WINDOW_SECONDS, validateDraft, } from '@raidiant/notifai-protocol';
 import { sha256Hex } from '@raidiant/notifai-protocol/node';
 import { ApiCallError, NetworkError, createClient, isRetryableReplyPollError, } from './client.js';
-import { BOOLEAN_CONFIG_KEYS, CONFIG_KEYS, LOG_LEVELS, NUMERIC_CONFIG_KEYS, configBounds, configDefaultValue, findProjectConfigPath, findProjectLocalConfigPath, globalConfigPath, loadConfig, sessionConfigPath, } from './config.js';
+import { BOOLEAN_CONFIG_KEYS, CONFIG_KEYS, LOG_LEVELS, NUMERIC_CONFIG_KEYS, configBounds, configDefaultValue, findProjectConfigPath, personalProjectConfigPath, globalConfigPath, loadConfig, sessionConfigPath, } from './config.js';
 import { acceptedValues, configInfo } from './config-schema.js';
-import { skillsSource } from './release.js';
+import { packageVersion, skillsSource } from './release.js';
 import { atomicWriteFileSync } from './atomic-file.js';
 import { withTargetFileLock } from './file-lock.js';
 import { renderConfigExplain, renderConfigList, renderConfigPlain, } from './ui/config-view.js';
-import { firstBlocker, openItems, } from './readiness.js';
+import { firstBlocker, } from './readiness.js';
 import { WAITER_CEILING_SECONDS, handleSessionEnd, handleStop, handleUserPromptSubmit, parseHookInput, pruneAbandonedSessions, readLiveProjectSessionPointers, readMatchingProjectSessionPointer, readProjectSession, readProjectSessionPointer, readSessionState, registerQuestion, } from './hooks.js';
 import { LOG_EVENTS, activeLogPath, archiveLogPaths, logConfigResolved, logSettingsFrom, logsDiskUsage, nullLogger, readLogRecords, renderRecord, } from './logging.js';
-import { BLOCKING_STOP_TIMEOUT_SECONDS, CLAUDE_ASYNC_STOP_TIMEOUT_SECONDS, HARNESSES, applyPlan, buildCursorHookConfig, buildHookConfig, codexLayerDir, codexTrustProblems, codexProjectRoot, detectHarness, findInstallations, handlerEvent, loadCursorSettings, loadSettings, mergeCursorHooks, mergeHooks, removeCursorHooks, removeHooks, settingsFile, } from './install-hooks.js';
-import { HARNESS_CAPABILITIES } from './harnesses.js';
+import { BLOCKING_STOP_TIMEOUT_SECONDS, CLAUDE_ASYNC_STOP_TIMEOUT_SECONDS, HARNESSES, applyPlan, buildCursorHookConfig, buildHookConfig, collapseUnusedCodexRepresentation, codexLayerDir, codexLayerPaths, codexRepresentationProblems, codexTrustProblems, codexProjectRoot, detectHarness, detectedHarnesses, findInstallations, handlerEvent, hookDefinitionFiles, inspectCodexLayer, loadCursorSettings, loadSettings, mergeCursorHooks, mergeHooks, removeCursorHooks, removeHooks, settingsFile, } from './install-hooks.js';
+import { HARNESS_CAPABILITIES, HARNESS_LABELS } from './harnesses.js';
 import { claudeWakeRoute, inspectClaudeInbox, systemClaudeWakeAdapters, } from './claude-wake.js';
 import { codexWakeRoute, inspectCodexResume, } from './codex-wake.js';
-import { inspectHookAdapter, installHookAdapter, } from './hook-adapter.js';
+import { inspectHookAdapter, installHookAdapter, isNpxAdapterTarget, } from './hook-adapter.js';
 import { isOurOpencodePlugin, opencodePluginSource, } from './opencode-plugin.js';
 import { CHOICE_USAGE, buildDraft, formatReceipt, parseChoices, receiptExitCode, slugify, } from './send.js';
 /** The invocation's logger, or one that discards everything. */
@@ -1628,22 +1628,87 @@ export async function closeCommand(deps, requestId) {
         return reportError(deps, err);
     }
 }
+/** True when this process is `npx` / `npm exec`, not a global or linked install. */
+export function runningViaNpx(env, scriptPath) {
+    if (env['npm_command'] === 'exec')
+        return true;
+    return scriptPath.includes(`${path.sep}_npx${path.sep}`);
+}
+function fileHookInstallTarget(target) {
+    if (target === undefined || isNpxAdapterTarget(target))
+        return undefined;
+    return target;
+}
+function resolveHookAdapterTarget(deps, flags) {
+    if (deps.hookInstallTarget !== undefined && isNpxAdapterTarget(deps.hookInstallTarget)) {
+        return deps.hookInstallTarget;
+    }
+    const fileTarget = fileHookInstallTarget(deps.hookInstallTarget);
+    const execPath = flags.execPath ?? fileTarget?.execPath ?? process.execPath;
+    const scriptPath = flags.scriptPath ?? fileTarget?.scriptPath ?? process.argv[1] ?? 'notifai';
+    if (runningViaNpx(deps.env, scriptPath)) {
+        const version = packageVersion();
+        const npmCli = deps.env['npm_execpath'];
+        if (version === null) {
+            throw new Error('Could not read this CLI version, so an npx hook target cannot be pinned. Install `@raidiant/notifai` globally and rerun `notifai hooks install`.');
+        }
+        if (typeof npmCli !== 'string' || npmCli === '') {
+            throw new Error('This process looks like npx but npm_execpath is missing. Install `@raidiant/notifai` globally and rerun `notifai hooks install`.');
+        }
+        return { kind: 'npx', execPath, npmCli, spec: `@raidiant/notifai@${version}` };
+    }
+    return { execPath, scriptPath };
+}
+function printHooksInstallClose(deps, harness, file) {
+    const label = HARNESS_LABELS[harness];
+    if (deps.io.interactive === true && deps.io.note) {
+        void deps.io.note(`${file}\nSend one ${label} prompt, then run \`notifai doctor\`.`, `${label} hooks installed`);
+        return;
+    }
+    deps.io.out(`Installed ${harness} hooks in ${file}`);
+    deps.io.out(`Send one ${label} prompt, then check \`notifai doctor\`.`);
+}
 export function hooksInstallCommand(deps, flags) {
+    if (flags.harness === undefined) {
+        const detected = detectedHarnesses(deps.cwd, deps.env);
+        if (detected.length === 0) {
+            deps.io.err(`Could not tell which harness to install for — pass --harness <${HARNESSES.join('|')}>.`);
+            return EXIT.usage;
+        }
+        let ok = true;
+        for (const harness of detected) {
+            if (hooksInstallCommand(deps, { ...flags, harness }) !== EXIT.ok)
+                ok = false;
+        }
+        return ok ? EXIT.ok : EXIT.failed;
+    }
     const harness = resolveHarness(deps, flags.harness);
     if (!harness)
         return EXIT.usage;
-    const execPath = flags.execPath ?? process.execPath;
-    const scriptPath = flags.scriptPath ?? process.argv[1] ?? 'notifai';
+    const adapterTarget = resolveHookAdapterTarget(deps, flags);
+    const scriptPath = flags.scriptPath ?? fileHookInstallTarget(adapterTarget)?.scriptPath ?? process.argv[1] ?? 'notifai';
     let adapterPath;
     try {
-        adapterPath = installHookAdapter({ execPath, scriptPath }, deps.hookAdapterHome).path;
+        adapterPath = installHookAdapter(adapterTarget, deps.hookAdapterHome).path;
     }
     catch (err) {
         deps.io.err(`Could not prepare the stable hook adapter: ${String(err)}`);
         return EXIT.failed;
     }
-    const config = loadLoggedConfig(deps, { cwd: deps.cwd, env: deps.env });
-    const file = settingsFile(harness, flags.global ?? false, deps.cwd, deps.env);
+    const wantGlobal = flags.global === true;
+    const existing = findInstallations(deps.cwd, deps.env, deps.hookAdapterHome).filter((installation) => installation.harness === harness);
+    const otherScope = existing.filter((installation) => installation.global !== wantGlobal);
+    if (!wantGlobal && otherScope.some((installation) => installation.global)) {
+        const globalFile = otherScope.find((installation) => installation.global)?.file;
+        deps.io.out(`${HARNESS_LABELS[harness]} hooks already cover this machine (${globalFile}). This project does not need its own copy. To wire only this project: notifai hooks uninstall --harness ${harness} --global && notifai hooks install --harness ${harness}`);
+        return EXIT.ok;
+    }
+    if (wantGlobal && otherScope.some((installation) => !installation.global)) {
+        if (hooksUninstallCommand(deps, { ...flags, global: false, harness }) !== EXIT.ok) {
+            return EXIT.failed;
+        }
+    }
+    const file = settingsFile(harness, wantGlobal, deps.cwd, deps.env);
     // OpenCode's adapter is a generated plugin module rather than a handler
     // merged into a settings document, so it owns the whole file.
     if (harness === 'opencode') {
@@ -1653,9 +1718,8 @@ export function hooksInstallCommand(deps, flags) {
         });
     }
     if (harness === 'cursor') {
-        let merged;
         try {
-            merged = withTargetFileLock(file, () => {
+            withTargetFileLock(file, () => {
                 const document = loadCursorSettings(file);
                 const result = mergeCursorHooks(document, buildCursorHookConfig({
                     adapterPath,
@@ -1669,28 +1733,15 @@ export function hooksInstallCommand(deps, flags) {
             deps.io.err(String(err));
             return EXIT.failed;
         }
-        deps.io.out(`Installed ${harness} hooks in ${file}`);
-        if (merged.replaced.length > 0)
-            deps.io.out(`  replaced: ${merged.replaced.join(', ')}`);
-        if (merged.added.length > 0)
-            deps.io.out(`  added: ${merged.added.join(', ')}`);
-        if (flags.global) {
-            deps.io.out('Send one Cursor prompt, then check `notifai doctor`. If the hook has not fired,');
-            deps.io.out('start a new Cursor session and try one prompt again.');
-        }
-        else {
-            deps.io.out('Send one Cursor prompt, then check `notifai doctor`. If the hook has not fired,');
-            deps.io.out('start a new Cursor session and try one prompt again.');
-        }
-        deps.io.out('Cursor hooks can emit a native follow-up, but its agent shell does not expose');
-        deps.io.out('the exact conversation id needed to register safely. `notifai ask` therefore');
-        deps.io.out('fails closed; use blocking `notifai send --reply` for questions.');
+        printHooksInstallClose(deps, harness, file);
         return EXIT.ok;
     }
-    let merged;
+    let foreignStopCount = 0;
+    let collapsedFrom = null;
     try {
-        merged = withTargetFileLock(file, () => {
+        withTargetFileLock(file, () => {
             const document = loadSettings(file);
+            foreignStopCount = foreignStopHandlers(document).length;
             const result = mergeHooks(document, buildHookConfig({
                 adapterPath,
                 harness,
@@ -1698,61 +1749,41 @@ export function hooksInstallCommand(deps, flags) {
             applyPlan(file, result.document);
             return result;
         });
+        if (harness === 'codex') {
+            collapsedFrom = collapseUnusedCodexRepresentation(file, scriptPath, codexLayerPaths(flags.global ?? false, deps.cwd, deps.env));
+        }
     }
     catch (err) {
         deps.io.err(String(err));
         return EXIT.failed;
     }
-    deps.io.out(`Installed ${harness} hooks in ${file}`);
-    if (merged.replaced.length > 0)
-        deps.io.out(`  replaced: ${merged.replaced.join(', ')}`);
-    if (merged.added.length > 0)
-        deps.io.out(`  added: ${merged.added.join(', ')}`);
-    if (merged.removed.length > 0) {
-        deps.io.out(`  removed: ${merged.removed.join(', ')} (this build no longer serves them)`);
-    }
-    deps.io.out('');
-    deps.io.out(config.ask_grace_seconds.value === 0
-        ? 'A question registered with `notifai ask` goes to your devices immediately when the agent turn ends, whether or not you are at this machine.'
-        : `A question registered with \`notifai ask\` stays in the terminal for ${config.ask_grace_seconds.value}s from registration and then goes to your devices whether or not you are at this machine.`);
     if (harness === 'codex') {
         const layer = flags.global ? null : codexLayerDir(deps.cwd);
-        if (layer !== null) {
-            // Codex reads project hooks from the main repository but only looks when
-            // a `.codex` directory sits at or above cwd, so a worktree install has to
-            // write one file and create one directory in two different places. Doing
-            // it silently would leave the next person deriving this the hard way
-            //.
+        if (layer !== null)
             mkdirSync(layer, { recursive: true });
-            deps.io.out('');
-            deps.io.out('You are in a worktree. Codex reads project hooks from the main repository,');
-            deps.io.out(`so they were written to ${file}. ${layer} was created so this`);
-            deps.io.out('worktree discovers that file. Each other worktree needs its own `.codex`');
-            deps.io.out('directory; rerun this installer from that worktree to create it.');
-        }
-    }
-    deps.io.out('');
-    if (harness === 'claude-code') {
-        // Codex deliberately gets no counterpart line: its Stop definition is
-        // byte-identical to the one earlier builds wrote, so nothing about its
-        // trust state changed and saying so would invent a gate that is not there.
-        deps.io.out(`The Stop handler is asynchronous: it returns at once, so your turn ends normally, and it waits for your answer out of band for up to ${CLAUDE_ASYNC_STOP_TIMEOUT_SECONDS}s before delivering it back into this session. That timeout is written explicitly because Claude Code kills a background hook at its own 600s default and reports nothing when it does.`);
-        deps.io.out('');
     }
-    if (harness === 'claude-code' && flags.global !== true) {
-        deps.io.out('Claude Code reloads project hook files without a restart. Send one new prompt,');
-        deps.io.out('then check `notifai doctor` to confirm that the hook fired.');
+    printHooksInstallClose(deps, harness, file);
+    if (collapsedFrom !== null) {
+        deps.io.out(`Collapsed ${collapsedFrom} onto ${file} so this layer has one representation.`);
     }
-    else if (harness === 'claude-code') {
-        deps.io.out('Send one new Claude Code prompt, then check `notifai doctor`. If the hook has');
-        deps.io.out('not fired, start a new Claude Code session and try one prompt again.');
+    if (foreignStopCount > 0) {
+        deps.io.out("This layer already has a Stop handler. Codex runs every matching handler, so Notifai's Stop and the existing one will both fire.");
     }
-    else {
-        deps.io.out('Send one Codex prompt, then check `notifai doctor`. If the hook has not fired,');
-        deps.io.out('start a new Codex session and try one prompt again.');
+    if (harness === 'codex') {
+        for (const problem of codexRepresentationProblems(deps.cwd, deps.env)) {
+            deps.io.out(problem);
+        }
     }
     return EXIT.ok;
 }
+function foreignStopHandlers(document) {
+    const groups = document.hooks?.['Stop'];
+    if (!Array.isArray(groups))
+        return [];
+    return groups
+        .flatMap((group) => group.hooks ?? [])
+        .filter((handler) => !/ hook (user-prompt-submit|stop|session-end)\b/.test(handler.command));
+}
 /**
  * Writes the OpenCode plugin, replacing any Notifai plugin already there —
  * including one a different checkout wrote, matched on the managed marker for
@@ -1779,16 +1810,7 @@ function installOpencodePlugin(deps, file, options) {
         deps.io.err(String(err));
         return EXIT.failed;
     }
-    deps.io.out(`Installed the OpenCode plugin at ${file}`);
-    deps.io.out('');
-    deps.io.out('It maps chat.message to presence, session.idle to question escalation, and');
-    deps.io.out('session.deleted to local cleanup through the same `notifai hook` commands');
-    deps.io.out('the other harnesses run. Permission prompts stay in OpenCode.');
-    deps.io.out('OpenCode does not expose a proven exactly-once continuation after session.idle,');
-    deps.io.out('so `notifai ask` fails closed there. Use blocking `notifai send --reply` when');
-    deps.io.out('the answer must return to the agent without another human prompt.');
-    deps.io.out('');
-    deps.io.out('Restart OpenCode: it loads plugins once at start.');
+    printHooksInstallClose(deps, 'opencode', file);
     return EXIT.ok;
 }
 export function hooksUninstallCommand(deps, flags) {
@@ -1845,28 +1867,34 @@ export function hooksUninstallCommand(deps, flags) {
             : `No Notifai hooks found in ${file}`);
         return EXIT.ok;
     }
-    let stripped;
+    const files = hookDefinitionFiles(harness, flags.global ?? false, deps.cwd, deps.env);
+    const existing = files.filter((candidate) => existsSync(candidate));
+    if (existing.length === 0) {
+        deps.io.out(`Nothing to remove: ${file} does not exist.`);
+        return EXIT.ok;
+    }
+    let removedAny = false;
     try {
-        stripped = withTargetFileLock(file, () => {
-            if (!existsSync(file))
-                return null;
-            const document = loadSettings(file);
-            const result = removeHooks(document, scriptPath);
-            applyPlan(file, result.document);
-            return result;
-        });
+        for (const candidate of existing) {
+            const stripped = withTargetFileLock(candidate, () => {
+                const document = loadSettings(candidate);
+                const result = removeHooks(document, scriptPath);
+                applyPlan(candidate, result.document);
+                return result;
+            });
+            if (stripped.replaced.length > 0) {
+                removedAny = true;
+                deps.io.out(`Removed Notifai hooks (${stripped.replaced.join(', ')}) from ${candidate}`);
+            }
+        }
     }
     catch (err) {
         deps.io.err(String(err));
         return EXIT.failed;
     }
-    if (stripped === null) {
-        deps.io.out(`Nothing to remove: ${file} does not exist.`);
-        return EXIT.ok;
+    if (!removedAny) {
+        deps.io.out(`No Notifai hooks found in ${existing.join(', ')}`);
     }
-    deps.io.out(stripped.replaced.length > 0
-        ? `Removed Notifai hooks (${stripped.replaced.join(', ')}) from ${file}`
-        : `No Notifai hooks found in ${file}`);
     return EXIT.ok;
 }
 function assertOwnedRegularFile(file) {
@@ -1879,6 +1907,12 @@ function assertOwnedRegularFile(file) {
         throw new Error(`${file} is owned by uid ${stat.uid}, not the current user.`);
     }
 }
+const HARNESS_LABEL = {
+    'claude-code': 'Claude Code',
+    codex: 'Codex',
+    cursor: 'Cursor',
+    opencode: 'OpenCode',
+};
 function resolveHarness(deps, requested) {
     if (requested !== undefined) {
         if (HARNESSES.includes(requested))
@@ -1886,20 +1920,61 @@ function resolveHarness(deps, requested) {
         deps.io.err(`Unknown harness "${requested}". Supported: ${HARNESSES.join(', ')}.`);
         return null;
     }
-    const detected = detectHarness(deps.cwd);
+    const detected = detectHarness(deps.cwd, deps.env);
     if (!detected) {
         deps.io.err(`Could not tell which harness to install for — pass --harness <${HARNESSES.join('|')}>.`);
         return null;
     }
     return detected;
 }
+/**
+ * Which harnesses to wire. An explicit `--harness` still wins as a singleton.
+ * Otherwise: every detected harness, or a human picker when detection is empty
+ * or names more than one.
+ */
+async function pickHarnessesToInstall(deps, requested) {
+    if (requested !== undefined) {
+        const harness = resolveHarness(deps, requested);
+        return harness === null ? null : [harness];
+    }
+    const detected = detectedHarnesses(deps.cwd, deps.env);
+    if (detected.length === 1)
+        return detected;
+    if (deps.io.interactive === true && deps.io.multiselect) {
+        const picked = await deps.io.multiselect('Which agent harnesses should Notifai wire here?', HARNESSES.map((name) => ({
+            value: name,
+            label: HARNESS_LABEL[name],
+            ...(detected.includes(name) ? { hint: 'detected on this machine' } : {}),
+        })), detected);
+        if (picked === null)
+            return null;
+        const unknown = picked.filter((name) => !HARNESSES.includes(name));
+        if (unknown.length > 0) {
+            deps.io.err(`Unknown harness "${unknown[0]}". Supported: ${HARNESSES.join(', ')}.`);
+            return null;
+        }
+        return picked;
+    }
+    if (detected.length === 0) {
+        deps.io.err(`Could not tell which harness to wire. Run: notifai hooks install --harness <${HARNESSES.join('|')}>`);
+        return null;
+    }
+    return detected;
+}
 // ---------------------------------------------------------------------------
 // config show / set / unset
 // ---------------------------------------------------------------------------
 export function configShowCommand(deps, flags) {
     const config = loadLoggedConfig(deps, { cwd: deps.cwd, env: deps.env });
     if (flags.json) {
-        const output = Object.fromEntries(CONFIG_KEYS.map((key) => [key, { value: config[key].value, source: config[key].source }]));
+        const output = Object.fromEntries(CONFIG_KEYS.map((key) => [
+            key,
+            {
+                value: config[key].value,
+                source: config[key].source,
+                summary: configInfo(key).summary,
+            },
+        ]));
         deps.io.out(JSON.stringify(output, null, 2));
         return EXIT.ok;
     }
@@ -2073,7 +2148,7 @@ async function configMutationTarget(deps, flags) {
         const selected = await deps.io.select('Where should this setting live?', [
             { value: 'global', label: 'This machine', hint: 'applies across projects' },
             { value: 'project', label: 'This project (shared)', hint: '.notifai/config.toml' },
-            { value: 'local', label: 'This project (personal)', hint: 'keep config.local.toml gitignored' },
+            { value: 'local', label: 'This project (personal)', hint: 'stored on this machine, not in the repo' },
         ]);
         if (selected === null) {
             deps.io.err('No configuration layer selected.');
@@ -2084,7 +2159,7 @@ async function configMutationTarget(deps, flags) {
     const targetPath = flags.session
         ? sessionConfigPath(flags.session, deps.env)
         : layer === 'local'
-            ? (findProjectLocalConfigPath(deps.cwd) ?? path.join(deps.cwd, '.notifai', 'config.local.toml'))
+            ? personalProjectConfigPath(deps.cwd, deps.env)
             : layer === 'project'
                 ? (findProjectConfigPath(deps.cwd) ?? path.join(deps.cwd, '.notifai', 'config.toml'))
                 : globalConfigPath(deps.env);
@@ -2491,17 +2566,15 @@ async function closeGap(deps, state, flags) {
         return 'closed';
     }
     if (state.id === 'hooks') {
-        let harness = detectHarness(deps.cwd);
-        if (harness === null && deps.io.interactive === true && deps.io.select) {
-            const picked = await deps.io.select('Which agent harness do you use here?', HARNESSES.map((name) => ({ value: name, label: name })));
-            if (picked !== null)
-                harness = picked;
-        }
-        if (harness === null) {
-            deps.io.err(`Could not tell which harness to wire. Run: notifai hooks install --harness <${HARNESSES.join('|')}>`);
+        const harnesses = await pickHarnessesToInstall(deps);
+        if (harnesses === null || harnesses.length === 0)
             return 'failed';
+        let ok = true;
+        for (const harness of harnesses) {
+            if (hooksInstallCommand(deps, { harness }) !== EXIT.ok)
+                ok = false;
         }
-        return hooksInstallCommand(deps, { harness }) === EXIT.ok ? 'closed' : 'failed';
+        return ok ? 'closed' : 'failed';
     }
     if (state.id === 'skill') {
         if (deps.nativeSkills === undefined) {
@@ -2790,6 +2863,12 @@ async function runSetupProof(deps) {
         'Proof may still arrive — re-run `notifai init` and it will re-check this same notification.');
     return 'pending';
 }
+/** Closing a local gap cannot have changed the service, the keychain, or devices. */
+function refreshAfterClose(id) {
+    return id === 'project' || id === 'hooks' || id === 'skill' || id === 'question-routing-settings'
+        ? ['local']
+        : undefined;
+}
 /** Whether an optional gap should be closed, given flags and who is watching. */
 function wantsOptional(deps, state, flags) {
     // Naming the project is init's whole reason to touch the filesystem, costs
@@ -2843,8 +2922,12 @@ export async function initCommand(deps, flags) {
         return EXIT.usage;
     }
     await deps.io.intro?.('Notifai setup');
-    const reassess = () => assessReadiness(deps, flags.skillsScope === undefined ? {} : { skillScope: flags.skillsScope });
-    let readiness = await reassess();
+    const skillOpts = flags.skillsScope === undefined ? {} : { skillScope: flags.skillsScope };
+    let readiness = await assessReadiness(deps, skillOpts);
+    const reassess = (refresh) => assessReadiness(deps, {
+        ...skillOpts,
+        ...(refresh === undefined ? {} : { previous: readiness, refresh }),
+    });
     let failed = false;
     const attempted = new Set();
     // Re-assess after every successful action. This is how a browser approval or
@@ -2876,7 +2959,7 @@ export async function initCommand(deps, flags) {
                 if (result === 'failed')
                     failed = true;
                 if (result === 'failed' && state.status === 'optional-gap') {
-                    readiness = await reassess();
+                    readiness = await reassess(refreshAfterClose(state.id));
                     advanced = true;
                     break;
                 }
@@ -2884,7 +2967,7 @@ export async function initCommand(deps, flags) {
                     stop = true;
                     break;
                 }
-                readiness = await reassess();
+                readiness = await reassess(refreshAfterClose(state.id));
                 advanced = true;
                 break;
             }
@@ -2897,7 +2980,7 @@ export async function initCommand(deps, flags) {
                     stop = true;
                     break;
                 }
-                readiness = await reassess();
+                readiness = await reassess(refreshAfterClose(state.id));
                 advanced = true;
                 break;
             }
@@ -2939,34 +3022,74 @@ export async function initCommand(deps, flags) {
         if (stop || !advanced)
             break;
     }
-    readiness = await reassess();
-    for (const state of readiness.states.filter((s) => s.status === 'ready')) {
-        deps.io.out(`${state.title}: ${state.detail}`);
+    await printInitClose(deps, readiness, flags);
+    const blocker = firstBlocker(readiness);
+    if (blocker === null)
+        return failed ? EXIT.failed : EXIT.ok;
+    return failed || deps.io.interactive !== true ? EXIT.failed : EXIT.ok;
+}
+function isHookSubstate(id) {
+    return id === 'hooks' || id.startsWith('hooks-') || id === 'question-routing-settings';
+}
+function leftoverOptionals(readiness, flags) {
+    return readiness.states.filter((state) => {
+        if (state.status !== 'optional-gap')
+            return false;
+        if (isHookSubstate(state.id))
+            return false;
+        if (state.id === 'skill' && flags.skills === false)
+            return false;
+        return true;
+    });
+}
+function printOptionalLeftovers(deps, leftovers) {
+    for (const state of leftovers) {
+        deps.io.out(`Optional, not set up — ${remedyLine(state)}`);
     }
+}
+function questionsWillRoute(readiness) {
+    const hooks = readiness.states.find((state) => state.id === 'hooks');
+    const settings = readiness.states.find((state) => state.id === 'question-routing-settings');
+    return hooks?.status === 'ready' && settings?.status !== 'gap';
+}
+async function printInitClose(deps, readiness, flags) {
     const blocker = firstBlocker(readiness);
+    const canSend = readiness.states.find((state) => state.id === 'devices')?.status === 'ready';
+    const questions = questionsWillRoute(readiness);
+    const leftovers = leftoverOptionals(readiness, flags);
+    if (deps.io.interactive === true) {
+        if (blocker === null) {
+            const lines = [
+                canSend ? 'You can send notifications.' : 'You are signed in.',
+                questions
+                    ? 'Questions will reach your devices.'
+                    : 'Questions stay in the terminal until hooks are installed.',
+            ];
+            await deps.io.note?.(lines.join('\n'), 'Ready');
+            printOptionalLeftovers(deps, leftovers);
+            deps.io.out('All set. Agents in this project can notify you and ask questions.');
+            await deps.io.outro?.('All set ✨');
+            return;
+        }
+        await deps.io.note?.(`${blocker.title} — ${blocker.detail}\n${remedyLine(blocker)}`, 'Next');
+        deps.io.out(`Next: ${blocker.title} — ${blocker.detail}`);
+        deps.io.out(`  ${remedyLine(blocker)}`);
+        if (blocker.remedy?.by === 'user-elsewhere' || blocker.remedy?.by === 'user-here') {
+            deps.io.out('  Then re-run `notifai init` and it will pick up from here.');
+        }
+        await deps.io.outro?.('One step remains (above)');
+        return;
+    }
     if (blocker === null) {
-        const skipped = openItems(readiness).filter((state) => !(state.id === 'skill' && flags.skills === false));
-        for (const state of skipped)
-            deps.io.out(`Optional, not set up — ${remedyLine(state)}`);
+        printOptionalLeftovers(deps, leftovers);
         deps.io.out('All set. Agents in this project can notify you and ask questions.');
-        await deps.io.outro?.('All set ✨');
-        return failed ? EXIT.failed : EXIT.ok;
+        return;
     }
-    // Exactly one. Everything else waits until this is done, because the next
-    // gap is frequently a consequence of this one and naming it now would send
-    // the reader off to fix something that is not actually wrong.
-    deps.io.out('');
     deps.io.out(`Next: ${blocker.title} — ${blocker.detail}`);
     deps.io.out(`  ${remedyLine(blocker)}`);
-    // Both "do it here" and "do it elsewhere" leave setup mid-journey; re-run is
-    // how the rest is recovered either way.
     if (blocker.remedy?.by === 'user-elsewhere' || blocker.remedy?.by === 'user-here') {
         deps.io.out('  Then re-run `notifai init` and it will pick up from here.');
     }
-    await deps.io.outro?.('One step remains (above)');
-    // An agent must be able to branch on setup being blocked without parsing
-    // prose. A present human may deliberately leave and resume later.
-    return failed || deps.io.interactive !== true ? EXIT.failed : EXIT.ok;
 }
 // ---------------------------------------------------------------------------
 // doctor
@@ -3009,23 +3132,10 @@ async function contractCheck(client) {
         };
     }
 }
-/**
- * Read the whole setup once, in dependency order.
- *
- * Descent stops where a prerequisite is missing: without a credential there is
- * nothing to ask the server with, and without a reachable server a contract
- * mismatch is unknowable rather than absent. Those downstream states report
- * `unknown`, which is the honest answer and keeps a network outage from
- * looking like a broken install.
- */
-export async function assessReadiness(deps, options = {}) {
-    const config = loadLoggedConfig(deps, { cwd: deps.cwd, env: deps.env });
-    const states = [];
-    let accountClient = null;
-    let accountDevices = null;
+function projectReadiness(deps, config) {
     const configPath = path.join(deps.cwd, '.notifai', 'config.toml');
     const projectSlug = config.project.value;
-    states.push(projectSlug !== null
+    return projectSlug !== null
         ? {
             id: 'project',
             title: 'Project identity',
@@ -3045,7 +3155,73 @@ export async function assessReadiness(deps, options = {}) {
                 summary: 'name this project after its directory',
                 command: 'notifai init',
             },
-        });
+        };
+}
+function remoteStatesFrom(previous) {
+    const pick = (id) => previous.states.find((state) => state.id === id);
+    const credential = pick('credential');
+    const server = pick('server');
+    const contract = pick('contract');
+    const auth = pick('auth');
+    const devices = pick('devices');
+    const proof = pick('proof');
+    if (credential === undefined ||
+        server === undefined ||
+        contract === undefined ||
+        auth === undefined ||
+        devices === undefined ||
+        proof === undefined) {
+        return null;
+    }
+    return { credential, server, contract, auth, devices, proof };
+}
+function remoteInvalidatedByConfig(previous, config) {
+    if (config.base_url.source === 'default')
+        return false;
+    const server = previous.states.find((state) => state.id === 'server');
+    return server === undefined || !server.detail.includes(config.base_url.value);
+}
+/**
+ * Read the whole setup once, in dependency order.
+ *
+ * Descent stops where a prerequisite is missing: without a credential there is
+ * nothing to ask the server with, and without a reachable server a contract
+ * mismatch is unknowable rather than absent. Those downstream states report
+ * `unknown`, which is the honest answer and keeps a network outage from
+ * looking like a broken install.
+ */
+export async function assessReadiness(deps, options = {}) {
+    const config = loadLoggedConfig(deps, { cwd: deps.cwd, env: deps.env });
+    const previous = options.previous;
+    const refresh = options.refresh;
+    if (previous !== undefined && refresh !== undefined && refresh.length === 0)
+        return previous;
+    const reuseRemote = previous !== undefined &&
+        refresh !== undefined &&
+        !refresh.includes('remote') &&
+        !remoteInvalidatedByConfig(previous, config);
+    if (reuseRemote) {
+        const reused = remoteStatesFrom(previous);
+        if (reused !== null) {
+            return {
+                states: [
+                    projectReadiness(deps, config),
+                    reused.credential,
+                    reused.server,
+                    reused.contract,
+                    reused.auth,
+                    ...hookStates(deps),
+                    await skillReadiness(deps, options.skillScope),
+                    reused.devices,
+                    reused.proof,
+                ],
+            };
+        }
+    }
+    const states = [];
+    let accountClient = null;
+    let accountDevices = null;
+    states.push(projectReadiness(deps, config));
     const credential = deps.store.load();
     states.push(credential
         ? {
@@ -3084,10 +3260,10 @@ export async function assessReadiness(deps, options = {}) {
             id: 'server',
             title: 'Service',
             status: 'gap',
-            detail: `cannot reach ${baseUrl} (${config.base_url.source})`,
+            detail: `cannot reach ${baseUrl}`,
             remedy: {
                 by: 'user-here',
-                summary: 'check your network, or the base_url shown above',
+                summary: 'check your network',
                 command: 'notifai doctor',
             },
         });
@@ -3293,8 +3469,8 @@ async function setupProofState(deps, config, client, devices) {
         };
     }
 }
-export async function doctorCommand(deps, flags) {
-    const readiness = await assessReadiness(deps);
+export async function doctorCommand(deps, flags, options = {}) {
+    const readiness = options.readiness ?? (await assessReadiness(deps));
     const blocker = firstBlocker(readiness);
     const ok = blocker === null;
     if (flags.json) {
@@ -3511,6 +3687,20 @@ function hookChecks(deps) {
             .map((i) => `${i.harness} ${i.global ? 'global' : 'project'} (${i.file})`)
             .join(', '),
     });
+    const wired = new Set(installations.map((installation) => installation.harness));
+    const unwired = detectedHarnesses(deps.cwd, deps.env).filter((harness) => !wired.has(harness));
+    if (unwired.length > 0) {
+        checks.push({
+            name: 'hooks (detected)',
+            ok: false,
+            informational: true,
+            detail: `${unwired.map((harness) => HARNESS_LABEL[harness]).join(', ')} detected on this machine but not wired`,
+            remedy: {
+                summary: 'install hooks for every detected harness',
+                command: 'notifai hooks install',
+            },
+        });
+    }
     const { active, contested } = resolveActiveHarness(deps.env, deps.cwd, (deps.now ?? Date.now)());
     const activeInstallations = active === null
         ? []
@@ -3621,7 +3811,8 @@ function hookChecks(deps) {
         harness,
         installations: installations.filter((i) => i.harness === harness),
     }))
-        .filter((entry) => entry.installations.length > 1);
+        .filter((entry) => entry.installations.some((installation) => installation.global) &&
+        entry.installations.some((installation) => !installation.global));
     if (duplicated.length > 0) {
         checks.push({
             name: 'hooks (duplicates)',
@@ -3631,6 +3822,25 @@ function hookChecks(deps) {
                 .join('; '),
         });
     }
+    const representationProblems = codexRepresentationProblems(deps.cwd, deps.env);
+    if (representationProblems.length > 0) {
+        const collapseCommand = representationProblems.some((problem) => problem.includes('--global'))
+            ? 'notifai hooks install --harness codex --global'
+            : 'notifai hooks install --harness codex';
+        checks.push({
+            name: 'hooks (codex representation)',
+            ok: false,
+            detail: representationProblems.join('; '),
+            ...(representationProblems.some((problem) => problem.includes('to collapse onto'))
+                ? {
+                    remedy: {
+                        summary: 'collapse this Codex layer onto a single hook file',
+                        command: collapseCommand,
+                    },
+                }
+                : {}),
+        });
+    }
     if (active !== null && activeInstallations.length > 0) {
         const admissionProblems = activeQuestionRouteProblems(deps, active, installations);
         checks.push({
@@ -3795,15 +4005,20 @@ function codexStrayWorktreeCheck(deps) {
     if (layer === null)
         return null;
     const root = codexProjectRoot(deps.cwd);
-    const stray = path.join(path.dirname(layer), '.codex', 'hooks.json');
-    if (!existsSync(path.join(root, '.codex', 'hooks.json')))
+    const project = inspectCodexLayer(codexLayerPaths(false, deps.cwd, deps.env));
+    if (project.jsonEvents.length === 0 && project.tomlEvents.length === 0)
         return null;
+    const strayJson = path.join(path.dirname(layer), '.codex', 'hooks.json');
+    const strayToml = path.join(path.dirname(layer), '.codex', 'config.toml');
     const problems = [];
     if (!existsSync(layer)) {
         problems.push(`${layer} is missing, so Codex never looks for project hooks here`);
     }
-    if (existsSync(stray)) {
-        problems.push(`${stray} is never read — Codex reads ${root}/.codex/hooks.json instead`);
+    if (existsSync(strayJson) && path.resolve(strayJson) !== path.resolve(project.paths.hooksJson)) {
+        problems.push(`${strayJson} is never read — Codex reads ${project.writeTarget} instead`);
+    }
+    if (existsSync(strayToml) && path.resolve(strayToml) !== path.resolve(project.paths.configToml)) {
+        problems.push(`${strayToml} is never read — Codex reads ${project.writeTarget} instead`);
     }
     return {
         name: 'hooks (codex worktree)',
@@ -3863,6 +4078,18 @@ export function realIo(env = process.env) {
             const answer = await p.select({ message, options });
             return p.isCancel(answer) ? null : answer;
         },
+        multiselect: async (message, options, initial) => {
+            if (!interactive())
+                return null;
+            const p = await clack();
+            const answer = await p.multiselect({
+                message,
+                options,
+                required: true,
+                ...(initial !== undefined && initial.length > 0 ? { initialValues: initial } : {}),
+            });
+            return p.isCancel(answer) ? null : answer;
+        },
         intro: async (title) => {
             if (!interactive())
                 return;