@raidiant/notifai 10.1.6 → 11.0.1

package/dist/commands-doctor.js

@@ -1,14 +1,14 @@
 import { NOTIFICATION_CONTRACT_FINGERPRINT, PLATFORMS, SHIPPED_CLI_CAPABILITIES, } from '@raidiant/notifai-protocol';
 import { existsSync } from 'node:fs';
-import path from 'node:path';
 import { inspectClaudeInbox, systemClaudeWakeAdapters } from './claude-wake.js';
 import { ApiCallError } from './client.js';
 import { inspectCodexResume } from './codex-wake.js';
 import {} from './config.js';
-import { HARNESS_CAPABILITIES, HARNESS_LABELS, HERMES_QUESTION_ROUTING_UNAVAILABLE, isHookInstallableHarness, } from './harnesses.js';
+import { HARNESS_LABELS, HERMES_QUESTION_ROUTING_UNAVAILABLE, isHookInstallableHarness, questionRoutingCapability, } from './harnesses.js';
 import { hookAdapterTargetsArtifact, inspectHookAdapter, isNpxAdapterTarget, } from './hook-adapter.js';
-import { readLiveProjectSessionPointers, readProjectSessionPointer, readSessionState, } from './hooks.js';
-import { NON_ROUTING_BLOCKING_STOP_TIMEOUT_SECONDS, QUESTION_STOP_TIMEOUT_SECONDS, codexCoexistenceNotes, codexHomeNote, codexLayerDir, codexLayerPaths, codexProjectRoot, codexRepresentationProblems, codexTrustProblems, detectedHarnesses, findInstallations, handlerEvent, inspectCodexLayer, } from './install-hooks.js';
+import { readLiveProjectSessionPointers, readProjectSessionPointer, } from './hook-project-sessions.js';
+import { readSessionState } from './hook-session-state.js';
+import { NON_ROUTING_BLOCKING_STOP_TIMEOUT_SECONDS, QUESTION_STOP_TIMEOUT_SECONDS, codexCoexistenceNotes, codexHomeNote, codexRepresentationProblems, codexTrustProblems, detectedHarnesses, findInstallations, findLegacyProjectInstallations, handlerEvent, } from './install-hooks.js';
 import { inferInvocationContext } from './invocation-context.js';
 import { firstBlocker, readinessJson, } from './readiness.js';
 import { packageVersion } from './release.js';
@@ -17,12 +17,14 @@ import { deviceInstallRemedy, readyCompanionDevices } from './commands-devices.j
 import { setupAccessUrl } from './setup-destinations.js';
 import { claudeSessionPid, resolveActiveHarness, } from './commands-harness-context.js';
 import { stopShapeProblems } from './commands-hook-shape.js';
-import { CODEX_ACTIVATION_INSTALLATION_MISSING_PROBLEM, CODEX_FRESH_SESSION_USER_ACTION, CODEX_HOOK_APPROVAL_USER_ACTION, CODEX_STOP_DEFINITION_NOT_SINGULAR_PROBLEM, CODEX_STALE_STOP_DEFINITION_PROBLEM, HOOK_EVENTS, activeQuestionRouteProblems, hookActivationAdvice, requiredHookEvents, } from './commands-hooks.js';
+import { CODEX_FRESH_SESSION_USER_ACTION, CODEX_HOOK_APPROVAL_USER_ACTION, CODEX_STOP_DEFINITION_NOT_SINGULAR_PROBLEM, CODEX_STALE_STOP_DEFINITION_PROBLEM, activeQuestionRouteProblems, hookActivationAdvice, } from './commands-hook-diagnostics.js';
+import { HOOK_EVENTS, requiredHookEvents } from './hook-events.js';
 import { cliBinReadiness, inspectCliInstallations } from './cli-bin.js';
 import { latestPublishedCliVersion, newerPublishedCli, shouldConsultCliRegistry, thisCliVersion, } from './cli-release.js';
 import { SETUP_PROOF_STALE_MS, observedCompanionReceipt, readSetupProof, setupProofProject, setupProofIsStale, setupProofApplies, } from './commands-setup-proof.js';
 import { skillReadiness } from './commands-skill.js';
 import { projectBinding, projectEnabled } from './project-enablement.js';
