oh-my-codex 0.18.6 → 0.18.8

package/dist/autopilot/ralplan-gate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ralplan-gate.d.ts","sourceRoot":"","sources":["../../src/autopilot/ralplan-gate.ts"],"names":[],"mappings":"AAAA,OAAO,EAAwC,KAAK,4BAA4B,EAAE,MAAM,8BAA8B,CAAC;AAEvH,KAAK,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAE1C,MAAM,WAAW,kCAAkC;IACjD,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,YAAY,CAAC,EAAE,UAAU,GAAG,IAAI,CAAC;IACjC,SAAS,CAAC,EAAE,UAAU,GAAG,IAAI,CAAC;CAC/B;AAED,MAAM,WAAW,qCAAqC;IACpD,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,4BAA4B,CAAC;CACzC;AAoCD,wBAAgB,qCAAqC,CACnD,KAAK,EAAE,kCAAkC,GACxC,qCAAqC,CAoBvC;AAED,wBAAgB,uCAAuC,CACrD,QAAQ,EAAE,qCAAqC,GAC9C,MAAM,CAKR"}

package/dist/autopilot/ralplan-gate.js

@@ -0,0 +1,61 @@
+import { buildRalplanConsensusGateFromSources } from '../ralplan/consensus-gate.js';
+function safeObject(value) {
+    return value && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : null;
+}
+function nestedState(state) {
+    return safeObject(state?.state);
+}
+function handoffArtifacts(state) {
+    return safeObject(state?.handoff_artifacts) ?? safeObject(nestedState(state)?.handoff_artifacts);
+}
+function ralplanHandoff(state) {
+    return safeObject(handoffArtifacts(state)?.ralplan);
+}
+function gateSources(input) {
+    const sources = [];
+    for (const [label, state] of [
+        ['next-autopilot-state', input.nextState],
+        ['current-autopilot-state', input.currentState],
+    ]) {
+        if (!state)
+            continue;
+        sources.push({ source: label, value: state });
+        const handoffs = handoffArtifacts(state);
+        if (handoffs)
+            sources.push({ source: `${label}:handoff_artifacts`, value: handoffs });
+        const ralplan = ralplanHandoff(state);
+        if (ralplan)
+            sources.push({ source: `${label}:handoff_artifacts.ralplan`, value: ralplan });
+    }
+    return sources;
+}
+export function canAdvanceAutopilotRalplanToUltragoal(input) {
+    const evidence = buildRalplanConsensusGateFromSources(gateSources(input), {
+        cwd: input.cwd,
+        sessionId: input.sessionId,
+        requireNativeSubagents: true,
+    });
+    if (evidence.complete) {
+        return {
+            allowed: true,
+            reason: 'tracker-backed native ralplan architect and critic consensus evidence',
+            evidence,
+        };
+    }
+    return {
+        allowed: false,
+        reason: evidence.blockedReason === 'native_subagent_consensus_evidence_missing'
+            ? 'ralplan consensus lacks tracker-backed native architect and critic lanes'
+            : 'missing ralplan consensus gate with tracker-backed native architect and critic lanes',
+        evidence,
+    };
+}
+export function buildAutopilotRalplanUltragoalGateError(decision) {
+    const details = decision.evidence?.blockedDetails?.length
+        ? ` Details: ${decision.evidence.blockedDetails.join('; ')}.`
+        : '';
+    return `Cannot transition ralplan -> ultragoal: ${decision.reason}.${details}`;
+}
+//# sourceMappingURL=ralplan-gate.js.map

package/dist/autopilot/ralplan-gate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ralplan-gate.js","sourceRoot":"","sources":["../../src/autopilot/ralplan-gate.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oCAAoC,EAAqC,MAAM,8BAA8B,CAAC;AAiBvH,SAAS,UAAU,CAAC,KAAc;IAChC,OAAO,KAAK,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;QAChE,CAAC,CAAC,KAAmB;QACrB,CAAC,CAAC,IAAI,CAAC;AACX,CAAC;AAED,SAAS,WAAW,CAAC,KAAoC;IACvD,OAAO,UAAU,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;AAClC,CAAC;AAED,SAAS,gBAAgB,CAAC,KAAoC;IAC5D,OAAO,UAAU,CAAC,KAAK,EAAE,iBAAiB,CAAC,IAAI,UAAU,CAAC,WAAW,CAAC,KAAK,CAAC,EAAE,iBAAiB,CAAC,CAAC;AACnG,CAAC;AAED,SAAS,cAAc,CAAC,KAAoC;IAC1D,OAAO,UAAU,CAAC,gBAAgB,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC,CAAC;AACtD,CAAC;AAED,SAAS,WAAW,CAAC,KAAyC;IAC5D,MAAM,OAAO,GAA8C,EAAE,CAAC;IAC9D,KAAK,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,IAAI;QAC3B,CAAC,sBAAsB,EAAE,KAAK,CAAC,SAAS,CAAC;QACzC,CAAC,yBAAyB,EAAE,KAAK,CAAC,YAAY,CAAC;KACvC,EAAE,CAAC;QACX,IAAI,CAAC,KAAK;YAAE,SAAS;QACrB,OAAO,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC,CAAC;QAC9C,MAAM,QAAQ,GAAG,gBAAgB,CAAC,KAAK,CAAC,CAAC;QACzC,IAAI,QAAQ;YAAE,OAAO,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,GAAG,KAAK,oBAAoB,EAAE,KAAK,EAAE,QAAQ,EAAE,CAAC,CAAC;QACtF,MAAM,OAAO,GAAG,cAAc,CAAC,KAAK,CAAC,CAAC;QACtC,IAAI,OAAO;YAAE,OAAO,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,GAAG,KAAK,4BAA4B,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC,CAAC;IAC9F,CAAC;IACD,OAAO,OAAO,CAAC;AACjB,CAAC;AAED,MAAM,UAAU,qCAAqC,CACnD,KAAyC;IAEzC,MAAM,QAAQ,GAAG,oCAAoC,CAAC,WAAW,CAAC,KAAK,CAAC,EAAE;QACxE,GAAG,EAAE,KAAK,CAAC,GAAG;QACd,SAAS,EAAE,KAAK,CAAC,SAAS;QAC1B,sBAAsB,EAAE,IAAI;KAC7B,CAAC,CAAC;IACH,IAAI,QAAQ,CAAC,QAAQ,EAAE,CAAC;QACtB,OAAO;YACL,OAAO,EAAE,IAAI;YACb,MAAM,EAAE,uEAAuE;YAC/E,QAAQ;SACT,CAAC;IACJ,CAAC;IACD,OAAO;QACL,OAAO,EAAE,KAAK;QACd,MAAM,EAAE,QAAQ,CAAC,aAAa,KAAK,4CAA4C;YAC7E,CAAC,CAAC,0EAA0E;YAC5E,CAAC,CAAC,sFAAsF;QAC1F,QAAQ;KACT,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,uCAAuC,CACrD,QAA+C;IAE/C,MAAM,OAAO,GAAG,QAAQ,CAAC,QAAQ,EAAE,cAAc,EAAE,MAAM;QACvD,CAAC,CAAC,aAAa,QAAQ,CAAC,QAAQ,CAAC,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG;QAC7D,CAAC,CAAC,EAAE,CAAC;IACP,OAAO,2CAA2C,QAAQ,CAAC,MAAM,IAAI,OAAO,EAAE,CAAC;AACjF,CAAC"}

