oh-my-codex 0.20.3 → 0.20.5

package/src/scripts/__tests__/smoke-packed-install.test.ts

@@ -7,6 +7,7 @@ import { delimiter, join } from 'node:path';
 import { PassThrough } from 'node:stream';
 import { test } from 'node:test';
 import {
+  assertPackedLaunchCwdPreserved,
   assertInstalledPluginSurface,
   assertInstalledReasoningDeclarationContract,
   assertInstalledReasoningRuntimeContract,
@@ -14,9 +15,11 @@ import {
   assertInstalledRootReasoningRejection,
   assertInstalledTeamSkillContract,
   assertPackedInstallFileMetadata,
+  assertPackedRegressionWorkflowState,
   buildNativeHookSmokePayload,
   ensureRepoDependencies,
   hasUsableNodeModules,
+  buildPackedProbeEnv,
   buildPackedRegressionEnvironment,
   CODEX_APP_SERVER_TIMEOUTS,
   CodexAppServer,
@@ -41,9 +44,13 @@ import {
   parseNpmPackJsonOutput,
   parseCodexHooksListResult,
   probeCodexVersion,
+  parseArgs,
   resolveGitCommonDir,
   resolveReusableNodeModulesSource,
+  replacePathKeyCaseInsensitive,
+  resolvePackedSmokeRuntimeBinary,
   validateHookStdout,
+  shouldPackedRegressionStopBlock,
   assertCodexBatchWriteResult,
   assertGeneratedTrustMatchesCodex,
   managedCodexHooksByEvent,
@@ -65,6 +72,126 @@ function createFakeCodexAppServer(
 }
 
 
+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'],
@@ -98,20 +225,33 @@ test('packed 0.144.5 fixture is sanitized, pointer-free, and kept separate from
   assert.equal(PACKED_CODEX_01445_NO_POINTER_NO_TRACKER_FIXTURE.session_id.includes('-'), true);
 });
 
-test('packed plugin collaboration success stays authoritative over unrelated child prose', () => {
-  const packedResponse = JSON.stringify({
+test('source parser regression keeps collaboration results authoritative over unrelated child prose', () => {
+  const successfulResponse = JSON.stringify({
     success: true,
     status: 'completed',
-    output: 'Packed/plugin child succeeded; an optional adapter was unavailable, unsupported, and not found.',
+    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, packedResponse).kind, 'success', toolName);
+    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', () => {
@@ -714,24 +854,40 @@ test('packed lifecycle fails before probing the 33rd unique PATH candidate', asy
   if (process.platform === 'win32') 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: string[] = [];
+  const spawnSyncImpl = ((command: string) => {
+    spawnedExecutables.push(command);
+    return { status: 1, stdout: '', stderr: '', error: undefined };
+  }) as never;
   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) }),
+      () => probeCodexVersion(root, { PATH: pathValue }, { spawnSyncImpl }),
       /32-candidate PATH budget/,
     );
-    await assert.rejects(access(thirtyThirdProbe));
+    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 });
   }
@@ -990,13 +1146,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 },
@@ -1028,13 +1184,39 @@ 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 },
@@ -1265,6 +1447,14 @@ test('packed install helpers freeze installed runtime and declaration reasoning
   );
 });
 
