oh-my-codex 0.20.1 → 0.20.3

package/dist/cli/__tests__/doctor-warning-copy.test.js

@@ -1,14 +1,16 @@
 import { describe, it } from "node:test";
 import assert from "node:assert/strict";
-import { cp, mkdir, mkdtemp, readFile, rm, symlink, writeFile, } from "node:fs/promises";
-import { existsSync } from "node:fs";
+import { cp, link, mkdir, mkdtemp, realpath, readFile, rename, rm, symlink, writeFile, } from "node:fs/promises";
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { tmpdir } from "node:os";
 import { spawnSync } from "node:child_process";
 import { fileURLToPath } from "node:url";
 import { withPackagedExploreHarnessHidden, withPackagedExploreHarnessLock, } from "./packaged-explore-harness-lock.js";
-import { checkExploreHarness, checkExternalCodexProcessGuards, buildPostCompactSmokeSpawnInvocation, checkNativeHookDistSmoke, classifyPostCompactHookStdout, checkLegacyMultiAgentCompatibility, } from "../doctor.js";
-import { buildManagedCodexNativeHookCommand } from "../../config/codex-hooks.js";
+import { buildPostCompactSmokeSpawnInvocation, checkExternalCodexProcessGuards, checkExploreHarness, checkLegacyMultiAgentCompatibility, checkNativeHookDistSmoke, checkNativePostCompactHookRuntime, checkNativeHooks, classifyPostCompactHookStdout, doctor, setDoctorClaimJournalDurabilityForTest, } from "../doctor.js";
+import { createNativeHookClaimJournalDurability, persistNativeHookClaimJournal, } from "../native-hook-claim-journal.js";
+import { syncRegularFile } from "../../utils/file-durability.js";
+import { buildManagedCodexNativeHookCommand, buildManagedCodexNativeHookWindowsShimContent, } from "../../config/codex-hooks.js";
 const MANAGED_HOOK_EVENTS = [
     "SessionStart",
     "PreToolUse",
@@ -54,6 +56,13 @@ function currentNativeHookCommand(codexHomeDir) {
         codexHomeDir,
     });
 }
+function buildWindowsShimCommand(shimPath) {
+    return `& 'C:\\Windows\\System32\\WindowsPowerShell\\v1.0\\powershell.exe' -NoProfile -ExecutionPolicy Bypass -File '${shimPath.replace(/'/g, "''")}'`;
+}
+function buildWindowsShimHooksJson(shimPath, codexHomeDir) {
+    const command = buildWindowsShimCommand(shimPath);
+    return buildHooksJsonWithPostCompactCommand(command, codexHomeDir, command);
+}
 async function installPluginCacheFixture(codexDir) {
     const root = repoRoot();
     const sourcePluginDir = join(root, "plugins", "oh-my-codex");
@@ -77,8 +86,7 @@ async function packagedPluginVersion() {
     }
     return manifest.version;
 }