+import { CLI_UPDATE_AVAILABLE, SERVICE_UPDATE_IN_PROGRESS } from './cli-contract.js';
 // ---------------------------------------------------------------------------
 // doctor
 // ---------------------------------------------------------------------------
@@ -84,7 +86,7 @@ async function compatibilityCheck(client, deps) {
                 status: 'optional-gap',
                 detail: scheduled
                     ? 'Update Notifai soon to keep sending notifications.'
-                    : 'A newer Notifai is available.',
+                    : CLI_UPDATE_AVAILABLE,
                 technical,
                 remedy: {
                     by: 'user-here',
@@ -98,7 +100,7 @@ async function compatibilityCheck(client, deps) {
                 id: 'contract',
                 title: 'Notifai update',
                 status: 'optional-gap',
-                detail: 'The service is being updated; try again later.',
+                detail: SERVICE_UPDATE_IN_PROGRESS,
                 technical,
                 remedy: {
                     by: 'user-here',
@@ -117,7 +119,7 @@ async function compatibilityCheck(client, deps) {
                 id: 'contract',
                 title: 'Notifai update',
                 status: 'optional-gap',
-                detail: 'The service is being updated; try again later.',
+                detail: SERVICE_UPDATE_IN_PROGRESS,
                 technical,
                 remedy: {
                     by: 'user-here',
@@ -139,7 +141,7 @@ async function compatibilityCheck(client, deps) {
             id: 'contract',
             title: 'Notifai update',
             status: 'optional-gap',
-            detail: 'The service is being updated; try again later.',
+            detail: SERVICE_UPDATE_IN_PROGRESS,
             technical: {
                 error: err instanceof ApiCallError
                     ? { code: err.code, status: err.status }
@@ -168,13 +170,8 @@ function projectReadiness(deps, config) {
         return {
             id: 'project',
             title: 'Project identity',
-            status: 'optional-gap',
-            detail: `"${inferred}" is inferred for each send; init can stamp it into shared config`,
-            remedy: {
-                by: 'cli',
-                summary: 'make the inferred Project identity explicit for every checkout',
-                command: 'notifai init',
-            },
+            status: 'ready',
+            detail: `"${inferred}" (inferred from Git or the current directory)`,
         };
     }
     return {
@@ -514,7 +511,7 @@ async function applyRegistryRecommendation(deps, json, states) {
     if (contract === undefined || contract.status === 'gap')
         return;
     contract.status = 'optional-gap';
-    contract.detail = 'A newer Notifai is available.';
+    contract.detail = CLI_UPDATE_AVAILABLE;
     contract.remedy = {
         by: 'user-here',
         summary: 'update Notifai',
@@ -707,7 +704,7 @@ export function remedyLine(state) {
  * a remedy.
  */
 function hookStates(deps) {
-    const installations = findInstallations(deps.cwd, deps.env, deps.hookAdapterHome, deps.hookPlatform);
+    const installations = findInstallations(deps.env, deps.hookAdapterHome, deps.hookPlatform);
     const { active, contested } = resolveActiveHarness(deps.env, deps.cwd, (deps.now ?? Date.now)());
     const config = loadLoggedConfig(deps, { cwd: deps.cwd, env: deps.env });
     const settings = {
@@ -787,7 +784,7 @@ function hookStates(deps) {
         'hooks (adapter)': 'Hook adapter',
         'hooks (trust)': 'Codex hook trust',
         'hooks (stop shape)': 'Turn-end hook shape',
-        'hooks (duplicates)': 'Duplicate hook installs',
+        'hooks (legacy project install)': 'Leftover project hook install',
         'hooks (codex representation)': 'Codex hook representation',
         'hooks (question admission)': 'Question admission',
         'hooks (fired)': 'Hooks have run here',
@@ -808,13 +805,14 @@ function hookStates(deps) {
                     : 'gap',
             detail: check.detail,
             ...(check.technical === undefined ? {} : { technical: check.technical }),
-            ...(check.ok
+            ...(check.ok || (check.reportOnly === true && check.remedy === undefined)
                 ? {}
                 : {
                     remedy: {
                         // The check's own remedy when it has one; the generic reinstall
                         // line was wrong exactly where it mattered (an unfired pointer
-                        // needs a prompt, not `hooks install`).
+                        // needs a prompt, not `hooks install`). A report-only capability
+                        // with no remedy is intentionally absent, not repairable.
                         ...(check.remedy ?? {
                             summary: 'the detail above names what to change',
                             command: 'notifai hooks install',
@@ -828,7 +826,7 @@ function hookStates(deps) {
 }
 function hookChecks(deps) {
     const checks = [];
-    const installations = findInstallations(deps.cwd, deps.env, deps.hookAdapterHome, deps.hookPlatform);
+    const installations = findInstallations(deps.env, deps.hookAdapterHome, deps.hookPlatform);
     // Not having hooks is a setup someone chose, not a fault: `send` works
     // without them. A setup that cannot work is what deserves to go red.
     if (installations.length === 0) {
@@ -842,9 +840,7 @@ function hookChecks(deps) {
     checks.push({
         name: 'hooks',
         ok: true,
-        detail: installations
-            .map((i) => `${i.harness} ${i.global ? 'global' : 'project'} (${i.file})`)
-            .join(', '),
+        detail: installations.map((i) => `${i.harness} (${i.file})`).join(', '),
     });
     const wired = new Set(installations.map((installation) => installation.harness));
     const unwired = detectedHarnesses(deps.cwd, deps.env).filter((harness) => !wired.has(harness));
@@ -973,9 +969,8 @@ function hookChecks(deps) {
         checks.push({
             name: 'hooks (adapter)',
             ok: false,
-            // A machine-global install for a harness that is not active in this
-            // project is useful diagnosis, but it is not this project's failure.
-            reportOnly: active === null && installations.every((installation) => installation.global),
+            // The adapter is one Machine-level file every harness runs through, so
+            // a defect in it is always this machine's to fix and always fixable.
             detail: adapterProblems.join('; '),
             ...(adapterMismatch
                 ? { technical: { effective_cli_artifact: effectiveArtifact, registered_target: sharedAdapter.target } }
@@ -1008,38 +1003,38 @@ function hookChecks(deps) {
                 },
             }),
     });
-    const shapeProblems = installations.flatMap((installation) => stopShapeProblems(installation, deps.hookPlatform).map((problem) => `${problem} — run \`notifai hooks install --harness ${installation.harness}${installation.global ? ' --global' : ''}\``));
+    const shapeProblems = installations.flatMap((installation) => stopShapeProblems(installation, deps.hookPlatform).map((problem) => `${problem} — run \`notifai hooks install --harness ${installation.harness}\``));
     checks.push({
         name: 'hooks (stop shape)',
         ok: shapeProblems.length === 0,
         detail: shapeProblems.length === 0
-            ? `every installed Stop handler declares the shape its harness needs: Claude Code async and Codex blocking with an explicit ${QUESTION_STOP_TIMEOUT_SECONDS}s full-window budget; non-routing blocking hosts ${NON_ROUTING_BLOCKING_STOP_TIMEOUT_SECONDS}s`
+            ? `every installed Stop handler declares the shape its harness and host need: Claude Code async on POSIX and blocking on Windows, Codex blocking, each with an explicit ${QUESTION_STOP_TIMEOUT_SECONDS}s full-window budget; non-routing blocking hosts ${NON_ROUTING_BLOCKING_STOP_TIMEOUT_SECONDS}s`
             : shapeProblems.join('; '),
     });
-    // Project and global definitions for one harness both fire. Stable adapter
-    // identity deliberately makes their command bytes equal, so comparing
-    // command targets would now hide this duplicate rather than diagnose it.
-    // Cursor is the exception to harness independence because it may also load
-    // Claude's user hook file. The shared adapter detects Cursor's hook-only
-    // environment and makes that compatibility copy a no-op; the native Cursor
-    // definition remains the single routing owner.
-    const duplicated = [...new Set(installations.map((i) => i.harness))]
-        .map((harness) => ({
-        harness,
-        installations: installations.filter((i) => i.harness === harness),
-    }))
-        .filter((entry) => entry.installations.some((installation) => installation.global) &&
-        entry.installations.some((installation) => !installation.global));
-    if (duplicated.length > 0) {
+    // A Project-scoped definition an older build wrote still fires beside the
+    // Machine one, so each event runs twice and the Project copy keeps serving a
+    // definition no install refreshes. Notifai no longer creates these and never
+    // accepts one as a working route: it is a gap with an exact removal command.
+    const legacy = findLegacyProjectInstallations(deps.cwd, deps.env, deps.hookAdapterHome, deps.hookPlatform);
+    if (legacy.length > 0) {
+        const harnesses = [...new Set(legacy.map((installation) => installation.harness))];
+        const command = harnesses
+            .map((harness) => `notifai hooks install --harness ${harness}`)
+            .join(' && ');
         checks.push({
-            name: 'hooks (duplicates)',
+            name: 'hooks (legacy project install)',
             ok: false,
-            detail: duplicated
-                .map((entry) => `${entry.harness}: ${entry.installations.length} hook definitions are active, so each event will fire all of them. Keep either project or global routing and uninstall the other: ${entry.installations.map((installation) => installation.file).join(', ')}`)
-                .join('; '),
+            detail: `${legacy
+                .map((installation) => `${installation.harness} (${installation.file})`)
+                .join(', ')} — Notifai installs for this machine only, and a leftover Project copy fires beside it. Run \`${command}\` to remove it`,
+            remedy: {
+                by: 'cli',
+                summary: 'remove the leftover Project-scoped Notifai hooks',
+                command,
+            },
         });
     }
-    const representationProblems = codexRepresentationProblems(deps.cwd, deps.env, deps.hookPlatform);
+    const representationProblems = codexRepresentationProblems(deps.env, deps.hookPlatform);
     if (representationProblems.length > 0) {
         checks.push({
             name: 'hooks (codex representation)',
@@ -1048,7 +1043,7 @@ function hookChecks(deps) {
         });
     }
     else {
-        const coexistence = codexCoexistenceNotes(deps.cwd, deps.env, deps.hookPlatform);
+        const coexistence = codexCoexistenceNotes(deps.env, deps.hookPlatform);
         if (coexistence.length > 0) {
             checks.push({
                 name: 'hooks (codex representation)',
@@ -1062,48 +1057,33 @@ function hookChecks(deps) {
         checks.push({ name: 'hooks (codex home)', ok: true, detail: codexHome });
     }
     if (active !== null && activeInstallations.length > 0) {
-        // Installation inventory belongs to the invocation checkout, while exact
-        // question admission belongs to the checkout whose definition activated
-        // this Agent Session. Keep those diagnostics separate just as ask does.
-        const activationCwd = active.sessionId === undefined
-            ? deps.cwd
-            : readSessionState(active.sessionId, deps.env).activation_cwd ?? deps.cwd;
-        const admissionDeps = activationCwd === deps.cwd ? deps : { ...deps, cwd: activationCwd };
-        const admissionInstallations = activationCwd === deps.cwd
-            ? installations
-            : findInstallations(activationCwd, deps.env, deps.hookAdapterHome, deps.hookPlatform);
-        const admissionProblems = activeQuestionRouteProblems(admissionDeps, active, admissionInstallations);
+        // One Machine installation per harness means the inventory no longer
+        // depends on which checkout activated the session, so admission reads the
+        // same installations doctor already listed.
+        const admissionProblems = activeQuestionRouteProblems(deps, active, installations);
         checks.push({
             name: 'hooks (question admission)',
             ok: admissionProblems.length === 0,
             detail: admissionProblems.length === 0
                 ? `the active ${active.label} route is exact, current, singular, trusted where applicable, and bounded by a live owner`
                 : admissionProblems.join('; '),
-            ...(admissionProblems.some((problem) => problem.startsWith(CODEX_ACTIVATION_INSTALLATION_MISSING_PROBLEM))
+            ...(admissionProblems.includes(CODEX_STOP_DEFINITION_NOT_SINGULAR_PROBLEM)
                 ? {
                     remedy: {
                         by: 'cli',
-                        summary: `install Codex hooks from the Agent Session activation checkout ${activationCwd}`,
+                        summary: 'restore exactly one current Codex Stop definition',
                         command: 'notifai hooks install --harness codex',
                     },
                 }
-                : admissionProblems.includes(CODEX_STOP_DEFINITION_NOT_SINGULAR_PROBLEM)
+                : admissionProblems.includes(CODEX_STALE_STOP_DEFINITION_PROBLEM)
                     ? {
                         remedy: {
-                            by: 'cli',
-                            summary: 'restore exactly one current Codex Stop definition',
-                            command: 'notifai hooks install --harness codex',
+                            summary: 'start one fresh Codex session so it loads the current trusted Stop definition',
+                            command: 'notifai doctor',
+                            user_action: CODEX_FRESH_SESSION_USER_ACTION,
                         },
                     }
-                    : admissionProblems.includes(CODEX_STALE_STOP_DEFINITION_PROBLEM)
-                        ? {
-                            remedy: {
-                                summary: 'start one fresh Codex session so it loads the current trusted Stop definition',
-                                command: 'notifai doctor',
-                                user_action: CODEX_FRESH_SESSION_USER_ACTION,
-                            },
-                        }
-                        : {}),
+                    : {}),
         });
     }
     // Which route this judges, and which remedy it prints, must both belong to
@@ -1122,7 +1102,7 @@ function hookChecks(deps) {
     const firedState = firedPointer === null ? null : readSessionState(firedPointer.sessionId, deps.env);
     const promptFired = firedState?.last_prompt_at !== undefined;
     const stopFired = firedState?.last_stop_at !== undefined;
-    const fired = firedPointer !== null && promptFired && stopFired;
+    const fired = firedPointer !== null && promptFired;
     // Installations for other harnesses are irrelevant to the active one, and an
     // active harness with none of its own has nothing to activate: say that
     // instead of advising a prompt in some other harness. When the environment
@@ -1142,14 +1122,15 @@ function hookChecks(deps) {
     checks.push({
         name: 'hooks (fired)',
         ok: fired,
-        // Nothing here is a command. Whether the pointer is absent or the turn is
-        // half-finished, the only thing that closes this is a turn ending — which
-        // an agent running `init` inside that very turn cannot supply.
+        // UserPromptSubmit proves that this exact session reached the installed
+        // lifecycle path. A historical Stop is only telemetry: requiring one made
+        // a first-turn question impossible even after the current Stop definition,
+        // trust, shape, and continuation owner had all been proven above.
         reportOnly: true,
         detail: fired
             ? active === null
-                ? 'a session in this directory has run UserPromptSubmit and Stop'
-                : `the active ${active.label} session has run UserPromptSubmit and Stop`
+                ? `a session in this directory has run UserPromptSubmit and is ready for this turn's Stop${stopFired ? '; an earlier Stop was also observed' : ''}`
+                : `the active ${active.label} session has run UserPromptSubmit and is ready for this turn's Stop${stopFired ? '; an earlier Stop was also observed' : ''}`
             : firedPointer === null
                 ? `no ${contested.length > 1
                     ? `session pointer for any harness whose markers are present here (${contested
@@ -1158,14 +1139,14 @@ function hookChecks(deps) {
                     : active === null
                         ? 'session pointer'
                         : `${active.label} session pointer`} from the last 24 hours — ${activationAdvice}`
-                : `the routed session has fired ${promptFired ? 'UserPromptSubmit' : 'neither required event'}, but Stop has not been observed — end one harmless turn, send a new prompt, then check again`,
+                : `the routed session has not fired UserPromptSubmit — send one prompt, then check again`,
         ...(fired
             ? {}
             : {
                 remedy: {
                     summary: firedPointer === null
                         ? `send one ${active === null || contested.length > 1 ? '' : `${active.label} `}prompt in a session here, then re-check`
-                        : 'end one harmless turn, send a new prompt, then re-check',
+                        : 'send one prompt in the routed session, then re-check',
                     command: 'notifai doctor',
                 },
             }),
@@ -1177,37 +1158,36 @@ function hookChecks(deps) {
     checks.push({
         name: 'hooks (answer continuation)',
         ok: continuationHarnesses.length > 0 &&
-            continuationHarnesses.every((harness) => HARNESS_CAPABILITIES[harness].stopContinuation !== 'unsupported'),
+            continuationHarnesses.every((harness) => questionRoutingCapability(harness, deps.hookPlatform ?? process.platform)
+                .stopContinuation !== 'unsupported'),
         reportOnly: active === null,
         detail: continuationHarnesses.length === 0
             ? active === null
                 ? 'no installed harness route to assess'
                 : `the active ${active.label} session has no matching continuation adapter`
             : continuationHarnesses
-                .map((harness) => `${harness}: ${HARNESS_CAPABILITIES[harness].deliveryContract}`)
+                .map((harness) => `${harness}: ${questionRoutingCapability(harness, deps.hookPlatform ?? process.platform).deliveryContract}`)
                 .join('; '),
     });
     const wakeRoute = wakeRouteCheck(deps, active, activeInstallations);
     if (wakeRoute !== null)
         checks.push(wakeRoute);
-    const stray = codexStrayWorktreeCheck(deps);
-    if (stray !== null)
-        checks.push(stray);
     return checks;
 }
 /**
- * Whether an answer arriving after this turn ends could actually reach this
- * exact session — the question `notifai ask` really turns on, and the one no
- * other check answers.
+ * Whether an answer arriving after this turn's ordinary continuation returns
+ * could start another turn in this exact session without a new User prompt.
+ * This is a named optional capability, separate from the held Stop
+ * continuation that already makes Question Routing usable.
  *
  * Read-only, and deliberately so: nothing here connects to a socket, takes a
  * lock, or sends a message. A diagnostic that wakes the agent it is diagnosing
  * would be its own bug report.
  *
- * Everything it can report negatively is a degradation rather than a failure —
- * the accepted journal still replays the answer at the session's next turn —
- * so this is never a blocker. What it buys is that the reason has a name
- * before the user notices the silence.
+ * Everything it can report negatively is optional rather than a routing
+ * failure: a held continuation can still return the answer, or the accepted
+ * journal can replay it at the session's next turn. What it buys is that the
+ * direct-wake capability and its limits have an explicit name.
  *
  * It never asks for `crossSessionInbound`. The poster is the session's own
  * hook child and takes the privileged own-child path, verified to be delivered
@@ -1219,9 +1199,19 @@ function wakeRouteCheck(deps, active, activeInstallations) {
     if (active === null || activeInstallations.length === 0)
         return null;
     if (active.harness === 'claude-code') {
+        const platform = deps.hookPlatform ?? process.platform;
+        if (platform === 'win32') {
+            return {
+                name: 'hooks (wake route)',
+                ok: false,
+                reportOnly: true,
+                technical: { held_stop_continuation: true },
+                detail: 'direct inbox wake is unavailable on Windows; the held Stop still returns the answer to this same Agent Session without another User prompt',
+            };
+        }
         const readiness = inspectClaudeInbox({
             pid: deps.claudeSourcePid ?? claudeSessionPid(deps.env),
-            platform: deps.hookPlatform ?? process.platform,
+            platform,
             readDescriptor: deps.claudeWake?.readDescriptor ?? systemClaudeWakeAdapters(deps.env).readDescriptor,
             socketExists: (socketPath) => existsSync(socketPath),
         });
@@ -1243,6 +1233,7 @@ function wakeRouteCheck(deps, active, activeInstallations) {
             name: 'hooks (wake route)',
             ok: readiness.state === 'ready',
             reportOnly: true,
+            technical: { held_stop_continuation: true },
             detail: readiness.state === 'ready'
                 ? `the held Codex turn continues from its own hook, and after it returns ${readiness.lockDirectory} can prove a stopped thread unowned before resuming it`
                 : `the held Codex turn still continues from its own hook, but after it returns nothing can be resumed: ${readiness.reason}. Answers wait for the next turn`,
@@ -1250,40 +1241,4 @@ function wakeRouteCheck(deps, active, activeInstallations) {
     }
     return null;
 }
-/**
- * A Codex hooks file sitting in a worktree, which Codex will never read.
- *
- * `settingsFile` now writes to the main repository, so this only fires for a
- * file an older build left behind — but that file is indistinguishable from a
- * working install if you go looking, and it is exactly what made this bug take
- * a day to find. Omitted entirely when there is nothing to say.
- */
-function codexStrayWorktreeCheck(deps) {
-    const layer = codexLayerDir(deps.cwd);
-    if (layer === null)
-        return null;
-    const root = codexProjectRoot(deps.cwd);
-    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(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)',
-        ok: problems.length === 0,
-        detail: problems.length === 0
-            ? `worktree wired to the main repository at ${root}`
-            : `${problems.join('; ')}. Re-run \`notifai hooks install\` to fix.`,
-    };
-}
 //# sourceMappingURL=commands-doctor.js.map