oh-my-codex 0.20.2 → 0.20.5

package/dist/scripts/__tests__/smoke-packed-install.test.js

@@ -1,12 +1,13 @@
 // @ts-nocheck
 import assert from 'node:assert/strict';
-import { access, chmod, mkdtemp, mkdir, rm, symlink, writeFile } from 'node:fs/promises';
+import { access, chmod, mkdtemp, mkdir, readFile, rm, symlink, writeFile } from 'node:fs/promises';
 import { EventEmitter } from 'node:events';
 import { tmpdir } from 'node:os';
 import { delimiter, join } from 'node:path';
 import { PassThrough } from 'node:stream';
 import { test } from 'node:test';
-import { ensureRepoDependencies, hasUsableNodeModules, buildPackedRegressionEnvironment, CODEX_APP_SERVER_TIMEOUTS, CodexAppServer, CodexExecutableNotFoundError, MANAGED_CODEX_HOOK_EVENTS, PACKED_INSTALL_NATIVE_HOOK_SMOKE_EVENTS, PACKED_INSTALL_NATIVE_HOOK_REGRESSION_PROMPTS, PACKED_INSTALL_SMOKE_CORE_COMMANDS, appendForeignHookGroups, appendDisplayOrderStableForeignHookGroups, buildNativeHookSmokePayload, createCodexBatchWriteEnvelope, createCodexHooksListEnvelope, createCodexInitializeEnvelope, foreignHookGroupSnapshot, generatedHookTrustState, parseNpmPackJsonOutput, parseCodexHooksListResult, probeCodexVersion, resolveGitCommonDir, resolveReusableNodeModulesSource, validateHookStdout, assertCodexBatchWriteResult, assertGeneratedTrustMatchesCodex, managedCodexHooksByEvent, } from '../smoke-packed-install.js';
+import { assertPackedLaunchCwdPreserved, assertInstalledPluginSurface, assertInstalledReasoningDeclarationContract, assertInstalledReasoningRuntimeContract, assertInstalledRootReasoningHelp, assertInstalledRootReasoningRejection, assertInstalledTeamSkillContract, assertPackedInstallFileMetadata, assertPackedRegressionWorkflowState, buildNativeHookSmokePayload, ensureRepoDependencies, hasUsableNodeModules, buildPackedProbeEnv, buildPackedRegressionEnvironment, CODEX_APP_SERVER_TIMEOUTS, CodexAppServer, CodexExecutableNotFoundError, MANAGED_CODEX_HOOK_EVENTS, PACKED_INSTALL_NATIVE_HOOK_SMOKE_EVENTS, PACKED_INSTALL_NATIVE_HOOK_REGRESSION_PROMPTS, PACKED_CODEX_01445_NO_POINTER_NO_TRACKER_FIXTURE, PACKED_INSTALL_SMOKE_CORE_COMMANDS, appendForeignHookGroups, appendDisplayOrderStableForeignHookGroups, createCodexBatchWriteEnvelope, createCodexHooksListEnvelope, createCodexInitializeEnvelope, foreignHookGroupSnapshot, generatedHookTrustState, isForbiddenPackedInstallArtifact, PACKED_INSTALL_FORBIDDEN_ARTIFACT_PATHS, PACKED_INSTALL_REQUIRED_ARTIFACT_PATHS, PACKED_INSTALL_PLUGIN_MCP_TARGETS, parseFakeCodexLaunches, parseNpmPackJsonOutput, parseCodexHooksListResult, probeCodexVersion, parseArgs, resolveGitCommonDir, resolveReusableNodeModulesSource, replacePathKeyCaseInsensitive, resolvePackedSmokeRuntimeBinary, validateHookStdout, shouldPackedRegressionStopBlock, assertCodexBatchWriteResult, assertGeneratedTrustMatchesCodex, managedCodexHooksByEvent, } from '../smoke-packed-install.js';
+import { parseNativeSubagentResultDisposition } from '../../leader/contract.js';
 function createFakeCodexAppServer(onRequest) {
     const child = Object.assign(new EventEmitter(), {
         stdin: new PassThrough(),
@@ -18,6 +19,98 @@ function createFakeCodexAppServer(onRequest) {
     child.stdin.on('finish', () => child.emit('close', 0, null));
     return new CodexAppServer(child);
 }
+test('packed smoke resolves and validates the platform-aware repo runtime', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'omx-packed-runtime-'));
+    try {
+        const debugDir = join(root, 'target', 'debug');
+        await mkdir(debugDir, { recursive: true });
+        const runtimePath = join(debugDir, 'omx-runtime');
+        await writeFile(runtimePath, '#!/bin/sh\nexit 0\n');
+        await chmod(runtimePath, 0o755);
+        assert.equal(resolvePackedSmokeRuntimeBinary(root, { platform: 'linux' }), runtimePath);
+        const windowsRuntimePath = join(debugDir, 'omx-runtime.exe');
+        await writeFile(windowsRuntimePath, 'windows executable fixture');
+        assert.equal(resolvePackedSmokeRuntimeBinary(root, { platform: 'win32' }), windowsRuntimePath);
+        assert.throws(() => resolvePackedSmokeRuntimeBinary(root, { platform: 'linux', candidate: 'relative/omx-runtime' }), /must be absolute/);
+        assert.equal(resolvePackedSmokeRuntimeBinary(root, { platform: 'linux', candidate: runtimePath }), runtimePath);
+        assert.throws(() => resolvePackedSmokeRuntimeBinary(join(root, 'missing'), { platform: 'linux' }), /run "npm run build:runtime"/);
+        const nonExecutablePath = join(root, 'non-executable-runtime');
+        await writeFile(nonExecutablePath, 'not executable');
+        await chmod(nonExecutablePath, 0o644);
+        assert.throws(() => resolvePackedSmokeRuntimeBinary(root, { platform: 'linux', candidate: nonExecutablePath }), /executable regular file/);
+    }
+    finally {
+        await rm(root, { recursive: true, force: true });
+    }
+});
+test('packed probe env strips ambient runtime and supports default, absent, and explicit provisioning', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'omx-packed-probe-env-'));
+    try {
+        const debugDir = join(root, 'target', 'debug');
+        await mkdir(debugDir, { recursive: true });
+        const runtimePath = join(debugDir, 'omx-runtime');
+        await writeFile(runtimePath, '#!/bin/sh\nexit 0\n');
+        await chmod(runtimePath, 0o755);
+        const defaultEnv = buildPackedProbeEnv({ OMX_RUNTIME_BINARY: '/tmp/ambient-decoy' }, { repoRoot: root });
+        assert.equal(defaultEnv.OMX_RUNTIME_BINARY, runtimePath);
+        const absentEnv = buildPackedProbeEnv({}, { runtimeBinary: null });
+        assert.equal(Object.hasOwn(absentEnv, 'OMX_RUNTIME_BINARY'), false);
+        const explicitEnv = buildPackedProbeEnv({}, { runtimeBinary: runtimePath });
+        assert.equal(explicitEnv.OMX_RUNTIME_BINARY, runtimePath);
+        assert.throws(() => buildPackedProbeEnv({}, { runtimeBinary: 'relative/omx-runtime' }), /must be absolute/);
+    }
+    finally {
+        await rm(root, { recursive: true, force: true });
+    }
+});
+test('packed fail-closed PATH replacement removes a win32-shaped decoy runtime and every casing variant', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'omx-packed-path-isolation-'));
+    try {
+        const decoyDir = join(root, 'decoy');
+        const isolatedDir = join(root, 'isolated');
+        await mkdir(decoyDir);
+        await mkdir(isolatedDir);
+        const decoyRuntime = join(decoyDir, 'omx-runtime.exe');
+        await writeFile(decoyRuntime, 'decoy');
+        await access(decoyRuntime);
+        const env = replacePathKeyCaseInsensitive({ Path: decoyDir, PATH: join(root, 'other'), KEEP: '1' }, isolatedDir);
+        const pathKeys = Object.keys(env).filter((key) => key.toUpperCase() === 'PATH');
+        assert.deepEqual(pathKeys, ['Path']);
+        assert.equal(env.Path, isolatedDir);
+        assert.equal(env.Path.split(delimiter).includes(decoyDir), false);
+        assert.equal(env.KEEP, '1');
+    }
+    finally {
+        await rm(root, { recursive: true, force: true });
+    }
+});
+test('packed fail-closed PATH replacement creates a single POSIX key when absent', () => {
+    const env = replacePathKeyCaseInsensitive({ KEEP: '1' }, '/isolated');
+    assert.deepEqual(env, { KEEP: '1', PATH: '/isolated' });
+});
+test('packed launch cwd assertion accepts filesystem aliases and rejects distinct directories', async () => {
+    if (process.platform === 'win32')
+        return;
+    const root = await mkdtemp(join(tmpdir(), 'omx-packed-cwd-'));
+    try {
+        const realDir = join(root, 'real');
+        const otherDir = join(root, 'other');
+        const aliasDir = join(root, 'alias');
+        await mkdir(realDir);
+        await mkdir(otherDir);
+        await symlink(realDir, aliasDir);
+        assert.doesNotThrow(() => assertPackedLaunchCwdPreserved(realDir, aliasDir, 'cwd mismatch'));
+        assert.throws(() => assertPackedLaunchCwdPreserved(realDir, otherDir, 'cwd mismatch'), /cwd mismatch: expected .* received /);
+    }
+    finally {
+        await rm(root, { recursive: true, force: true });
+    }
+});
+test('packed smoke arguments expose a probe-only mode and reject unknown flags', () => {
+    assert.deepEqual(parseArgs([]), { failClosedProbe: false });
+    assert.deepEqual(parseArgs(['--fail-closed-probe']), { failClosedProbe: true });
+    assert.throws(() => parseArgs(['--unknown']), /Unknown argument/);
+});
 test('packed install smoke retains narrow boot commands and adds the isolated lifecycle separately', () => {
     assert.deepEqual(PACKED_INSTALL_SMOKE_CORE_COMMANDS, [
         ['--help'],
@@ -28,6 +121,48 @@ test('packed install smoke retains narrow boot commands and adds the isolated li
     assert.equal(PACKED_INSTALL_SMOKE_CORE_COMMANDS.some((argv) => argv.includes('api')), true);
     assert.equal(PACKED_INSTALL_SMOKE_CORE_COMMANDS.some((argv) => argv.includes('sparkshell')), true);
 });
+test('packed 0.144.5 fixture is sanitized, pointer-free, and kept separate from the 0.142.5 lifecycle pin', () => {
+    assert.deepEqual(PACKED_CODEX_01445_NO_POINTER_NO_TRACKER_FIXTURE, {
+        hook_event_name: 'PreToolUse',
+        session_id: 'packed-01445-session',
+        turn_id: 'packed-01445-turn',
+        tool_name: 'Bash',
+        tool_use_id: 'packed-01445-tool',
+        tool_input: { command: 'omx ralplan role-intent write --role architect --parent-thread "$CODEX_THREAD_ID" --json' },
+    });
+    assert.equal(Object.hasOwn(PACKED_CODEX_01445_NO_POINTER_NO_TRACKER_FIXTURE, 'tracker'), false);
+    assert.equal(Object.hasOwn(PACKED_CODEX_01445_NO_POINTER_NO_TRACKER_FIXTURE, 'session_pointer'), false);
+    assert.equal(Object.hasOwn(PACKED_CODEX_01445_NO_POINTER_NO_TRACKER_FIXTURE, 'cwd'), false);
+    assert.equal(Object.hasOwn(PACKED_CODEX_01445_NO_POINTER_NO_TRACKER_FIXTURE, 'thread_id'), false);
+    assert.equal(PACKED_CODEX_01445_NO_POINTER_NO_TRACKER_FIXTURE.session_id.includes('-'), true);
+});
+test('source parser regression keeps collaboration results authoritative over unrelated child prose', () => {
+    const successfulResponse = JSON.stringify({
+        success: true,
+        status: 'completed',
+        agents: [{ agent_name: '/root', agent_status: 'running' }],
+        output: 'Child succeeded; an optional adapter was unavailable, unsupported, and not found.',
+    });
+    for (const toolName of [
+        'collaboration.spawn_agent',
+        'collaboration.list_agents',
+        'collaborationlist_agents',
+        'collaboration.followup_task',
+        'collaboration.wait_agent',
+    ]) {
+        assert.equal(parseNativeSubagentResultDisposition(toolName, successfulResponse).kind, 'success', toolName);
+    }
+    const nestedLifecycleOnly = JSON.stringify({
+        agents: [
+            { agent_name: '/root', agent_status: 'running' },
+            {
+                agent_name: '/root/reviewer',
+                agent_status: { completed: 'Optional adapter is unavailable and unsupported.' },
+            },
+        ],
+    });
+    assert.equal(parseNativeSubagentResultDisposition('collaborationlist_agents', nestedLifecycleOnly).kind, 'unknown');
+});
 test('packed lifecycle keeps the pinned newline-delimited Codex app-server envelopes literal', () => {
     assert.deepEqual(createCodexInitializeEnvelope('omx-hook-trust-regression'), {
         id: 1,
@@ -547,18 +682,30 @@ test('packed lifecycle fails before probing the 33rd unique PATH candidate', asy
         return;
     const root = await mkdtemp(join(tmpdir(), 'omx-codex-candidate-budget-'));
     const candidateDirs = Array.from({ length: 33 }, (_value, index) => join(root, `candidate-${index}`));
-    const thirtyThirdProbe = join(root, '33rd-candidate-was-probed');
+    // Duplicate the first PATH entry twice to demonstrate that PATH de-duplication
+    // (by resolved candidate path) does not consume extra candidate-budget slots,
+    // while still preserving first-occurrence probing order.
+    const pathValue = [candidateDirs[0], candidateDirs[0], ...candidateDirs].join(delimiter);
+    const spawnedExecutables = [];
+    const spawnSyncImpl = ((command) => {
+        spawnedExecutables.push(command);
+        return { status: 1, stdout: '', stderr: '', error: undefined };
+    });
     try {
         await Promise.all(candidateDirs.map((dir) => mkdir(dir, { recursive: true })));
-        await Promise.all(candidateDirs.map(async (dir, index) => {
+        await Promise.all(candidateDirs.map(async (dir) => {
             const executable = join(dir, 'codex');
-            await writeFile(executable, index === candidateDirs.length - 1
-                ? `#!/bin/sh\n: > ${JSON.stringify(thirtyThirdProbe)}\nprintf '%s\\n' 'codex-cli 0.142.5'\n`
-                : '#!/bin/sh\nexit 1\n');
+            // These candidates are never actually executed: spawnSyncImpl is a
+            // deterministic seam that returns an immediate nonzero result without
+            // starting a real shell process. Only filesystem presence is real.
+            await writeFile(executable, '#!/bin/sh\nexit 1\n');
             await chmod(executable, 0o755);
         }));
-        assert.throws(() => probeCodexVersion(root, { PATH: candidateDirs.join(delimiter) }), /32-candidate PATH budget/);
-        await assert.rejects(access(thirtyThirdProbe));
+        assert.throws(() => probeCodexVersion(root, { PATH: pathValue }, { spawnSyncImpl }), /32-candidate PATH budget/);
+        assert.equal(spawnedExecutables.length, 32, 'must probe exactly 32 unique candidates before the budget error');
+        assert.deepEqual(spawnedExecutables, candidateDirs.slice(0, 32).map((dir) => join(dir, 'codex')), 'must probe unique candidates in PATH order, with the duplicated first entry counted only once');
+        const thirtyThirdExecutable = join(candidateDirs[32], 'codex');
+        assert.ok(!spawnedExecutables.includes(thirtyThirdExecutable), 'the 33rd unique candidate must never be spawned');
     }
     finally {
         await rm(root, { recursive: true, force: true });
@@ -662,6 +809,16 @@ test('display-order-stable foreign fixture preserves pre-approved group and hand
         { event: 'PreToolUse', groupIndex: 1, handlerIndex: 2 },
     ]);
 });
+test('packed install smoke probes every advertised plugin MCP target', () => {
+    assert.deepEqual(PACKED_INSTALL_PLUGIN_MCP_TARGETS, [
+        ['omx_state', 'state', 'omx-state'],
+        ['omx_memory', 'memory', 'omx-memory'],
+        ['omx_code_intel', 'code-intel', 'omx-code-intel'],
+        ['omx_trace', 'trace', 'omx-trace'],
+        ['omx_wiki', 'wiki', 'omx-wiki'],
+        ['omx_hermes', 'hermes', 'omx-hermes'],
+    ]);
+});
 test('packed install smoke covers every installed native hook event with minimal payloads', () => {
     assert.deepEqual(PACKED_INSTALL_NATIVE_HOOK_SMOKE_EVENTS, [
         'SessionStart',
@@ -789,13 +946,13 @@ test('packed install smoke covers directive activation and terminal false-activa
         { name: 'doc-preserves-earlier', prompt: 'Use autopilot mode; "note"; use $ralplan is the workflow command.', expectedSkill: 'autopilot', expectedStopBlock: true },
         { name: 'doc-colon-followup', prompt: 'use $ralplan is the workflow command: use $autopilot build it', expectedSkill: 'autopilot', expectedStopBlock: true },
         { name: 'table-followup', prompt: 'Mode | Meaning\n--- | ---\nmanual | documentation\n$ralplan plan it', expectedSkill: 'ralplan', expectedStopBlock: true },
-        { name: 'neg-advance-reopen', prompt: 'Do not run $ralplan but advance to $ultragoal', expectedSkill: 'ultragoal', expectedStopBlock: false },
-        { name: 'neg-jump-reopen', prompt: 'Do not run $ralplan but jump straight to $ultragoal', expectedSkill: 'ultragoal', expectedStopBlock: false },
+        { name: 'neg-advance-reopen', prompt: 'Do not run $ralplan but advance to $ultragoal', expectedSkill: 'ultragoal', expectedStopBlock: false, insideTmux: true },
+        { name: 'neg-jump-reopen', prompt: 'Do not run $ralplan but jump straight to $ultragoal', expectedSkill: 'ultragoal', expectedStopBlock: false, insideTmux: true },
         { name: 'reference-plain-title', prompt: '[docs]: /target "title\nplain text"\n$ralplan plan it', expectedSkill: 'ralplan', expectedStopBlock: true },
         { name: 'reference-plain-destination', prompt: '[docs]: ./target\n$ralplan plan it', expectedSkill: 'ralplan', expectedStopBlock: true },
         { name: 'directive-use-the', prompt: 'Do not run $ralplan; use the $autopilot build it', expectedSkill: 'autopilot', expectedStopBlock: true },
         { name: 'directive-continue-after-quote', prompt: '"quoted"\ncontinue with $ralplan', expectedSkill: 'ralplan', expectedStopBlock: true },
-        { name: 'doc-advance-followup', prompt: 'use $ralplan is the workflow command; advance to $ultragoal', expectedSkill: 'ultragoal', expectedStopBlock: false },
+        { name: 'doc-advance-followup', prompt: 'use $ralplan is the workflow command; advance to $ultragoal', expectedSkill: 'ultragoal', expectedStopBlock: false, insideTmux: true },
         { name: 'directive-run-code-review', prompt: 'run $code-review', expectedSkill: 'code-review', expectedStopBlock: false },
         { name: 'directive-documentation', prompt: 'use $ralplan is the consensus-planning command', expectedSkill: null, expectedStopBlock: false },
         { name: 'nested-bounded-child-unbounded-parent', prompt: '"`x`\n$ralplan plan it', expectedSkill: null, expectedStopBlock: false },
@@ -827,12 +984,27 @@ test('packed install smoke covers directive activation and terminal false-activa
         { name: 'percent-suffix', prompt: '$ralplan%docs', expectedSkill: null, expectedStopBlock: false },
         { name: 'fullwidth-percent-suffix', prompt: '$ralplan％docs', expectedSkill: null, expectedStopBlock: false },
         { name: 'g1a-ordered-multi-skill', prompt: '$ralplan, $autopilot; $team', expectedSkill: 'ralplan', expectedStopBlock: true, expectedDeferredSkills: ['autopilot', 'team'], expectedActiveSkills: ['ralplan'], insideTmux: true },
-        { name: 'g1c-duplicate-alias', prompt: '$autopilot $oh-my-codex:autopilot build it', expectedSkill: 'autopilot', expectedStopBlock: true, expectedDeferredSkills: [], expectedActiveSkills: ['autopilot'] },
+        { name: 'g1c-duplicate-alias', prompt: '$autopilot $oh-my-codex:autopilot build it', expectedSkill: 'autopilot', expectedStopBlock: true, expectedDeferredSkills: [], expectedActiveSkills: [] },
         { name: 'b3-longer-valid-fence', prompt: '```text\n$autopilot build it\n````\n$ralplan plan it', expectedSkill: 'ralplan', expectedStopBlock: true },
         { name: 'b4-shorter-invalid-fence', prompt: '````text\n$autopilot build it\n```\n$ralplan plan it', expectedSkill: null, expectedStopBlock: false },
         { name: 'b5-different-marker-invalid-fence', prompt: '```text\n$autopilot build it\n~~~\n$ralplan plan it', expectedSkill: null, expectedStopBlock: false },
     ]);
 });
+test('packed regression workflow expectations distinguish active activation from receipt-unavailable Autopilot termination', () => {
+    assert.doesNotThrow(() => assertPackedRegressionWorkflowState({ name: 'active-ralplan', expectedSkill: 'ralplan' }, { active: true, skill: 'ralplan' }));
+    assert.doesNotThrow(() => assertPackedRegressionWorkflowState({ name: 'failed-autopilot', expectedSkill: 'autopilot' }, {
+        active: false,
+        skill: 'autopilot',
+        phase: 'failed',
+        error: 'documented_host_consensus_receipt_unavailable',
+        active_skills: [],
+    }));
+    assert.throws(() => assertPackedRegressionWorkflowState({ name: 'stale-active-autopilot', expectedSkill: 'autopilot' }, { active: true, skill: 'autopilot', phase: 'running', active_skills: [{ skill: 'autopilot' }] }), /persisted unexpected workflow state/);
+});
+test('packed regression Stop expectations release terminal receipt-unavailable Autopilot state', () => {
+    assert.equal(shouldPackedRegressionStopBlock({ expectedSkill: 'ralplan', expectedStopBlock: true }), true);
+    assert.equal(shouldPackedRegressionStopBlock({ expectedSkill: 'autopilot', expectedStopBlock: true }), false);
+});
 test('packed regression environment clears inherited Team routing state', () => {
     const environment = buildPackedRegressionEnvironment({ name: 'poisoned-team-case', insideTmux: true }, {
         OMX_ROOT: '/tmp/poison-root',
@@ -881,6 +1053,27 @@ test('packed install native hook stdout validation enforces event output contrac
     }
     assert.throws(() => validateHookStdout('UserPromptSubmit', '{not json'), /native hook UserPromptSubmit emitted invalid JSON stdout/);
 });
+test('fake Codex launch capture preserves argv and runtime side-effect evidence', () => {
+    const capture = `${JSON.stringify({
+        argv: ['--', '--spark'],
+        cwd: '/tmp/omx-packed-launch',
+        hasResumeSqlite: true,
+        OMX_NOTIFY_TEMP_CONTRACT: null,
+        OMX_TEAM_WORKER_LAUNCH_ARGS: null,
+    })}\n`;
+    assert.deepEqual(parseFakeCodexLaunches(capture), [{
+            argv: ['--', '--spark'],
+            cwd: '/tmp/omx-packed-launch',
+            hasResumeSqlite: true,
+            OMX_NOTIFY_TEMP_CONTRACT: null,
+            OMX_TEAM_WORKER_LAUNCH_ARGS: null,
+        }]);
+    assert.throws(() => parseFakeCodexLaunches(`${JSON.stringify({
+        argv: ['--spark'],
+        cwd: '/tmp/omx-packed-launch',
+        OMX_NOTIFY_TEMP_CONTRACT: null,
+    })}\n`), /fake Codex capture did not contain a valid launch record/);
+});
 test('parseNpmPackJsonOutput ignores prepack logs before npm pack JSON', () => {
     const parsed = parseNpmPackJsonOutput([
         '[sync-plugin-mirror] synced 29 canonical skill directories and plugin metadata',
@@ -893,6 +1086,204 @@ test('parseNpmPackJsonOutput ignores prepack logs before npm pack JSON', () => {
     ].join('\n'));
     assert.deepEqual(parsed, [{ filename: 'oh-my-codex-0.15.0.tgz' }]);
 });
+test('packed install metadata requires runtime, declarations, Team skills, and plugin assets only', () => {
+    const files = PACKED_INSTALL_REQUIRED_ARTIFACT_PATHS.map((path) => ({ path }));
+    assert.doesNotThrow(() => assertPackedInstallFileMetadata(files));
+    assert.equal(PACKED_INSTALL_REQUIRED_ARTIFACT_PATHS.some((path) => path.startsWith('docs/')), false, 'repository documentation must not become an npm package requirement');
+    assert.throws(() => assertPackedInstallFileMetadata(files.slice(1)), /npm pack is missing required artifact: dist\/config\/models\.js/);
+    assert.throws(() => assertPackedInstallFileMetadata([...files, { path: 'docs/reference/omx-config-schema-routing.md' }]), /npm pack includes forbidden workspace artifact: docs\/reference\/omx-config-schema-routing\.md/);
+    for (const path of [
+        '.gjc/session/plan.md',
+        'docs/reference/page.md',
+        '.omx/state/team.json',
+        'artifact.tgz',
+        'tmp/smoke-output.txt',
+        'temp/smoke-output.json',
+        'scratch.tmp',
+    ]) {
+        assert.equal(isForbiddenPackedInstallArtifact(path), true, `expected ${path} to be rejected`);
+    }
+    for (const prefix of PACKED_INSTALL_FORBIDDEN_ARTIFACT_PATHS) {
+        assert.equal(isForbiddenPackedInstallArtifact(`${prefix}probe`), true);
+    }
+    assert.equal(isForbiddenPackedInstallArtifact('templates/AGENTS.md'), false);
+    assert.equal(isForbiddenPackedInstallArtifact('dist/notifications/__tests__/temp-mode.test.d.ts'), false);
+});
+test('packed install helpers enforce root rejection and no config mutation', () => {
+    const help = 'Usage: omx reasoning <low|medium|high|xhigh>\n  --xhigh\n';
+    assert.doesNotThrow(() => assertInstalledRootReasoningHelp(help));
+    assert.throws(() => assertInstalledRootReasoningHelp(`${help}  --max\n`), /must not advertise --max/);
+    const maxStderr = [
+        'Reasoning mode "max" is not supported by "omx reasoning".',
+        'Per-agent "max" is configured with agentReasoning; direct -c model_reasoning_effort=... is passed to Codex and remains capability-dependent.',
+        'Invalid reasoning mode "max". Expected one of: low, medium, high, xhigh.',
+        'Usage: omx reasoning <low|medium|high|xhigh>',
+    ].join('\n');
+    assert.doesNotThrow(() => assertInstalledRootReasoningRejection('max', { status: 1, stdout: '', stderr: maxStderr }, undefined, undefined));
+    assert.throws(() => assertInstalledRootReasoningRejection('max', { status: 1, stdout: '', stderr: maxStderr }, undefined, 'created'), /must not create or mutate config\.toml/);
+    const ultraStderr = [
+        'Reasoning mode "ultra" is not supported by OMX root or per-agent reasoning and is not an alias for "max".',
+        'Direct -c model_reasoning_effort=... remains opaque Codex passthrough.',
+        'Invalid reasoning mode "ultra". Expected one of: low, medium, high, xhigh.',
+        'Usage: omx reasoning <low|medium|high|xhigh>',
+    ].join('\n');
+    assert.doesNotThrow(() => assertInstalledRootReasoningRejection('ultra', { status: 1, stdout: '', stderr: ultraStderr }, 'model = "preserve"\n', 'model = "preserve"\n'));
+});
+test('packed install helpers freeze installed runtime and declaration reasoning contracts', () => {
+    const models = {
+        CANONICAL_REASONING_EFFORTS: ['low', 'medium', 'high', 'xhigh'],
+        AMBIGUOUS_UNSUPPORTED_REASONING_EFFORTS: ['max', 'ultra'],
+        PER_AGENT_REASONING_EFFORTS: ['low', 'medium', 'high', 'xhigh', 'max'],
+        ROOT_REASONING_EFFORTS: ['low', 'medium', 'high', 'xhigh'],
+        ROOT_UNSUPPORTED_REASONING_EFFORTS: ['max', 'ultra'],
+        isAmbiguousUnsupportedReasoningEffort: (value) => value.toLowerCase() === 'max' || value.toLowerCase() === 'ultra',
+        isUnsupportedRootReasoningEffort: (value) => value.toLowerCase() === 'max' || value.toLowerCase() === 'ultra',
+        normalizeUnsupportedRootReasoningEffort: (value) => {
+            const normalized = value.trim().toLowerCase();
+            return normalized === 'max' || normalized === 'ultra' ? normalized : undefined;
+        },
+    };
+    assert.doesNotThrow(() => assertInstalledReasoningRuntimeContract(models));
+    const modelsDeclaration = [
+        'export declare const CANONICAL_REASONING_EFFORTS: readonly ["low", "medium", "high", "xhigh"];',
+        'export type ConfiguredAgentReasoningEffort = (typeof CANONICAL_REASONING_EFFORTS)[number];',
+        'export declare const AMBIGUOUS_UNSUPPORTED_REASONING_EFFORTS: readonly ["max", "ultra"];',
+        'export declare const PER_AGENT_REASONING_EFFORTS: readonly ["low", "medium", "high", "xhigh", "max"];',
+        'export type PerAgentReasoningEffort = (typeof PER_AGENT_REASONING_EFFORTS)[number];',
+        'export declare const ROOT_REASONING_EFFORTS: readonly ["low", "medium", "high", "xhigh"];',
+        'export type RootReasoningEffort = (typeof ROOT_REASONING_EFFORTS)[number];',
+        'export declare const ROOT_UNSUPPORTED_REASONING_EFFORTS: readonly ["max", "ultra"];',
+        'export declare function isUnsupportedRootReasoningEffort(value: string): boolean;',
+        'export declare function normalizeUnsupportedRootReasoningEffort(value: string): RootUnsupportedReasoningEffort | undefined;',
+    ].join('\n');
+    const definitionsDeclaration = [
+        'export interface AgentDefinition {',
+        "  reasoningEffort: 'low' | 'medium' | 'high' | 'xhigh';",
+        '}',
+    ].join('\n');
+    assert.doesNotThrow(() => assertInstalledReasoningDeclarationContract({
+        models: modelsDeclaration,
+        definitions: definitionsDeclaration,
+        nativeConfig: 'export interface GeneratedNativeAgentConfig {\n  reasoningEffort?: PerAgentReasoningEffort;\n}',
+        team: 'export type TeamReasoningEffort = PerAgentReasoningEffort;',
+    }));
+    assert.throws(() => assertInstalledReasoningDeclarationContract({
+        models: modelsDeclaration.replace(': boolean;', ': value is RootUnsupportedReasoningEffort;'),
+        definitions: definitionsDeclaration,
+        nativeConfig: 'reasoningEffort?: PerAgentReasoningEffort;',
+        team: 'export type TeamReasoningEffort = PerAgentReasoningEffort;',
+    }), /plain boolean, not a type predicate/);
+});
+test('packed install removes same-user native-anchor authentication', async () => {
+    const hookSource = await readFile(join(process.cwd(), 'src/scripts/codex-native-hook.ts'), 'utf8');
+    const cliSource = await readFile(join(process.cwd(), 'src/cli/index.ts'), 'utf8');
+    assert.doesNotMatch(hookSource, /isVerifiedPluginLauncherClaim|classifyNativeTranscriptProvenance|signNativeLeaderAttestation|native-anchor-auth/);
+    assert.match(hookSource, /unsupported_documented_leader_proof/);
+    assert.match(cliSource, /execWithOverlay[\s\S]+OMX_CODEX_LAUNCH_ID[\s\S]+buildHudRuntimeEnv\(\{ sessionId/);
+});
+test('packed install contract requires canonical/plugin Team skill parity and text', async () => {
+    const canonical = await readFile(join(process.cwd(), 'skills/team/SKILL.md'));
+    const pluginMirror = await readFile(join(process.cwd(), 'plugins/oh-my-codex/skills/team/SKILL.md'));
+    assert.doesNotThrow(() => assertInstalledTeamSkillContract(canonical, pluginMirror));
+});
+test('packed install plugin assertions enforce the packaged plugin contract', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'omx-packed-plugin-surface-'));
+    try {
+        const pluginRoot = join(root, 'plugins/oh-my-codex');
+        const pluginManifestPath = join(pluginRoot, '.codex-plugin/plugin.json');
+        const mcpManifestPath = join(pluginRoot, '.mcp.json');
+        const appManifestPath = join(pluginRoot, '.app.json');
+        const hooksManifestPath = join(pluginRoot, 'hooks/hooks.json');
+        const hookLauncherPath = join(pluginRoot, 'hooks/codex-native-hook.mjs');
+        const hookCommand = 'node "${PLUGIN_ROOT}/hooks/codex-native-hook.mjs"';
+        await mkdir(join(pluginRoot, '.codex-plugin'), { recursive: true });
+        await mkdir(join(pluginRoot, 'hooks'), { recursive: true });
+        const writeValidPluginSurface = async () => {
+            await writeFile(pluginManifestPath, JSON.stringify({
+                name: 'oh-my-codex',
+                version: '0.0.0-test',
+                skills: './skills/',
+                mcpServers: './.mcp.json',
+                apps: './.app.json',
+                hooks: './hooks/hooks.json',
+                interface: {
+                    displayName: 'OMX',
+                    shortDescription: 'Test plugin',
+                    longDescription: 'Structurally valid plugin test fixture.',
+                    developerName: 'Test',
+                    category: 'Developer Tools',
+                },
+            }));
+            await writeFile(mcpManifestPath, JSON.stringify({
+                mcpServers: Object.fromEntries([
+                    ['omx_state', 'state'],
+                    ['omx_memory', 'memory'],
+                    ['omx_code_intel', 'code-intel'],
+                    ['omx_trace', 'trace'],
+                    ['omx_wiki', 'wiki'],
+                    ['omx_hermes', 'hermes'],
+                ].map(([name, service]) => [name, {
+                        command: 'omx',
+                        args: ['mcp-serve', service],
+                        enabled: false,
+                    }])),
+            }));
+            await writeFile(appManifestPath, JSON.stringify({ apps: {} }));
+            await writeFile(hooksManifestPath, JSON.stringify({
+                hooks: Object.fromEntries(PACKED_INSTALL_NATIVE_HOOK_SMOKE_EVENTS.map((eventName) => [eventName, [{
+                            hooks: [{ type: 'command', command: hookCommand }],
+                        }]])),
+            }));
+            await writeFile(hookLauncherPath, [
+                '#!/usr/bin/env node',
+                "import { spawn } from 'node:child_process';",
+                "import { join } from 'node:path';",
+                "const OMX_PLUGIN_HOOK_LAUNCHER_CONTRACT_MARKER = 'omx-plugin-hook-launcher:v1';",
+                "const OMX_PLUGIN_HOOK_ROUTING_ONLY_MARKER = 'omx-plugin-hook-routing-only:v1';",
+                "const hookDir = new URL('.', import.meta.url).pathname;",
+                'function readPinnedLauncher() {',
+                "  const launcherPath = join(hookDir, 'omx-command.json');",
+                '  return { command: process.execPath, argsPrefix: [], launcherPath };',
+                '}',
+                'const input = Buffer.from(\'\');',
+                'const { command, argsPrefix } = readPinnedLauncher();',
+                "const child = spawn(command, [...argsPrefix, 'codex-native-hook']);",
+                'child.stdin.end(input);',
+                '',
+            ].join('\n'));
+        };
+        await writeValidPluginSurface();
+        assert.doesNotThrow(() => assertInstalledPluginSurface(root));
+        await writeValidPluginSurface();
+        await writeFile(hookLauncherPath, [
+            '#!/usr/bin/env node',
+            "const OMX_PLUGIN_HOOK_LAUNCHER_CONTRACT_MARKER = 'omx-plugin-hook-launcher:v1';",
+            'process.stdout.write(OMX_PLUGIN_HOOK_LAUNCHER_CONTRACT_MARKER);',
+            '',
+        ].join('\n'));
+        assert.throws(() => assertInstalledPluginSurface(root), /must read its pinned omx-command\.json delegate configuration/);
+        await writeFile(pluginManifestPath, '{}');
+        assert.throws(() => assertInstalledPluginSurface(root), /plugin\.json\.name/);
+        await writeValidPluginSurface();
+        await writeFile(mcpManifestPath, JSON.stringify({ mcpServers: {} }));
+        assert.throws(() => assertInstalledPluginSurface(root), /omx_state/);
+        await writeValidPluginSurface();
+        await writeFile(appManifestPath, JSON.stringify({ apps: [] }));
+        assert.throws(() => assertInstalledPluginSurface(root), /\.app\.json\.apps/);
+        await writeValidPluginSurface();
+        await writeFile(hooksManifestPath, JSON.stringify({ hooks: {} }));
+        assert.throws(() => assertInstalledPluginSurface(root), /hook event is missing: SessionStart/);
+        await writeValidPluginSurface();
+        await writeFile(hookLauncherPath, 'export {};\n');
+        assert.throws(() => assertInstalledPluginSurface(root), /must start with a Node shebang/);
+        await writeValidPluginSurface();
+        await writeFile(mcpManifestPath, '{not-json');
+        assert.throws(() => assertInstalledPluginSurface(root), /plugin manifest is not parseable JSON/);
+    }
+    finally {
+        await rm(root, { recursive: true, force: true });
+    }
+});
 test('resolveGitCommonDir resolves relative git common dir output against the repo root', () => {
     const commonDir = resolveGitCommonDir('/tmp/worktree', () => ({
         status: 0,