package/dist/cli/__tests__/codex-plugin-layout.test.js

@@ -3,7 +3,7 @@ import assert from 'node:assert/strict';
 import { spawnSync } from 'node:child_process';
 import { chmod, cp, mkdir, mkdtemp, readdir, readFile, rm, stat, writeFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
-import { delimiter, join, relative, sep } from 'node:path';
+import { delimiter, dirname, join, relative, sep } from 'node:path';
 import { buildMergedConfig } from '../../config/generator.js';
 import { getSetupInstallableSkillNames } from '../../catalog/installable.js';
 import { buildOmxPluginMcpManifest, OMX_FIRST_PARTY_MCP_ENTRYPOINTS, OMX_FIRST_PARTY_MCP_PLUGIN_TARGETS, OMX_FIRST_PARTY_MCP_SERVER_NAMES, OMX_PLUGIN_MCP_COMMAND, OMX_PLUGIN_MCP_SERVE_SUBCOMMAND, } from '../../config/omx-first-party-mcp.js';
@@ -14,11 +14,16 @@ const pluginManifestPath = join(pluginRoot, '.codex-plugin', 'plugin.json');
 const pluginMcpPath = join(pluginRoot, '.mcp.json');
 const pluginAppsPath = join(pluginRoot, '.app.json');
 const pluginHooksPath = join(pluginRoot, 'hooks', 'hooks.json');
+const pluginHookLauncherPath = join(pluginRoot, 'hooks', 'codex-native-hook.mjs');
 const marketplacePath = join(root, '.agents', 'plugins', 'marketplace.json');
 const omxBin = join(root, 'dist', 'cli', 'omx.js');
 async function readJson(path) {
     return JSON.parse(await readFile(path, 'utf-8'));
 }
+async function writeJson(path, value) {
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, JSON.stringify(value, null, 2), 'utf-8');
+}
 function escapeRegex(value) {
     return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
@@ -44,6 +49,166 @@ async function writeOmxShim(binDir) {
     await writeFile(shimPath, `#!/bin/sh\nexec "${process.execPath}" "${omxBin}" "$@"\n`, 'utf-8');
     await chmod(shimPath, 0o755);
 }
+async function createPluginMirrorFixtureRoot() {
+    const fixtureRoot = await mkdtemp(join(tmpdir(), 'omx-plugin-mirror-fixture-'));
+    await Promise.all([
+        mkdir(join(fixtureRoot, 'plugins'), { recursive: true }),
+        mkdir(join(fixtureRoot, 'src', 'catalog'), { recursive: true }),
+    ]);
+    await Promise.all([
+        cp(join(root, 'package.json'), join(fixtureRoot, 'package.json')),
+        cp(join(root, 'plugins', pluginName), join(fixtureRoot, 'plugins', pluginName), { recursive: true }),
+        cp(join(root, 'skills'), join(fixtureRoot, 'skills'), { recursive: true }),
+        cp(join(root, 'src', 'catalog', 'manifest.json'), join(fixtureRoot, 'src', 'catalog', 'manifest.json')),
+    ]);
+    return fixtureRoot;
+}
+async function assertSyncPluginRepairsMissingHooksPointer() {
+    const fixtureRoot = await createPluginMirrorFixtureRoot();
+    try {
+        const fixtureManifestPath = join(fixtureRoot, 'plugins', pluginName, '.codex-plugin', 'plugin.json');
+        const fixtureHooksPath = join(fixtureRoot, 'plugins', pluginName, 'hooks', 'hooks.json');
+        const originalManifest = await readFile(fixtureManifestPath, 'utf-8');
+        const manifest = JSON.parse(originalManifest);
+        delete manifest.hooks;
+        await writeFile(fixtureManifestPath, `${JSON.stringify(manifest, null, 2)}\n`, 'utf-8');
+        const result = spawnSync(process.execPath, [join(root, 'dist', 'scripts', 'sync-plugin-mirror.js')], {
+            cwd: fixtureRoot,
+            encoding: 'utf-8',
+            env: {
+                ...process.env,
+                OMX_AUTO_UPDATE: '0',
+            },
+        });
+        assert.equal(result.status, 0, result.stderr || result.stdout);
+        const repairedManifest = await readJson(fixtureManifestPath);
+        assert.equal(repairedManifest.hooks, './hooks/hooks.json');
+        const hooksManifest = await readJson(fixtureHooksPath);
+        const preToolUseEntries = hooksManifest.hooks?.PreToolUse ?? [];
+        assert.notEqual(preToolUseEntries.length, 0, 'fixture sync should keep PreToolUse hook entries');
+        assert.deepEqual(preToolUseEntries.map((entry) => entry.matcher).filter((matcher) => typeof matcher === 'string'), [], 'fixture sync must not reintroduce a Bash-only PreToolUse matcher');
+    }
+    finally {
+        await rm(fixtureRoot, { recursive: true, force: true });
+    }
+}
+async function assertSyncPluginCheckRejectsLauncherWithoutContract() {
+    const fixtureRoot = await createPluginMirrorFixtureRoot();
+    try {
+        const fixtureHookLauncherPath = join(fixtureRoot, 'plugins', pluginName, 'hooks', 'codex-native-hook.mjs');
+        const launcher = await readFile(fixtureHookLauncherPath, 'utf-8');
+        await writeFile(fixtureHookLauncherPath, launcher.replace('omx-plugin-hook-launcher:v1', 'omx-plugin-hook-launcher:missing'), 'utf-8');
+        const result = spawnSync(process.execPath, [join(root, 'dist', 'scripts', 'sync-plugin-mirror.js'), '--check'], {
+            cwd: fixtureRoot,
+            encoding: 'utf-8',
+            env: {
+                ...process.env,
+                OMX_AUTO_UPDATE: '0',
+            },
+        });
+        assert.notEqual(result.status, 0, 'sync-plugin-mirror --check should reject launcher contract drift');
+        assert.match(result.stderr, /plugin_bundle_metadata_out_of_sync/);
+        assert.match(result.stderr, /kind=hook-launcher/);
+    }
+    finally {
+        await rm(fixtureRoot, { recursive: true, force: true });
+    }
+}
+async function assertPluginHookEventsAlignWithLauncher() {
+    const hooksManifest = await readJson(pluginHooksPath);
+    const launcher = await readFile(pluginHookLauncherPath, 'utf-8');
+    const eventSetMatch = launcher.match(/const CODEX_HOOK_EVENT_NAMES = new Set\(\[([\s\S]*?)\]\);/);
+    assert.ok(eventSetMatch, 'plugin hook launcher should declare a CODEX_HOOK_EVENT_NAMES set');
+    const launcherEvents = Array.from(eventSetMatch[1].matchAll(/'([^']+)'/g), (match) => match[1]).sort();
+    assert.deepEqual(launcherEvents, Object.keys(hooksManifest.hooks ?? {}).sort(), 'plugin hook launcher event allowlist must stay aligned with generated plugin hooks manifest');
+}
+async function assertPluginHookLaunchesPostCompactFromCache() {
+    const cacheRoot = await mkdtemp(join(tmpdir(), 'omx-plugin-hook-cache-'));
+    const cachePluginRoot = join(cacheRoot, pluginName, 'local');
+    const shimDir = join(cacheRoot, 'bin');
+    await cp(pluginRoot, cachePluginRoot, { recursive: true });
+    await writeOmxShim(shimDir);
+    try {
+        const payload = JSON.stringify({
+            hook_event_name: 'PostCompact',
+            session_id: 'omx-plugin-hook-postcompact-smoke',
+            transcript_path: join(cacheRoot, 'missing-transcript.jsonl'),
+            cwd: cacheRoot,
+        });
+        const result = spawnSync(process.execPath, [join(cachePluginRoot, 'hooks', 'codex-native-hook.mjs')], {
+            cwd: cachePluginRoot,
+            encoding: 'utf-8',
+            input: payload,
+            env: {
+                ...process.env,
+                PATH: `${shimDir}${delimiter}${process.env.PATH || ''}`,
+                OMX_AUTO_UPDATE: '0',
+                OMX_NOTIFY_FALLBACK: '0',
+                OMX_HOOK_DERIVED_SIGNALS: '0',
+                OMX_ROOT: join(cacheRoot, '.omx-root'),
+                OMX_SESSION_ID: 'omx-plugin-hook-postcompact-smoke',
+                OMX_SOURCE_CWD: cacheRoot,
+                OMX_STARTUP_CWD: cacheRoot,
+            },
+        });
+        assert.equal(result.status, 0, result.stderr || result.stdout);
+        assert.equal(result.stdout, '', 'PostCompact plugin hook launcher should emit no stdout');
+        assert.doesNotMatch(result.stderr, /MODULE_NOT_FOUND|Cannot find module/);
+    }
+    finally {
+        await rm(cacheRoot, { recursive: true, force: true });
+    }
+}
+async function assertPluginHookDelegatesPostCompactToPinnedCommand() {
+    const cacheRoot = await mkdtemp(join(tmpdir(), 'omx-plugin-hook-delegate-'));
+    const cachePluginRoot = join(cacheRoot, pluginName, 'local');
+    const recorderPath = join(cacheRoot, 'record-hook.mjs');
+    const argsPath = join(cacheRoot, 'recorded-args.json');
+    const stdinPath = join(cacheRoot, 'recorded-stdin.json');
+    await cp(pluginRoot, cachePluginRoot, { recursive: true });
+    await writeFile(recorderPath, [
+        "import { writeFileSync } from 'node:fs';",
+        "const chunks = [];",
+        "for await (const chunk of process.stdin) chunks.push(Buffer.from(chunk));",
+        `writeFileSync(${JSON.stringify(argsPath)}, JSON.stringify(process.argv.slice(2)));`,
+        `writeFileSync(${JSON.stringify(stdinPath)}, Buffer.concat(chunks));`,
+        "",
+    ].join('\n'), 'utf-8');
+    await writeJson(join(cachePluginRoot, 'hooks', 'omx-command.json'), {
+        command: process.execPath,
+        argsPrefix: [recorderPath],
+    });
+    try {
+        const payload = JSON.stringify({
+            hook_event_name: 'PostCompact',
+            session_id: 'omx-plugin-hook-postcompact-delegate',
+            transcript_path: join(cacheRoot, 'missing-transcript.jsonl'),
+            cwd: cacheRoot,
+        });
+        const result = spawnSync(process.execPath, [join(cachePluginRoot, 'hooks', 'codex-native-hook.mjs')], {
+            cwd: cachePluginRoot,
+            encoding: 'utf-8',
+            input: payload,
+            env: {
+                ...process.env,
+                OMX_AUTO_UPDATE: '0',
+                OMX_NOTIFY_FALLBACK: '0',
+                OMX_HOOK_DERIVED_SIGNALS: '0',
+                OMX_ROOT: join(cacheRoot, '.omx-root'),
+                OMX_SESSION_ID: 'omx-plugin-hook-postcompact-delegate',
+                OMX_SOURCE_CWD: cacheRoot,
+                OMX_STARTUP_CWD: cacheRoot,
+            },
+        });
+        assert.equal(result.status, 0, result.stderr || result.stdout);
+        assert.equal(result.stdout, '', 'PostCompact plugin hook launcher should emit no stdout when delegate is quiet');
+        assert.deepEqual(JSON.parse(await readFile(argsPath, 'utf-8')), ['codex-native-hook']);
+        assert.deepEqual(JSON.parse(await readFile(stdinPath, 'utf-8')), JSON.parse(payload));
+    }
+    finally {
+        await rm(cacheRoot, { recursive: true, force: true });
+    }
+}
 async function assertPluginCacheLaunchable(entrypoint) {
     const cacheRoot = await mkdtemp(join(tmpdir(), 'omx-plugin-cache-'));
     const cachePluginRoot = join(cacheRoot, pluginName, 'local');
@@ -70,6 +235,39 @@ async function assertPluginCacheLaunchable(entrypoint) {
         await rm(cacheRoot, { recursive: true, force: true });
     }
 }
+function parseSingleJsonStdout(stdout) {
+    const trimmed = stdout.trim();
+    assert.notEqual(trimmed, '');
+    assert.equal(trimmed.split('\n').length, 1);
+    return JSON.parse(trimmed);
+}
+async function withPluginCacheCopy(run) {
+    const cacheRoot = await mkdtemp(join(tmpdir(), 'omx-plugin-hook-cache-'));
+    const cachePluginRoot = join(cacheRoot, pluginName, 'local');
+    await cp(pluginRoot, cachePluginRoot, { recursive: true });
+    try {
+        return await run(cachePluginRoot, cacheRoot);
+    }
+    finally {
+        await rm(cacheRoot, { recursive: true, force: true });
+    }
+}
+function pluginHookEnv(overrides = {}) {
+    const env = { ...process.env };
+    for (const key of ['OMX_TEAM_STATE_ROOT', 'OMX_ROOT', 'OMX_STATE_ROOT', 'OMX_SESSION_ID', 'CODEX_SESSION_ID']) {
+        delete env[key];
+    }
+    return { ...env, ...overrides };
+}
+function runPluginNativeHook(cachePluginRoot, input, env = {}) {
+    return spawnSync(process.execPath, [join(cachePluginRoot, 'hooks', 'codex-native-hook.mjs')], {
+        cwd: cachePluginRoot,
+        input,
+        encoding: 'utf-8',
+        stdio: ['pipe', 'pipe', 'pipe'],
+        env: pluginHookEnv(env),
+    });
+}
 describe('official Codex plugin layout', () => {
     it('defines a plugin manifest under a plugin root and keeps .codex-plugin limited to plugin.json', async () => {
         const pkg = await readJson(join(root, 'package.json'));
@@ -88,6 +286,15 @@ describe('official Codex plugin layout', () => {
         assert.ok(manifest.interface?.longDescription, 'expected long interface description');
         assert.ok(manifest.interface?.developerName, 'expected developerName');
     });
+    it('repairs a missing plugin hooks manifest pointer during plugin sync', async () => {
+        await assertSyncPluginRepairsMissingHooksPointer();
+    });
+    it('rejects plugin hook launcher drift during plugin sync check', async () => {
+        await assertSyncPluginCheckRejectsLauncherWithoutContract();
+    });
+    it('keeps generated plugin hook events aligned with the launcher allowlist', async () => {
+        await assertPluginHookEventsAlignWithLauncher();
+    });
     it('ships plugin-scoped hooks and disabled-by-default MCP compatibility metadata', async () => {
         const [mcpManifest, appsManifest, hooksManifest] = await Promise.all([
             readJson(pluginMcpPath),
@@ -105,6 +312,7 @@ describe('official Codex plugin layout', () => {
             .flatMap((entry) => entry.hooks ?? [])
             .map((hook) => hook.command);
         assert.ok(hookCommands.every((command) => command === 'node "${PLUGIN_ROOT}/hooks/codex-native-hook.mjs"'), 'plugin hooks should use Codex PLUGIN_ROOT instead of setup-owned .codex/hooks.json');
+        assert.equal(hooksManifest.hooks?.PreToolUse?.some((entry) => typeof entry.matcher === 'string'), false, 'plugin PreToolUse hooks must cover non-Bash tools just like setup-owned native hooks');
         assert.deepEqual(mcpManifest, expectedPluginMcpManifest);
         for (const [serverName, server] of Object.entries(mcpManifest.mcpServers ?? {})) {
             assert.equal(server.command, OMX_PLUGIN_MCP_COMMAND, `${serverName} should run via omx`);
@@ -119,6 +327,302 @@ describe('official Codex plugin layout', () => {
             assert.equal(target?.endsWith('-server.js'), false, `${serverName} should not expose internal dist filenames in plugin metadata`);
         }
     });
+    it('emits Stop JSON when the plugin hook pinned launcher is invalid', async () => {
+        await withPluginCacheCopy(async (cachePluginRoot) => {
+            await writeFile(join(cachePluginRoot, 'hooks', 'omx-command.json'), '{"command":', 'utf-8');
+            const result = runPluginNativeHook(cachePluginRoot, JSON.stringify({
+                hook_event_name: 'Stop',
+                session_id: 'sess-plugin-invalid-launcher-stop',
+            }));
+            assert.equal(result.status, 0, result.stderr || result.stdout);
+            assert.match(result.stderr, /invalid plugin hook launcher/);
+            const output = parseSingleJsonStdout(result.stdout);
+            assert.equal(output.decision, 'block');
+            assert.equal(output.stopReason, 'plugin_stop_hook_launcher_failure');
+        });
+    });
+    it('emits Stop JSON when the plugin hook command cannot spawn', async () => {
+        await withPluginCacheCopy(async (cachePluginRoot, cacheRoot) => {
+            const result = runPluginNativeHook(cachePluginRoot, JSON.stringify({ hook_event_name: 'Stop', session_id: 'sess-plugin-missing-command-stop' }), {
+                OMX_NATIVE_HOOK_COMMAND: join(cacheRoot, 'bin', 'missing-omx-command'),
+            });
+            assert.equal(result.status, 0, result.stderr || result.stdout);
+            const output = parseSingleJsonStdout(result.stdout);
+            assert.equal(output.decision, 'block');
+            assert.equal(output.stopReason, 'plugin_stop_hook_launcher_spawn_error');
+        });
+    });
+    it('emits Stop JSON when the launched plugin hook command exits before producing stdout', async () => {
+        await withPluginCacheCopy(async (cachePluginRoot) => {
+            const result = runPluginNativeHook(cachePluginRoot, JSON.stringify({ hook_event_name: 'Stop', session_id: 'sess-plugin-false-command-stop' }), {
+                OMX_NATIVE_HOOK_COMMAND: process.platform === 'win32' ? 'cmd.exe /c exit 1' : '/bin/false',
+            });
+            assert.equal(result.status, 0, result.stderr || result.stdout);
+            const output = parseSingleJsonStdout(result.stdout);
+            assert.equal(output.decision, 'block');
+            assert.match(String(output.stopReason ?? ''), /plugin_stop_hook_launcher_(?:exit|stdin_error)/);
+        });
+    });
+    it('emits Stop JSON when the launched plugin hook command exits successfully without stdout', async () => {
+        await withPluginCacheCopy(async (cachePluginRoot, cacheRoot) => {
+            const commandPath = join(cacheRoot, process.platform === 'win32' ? 'empty-ok.cmd' : 'empty-ok.sh');
+            if (process.platform === 'win32') {
+                await writeFile(commandPath, '@echo off\r\nexit /b 0\r\n', 'utf-8');
+            }
+            else {
+                await writeFile(commandPath, '#!/bin/sh\nexit 0\n', 'utf-8');
+                await chmod(commandPath, 0o755);
+            }
+            const result = runPluginNativeHook(cachePluginRoot, JSON.stringify({ hook_event_name: 'Stop', session_id: 'sess-plugin-empty-ok-stop' }), { OMX_NATIVE_HOOK_COMMAND: commandPath });
+            assert.equal(result.status, 0, result.stderr || result.stdout);
+            const output = parseSingleJsonStdout(result.stdout);
+            assert.equal(output.decision, 'block');
+            assert.equal(output.stopReason, 'plugin_stop_hook_launcher_empty_stdout');
+        });
+    });
+    it('does not append fallback Stop JSON after partial child stdout', async () => {
+        await withPluginCacheCopy(async (cachePluginRoot, cacheRoot) => {
+            const commandPath = join(cacheRoot, process.platform === 'win32' ? 'partial.cmd' : 'partial.sh');
+            if (process.platform === 'win32') {
+                await writeFile(commandPath, '@echo off\r\n<nul set /p=PARTIAL\r\nexit /b 2\r\n', 'utf-8');
+            }
+            else {
+                await writeFile(commandPath, '#!/bin/sh\nprintf PARTIAL\nexit 2\n', 'utf-8');
+                await chmod(commandPath, 0o755);
+            }
+            const result = runPluginNativeHook(cachePluginRoot, JSON.stringify({ hook_event_name: 'Stop', session_id: 'sess-plugin-partial-stop' }), { OMX_NATIVE_HOOK_COMMAND: commandPath });
+            assert.equal(result.status, 2, result.stderr || result.stdout);
+            assert.equal(result.stdout, 'PARTIAL');
+            assert.doesNotMatch(result.stdout, /plugin_stop_hook_launcher/);
+        });
+    });
+    it('emits Stop JSON for malformed Stop-looking stdin before invalid launcher failure', async () => {
+        await withPluginCacheCopy(async (cachePluginRoot) => {
+            await writeFile(join(cachePluginRoot, 'hooks', 'omx-command.json'), '{"command":', 'utf-8');
+            const result = runPluginNativeHook(cachePluginRoot, '{"hook_event_name":"Stop",');
+            assert.equal(result.status, 0, result.stderr || result.stdout);
+            const output = parseSingleJsonStdout(result.stdout);
+            assert.equal(output.decision, 'block');
+            assert.equal(output.stopReason, 'plugin_stop_hook_launcher_failure');
+        });
+    });
+    it('emits Stop JSON for the core-supported name alias before invalid launcher failure', async () => {
+        await withPluginCacheCopy(async (cachePluginRoot) => {
+            await writeFile(join(cachePluginRoot, 'hooks', 'omx-command.json'), '{"command":', 'utf-8');
+            const result = runPluginNativeHook(cachePluginRoot, '{"name":"Stop",');
+            assert.equal(result.status, 0, result.stderr || result.stdout);
+            const output = parseSingleJsonStdout(result.stdout);
+            assert.equal(output.decision, 'block');
+            assert.equal(output.stopReason, 'plugin_stop_hook_launcher_failure');
+        });
+    });
+    it('keeps non-Stop plugin hook launcher failures fail-closed without Stop JSON', async () => {
+        await withPluginCacheCopy(async (cachePluginRoot) => {
+            await writeFile(join(cachePluginRoot, 'hooks', 'omx-command.json'), '{"command":', 'utf-8');
+            const result = runPluginNativeHook(cachePluginRoot, JSON.stringify({
+                hook_event_name: 'UserPromptSubmit',
+                prompt: 'hello',
+            }));
+            assert.equal(result.status, 1);
+            assert.equal(result.stdout, '');
+            assert.match(result.stderr, /invalid plugin hook launcher/);
+        });
+    });
+    it('does not classify valid non-Stop plugin JSON with nested Stop text as Stop', async () => {
+        await withPluginCacheCopy(async (cachePluginRoot) => {
+            await writeFile(join(cachePluginRoot, 'hooks', 'omx-command.json'), '{"command":', 'utf-8');
+            const result = runPluginNativeHook(cachePluginRoot, JSON.stringify({
+                hook_event_name: 'PreToolUse',
+                tool_input: { name: 'Stop' },
+            }));
+            assert.equal(result.status, 1);
+            assert.equal(result.stdout, '');
+            assert.match(result.stderr, /invalid plugin hook launcher/);
+        });
+    });
+    it('does not classify malformed non-Stop plugin JSON with nested Stop text as Stop', async () => {
+        await withPluginCacheCopy(async (cachePluginRoot) => {
+            await writeFile(join(cachePluginRoot, 'hooks', 'omx-command.json'), '{"command":', 'utf-8');
+            const result = runPluginNativeHook(cachePluginRoot, '{"hook_event_name":"PreToolUse","tool_input":{"name":"Stop"},');
+            assert.equal(result.status, 1);
+            assert.equal(result.stdout, '');
+            assert.match(result.stderr, /invalid plugin hook launcher/);
+        });
+    });
+    it('allows oversized plugin Stop stdin when no active workflow state is present', async () => {
+        await withPluginCacheCopy(async (cachePluginRoot) => {
+            const oversizedStop = `{"hook_event_name":"Stop","padding":"${'x'.repeat(1024 * 1024 + 1)}`;
+            const result = runPluginNativeHook(cachePluginRoot, oversizedStop);
+            assert.equal(result.status, 0, result.stderr || result.stdout);
+            assert.deepEqual(parseSingleJsonStdout(result.stdout), {});
+        });
+    });
+    it('blocks oversized plugin Stop stdin when current session autopilot state is active', async () => {
+        await withPluginCacheCopy(async (cachePluginRoot) => {
+            const sessionId = 'sess-plugin-oversized-active';
+            await writeJson(join(cachePluginRoot, '.omx', 'state', 'session.json'), { session_id: sessionId });
+            await writeJson(join(cachePluginRoot, '.omx', 'state', 'sessions', sessionId, 'autopilot-state.json'), {
+                active: true,
+                current_phase: 'execution',
+            });
+            const oversizedStop = `{"hook_event_name":"Stop","cwd":"${cachePluginRoot}","session_id":"${sessionId}","padding":"${'x'.repeat(1024 * 1024 + 1)}`;
+            const result = runPluginNativeHook(cachePluginRoot, oversizedStop);
+            assert.equal(result.status, 0, result.stderr || result.stdout);
+            const output = parseSingleJsonStdout(result.stdout);
+            assert.equal(output.decision, 'block');
+            assert.equal(output.stopReason, 'plugin_stop_hook_stdin_oversized_active_workflow');
+        });
+    });
+    it('does not let unrelated terminal run-state suppress active plugin Autopilot oversized Stop blocking', async () => {
+        await withPluginCacheCopy(async (cachePluginRoot) => {
+            const sessionId = 'sess-plugin-oversized-unrelated-terminal';
+            await writeJson(join(cachePluginRoot, '.omx', 'state', 'session.json'), { session_id: sessionId });
+            await writeJson(join(cachePluginRoot, '.omx', 'state', 'sessions', sessionId, 'autopilot-state.json'), {
+                active: true,
+                current_phase: 'execution',
+            });
+            await writeJson(join(cachePluginRoot, '.omx', 'state', 'sessions', sessionId, 'run-state.json'), {
+                mode: 'ralph',
+                active: false,
+                outcome: 'finish',
+            });
+            const oversizedStop = `{"hook_event_name":"Stop","cwd":"${cachePluginRoot}","session_id":"${sessionId}","padding":"${'x'.repeat(1024 * 1024 + 1)}`;
+            const result = runPluginNativeHook(cachePluginRoot, oversizedStop);
+            assert.equal(result.status, 0, result.stderr || result.stdout);
+            const output = parseSingleJsonStdout(result.stdout);
+            assert.equal(output.decision, 'block');
+            assert.equal(output.stopReason, 'plugin_stop_hook_stdin_oversized_active_workflow');
+        });
+    });
+    it('allows oversized plugin Stop stdin when terminal Autopilot run-state shadows stale active state', async () => {
+        await withPluginCacheCopy(async (cachePluginRoot) => {
+            const sessionId = 'sess-plugin-oversized-terminal-autopilot';
+            await writeJson(join(cachePluginRoot, '.omx', 'state', 'session.json'), { session_id: sessionId });
+            await writeJson(join(cachePluginRoot, '.omx', 'state', 'sessions', sessionId, 'autopilot-state.json'), {
+                active: true,
+                current_phase: 'execution',
+            });
+            await writeJson(join(cachePluginRoot, '.omx', 'state', 'sessions', sessionId, 'run-state.json'), {
+                mode: 'autopilot',
+                active: false,
+                outcome: 'blocked_on_user',
+            });
+            const oversizedStop = `{"hook_event_name":"Stop","cwd":"${cachePluginRoot}","session_id":"${sessionId}","padding":"${'x'.repeat(1024 * 1024 + 1)}`;
+            const result = runPluginNativeHook(cachePluginRoot, oversizedStop);
+            assert.equal(result.status, 0, result.stderr || result.stdout);
+            assert.deepEqual(parseSingleJsonStdout(result.stdout), {});
+        });
+    });
+    it('detects active plugin Autopilot state for oversized Stop under OMX_ROOT', async () => {
+        await withPluginCacheCopy(async (cachePluginRoot, cacheRoot) => {
+            const sessionId = 'sess-plugin-oversized-omx-root';
+            const omxRoot = join(cacheRoot, 'boxed-root');
+            await writeJson(join(omxRoot, '.omx', 'state', 'session.json'), { session_id: sessionId });
+            await writeJson(join(omxRoot, '.omx', 'state', 'sessions', sessionId, 'autopilot-state.json'), {
+                active: true,
+                current_phase: 'execution',
+            });
+            const oversizedStop = `{"hook_event_name":"Stop","cwd":"${cachePluginRoot}","session_id":"${sessionId}","padding":"${'x'.repeat(1024 * 1024 + 1)}`;
+            const result = runPluginNativeHook(cachePluginRoot, oversizedStop, { OMX_ROOT: omxRoot });
+            assert.equal(result.status, 0, result.stderr || result.stdout);
+            const output = parseSingleJsonStdout(result.stdout);
+            assert.equal(output.decision, 'block');
+            assert.equal(output.stopReason, 'plugin_stop_hook_stdin_oversized_active_workflow');
+        });
+    });
+    it('lets terminal OMX_ROOT Autopilot state override stale cwd active state for oversized Stop', async () => {
+        await withPluginCacheCopy(async (cachePluginRoot, cacheRoot) => {
+            const sessionId = 'sess-plugin-oversized-omx-root-terminal';
+            const omxRoot = join(cacheRoot, 'boxed-root-terminal');
+            await writeJson(join(omxRoot, '.omx', 'state', 'session.json'), { session_id: sessionId });
+            await writeJson(join(omxRoot, '.omx', 'state', 'sessions', sessionId, 'run-state.json'), {
+                mode: 'autopilot',
+                outcome: 'blocked_on_user',
+            });
+            await writeJson(join(cachePluginRoot, '.omx', 'state', 'session.json'), { session_id: sessionId });
+            await writeJson(join(cachePluginRoot, '.omx', 'state', 'sessions', sessionId, 'autopilot-state.json'), {
+                active: true,
+                current_phase: 'execution',
+            });
+            const oversizedStop = `{"hook_event_name":"Stop","cwd":"${cachePluginRoot}","session_id":"${sessionId}","padding":"${'x'.repeat(1024 * 1024 + 1)}`;
+            const result = runPluginNativeHook(cachePluginRoot, oversizedStop, { OMX_ROOT: omxRoot });
+            assert.equal(result.status, 0, result.stderr || result.stdout);
+            assert.deepEqual(parseSingleJsonStdout(result.stdout), {});
+        });
+    });
+    it('allows oversized plugin Stop when Autopilot state is active but terminal by phase', async () => {
+        await withPluginCacheCopy(async (cachePluginRoot) => {
+            const sessionId = 'sess-plugin-oversized-terminal-phase';
+            await writeJson(join(cachePluginRoot, '.omx', 'state', 'session.json'), { session_id: sessionId });
+            await writeJson(join(cachePluginRoot, '.omx', 'state', 'sessions', sessionId, 'autopilot-state.json'), {
+                active: true,
+                current_phase: 'complete',
+            });
+            const oversizedStop = `{"hook_event_name":"Stop","cwd":"${cachePluginRoot}","session_id":"${sessionId}","padding":"${'x'.repeat(1024 * 1024 + 1)}`;
+            const result = runPluginNativeHook(cachePluginRoot, oversizedStop);
+            assert.equal(result.status, 0, result.stderr || result.stdout);
+            assert.deepEqual(parseSingleJsonStdout(result.stdout), {});
+        });
+    });
+    it('ignores stale plugin session state whose cwd does not match oversized Stop cwd', async () => {
+        await withPluginCacheCopy(async (cachePluginRoot, cacheRoot) => {
+            const sessionId = 'sess-plugin-oversized-stale-cwd';
+            await writeJson(join(cachePluginRoot, '.omx', 'state', 'session.json'), {
+                session_id: sessionId,
+                cwd: join(cacheRoot, 'different-cwd'),
+            });
+            await writeJson(join(cachePluginRoot, '.omx', 'state', 'sessions', sessionId, 'autopilot-state.json'), {
+                active: true,
+                current_phase: 'execution',
+            });
+            const oversizedStop = `{"hook_event_name":"Stop","cwd":"${cachePluginRoot}","session_id":"${sessionId}","padding":"${'x'.repeat(1024 * 1024 + 1)}`;
+            const result = runPluginNativeHook(cachePluginRoot, oversizedStop);
+            assert.equal(result.status, 0, result.stderr || result.stdout);
+            assert.deepEqual(parseSingleJsonStdout(result.stdout), {});
+        });
+    });
+    it('fails oversized non-Stop plugin stdin without Stop JSON', async () => {
+        await withPluginCacheCopy(async (cachePluginRoot) => {
+            const result = runPluginNativeHook(cachePluginRoot, 'x'.repeat(1024 * 1024 + 1));
+            assert.equal(result.status, 1);
+            assert.equal(result.stdout, '');
+            assert.match(result.stderr, /plugin hook stdin exceeded/);
+        });
+    });
+    it('forwards under-cap plugin hook stdin bytes unchanged to the delegated command', async () => {
+        await withPluginCacheCopy(async (cachePluginRoot, cacheRoot) => {
+            const capturePath = join(cacheRoot, 'captured-stdin.json');
+            const commandPath = join(cacheRoot, 'capture-hook.mjs');
+            const launcherPath = join(cacheRoot, process.platform === 'win32' ? 'capture-hook.cmd' : 'capture-hook.sh');
+            await writeFile(commandPath, `import { writeFileSync } from 'node:fs';
+const chunks = [];
+process.stdin.on('data', (chunk) => chunks.push(chunk));
+process.stdin.on('end', () => {
+  writeFileSync(process.env.CAPTURE_PATH, Buffer.concat(chunks));
+  process.stdout.write('{}\\n');
+});
+`, 'utf-8');
+            if (process.platform === 'win32') {
+                await writeFile(launcherPath, `@echo off\r\n"${process.execPath}" "${commandPath}" %*\r\n`, 'utf-8');
+            }
+            else {
+                await writeFile(launcherPath, `#!/bin/sh\nexec "${process.execPath}" "${commandPath}" "$@"\n`, 'utf-8');
+                await chmod(launcherPath, 0o755);
+            }
+            const input = JSON.stringify({
+                hook_event_name: 'Stop',
+                session_id: 'sess-plugin-forward-stdin',
+                payload: 'keep these bytes unchanged',
+            });
+            const result = runPluginNativeHook(cachePluginRoot, input, {
+                OMX_NATIVE_HOOK_COMMAND: launcherPath,
+                CAPTURE_PATH: capturePath,
+            });
+            assert.equal(result.status, 0, result.stderr || result.stdout);
+            assert.deepEqual(parseSingleJsonStdout(result.stdout), {});
+            assert.equal(await readFile(capturePath, 'utf-8'), input);
+        });
+    });
     it('keeps plugin MCP metadata aligned with the explicit compat setup-managed MCP roster', async () => {
         const mcpManifest = await readJson(pluginMcpPath);
         const defaultConfig = buildMergedConfig('', root, { includeTui: false });
@@ -142,12 +646,19 @@ describe('official Codex plugin layout', () => {
             await assertPluginCacheLaunchable(target);
         }
     });
+    it('launches the plugin-scoped native hook for PostCompact from a cache-style plugin root', async () => {
+        await assertPluginHookLaunchesPostCompactFromCache();
+    });
+    it('delegates PostCompact plugin hook payloads to the pinned launcher command', async () => {
+        await assertPluginHookDelegatesPostCompactToPinnedCommand();
+    });
     it('does not stage setup-owned hook or runtime directories inside the plugin', async () => {
         const pluginEntries = await readdir(pluginRoot);
         assert.equal(pluginEntries.includes('.codex'), false, 'official plugin should not ship setup-owned .codex hook assets');
         assert.equal(pluginEntries.includes('.omx'), false, 'official plugin should not ship runtime hook directories');
         assert.equal(pluginEntries.includes('hooks.json'), false, 'official plugin hook metadata should stay under hooks/');
         assert.equal(pluginEntries.includes('hooks'), true, 'official plugin should ship plugin-scoped lifecycle hooks');
+        await stat(pluginHookLauncherPath);
     });
     it('registers the plugin in the repo marketplace with explicit source, policy, and category', async () => {
         const marketplace = await readJson(marketplacePath);