@@ -439,7 +439,11 @@ def test_unused_selected_static_archive_cannot_supply_link_identity(self):
         identity['archive']['members']['test/installed/consumer.cpp'] = compiled['sources'][str(unit)]
         identity['package'] = {p: bench.artifact(p)['sha256'] for p in identity['package']}
         artifacts = {str(p): bench.artifact(p) for p in directory.iterdir() if p.is_file()}
-        with self.assertRaisesRegex(ValueError, 'static archive'):
+        context = json.dumps(dict(compiled=compiled, identity=identity, artifacts=artifacts,
+            commands=commands, libraries=[bench.artifact(path) for path in libraries],
+            depfiles={str(path): path.read_text() for path in directory.glob('*.d')}),
+            indent=2, sort_keys=True)
+        with self.assertRaisesRegex(ValueError, 'static archive', msg=context):
             adapter.validate_compile(compiled, 'static', identity, artifacts, commands)
         # The same real consumer succeeds when the selected archive contributes.
         commands[1]['argv'].remove(libraries[0])
 
@@ -258,19 +258,29 @@ def test_explicit_tools_reach_real_make_and_python_compiler_checks(self):
     @unittest.skipIf(os.name == 'nt', 'selected make fixture requires POSIX scripts and GNU make')
     def test_native_fixture_uses_callers_selected_make_for_test_enumeration(self):
         with tempfile.TemporaryDirectory() as directory:
-            root = Path(directory)
-            make = root / 'caller-make'
-            real_make = os.environ.get('MAKE') or shutil.which('gmake') or shutil.which('make')
-            calls = root / 'make-calls.jsonl'
-            make.write_text('#!' + sys.executable + '\nimport json, os, sys\n' +
-                'with open(' + repr(str(calls)) + ', "a") as stream: stream.write(json.dumps(sys.argv[1:]) + "\\n")\n' +
-                'os.execv(' + repr(real_make) + ', [' + repr(real_make) + '] + sys.argv[1:])\n')
-            make.chmod(0o755)
-            with patch.dict(os.environ, MAKE=str(make)), self.assertRaises(self.NativeChecksComplete):
-                self.native_checks(root)
-            self.assertTrue(calls.is_file(), 'native fixture bypassed the caller-selected make')
-            invocations = [json.loads(line) for line in calls.read_text().splitlines()]
-            self.assertEqual(sum('--eval' in argv for argv in invocations), 2)
+            tools = Path(directory)
+            requested = os.environ.get('MAKE') or shutil.which('gmake') or shutil.which('make')
+            selected = shutil.which(requested)
+            self.assertIsNotNone(selected, 'caller-selected GNU make must be available')
+            (tools / 'gmake').symlink_to(selected)
+            for caller_make in (requested, 'gmake'):
+                with self.subTest(make=caller_make), tempfile.TemporaryDirectory() as fixture, \
+                        patch.dict(os.environ, MAKE=caller_make,
+                                   PATH=str(tools) + os.pathsep + os.environ['PATH']):
+                    root = Path(fixture)
+                    make = root / 'caller-make'
+                    real_make = shutil.which(os.environ['MAKE'])
+                    self.assertIsNotNone(real_make, 'caller-selected GNU make must be available')
+                    calls = root / 'make-calls.jsonl'
+                    make.write_text('#!' + sys.executable + '\nimport json, os, sys\n' +
+                        'with open(' + repr(str(calls)) + ', "a") as stream: stream.write(json.dumps(sys.argv[1:]) + "\\n")\n' +
+                        'os.execv(' + repr(real_make) + ', [' + repr(real_make) + '] + sys.argv[1:])\n')
+                    make.chmod(0o755)
+                    with patch.dict(os.environ, MAKE=str(make)), self.assertRaises(self.NativeChecksComplete):
+                        self.native_checks(root)
+                    self.assertTrue(calls.is_file(), 'native fixture bypassed the caller-selected make')
+                    invocations = [json.loads(line) for line in calls.read_text().splitlines()]
+                    self.assertEqual(sum('--eval' in argv for argv in invocations), 2)
 
     @unittest.skipIf(os.name == 'nt', 'selected tool retention fixture uses POSIX executable aliases')
     def test_archive_retains_compound_compilers_and_spaced_make_exact_bytes(self):