-function buildHooksJsonWithPostCompactCommand(postCompactCommand, codexHomeDir) {
-    const expectedCommand = currentNativeHookCommand(codexHomeDir);
+function buildHooksJsonWithPostCompactCommand(postCompactCommand, codexHomeDir, expectedCommand = currentNativeHookCommand(codexHomeDir)) {
     return `${JSON.stringify({
         hooks: Object.fromEntries(MANAGED_HOOK_EVENTS.map((eventName) => [
             eventName,
@@ -97,6 +105,40 @@ function buildHooksJsonWithPostCompactCommand(postCompactCommand, codexHomeDir)
         ])),
     }, null, 2)}\n`;
 }
+async function withRecoverableDoctorClaimJournal(run) {
+    const wd = await mkdtemp(join(tmpdir(), "omx-doctor-claim-recovery-"));
+    const codexHomeDir = join(wd, ".codex");
+    const hooksPath = join(codexHomeDir, "hooks.json");
+    const claimPath = join(codexHomeDir, ".hooks.json.omx-claim-test.tmp");
+    const previousCwd = process.cwd();
+    const previousCodexHome = process.env.CODEX_HOME;
+    try {
+        await mkdir(codexHomeDir, { recursive: true });
+        await writeFile(hooksPath, "{\"hooks\":{}}\n");
+        await persistNativeHookClaimJournal(codexHomeDir, {
+            canonicalPath: hooksPath,
+            claimPath,
+            before: Buffer.from("{\"hooks\":{}}\n"),
+            after: null,
+        }, createNativeHookClaimJournalDurability());
+        await rename(hooksPath, claimPath);
+        const journalPath = join(codexHomeDir, ".omx", "native-hook-claim-journal.json");
+        const journal = JSON.parse(await readFile(journalPath, "utf-8"));
+        journal.ownerPid = 2_147_483_647;
+        await writeFile(journalPath, `${JSON.stringify(journal, null, 2)}\n`, "utf-8");
+        process.env.CODEX_HOME = codexHomeDir;
+        process.chdir(wd);
+        return await run(codexHomeDir);
+    }
+    finally {
+        process.chdir(previousCwd);
+        if (previousCodexHome === undefined)
+            delete process.env.CODEX_HOME;
+        else
+            process.env.CODEX_HOME = previousCodexHome;
+        await rm(wd, { recursive: true, force: true });
+    }
+}
 describe("omx doctor onboarding warning copy", () => {
     it("warns about external LaunchAgents that kill Codex app-server MCP children", async () => {
         const wd = await mkdtemp(join(tmpdir(), "omx-doctor-external-guard-"));
@@ -891,7 +933,7 @@ OMX_LORE_COMMIT_GUARD = "truee"
                 return;
             assert.equal(res.status, 0, res.stderr || res.stdout);
             assert.doesNotMatch(res.stdout, /Resolved setup install mode: plugin \(inferred from Codex plugin config\)/);
-            assert.match(res.stdout, /Native hooks: expected setup-owned hooks\.json is missing at .*\.codex[\\/]+hooks\.json even though config\.toml has OMX entries; run "omx setup --force" to restore native hook coverage/);
+            assert.match(res.stdout, /Native hooks: expected setup-owned hooks\.json is missing at .*\.codex[\\/]+hooks\.json even though config\.toml has OMX entries; run "omx setup" to restore native hook coverage/);
             assert.match(res.stdout, /Prompts: prompts directory not found/);
         }
         finally {
@@ -1144,7 +1186,7 @@ OMX_LORE_COMMIT_GUARD = "truee"
             if (shouldSkipForSpawnPermissions(res.error))
                 return;
             assert.equal(res.status, 0, res.stderr || res.stdout);
-            assert.match(res.stdout, new RegExp(`\\[!!\\] Native hooks: plugin-scoped hooks are enabled, but cached plugin hook files or pinned hook launcher in ${cacheDir.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")} do not match the packaged plugin; setup-owned hooks\\.json is intentionally absent at .*\\.codex[\\/]+hooks\\.json; run "omx setup --plugin --force" to refresh the plugin cache`));
+            assert.match(res.stdout, new RegExp(`\\[!!\\] Native hooks: plugin-scoped hooks are enabled, but cached plugin hook files or pinned hook launcher in ${cacheDir.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")} do not match the packaged plugin; setup-owned hooks\\.json is intentionally absent at .*\\.codex[\\/]+hooks\\.json; run "omx setup --plugin" to refresh the plugin cache`));
             assert.doesNotMatch(res.stdout, /plugin cache native hook coverage smoke passed/);
         }
         finally {
@@ -1194,7 +1236,7 @@ OMX_LORE_COMMIT_GUARD = "truee"
             if (shouldSkipForSpawnPermissions(res.error))
                 return;
             assert.equal(res.status, 0, res.stderr || res.stdout);
-            assert.match(res.stdout, new RegExp(`\\[OK\\] Native hooks: plugin-scoped hooks are enabled; existing hooks\\.json at .*\\.codex[\\/]+hooks\\.json is treated as user-owned because plugin-scoped hooks are enabled, and plugin cache native hook coverage smoke passed via ${join(cacheDir, "hooks", "hooks.json").replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}`));
+            assert.match(res.stdout, new RegExp(`\\[OK\\] Native hooks: plugin-scoped hooks are enabled; existing hooks\\.json at .*\\.codex[\\/]+hooks\\.json is retained read-only and validated separately because plugin-scoped hooks are enabled, and plugin cache native hook coverage smoke passed via ${join(cacheDir, "hooks", "hooks.json").replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}`));
             assert.doesNotMatch(res.stdout, /hooks\.json is missing OMX-managed coverage/);
             assert.doesNotMatch(res.stdout, /run "omx setup --force" to restore native hooks/);
         }
@@ -1229,7 +1271,7 @@ OMX_LORE_COMMIT_GUARD = "truee"
             if (shouldSkipForSpawnPermissions(res.error))
                 return;
             assert.equal(res.status, 0, res.stderr || res.stdout);
-            assert.match(res.stdout, /Native hooks: hooks\.json is missing OMX-managed coverage for PreToolUse, PostToolUse, UserPromptSubmit, PreCompact, PostCompact, Stop; run "omx setup --force" to restore native hooks/);
+            assert.match(res.stdout, /Native hooks: hooks\.json is missing OMX-managed coverage for PreToolUse, PostToolUse, UserPromptSubmit, PreCompact, PostCompact, Stop; run "omx setup" to restore native hooks/);
         }
         finally {
             await rm(wd, { recursive: true, force: true });
@@ -1289,7 +1331,7 @@ command = "node"
             if (shouldSkipForSpawnPermissions(res.error))
                 return;
             assert.equal(res.status, 0, res.stderr || res.stdout);
-            assert.match(res.stdout, /Native hooks: expected setup-owned hooks\.json is missing at .*\.codex[\/]+hooks\.json even though config\.toml has OMX entries; run "omx setup --force" to restore native hook coverage/);
+            assert.match(res.stdout, /Native hooks: expected setup-owned hooks\.json is missing at .*\.codex[\/]+hooks\.json even though config\.toml has OMX entries; run "omx setup" to restore native hook coverage/);
         }
         finally {
             await rm(wd, { recursive: true, force: true });
@@ -1309,7 +1351,508 @@ command = "node"
             if (shouldSkipForSpawnPermissions(res.error))
                 return;
             assert.equal(res.status, 0, res.stderr || res.stdout);
-            assert.match(res.stdout, /\[XX\] Native hooks: invalid hooks\.json; Codex may skip OMX hook coverage until "omx setup --force" repairs it/);
+            assert.match(res.stdout, /\[XX\] Native hooks: hooks\.json failed strict load validation \(invalid_document\): hooks\.json must contain a JSON object; inspect the file manually because doctor will not modify it/);
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it("reports matcher-aware discovery warnings without touching hooks.json", async () => {
+        const wd = await mkdtemp(join(tmpdir(), "omx-doctor-hooks-matcher-warning-"));
+        try {
+            const home = join(wd, "home");
+            const codexDir = join(home, ".codex");
+            await mkdir(codexDir, { recursive: true });
+            await writeFile(join(codexDir, "hooks.json"), JSON.stringify({
+                hooks: {
+                    SessionStart: [{
+                            matcher: "[",
+                            hooks: [{ type: "command", command: "echo user-owned" }],
+                        }],
+                },
+            }, null, 2) + "\n");
+            const res = runOmx(wd, ["doctor"], { HOME: home, CODEX_HOME: codexDir });
+            if (shouldSkipForSpawnPermissions(res.error))
+                return;
+            assert.equal(res.status, 0, res.stderr || res.stdout);
+            assert.match(res.stdout, /Native hooks: hooks\.json discovery warnings: SessionStart\[0\]: Codex skips groups whose matcher is not a valid regular expression; Codex may ignore the listed entries, and doctor will not modify them/);
+            assert.doesNotMatch(res.stdout, /Native hooks:.*--force/);
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it("treats UserPromptSubmit and Stop matcher groups as valid foreign survivors", async () => {
+        const wd = await mkdtemp(join(tmpdir(), "omx-doctor-hooks-foreign-survivors-"));
+        try {
+            const home = join(wd, "home");
+            const codexDir = join(home, ".codex");
+            await mkdir(codexDir, { recursive: true });
+            await writeFile(join(codexDir, "hooks.json"), JSON.stringify({
+                hooks: {
+                    UserPromptSubmit: [{ matcher: "[", hooks: [{ type: "command", command: "echo prompt" }] }],
+                    Stop: [{ matcher: "[", hooks: [{ type: "command", command: "echo stop" }] }],
+                },
+            }, null, 2) + "\n");
+            const res = runOmx(wd, ["doctor"], { HOME: home, CODEX_HOME: codexDir });
+            if (shouldSkipForSpawnPermissions(res.error))
+                return;
+            assert.equal(res.status, 0, res.stderr || res.stdout);
+            assert.match(res.stdout, /\[OK\] Native hooks: hooks\.json contains valid foreign hook entries and no OMX-managed wrappers; doctor will preserve the user-owned configuration/);
+            assert.doesNotMatch(res.stdout, /hooks\.json discovery warnings/);
+            assert.doesNotMatch(res.stdout, /Native hooks:.*--force/);
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it("reports unsafe managed removal without recommending destructive repair", async () => {
+        const wd = await mkdtemp(join(tmpdir(), "omx-doctor-hooks-unsafe-removal-"));
+        try {
+            const home = join(wd, "home");
+            const codexDir = join(home, ".codex");
+            await mkdir(codexDir, { recursive: true });
+            await writeFile(join(codexDir, "hooks.json"), JSON.stringify({
+                hooks: {
+                    SessionStart: [{
+                            matcher: "startup|resume|clear",
+                            hooks: [
+                                { type: "command", command: 'node "/repo/dist/scripts/codex-native-hook.js"' },
+                                { type: "command", command: "echo user-owned" },
+                            ],
+                        }],
+                },
+            }, null, 2) + "\n");
+            const res = runOmx(wd, ["doctor"], { HOME: home, CODEX_HOME: codexDir });
+            if (shouldSkipForSpawnPermissions(res.error))
+                return;
+            assert.equal(res.status, 0, res.stderr || res.stdout);
+            assert.match(res.stdout, /\[!!\] Native hooks: hooks\.json has OMX entries that cannot be safely removed \(unsafe_managed_removal\): Removing OMX hooks would shift a foreign coordinate or discard opaque metadata; manual cleanup is required because doctor will not overwrite or remove it/);
+            assert.doesNotMatch(res.stdout, /Native hooks:.*--force/);
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it("fails closed when a Windows native hook references a missing shim", async () => {
+        const wd = await mkdtemp(join(tmpdir(), "omx-doctor-windows-shim-missing-"));
+        try {
+            const codexDir = join(wd, ".codex");
+            const hooksPath = join(codexDir, "hooks.json");
+            const shimPath = join(codexDir, "hooks", "omx-native-hook-windows-shim.ps1");
+            await mkdir(codexDir, { recursive: true });
+            const original = buildWindowsShimHooksJson(shimPath, codexDir);
+            await writeFile(hooksPath, original);
+            const check = await checkNativeHooks(hooksPath, join(codexDir, "config.toml"), {
+                codexHomeDir: codexDir,
+                platform: "win32",
+            });
+            assert.equal(check.status, "fail");
+            assert.match(check.message, /referenced Windows native hook shim is missing at/);
+            assert.match(check.message, /manually reinstall the matching oh-my-codex version/);
+            assert.doesNotMatch(check.message, /omx setup|--force/);
+            assert.equal(existsSync(shimPath), false);
+            assert.equal(await readFile(hooksPath, "utf-8"), original);
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it("fails closed when a referenced Windows native hook shim is tampered", async () => {
+        const wd = await mkdtemp(join(tmpdir(), "omx-doctor-windows-shim-tampered-"));
+        try {
+            const codexDir = join(wd, ".codex");
+            const hooksPath = join(codexDir, "hooks.json");
+            const shimPath = join(codexDir, "hooks", "omx-native-hook-windows-shim.ps1");
+            await mkdir(dirname(shimPath), { recursive: true });
+            const original = buildWindowsShimHooksJson(shimPath, codexDir);
+            const tamperedShim = `${buildManagedCodexNativeHookWindowsShimContent(repoRoot())}# user change\n`;
+            await writeFile(hooksPath, original);
+            await writeFile(shimPath, tamperedShim, "utf-8");
+            const check = await checkNativeHooks(hooksPath, join(codexDir, "config.toml"), {
+                codexHomeDir: codexDir,
+                platform: "win32",
+            });
+            assert.equal(check.status, "fail");
+            assert.match(check.message, /not an exact current or complete historical generated shim/);
+            assert.match(check.message, /modified, truncated, have extra content, or use ambiguous encoding/);
+            assert.doesNotMatch(check.message, /omx setup|--force/);
+            assert.equal(await readFile(hooksPath, "utf-8"), original);
+            assert.equal(await readFile(shimPath, "utf-8"), tamperedShim);
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it("accepts a complete historical Windows native hook shim without modifying it", async () => {
+        const wd = await mkdtemp(join(tmpdir(), "omx-doctor-windows-shim-historical-"));
+        try {
+            const codexDir = join(wd, ".codex");
+            const hooksPath = join(codexDir, "hooks.json");
+            const shimPath = join(codexDir, "hooks", "omx-native-hook-windows-shim.ps1");
+            await mkdir(dirname(shimPath), { recursive: true });
+            const original = buildWindowsShimHooksJson(shimPath, codexDir);
+            const historicalShim = buildManagedCodexNativeHookWindowsShimContent("", {
+                nodePath: "C:\\Historical Node\\node.exe",
+                hookScriptPath: "C:\\Historical Install\\oh-my-codex\\dist\\scripts\\codex-native-hook.js",
+            });
+            await writeFile(hooksPath, original);
+            await writeFile(shimPath, historicalShim, "utf-8");
+            const check = await checkNativeHooks(hooksPath, join(codexDir, "config.toml"), {
+                codexHomeDir: codexDir,
+                platform: "win32",
+            });
+            assert.equal(check.status, "pass");
+            assert.match(check.message, /includes OMX-managed coverage for all native hook events/);
+            assert.equal(await readFile(hooksPath, "utf-8"), original);
+            assert.equal(await readFile(shimPath, "utf-8"), historicalShim);
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it("reports Windows shim integrity before an unsafe managed/foreign group coordinate warning", async () => {
+        for (const fixture of [
+            {
+                name: "missing",
+                shimContent: null,
+                integrity: /referenced Windows native hook shim is missing at/,
+            },
+            {
+                name: "tampered",
+                shimContent: `${buildManagedCodexNativeHookWindowsShimContent(repoRoot())}# mixed-group sentinel\n`,
+                integrity: /not an exact current or complete historical generated shim/,
+            },
+        ]) {
+            const wd = await mkdtemp(join(tmpdir(), `omx-doctor-windows-shim-${fixture.name}-unsafe-`));
+            try {
+                const codexDir = join(wd, ".codex");
+                const hooksPath = join(codexDir, "hooks.json");
+                const shimPath = join(codexDir, "hooks", "omx-native-hook-windows-shim.ps1");
+                const parsed = JSON.parse(buildWindowsShimHooksJson(shimPath, codexDir));
+                parsed.hooks.PreToolUse[0].hooks.push({
+                    type: "command",
+                    command: "echo foreign-handler",
+                });
+                await mkdir(codexDir, { recursive: true });
+                await writeFile(hooksPath, `${JSON.stringify(parsed, null, 2)}\n`);
+                if (fixture.shimContent !== null) {
+                    await mkdir(dirname(shimPath), { recursive: true });
+                    await writeFile(shimPath, fixture.shimContent, "utf-8");
+                }
+                const check = await checkNativeHooks(hooksPath, join(codexDir, "config.toml"), {
+                    codexHomeDir: codexDir,
+                    platform: "win32",
+                });
+                assert.equal(check.status, "fail", fixture.name);
+                assert.match(check.message, fixture.integrity, fixture.name);
+                assert.match(check.message, /unsafe_managed_removal/, fixture.name);
+                assert.ok(check.message.search(fixture.integrity) < check.message.indexOf("unsafe_managed_removal"), `${fixture.name} shim integrity must take precedence over the coordinate warning`);
+            }
+            finally {
+                await rm(wd, { recursive: true, force: true });
+            }
+        }
+    });
+    it("never executes missing, tampered, historical, hard-linked, or symlinked Windows shim sentinels during verbose validation", async () => {
+        for (const fixture of [
+            {
+                name: "missing",
+                shimContent: null,
+                hardLink: false,
+                symlinkTarget: null,
+                expected: /referenced Windows native hook shim is missing at/,
+            },
+            {
+                name: "tampered",
+                shimContent: `${buildManagedCodexNativeHookWindowsShimContent(repoRoot())}# verbose-execution sentinel\n`,
+                hardLink: false,
+                symlinkTarget: null,
+                expected: /not an exact current or complete historical generated shim/,
+            },
+            {
+                name: "historical",
+                shimContent: buildManagedCodexNativeHookWindowsShimContent("", {
+                    nodePath: "C:\\Historical Node\\node.exe",
+                    hookScriptPath: "C:\\Historical Install\\oh-my-codex\\dist\\scripts\\codex-native-hook.js",
+                }),
+                hardLink: false,
+                symlinkTarget: null,
+                expected: /complete historical generated shim.*run "omx setup" to migrate/,
+            },
+            {
+                name: "hard-linked",
+                shimContent: buildManagedCodexNativeHookWindowsShimContent(repoRoot()),
+                hardLink: true,
+                symlinkTarget: null,
+                expected: /is hard-linked; doctor will not execute or modify it/,
+            },
+            {
+                name: "symlinked",
+                shimContent: null,
+                hardLink: false,
+                symlinkTarget: buildManagedCodexNativeHookWindowsShimContent(repoRoot()),
+                expected: /is not a regular file; doctor will not follow or modify it/,
+            },
+        ]) {
+            const wd = await mkdtemp(join(tmpdir(), `omx-doctor-verbose-windows-shim-${fixture.name}-`));
+            try {
+                const codexDir = join(wd, ".codex");
+                const hooksPath = join(codexDir, "hooks.json");
+                const shimPath = join(codexDir, "hooks", "omx-native-hook-windows-shim.ps1");
+                const command = buildWindowsShimCommand(shimPath);
+                await mkdir(codexDir, { recursive: true });
+                await writeFile(hooksPath, buildWindowsShimHooksJson(shimPath, codexDir));
+                if (fixture.symlinkTarget !== null) {
+                    const symlinkTargetPath = join(wd, "symlink-target.ps1");
+                    await mkdir(dirname(shimPath), { recursive: true });
+                    await writeFile(symlinkTargetPath, fixture.symlinkTarget, "utf-8");
+                    await symlink(symlinkTargetPath, shimPath);
+                }
+                else if (fixture.shimContent !== null) {
+                    await mkdir(dirname(shimPath), { recursive: true });
+                    await writeFile(shimPath, fixture.shimContent, "utf-8");
+                    if (fixture.hardLink) {
+                        await link(shimPath, join(wd, "canonical-shim-hardlink.ps1"));
+                    }
+                }
+                let spawned = false;
+                const check = await checkNativePostCompactHookRuntime(hooksPath, wd, codexDir, {
+                    platform: "win32",
+                    expectedCommand: command,
+                    runner: (() => {
+                        spawned = true;
+                        throw new Error("unverified Windows shim execution");
+                    }),
+                });
+                assert.equal(spawned, false, `${fixture.name} shim executed`);
+                assert.ok(check, `${fixture.name} shim must produce a safety diagnostic`);
+                assert.notEqual(check.status, "pass", fixture.name);
+                assert.match(check.message, fixture.expected, fixture.name);
+            }
+            finally {
+                await rm(wd, { recursive: true, force: true });
+            }
+        }
+    });
+    it("runs exact current Windows shim bytes in memory after canonical replacement, hard-linking, and ancestor retargeting", async () => {
+        const wd = await mkdtemp(join(tmpdir(), "omx-doctor-verbose-windows-shim-in-memory-"));
+        try {
+            const codexDir = join(wd, ".codex");
+            const hooksPath = join(codexDir, "hooks.json");
+            const hooksDir = join(codexDir, "hooks");
+            const shimPath = join(hooksDir, "omx-native-hook-windows-shim.ps1");
+            const command = buildWindowsShimCommand(shimPath);
+            const currentShim = buildManagedCodexNativeHookWindowsShimContent(repoRoot());
+            const sentinel = "# foreign canonical shim sentinel\n";
+            const foreignHooksDir = join(codexDir, "foreign-hooks");
+            const foreignShimPath = join(foreignHooksDir, "omx-native-hook-windows-shim.ps1");
+            const foreignHardLinkPath = join(foreignHooksDir, "foreign-shim-hard-link.ps1");
+            await mkdir(hooksDir, { recursive: true });
+            await writeFile(hooksPath, buildWindowsShimHooksJson(shimPath, codexDir));
+            await writeFile(shimPath, currentShim, "utf-8");
+            const check = await checkNativePostCompactHookRuntime(hooksPath, wd, codexDir, {
+                platform: "win32",
+                expectedCommand: command,
+                beforeWindowsShimSmoke: async () => {
+                    const parkedHooksDir = join(codexDir, "validated-hooks");
+                    await rename(hooksDir, parkedHooksDir);
+                    await mkdir(foreignHooksDir, { recursive: true });
+                    await writeFile(foreignShimPath, sentinel);
+                    await link(foreignShimPath, foreignHardLinkPath);
+                    await symlink(foreignHooksDir, hooksDir, "dir");
+                },
+                runner: ((_command, args) => {
+                    const encodedCommand = args[args.indexOf("-EncodedCommand") + 1];
+                    if (typeof encodedCommand !== "string") {
+                        throw new Error("PowerShell smoke must receive an encoded in-memory command");
+                    }
+                    assert.doesNotMatch(args.join("\u0000"), /(?:^|\u0000)-File(?:\u0000|$)/);
+                    const smokeCommand = Buffer.from(encodedCommand, "base64").toString("utf16le");
+                    assert.doesNotMatch(smokeCommand, /(?:^|\s)-File(?:\s|$)/);
+                    assert.equal(smokeCommand.includes(shimPath), false);
+                    assert.match(smokeCommand, /\[ScriptBlock\]::Create\(\$omxShimSource\)/);
+                    const encodedShimBytes = /FromBase64String\('([A-Za-z0-9+/=]+)'\)/.exec(smokeCommand)?.[1];
+                    if (encodedShimBytes === undefined) {
+                        throw new Error("encoded PowerShell smoke command omitted validated shim bytes");
+                    }
+                    assert.deepEqual(Buffer.from(encodedShimBytes, "base64"), Buffer.from(currentShim, "utf-8"));
+                    assert.equal(readFileSync(shimPath, "utf-8"), sentinel);
+                    assert.equal(readFileSync(foreignHardLinkPath, "utf-8"), sentinel);
+                    return { status: 0, stdout: "", stderr: "" };
+                }),
+            });
+            assert.equal(check?.status, "pass");
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it("preserves a swapped Windows PostCompact smoke root instead of recursively deleting it", async () => {
+        const wd = await mkdtemp(join(tmpdir(), "omx-doctor-verbose-windows-smoke-root-"));
+        let foreignSmokeCwd = null;
+        let parkedSmokeCwd = null;
+        try {
+            const codexDir = join(wd, ".codex");
+            const hooksPath = join(codexDir, "hooks.json");
+            const hooksDir = join(codexDir, "hooks");
+            const shimPath = join(hooksDir, "omx-native-hook-windows-shim.ps1");
+            const command = buildWindowsShimCommand(shimPath);
+            await mkdir(hooksDir, { recursive: true });
+            await writeFile(hooksPath, buildWindowsShimHooksJson(shimPath, codexDir));
+            await writeFile(shimPath, buildManagedCodexNativeHookWindowsShimContent(repoRoot()), "utf-8");
+            const check = await checkNativePostCompactHookRuntime(hooksPath, wd, codexDir, {
+                platform: "win32",
+                expectedCommand: command,
+                beforeWindowsShimSmoke: ({ smokeCwd }) => {
+                    foreignSmokeCwd = smokeCwd;
+                },
+                runner: (() => {
+                    const currentSmokeCwd = foreignSmokeCwd;
+                    if (currentSmokeCwd === null) {
+                        throw new Error("Windows smoke root was not captured before execution");
+                    }
+                    parkedSmokeCwd = `${currentSmokeCwd}-parked`;
+                    renameSync(currentSmokeCwd, parkedSmokeCwd);
+                    mkdirSync(currentSmokeCwd, { mode: 0o700 });
+                    writeFileSync(join(currentSmokeCwd, "foreign-sentinel.txt"), "foreign smoke root\n");
+                    return { status: 0, stdout: "", stderr: "" };
+                }),
+            });
+            assert.equal(check?.status, "warn");
+            assert.match(check?.message ?? "", /temporary PostCompact smoke directory changed during validation/);
+            if (foreignSmokeCwd === null)
+                assert.fail("Windows smoke root was not captured");
+            assert.equal(readFileSync(join(foreignSmokeCwd, "foreign-sentinel.txt"), "utf-8"), "foreign smoke root\n");
+        }
+        finally {
+            if (foreignSmokeCwd !== null)
+                await rm(foreignSmokeCwd, { recursive: true, force: true });
+            if (parkedSmokeCwd !== null)
+                await rm(parkedSmokeCwd, { recursive: true, force: true });
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it("preserves a failed PostCompact smoke result when cleanup retains the smoke directory", async () => {
+        const wd = await mkdtemp(join(tmpdir(), "omx-doctor-postcompact-smoke-cleanup-failure-"));
+        let smokeCwd = null;
+        try {
+            const codexDir = join(wd, ".codex");
+            const hooksPath = join(codexDir, "hooks.json");
+            const hooksDir = join(codexDir, "hooks");
+            const shimPath = join(hooksDir, "omx-native-hook-windows-shim.ps1");
+            const command = buildWindowsShimCommand(shimPath);
+            await mkdir(hooksDir, { recursive: true });
+            await writeFile(hooksPath, buildWindowsShimHooksJson(shimPath, codexDir));
+            await writeFile(shimPath, buildManagedCodexNativeHookWindowsShimContent(repoRoot()), "utf-8");
+            const check = await checkNativePostCompactHookRuntime(hooksPath, wd, codexDir, {
+                platform: "win32",
+                expectedCommand: command,
+                beforeWindowsShimSmoke: ({ smokeCwd: currentSmokeCwd }) => {
+                    smokeCwd = currentSmokeCwd;
+                },
+                runner: (() => {
+                    if (smokeCwd === null) {
+                        throw new Error("Windows smoke root was not captured before execution");
+                    }
+                    writeFileSync(join(smokeCwd, "retained-sentinel.txt"), "retained smoke root\n");
+                    return { status: 1, stdout: "", stderr: "hook failure" };
+                }),
+            });
+            assert.equal(check?.status, "fail");
+            assert.match(check?.message ?? "", /PostCompact hook smoke validation exited 1: hook failure/);
+            assert.match(check?.message ?? "", /temporary PostCompact smoke directory could not be removed without recursive deletion/);
+            if (smokeCwd === null)
+                assert.fail("Windows smoke root was not captured");
+            assert.equal(readFileSync(join(smokeCwd, "retained-sentinel.txt"), "utf-8"), "retained smoke root\n");
+        }
+        finally {
+            if (smokeCwd !== null)
+                await rm(smokeCwd, { recursive: true, force: true });
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it("preserves a thrown PostCompact smoke error when cleanup also fails", async () => {
+        const wd = await mkdtemp(join(tmpdir(), "omx-doctor-postcompact-smoke-thrown-cleanup-"));
+        let smokeCwd = null;
+        try {
+            const codexDir = join(wd, ".codex");
+            const hooksPath = join(codexDir, "hooks.json");
+            const hooksDir = join(codexDir, "hooks");
+            const shimPath = join(hooksDir, "omx-native-hook-windows-shim.ps1");
+            const command = buildWindowsShimCommand(shimPath);
+            await mkdir(hooksDir, { recursive: true });
+            await writeFile(hooksPath, buildWindowsShimHooksJson(shimPath, codexDir));
+            await writeFile(shimPath, buildManagedCodexNativeHookWindowsShimContent(repoRoot()), "utf-8");
+            await assert.rejects(checkNativePostCompactHookRuntime(hooksPath, wd, codexDir, {
+                platform: "win32",
+                expectedCommand: command,
+                beforeWindowsShimSmoke: ({ smokeCwd: currentSmokeCwd }) => {
+                    smokeCwd = currentSmokeCwd;
+                },
+                runner: (() => {
+                    if (smokeCwd === null)
+                        throw new Error("Windows smoke root was not captured before execution");
+                    writeFileSync(join(smokeCwd, "retained-sentinel.txt"), "retained smoke root\n");
+                    throw new Error("primary spawn failure");
+                }),
+            }), /primary spawn failure; temporary PostCompact smoke directory could not be removed without recursive deletion/);
+        }
+        finally {
+            if (smokeCwd !== null)
+                await rm(smokeCwd, { recursive: true, force: true });
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it("reports exact nested legacy hook trust state as migration-required without modifying hooks.json", async () => {
+        const wd = await mkdtemp(join(tmpdir(), "omx-doctor-hooks-legacy-trust-"));
+        try {
+            const home = join(wd, "home");
+            const codexDir = join(home, ".codex");
+            await mkdir(codexDir, { recursive: true });
+            const parsed = JSON.parse(buildHooksJsonWithPostCompactCommand(currentNativeHookCommand(codexDir), codexDir));
+            parsed.hooks.state = {
+                "custom:/hooks.json:stop:0:0": {
+                    trusted_hash: "sha256:legacy",
+                    enabled: false,
+                },
+            };
+            const hooksPath = join(codexDir, "hooks.json");
+            const original = `${JSON.stringify(parsed, null, 2)}\n`;
+            await writeFile(hooksPath, original);
+            const res = runOmx(wd, ["doctor"], { HOME: home, CODEX_HOME: codexDir });
+            if (shouldSkipForSpawnPermissions(res.error))
+                return;
+            assert.equal(res.status, 0, res.stderr || res.stdout);
+            assert.match(res.stdout, /\[!!\] Native hooks: hooks\.json contains 1 exact historical OMX hook trust-state entry that requires migration; run "omx setup" to migrate it after reviewing the configuration/);
+            assert.doesNotMatch(res.stdout, /Native hooks: hooks\.json includes OMX-managed coverage/);
+            assert.doesNotMatch(res.stdout, /Native hooks:.*--force/);
+            assert.equal(await readFile(hooksPath, "utf-8"), original);
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it("preserves nonmatching nested hooks.state without reporting a migration", async () => {
+        const wd = await mkdtemp(join(tmpdir(), "omx-doctor-hooks-nonlegacy-state-"));
+        try {
+            const home = join(wd, "home");
+            const codexDir = join(home, ".codex");
+            await mkdir(codexDir, { recursive: true });
+            const parsed = JSON.parse(buildHooksJsonWithPostCompactCommand(currentNativeHookCommand(codexDir), codexDir));
+            parsed.hooks.state = {
+                retained: { custom: true, trusted_hash: "sha256:not-omx" },
+            };
+            const hooksPath = join(codexDir, "hooks.json");
+            const original = `${JSON.stringify(parsed, null, 2)}\n`;
+            await writeFile(hooksPath, original);
+            const res = runOmx(wd, ["doctor"], { HOME: home, CODEX_HOME: codexDir });
+            if (shouldSkipForSpawnPermissions(res.error))
+                return;
+            assert.equal(res.status, 0, res.stderr || res.stdout);
+            assert.match(res.stdout, /\[OK\] Native hooks: hooks\.json includes OMX-managed coverage for all native hook events/);
+            assert.doesNotMatch(res.stdout, /Native hooks:.*legacy OMX hook trust-state/);
+            assert.equal(await readFile(hooksPath, "utf-8"), original);
         }
         finally {
             await rm(wd, { recursive: true, force: true });
@@ -1407,8 +1950,9 @@ command = "node"
             assert.equal(check.name, "Native hook dist smoke");
             assert.equal(check.status, "fail");
             assert.match(check.message, /minimal UserPromptSubmit smoke/);
-            assert.match(check.message, /npm install -g oh-my-codex@0\.18\.0 --force --min-release-age=0 --before=/);
-            assert.match(check.message, /omx setup --force/);
+            assert.match(check.message, /reinstall the matching oh-my-codex version/);
+            assert.doesNotMatch(check.message, /--force/);
+            assert.match(check.message, /run "omx setup"/);
         }
         finally {
             await rm(wd, { recursive: true, force: true });
@@ -1489,7 +2033,7 @@ command = "node"
             assert.equal(res.status, 0, res.stderr || res.stdout);
             assert.match(res.stdout, /Resolved setup scope: project \(from \.omx\/setup-scope\.json\)/);
             assert.equal(res.stdout.match(/\[!!\] GPT-5\.6 multi-agent compatibility:/g)?.length, 1);
-            assert.match(res.stdout, new RegExp(`project scope config at ${configPath}`));
+            assert.match(res.stdout, new RegExp(`project scope config at ${join(await realpath(wd), ".codex", "config.toml")}`));
             assert.match(res.stdout, /features\.multi_agent \(custom; custom-value\)/);
             assert.match(res.stdout, /agents\.max_threads \(custom; custom-value\)/);
             assert.match(res.stdout, /agents\.max_depth \(custom; custom-value\)/);
@@ -1526,5 +2070,198 @@ command = "node"
             await rm(wd, { recursive: true, force: true });
         }
     });
+    it("validates an existing global hooks.json before reporting plugin-cache status", async () => {
+        const wd = await mkdtemp(join(tmpdir(), "omx-doctor-plugin-global-invalid-"));
+        try {
+            const codexDir = join(wd, ".codex");
+            const configPath = join(codexDir, "config.toml");
+            const hooksPath = join(codexDir, "hooks.json");
+            await mkdir(codexDir, { recursive: true });
+            await writeFile(configPath, "plugin_hooks = true\n");
+            await writeFile(hooksPath, '{"state":{}}\n');
+            const check = await checkNativeHooks(hooksPath, configPath, {
+                codexHomeDir: codexDir,
+                installMode: "plugin",
+            });
+            assert.equal(check.status, "fail");
+            assert.match(check.message, /plugin-scoped hooks are enabled/);
+            assert.match(check.message, /existing global hooks\.json: hooks\.json failed strict load validation/);
+            assert.match(check.message, /unknown root field state/);
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it("fails plugin mode when an existing global Windows shim is tampered", async () => {
+        const wd = await mkdtemp(join(tmpdir(), "omx-doctor-plugin-global-shim-"));
+        try {
+            const codexDir = join(wd, ".codex");
+            const configPath = join(codexDir, "config.toml");
+            const hooksPath = join(codexDir, "hooks.json");
+            const shimPath = join(codexDir, "hooks", "omx-native-hook-windows-shim.ps1");
+            await mkdir(dirname(shimPath), { recursive: true });
+            await writeFile(configPath, "plugin_hooks = true\n");
+            await writeFile(hooksPath, `${JSON.stringify({
+                hooks: {
+                    PostCompact: [{ hooks: [{ type: "command", command: buildWindowsShimCommand(shimPath) }] }],
+                },
+            })}\n`);
+            await writeFile(shimPath, "# modified\n");
+            const check = await checkNativeHooks(hooksPath, configPath, {
+                codexHomeDir: codexDir,
+                installMode: "plugin",
+                platform: "win32",
+            });
+            assert.equal(check.status, "fail");
+            assert.match(check.message, /not an exact current or complete historical generated shim/);
+            assert.match(check.message, /plugin-scoped hooks are enabled/);
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it("fails ambiguous managed handler ownership instead of downgrading it to a warning", async () => {
+        const wd = await mkdtemp(join(tmpdir(), "omx-doctor-ambiguous-managed-handler-"));
+        try {
+            const codexDir = join(wd, ".codex");
+            const hooksPath = join(codexDir, "hooks.json");
+            await mkdir(codexDir, { recursive: true });
+            await writeFile(hooksPath, `${JSON.stringify({
+                hooks: {
+                    SessionStart: [{
+                            matcher: "startup|resume|clear",
+                            hooks: [{ type: "command", command: "node /repo/dist/scripts/codex-native-hook.js --unexpected" }],
+                        }],
+                },
+            })}\n`);
+            const check = await checkNativeHooks(hooksPath, join(codexDir, "config.toml"), {
+                codexHomeDir: codexDir,
+            });
+            assert.equal(check.status, "fail");
+            assert.match(check.message, /ambiguous_managed_handler/);
+            assert.match(check.message, /ambiguous or untrusted OMX ownership/);
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it("fails closed instead of recognizing a shell-expanding foreign command as an OMX hook", async () => {
+        const wd = await mkdtemp(join(tmpdir(), "omx-doctor-shell-expanding-handler-"));
+        try {
+            const codexDir = join(wd, ".codex");
+            const hooksPath = join(codexDir, "hooks.json");
+            await mkdir(codexDir, { recursive: true });
+            await writeFile(hooksPath, `${JSON.stringify({
+                hooks: {
+                    SessionStart: [{
+                            matcher: "startup|resume|clear",
+                            hooks: [{ type: "command", command: 'node "$HOME/repo/dist/scripts/codex-native-hook.js"' }],
+                        }],
+                },
+            })}\n`);
+            const check = await checkNativeHooks(hooksPath, join(codexDir, "config.toml"), {
+                codexHomeDir: codexDir,
+            });
+            assert.equal(check.status, "fail");
+            assert.match(check.message, /ambiguous_managed_handler|does not match the managed command grammar/i);
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it("ignores prompt, agent, and future-event metadata while scanning Windows shim references", async () => {
+        const wd = await mkdtemp(join(tmpdir(), "omx-doctor-inert-shim-metadata-"));
+        try {
+            const codexDir = join(wd, ".codex");
+            const hooksPath = join(codexDir, "hooks.json");
+            const missingShimPath = join(codexDir, "hooks", "omx-native-hook-windows-shim.ps1");
+            await mkdir(codexDir, { recursive: true });
+            await writeFile(hooksPath, `${JSON.stringify({
+                hooks: {
+                    PostCompact: [{ hooks: [
+                                { type: "prompt", command: buildWindowsShimCommand(missingShimPath) },
+                                { type: "agent", commandWindows: buildWindowsShimCommand(missingShimPath) },
+                            ] }],
+                    FutureSerdeEvent: [{ hooks: [{ type: "command", command: buildWindowsShimCommand(missingShimPath) }] }],
+                },
+            })}\n`);
+            const check = await checkNativeHooks(hooksPath, join(codexDir, "config.toml"), {
+                codexHomeDir: codexDir,
+                platform: "win32",
+            });
+            assert.equal(check.status, "warn");
+            assert.match(check.message, /hooks\.json discovery warnings/);
+            assert.doesNotMatch(check.message, /referenced Windows native hook shim/);
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it("recovers a claim journal after Windows regular-file EPERM with one degraded-durability warning", async () => {
+        const originalStderrWrite = process.stderr.write;
+        const stderr = [];
+        try {
+            await withRecoverableDoctorClaimJournal(async (codexHomeDir) => {
+                const restoreDurability = setDoctorClaimJournalDurabilityForTest({
+                    platform: "win32",
+                    syncRegularFile: async () => syncRegularFile({
+                        sync: async () => {
+                            throw Object.assign(new Error("injected Windows EPERM"), { code: "EPERM" });
+                        },
+                    }, "win32"),
+                    syncDirectory: async () => undefined,
+                });
+                process.stderr.write = ((chunk) => {
+                    stderr.push(String(chunk));
+                    return true;
+                });
+                try {
+                    await doctor();
+                    assert.equal(await readFile(join(codexHomeDir, "hooks.json"), "utf-8"), "{\"hooks\":{}}\n");
+                    await assert.rejects(readFile(join(codexHomeDir, ".omx", "native-hook-claim-journal.json")), /ENOENT/);
+                }
+                finally {
+                    restoreDurability();
+                }
+            });
+            assert.equal(stderr.length, 1);
+            assert.match(stderr[0], /Windows EPERM/);
+            assert.match(stderr[0], /native-hook claim-journal recovery/);
+            assert.match(stderr[0], /degraded durability/);
+        }
+        finally {
+            process.stderr.write = originalStderrWrite;
+        }
+    });
+    it("keeps non-EPERM regular-file and directory claim-journal sync failures fatal", async () => {
+        const regularError = Object.assign(new Error("injected regular-file EIO"), { code: "EIO" });
+        await withRecoverableDoctorClaimJournal(async () => {
+            const restoreDurability = setDoctorClaimJournalDurabilityForTest({
+                platform: "win32",
+                syncRegularFile: async () => { throw regularError; },
+                syncDirectory: async () => undefined,
+            });
+            try {
+                await assert.rejects(doctor(), (error) => error === regularError);
+            }
+            finally {
+                restoreDurability();
+            }
+        });
+        const directoryError = Object.assign(new Error("injected directory EPERM"), { code: "EPERM" });
+        await withRecoverableDoctorClaimJournal(async () => {
+            const restoreDurability = setDoctorClaimJournalDurabilityForTest({
+                platform: "win32",
+                syncRegularFile: async () => "synced",
+                syncDirectory: async () => { throw directoryError; },
+            });
+            try {
+                await assert.rejects(doctor(), (error) => error === directoryError);
+            }
+            finally {
+                restoreDurability();
+            }
+        });
+    });
 });
 //# sourceMappingURL=doctor-warning-copy.test.js.map