+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'));
@@ -1325,6 +1515,7 @@ test('packed install plugin assertions enforce the packaged plugin contract', as
         "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');",

package/src/scripts/__tests__/verify-native-release-assets.test.ts

@@ -0,0 +1,240 @@
+import assert from 'node:assert/strict';
+import { spawnSync } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { PassThrough } from 'node:stream';
+import { gzipSync } from 'node:zlib';
+import { describe, it } from 'node:test';
+import { compress as xzCompress } from '@napi-rs/lzma/xz';
+import * as tar from 'tar-stream';
+import * as yazl from 'yazl';
+import { fileURLToPath } from 'node:url';
+
+function sha256(value: Buffer): string {
+  return createHash('sha256').update(value).digest('hex');
+}
+
+function verify(manifest: string, artifacts: string) {
+  return spawnSync(process.execPath, [fileURLToPath(new URL('../verify-native-release-assets.js', import.meta.url)), '--manifest', manifest, '--artifacts-dir', artifacts], { encoding: 'utf-8' });
+}
+
+async function collect(stream: NodeJS.ReadableStream): Promise<Buffer> {
+  const output: Buffer[] = [];
+  for await (const chunk of stream) output.push(Buffer.from(chunk));
+  return Buffer.concat(output);
+}
+
+async function tarArchive(entries: Array<{ name: string; data?: Buffer; type?: tar.Headers['type']; linkname?: string }>, format: 'tar.gz' | 'tar.xz'): Promise<Buffer> {
+  const archive = tar.pack();
+  for (const item of entries) {
+    const header: tar.Headers = { name: item.name, type: item.type ?? 'file', size: item.data?.length ?? 0, linkname: item.linkname };
+    if ((item.type ?? 'file') === 'file') archive.entry(header, item.data ?? Buffer.alloc(0));
+    else archive.entry(header);
+  }
+  archive.finalize();
+  const raw = await collect(archive);
+  return format === 'tar.gz' ? gzipSync(raw) : xzCompress(raw);
+}
+
+async function zipArchive(entries: Array<{ name: string; data?: Buffer }>): Promise<Buffer> {
+  const archive = new yazl.ZipFile();
+  for (const item of entries) {
+    if (item.name.endsWith('/')) archive.addEmptyDirectory(item.name);
+    else archive.addBuffer(item.data ?? Buffer.alloc(0), item.name);
+  }
+  archive.end();
+  return collect(archive.outputStream);
+}
+
+function crc32(value: Buffer): number {
+  let crc = 0xffffffff;
+  for (const byte of value) {
+    crc ^= byte;
+    for (let bit = 0; bit < 8; bit += 1) crc = (crc >>> 1) ^ (-(crc & 1) & 0xedb88320);
+  }
+  return (crc ^ 0xffffffff) >>> 0;
+}
+
+function rawZip(name: string, mode: number, dosAttributes = 0, data = Buffer.alloc(0)): Buffer {
+  const fileName = Buffer.from(name);
+  const crc = crc32(data);
+  const local = Buffer.alloc(30);
+  local.writeUInt32LE(0x04034b50, 0);
+  local.writeUInt16LE(20, 4);
+  local.writeUInt32LE(crc, 14);
+  local.writeUInt32LE(data.length, 18);
+  local.writeUInt32LE(data.length, 22);
+  local.writeUInt16LE(fileName.length, 26);
+
+  const central = Buffer.alloc(46);
+  central.writeUInt32LE(0x02014b50, 0);
+  central.writeUInt16LE((3 << 8) | 20, 4);
+  central.writeUInt16LE(20, 6);
+  central.writeUInt32LE(crc, 16);
+  central.writeUInt32LE(data.length, 20);
+  central.writeUInt32LE(data.length, 24);
+  central.writeUInt16LE(fileName.length, 28);
+  central.writeUInt32LE((((mode & 0xffff) << 16) | dosAttributes) >>> 0, 38);
+
+  const directoryOffset = local.length + fileName.length + data.length;
+  const end = Buffer.alloc(22);
+  end.writeUInt32LE(0x06054b50, 0);
+  end.writeUInt16LE(1, 8);
+  end.writeUInt16LE(1, 10);
+  end.writeUInt32LE(central.length + fileName.length, 12);
+  end.writeUInt32LE(directoryOffset, 16);
+  return Buffer.concat([local, fileName, data, central, fileName, end]);
+}
+
+function manifestFor(archive: string, content: Buffer, overrides: Record<string, unknown> = {}) {
+  return {
+    manifest_version: 1,
+    version: '0.8.15',
+    tag: 'v0.8.15',
+    assets: [{
+      product: 'omx-api', version: '0.8.15', platform: 'linux', arch: 'x64', target: 'x86_64-unknown-linux-musl', libc: 'musl',
+      archive, binary: 'omx-api', binary_path: 'omx-api', sha256: sha256(content), size: content.length,
+      download_url: `https://example.invalid/${archive}`,
+      ...overrides,
+    }],
+  };
+}
+
+async function verifyArchive(root: string, archive: string, content: Buffer, overrides: Record<string, unknown> = {}, manifestOverrides: Record<string, unknown> = {}) {
+  await writeFile(join(root, archive), content);
+  const manifest = join(root, `${archive}.manifest.json`);
+  await writeFile(manifest, JSON.stringify({ ...manifestFor(archive, content, overrides), ...manifestOverrides }));
+  return verify(manifest, root);
+}
+
+describe('verify-native-release-assets', () => {
+  it('accepts tar.gz, tar.xz, and zip archives with one wrapped regular binary', async () => {
+    const wd = await mkdtemp(join(tmpdir(), 'omx-verify-native-release-'));
+    try {
+      for (const format of ['tar.gz', 'tar.xz', 'zip'] as const) {
+        const artifacts = join(wd, format.replace('.', '-'));
+        await mkdir(artifacts, { recursive: true });
+        const archive = `omx-api-x86_64-unknown-linux-musl.${format}`;
+        const content = format === 'zip'
+          ? await zipArchive([{ name: 'wrapper/', data: Buffer.alloc(0) }, { name: 'wrapper/omx-api', data: Buffer.from('x') }])
+          : await tarArchive([{ name: 'wrapper/', type: 'directory' }, { name: 'wrapper/omx-api', data: Buffer.from('x') }], format);
+        assert.equal((await verifyArchive(artifacts, archive, content)).status, 0, format);
+      }
+    } finally {
+      await rm(wd, { recursive: true, force: true });
+    }
+  });
+
+  it('accepts full-release siblings with logical Windows binary names and executable paths', async () => {
+    const wd = await mkdtemp(join(tmpdir(), 'omx-verify-native-release-full-'));
+    try {
+      const apiArchive = 'omx-api-x86_64-pc-windows-msvc.zip';
+      const runtimeArchive = 'omx-runtime-x86_64-pc-windows-msvc.zip';
+      const apiBytes = await zipArchive([{ name: 'omx-api.exe', data: Buffer.from('api') }]);
+      const runtimeBytes = await zipArchive([{ name: 'omx-runtime.exe', data: Buffer.from('runtime') }]);
+      await writeFile(join(wd, apiArchive), apiBytes);
+      await writeFile(join(wd, runtimeArchive), runtimeBytes);
+      const asset = (product: string, archive: string, binaryPath: string, content: Buffer) => ({
+        product,
+        version: '0.20.3',
+        platform: 'win32',
+        arch: 'x64',
+        target: 'x86_64-pc-windows-msvc',
+        archive,
+        binary: product,
+        binary_path: binaryPath,
+        sha256: sha256(content),
+        size: content.length,
+        download_url: `https://example.invalid/${archive}`,
+      });
+      const manifestPath = join(wd, 'native-release-manifest.json');
+      await writeFile(manifestPath, JSON.stringify({
+        manifest_version: 1,
+        version: '0.20.3',
+        tag: 'v0.20.3',
+        assets: [
+          asset('omx-api', apiArchive, 'omx-api.exe', apiBytes),
+          asset('omx-runtime', runtimeArchive, 'omx-runtime.exe', runtimeBytes),
+        ],
+      }));
+      const result = verify(manifestPath, wd);
+      assert.equal(result.status, 0, result.stderr || result.stdout);
+    } finally {
+      await rm(wd, { recursive: true, force: true });
+    }
+  });
+
+  it('rejects unsafe unrelated paths and links before selecting a binary', async () => {
+    const wd = await mkdtemp(join(tmpdir(), 'omx-verify-native-release-unsafe-'));
+    try {
+      for (const [index, unsafe] of ['../escape', '/absolute', 'C:/drive', 'dir\\backslash'].entries()) {
+        const archive = `unsafe-${index}.tar.gz`;
+        const content = await tarArchive([{ name: 'omx-api', data: Buffer.from('x') }, { name: unsafe, data: Buffer.from('x') }], 'tar.gz');
+        assert.notEqual((await verifyArchive(wd, archive, content)).status, 0, unsafe);
+      }
+      const linked = await tarArchive([{ name: 'omx-api', data: Buffer.from('x') }, { name: 'link', type: 'symlink', linkname: 'omx-api' }], 'tar.gz');
+      assert.notEqual((await verifyArchive(wd, 'linked.tar.gz', linked)).status, 0);
+    } finally {
+      await rm(wd, { recursive: true, force: true });
+    }
+  });
+
+  it('rejects ZIP entries with contradictory Unix types and directory markers', async () => {
+    const wd = await mkdtemp(join(tmpdir(), 'omx-verify-native-release-zip-types-'));
+    try {
+      const malformed = [
+        rawZip('regular/', 0o100644),
+        rawZip('regular', 0o100644, 0x10),
+        rawZip('directory', 0o040755),
+      ];
+      for (const [index, content] of malformed.entries()) {
+        assert.notEqual((await verifyArchive(wd, `zip-types-${index}.zip`, content)).status, 0);
+      }
+    } finally {
+      await rm(wd, { recursive: true, force: true });
+    }
+  });
+
+  it('rejects ambiguous, colliding, and zero-byte selected members', async () => {
+    const wd = await mkdtemp(join(tmpdir(), 'omx-verify-native-release-selection-'));
+    try {
+      const cases = [
+        await tarArchive([{ name: 'one/omx-api', data: Buffer.from('x') }, { name: 'two/omx-api', data: Buffer.from('x') }], 'tar.gz'),
+        await tarArchive([{ name: 'omx-api', data: Buffer.from('x') }, { name: 'omx-api/config', data: Buffer.from('x') }], 'tar.gz'),
+        await tarArchive([{ name: 'omx-api', data: Buffer.alloc(0) }], 'tar.gz'),
+      ];
+      for (const [index, content] of cases.entries()) {
+        assert.notEqual((await verifyArchive(wd, `selection-${index}.tar.gz`, content)).status, 0);
+      }
+    } finally {
+      await rm(wd, { recursive: true, force: true });
+    }
+  });
+
+  it('enforces manifest version, target, libc, and basename coherence', async () => {
+    const wd = await mkdtemp(join(tmpdir(), 'omx-verify-native-release-manifest-'));
+    try {
+      const content = await tarArchive([{ name: 'omx-api', data: Buffer.from('x') }], 'tar.gz');
+      const invalid = [
+        [{}, { manifest_version: undefined }],
+        [{}, { version: 'v0.8.15', tag: 'vv0.8.15' }],
+        [{}, { tag: 'v0.8.16' }],
+        [{ platform: 'darwin', arch: 'x64', target: 'x86_64-apple-darwin', libc: 'musl' }, {}],
+        [{ product: 'omx-unknown' }, {}],
+        [{ binary: 'omx-api.exe' }, {}],
+        [{ binary_path: '../omx-api' }, {}],
+        [{ archive: 'nested/omx-api-x86_64-unknown-linux-musl.tar.gz' }, {}],
+        [{ archive: 'omx-api-x86_64-unknown-linux-musl.tar.bz2' }, {}],
+        [{ archive: 'omx-api-x86_64-unknown-linux-gnu.tar.gz' }, {}],
+        [{ archive: 'omx-api-aarch64-unknown-linux-musl.tar.gz' }, {}],
+      ] as const;
+      for (const [index, [assetOverrides, documentOverrides]] of invalid.entries()) {
+        assert.notEqual((await verifyArchive(wd, `manifest-${index}.tar.gz`, content, assetOverrides, documentOverrides)).status, 0);
+      }
+    } finally {
+      await rm(wd, { recursive: true, force: true });
+    }
+  });
+});