@@ -280,7 +290,7 @@ def test_archive_retains_compound_compilers_and_spaced_make_exact_bytes(self):
             sys.path.insert(0, str(ROOT / 'scripts/lib'))
             from release_platform import Catalog
             catalog = Catalog(root / 'output/bundle/FreeBSD')
-            for path in (root / 'selected python', root / 'compiler alias.py', root / 'selected compiler.py',
+            for path in (root / 'selected python', root / 'compiler alias.py',
                          root / 'selected cc', root / 'selected make'):
                 with self.subTest(path=path):
                     self.assertEqual(catalog.path(str(path)).read_bytes(), path.read_bytes())
 
@@ -0,0 +1,64 @@
+# FEATURE-ci-darwin-python-host-fixtures
+
+Status: In Progress
+Base: v3 `cf15f14590672c8fb461147635da3f535238692f`
+Plan: `.groundwork-plans/FEATURE-ci-darwin-python-host-fixtures-plan.md`
+Journal: `.debug/ci-6b2-darwin-python-assertions-wrzyeazd/journal.md` in the primary checkout.
+
+Correct the four established Python fixture assumptions from Darwin archive
+40072260645 / job 120808170836, preserving all production validation policies.
+The archive reported 232 passes, two skips and five Python module failures.
+
+- [x] Canonicalize the valid restored-corpus fixture root; retain restored input,
+  all seed bytes, seed 987, reproduction and deliberate symlink rejection checks.
+- [x] Resolve the caller-selected make executable before fixture `os.execv`;
+  exercise inherited selection and a real PATH-selected `MAKE=gmake`, retaining
+  both TLS modes and exact test-enumeration calls.
+- [x] Require retained compiler argument aliases and their resolved target bytes;
+  exercise the real orchestrator, child, make and retention under symlinked TMPDIR.
+- [x] Replace both host `/usr/bin/timeout` assumptions with controlled fixture
+  executables; retain the exact selected deadline command, 180-second argument,
+  failed native case logs and frozen receipt checks. Explicitly verify missing
+  deadline selection fails before any make command. These fixtures establish
+  command construction and availability, not native GNU timeout timing.
+- [x] Enrich the unchanged strict static-archive assertion with compiled dependency
+  hashes, source/package/archive identities, recorded commands, depfile contents
+  and selected/foreign library artifact hashes for future required CI evidence.
+- [x] Complete bounded local fixture verification, Python compilation and diff checks.
+- [ ] Complete caller-owned validation/finalization.
+
+## Verification and limits
+
+RED reproduced corpus-symlink rejection, the unrequested raw compiler-target
+catalog entry, basename `os.execv` failure, and both missing-host-deadline failures.
+The corresponding focused GREEN checks pass. Final affected-module runs all
+passed locally, without skips:
+
+| Command (python3) | Tests | Retained log |
+| --- | ---: | --- |
+| test/integ/protocol_fuzz_runner_test.py | 13 | final-fuzz.log |
+| scripts/test-v3-platform-ci.py | 20 | final-platform.log |
+| test/integ/release_gate_runner_test.py | 47 | final-release-gates.log |
+| scripts/test-v3-packaged-adapters.py | 42 | final-adapters.log |
+| test/integ/release_artifact_test.py | 15 | final-release-artifact.log |
+
+All five changed Python modules passed `python3 -m py_compile` and
+`git diff --check` passed. No Python linter is documented; the project's cpplint
+command applies to C++ sources, which this task does not change. Logs are retained
+in the task worktree at `build/ci-darwin-python-host-fixtures/`. Local success is
+not native Darwin evidence, and does not close its unknown adapter failure.
+
+The adapter's Darwin `private or foreign dependency` failure remains UNKNOWN and
+its native gate INCOMPLETE. Its fixture root was already canonical; the native
+receipt did not retain the unexpected dependency input. The assertion still
+requires `ValueError` matching `static archive`; real compiler/archive/link-map
+negative and positive controls remain unchanged. Diagnostic context is evidence
+only and does not establish a fix. Next required CI on the approved correction
+head owns native input capture. No standalone Darwin adapter replay is authorized.
+
+Darwin, Windows and FreeBSD checks remain CI/v3-PR owned and unexecuted locally.
+Remote 6b2 CI is preserved; no push, cancellation or publication is part of this
+implementation. The prior epoll batch exhausted its 64-execution budget, remains
+CLOSED with unknown causality, and receives no additional execution or probes.
+The older closed investigations remain closed. No production library, runner,
+workflow, build configuration, identity or deadline policy is changed.
@@ -208,7 +208,7 @@ def test_seed_and_corpus_arguments_reject_invalid_inputs_before_compilation(self
     def test_restored_corpus_is_merged_without_following_links_or_overwriting_seeds(self):
         import os
         with tempfile.TemporaryDirectory() as directory:
-            location = pathlib.Path(directory)
+            location = pathlib.Path(directory).resolve()
             compiler = location / 'compiler'
             compiler.write_text("#!/usr/bin/env python3\nimport pathlib,sys\n"
                 "if '--version' in sys.argv: print('recorder'); sys.exit()\n"
 
@@ -123,6 +123,14 @@ def check_fixture(self, script, *cases):
                                     capture_output=True, text=True, timeout=60)
             self.assertEqual(result.returncode, 0, result.stdout + result.stderr)
 
+    def test_restored_corpus_through_symlinked_tmpdir(self):
+        self.check_fixture('test/integ/protocol_fuzz_runner_test.py',
+            'FuzzRunnerTest.test_restored_corpus_is_merged_without_following_links_or_overwriting_seeds')
+
+    def test_selected_compiler_retention_through_symlinked_tmpdir(self):
+        self.check_fixture('scripts/test-v3-platform-ci.py',
+            'SelectedPlatformEnvironment.test_archive_retains_compound_compilers_and_spaced_make_exact_bytes')
+
     def test_archive_parity_through_symlinked_tmpdir(self):
         self.check_fixture('test/integ/release_artifact_test.py', 'ArchiveContracts')
 
 
@@ -7,6 +7,7 @@
 import os
 from pathlib import Path
 import re
+import shlex
 import shutil
 import subprocess
 import sys
@@ -339,6 +340,39 @@ def test_tag_check_rejects_receipt_from_another_gate(self):
         manifest['stages'][0]['receipt']['gate'] = 'parity'
         with self.assertRaises(ValueError): self.gate.check_tag_ready(manifest)
 
+    def test_native_fixtures_do_not_require_a_host_timeout_installation(self):
+        from unittest.mock import patch
+        import release_execution
+        find_tool = shutil.which
+
+        def without_host_timeout(command, *args, **kwargs):
+            if command in ('/usr/bin/timeout', 'timeout', 'gtimeout'):
+                return None
+            return find_tool(command, *args, **kwargs)
+
+        cases = ('test_cxx_gate_bounds_each_native_test_before_waiting_for_aggregate',
+                 'test_package_receipt_survives_later_native_build_and_check')
+        for case in cases:
+            with self.subTest(case=case):
+                fixture = type(self)(case)
+                fixture.setUp()
+                self.addCleanup(fixture.doCleanups)
+                with patch.object(release_execution.shutil, 'which', side_effect=without_host_timeout):
+                    getattr(fixture, case)()
+
+    def test_native_check_rejects_missing_deadline_before_make(self):
+        from types import SimpleNamespace
+        from release_execution import ReleaseAttempt
+        args = SimpleNamespace(output=self.directory, compiler=sys.executable, cc=sys.executable,
+            make=sys.executable, provider_prefix=self.directory, asan_options='detect_leaks=0', jobs=1,
+            test_timeout_tool=str(self.directory / 'missing deadline'))
+        attempt = ReleaseAttempt(args, self.gate, {})
+        logs = self.directory / 'logs'; logs.mkdir()
+        commands = self.gate.Commands(logs)
+        with self.assertRaisesRegex(ValueError, 'required per-test deadline tool unavailable'):
+            attempt.native_check(commands, self.directory, attempt.env, 10)
+        self.assertEqual(commands.records, [])
+
     def test_cxx_gate_bounds_each_native_test_before_waiting_for_aggregate(self):
         from types import SimpleNamespace
         from release_execution import ReleaseAttempt
@@ -348,16 +382,20 @@ def test_cxx_gate_bounds_each_native_test_before_waiting_for_aggregate(self):
                         'Path("test/integ/native_case.log").write_text("actual failed case witness")\n'
                         'Path("test/integ/native_case.trs").write_text(":test-result: FAIL\\n")\n'
                         'raise SystemExit(2)\n'); make.chmod(0o755)
+        # This fixture checks command arguments; its make never executes LOG_COMPILER.
+        deadline = self.directory / 'selected deadline'
+        deadline.write_text('#!/bin/sh\nexit 99\n'); deadline.chmod(0o755)
         args = SimpleNamespace(output=self.directory / 'attempt', compiler=sys.executable, cc=sys.executable,
-            make=str(make), provider_prefix=self.directory, asan_options='detect_leaks=0', jobs=1, test_timeout_tool='/usr/bin/timeout')
+            make=str(make), provider_prefix=self.directory, asan_options='detect_leaks=0', jobs=1, test_timeout_tool=str(deadline))
         attempt = ReleaseAttempt(args, self.gate, {'stages': []}); attempt.source = ROOT
         lane = args.output / 'package/evidence/tls-no'; build = lane / 'build'
         (build / 'src').mkdir(parents=True); (build / 'config.h').write_text('/* TLS off */')
         (build / 'src/Makefile').write_text('abs_top_srcdir = ' + str(ROOT) + '\n')
         logs = self.directory / 'build-logs'; logs.mkdir()
         command = self.gate.Commands(logs)
-        with self.assertRaises(ValueError): attempt.cxx(command, 'no')
-        self.assertIn('LOG_COMPILER=/usr/bin/timeout --kill-after=5s 180s', command.records[0]['argv'])
+        with self.assertRaisesRegex(ValueError, 'command exited 2'): attempt.cxx(command, 'no')
+        self.assertIn('LOG_COMPILER=' + shlex.join([str(deadline), '--kill-after=5s', '180s']),
+                      command.records[0]['argv'])
         self.assertEqual((logs / 'native-tests/integ/native_case.log').read_text(), 'actual failed case witness')
         self.assertEqual((logs / 'native-tests/integ/native_case.trs').read_text(), ':test-result: FAIL\n')
 
@@ -740,10 +778,17 @@ def package(command):
         make.write_text('#!' + sys.executable + '\nfrom pathlib import Path\n'
             'Path("test/.deps/case.Po").write_text("compiled dependencies")\n'
             'Path("test/test-suite.log").write_text("# TOTAL: 1\\n# PASS: 1\\n# SKIP: 0\\n# XFAIL: 0\\n# FAIL: 0\\n# XPASS: 0\\n# ERROR: 0\\n")\n')
-        make.chmod(0o755); args.make = str(make); args.test_timeout_tool = '/usr/bin/timeout'
+        make.chmod(0o755); args.make = str(make)
+        # Only availability and command construction are under test, not timeout timing.
+        deadline = self.directory / 'selected deadline'
+        deadline.write_text('#!/bin/sh\nexit 99\n'); deadline.chmod(0o755)
+        args.test_timeout_tool = str(deadline)
         logs = output / 'later-native'; logs.mkdir()
         native, _ = attempt.normal_build('no')
-        attempt.native_check(self.gate.Commands(logs), native, attempt.env, 10)
+        command = self.gate.Commands(logs)
+        attempt.native_check(command, native, attempt.env, 10)
+        self.assertIn('LOG_COMPILER=' + shlex.join([str(deadline), '--kill-after=5s', '180s']),
+                      command.records[0]['argv'])
         checks = self.gate.load_runner('lib/release_checks.py')
         self.assertEqual(checks.automake_result(native, 'Linux')['tests'], 1)
         self.assertEqual((build / 'test/.deps/case.Po').read_text(), 'compiled dependencies')