Skip to content

Make Codex and Claude Code subscriptions go further: a local model router that gives routine agent work to economical models and keeps your strongest model for the hard parts.

31.7 KB
Raw Blame
#!/usr/bin/env python3
"""Test the native-context oracle and isolated fixture, without launching any Agent."""
import http.client
import io
import json
import os
from pathlib import Path
import subprocess
import sys
import tempfile
import threading
import unittest
from unittest.mock import Mock, patch

sys.dont_write_bytecode = True
REPO = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(REPO / 'crates/daemon/tests/support'))
import native_context_fixture as fixture
from native_context_product import assert_frozen_route, exact_history, publish_replacement_route, report_failure, save_context_source, wait_for_resumable_task
from publication_product import Product


class NativeContextOracleTests(unittest.TestCase):
    def setUp(self):
        self.temporary = tempfile.TemporaryDirectory()
        self.addCleanup(self.temporary.cleanup)
        self.root = Path(self.temporary.name)

    def test_product_does_not_inherit_native_context_overrides(self):
        keys = ('CLAUDE_CODE_AUTO_COMPACT_WINDOW', 'CLAUDE_CODE_MAX_CONTEXT_TOKENS',
                'CLAUDE_AUTOCOMPACT_PCT_OVERRIDE', 'CLAUDE_CODE_DISABLE_1M_CONTEXT',
                'CLAUDE_CODE_DISABLE_UNKNOWN_MODEL_WINDOW_ENFORCEMENT',
                'DISABLE_COMPACT', 'DISABLE_AUTO_COMPACT',
                'OPENCODE_CONFIG', 'OPENCODE_CONFIG_DIR', 'OPENCODE_CONFIG_CONTENT',
                'OPENCODE_DB')
        with patch.dict(os.environ, {key: 'host-context-override' for key in keys}):
            product = Product(REPO, root=self.root / 'isolated-context-product')
        try:
            self.assertTrue(all(key not in product.env for key in keys))
            self.assertEqual(Path(product.env['CLAUDE_CONFIG_DIR']),
                             product.root / 'home/.claude')
        finally:
            product.close()

    def test_product_listener_is_outside_the_hosts_outbound_ephemeral_range(self):
        product = Product(REPO, root=self.root / 'listener-product')
        try:
            bounds = (subprocess.check_output(['sysctl', '-n', 'net.inet.ip.portrange.first',
                       'net.inet.ip.portrange.last'], text=True).split() if sys.platform == 'darwin'
                      else Path('/proc/sys/net/ipv4/ip_local_port_range').read_text().split())
            first, last = map(int, bounds)
            self.assertFalse(first <= product.port <= last,
                             'a closed bind(0) probe can be stolen by a concurrent outbound client')
        finally:
            product.close()

    def test_product_listener_lease_survives_service_stop_and_releases_with_the_fixture(self):
        product = Product(REPO, root=self.root / 'lease-product')
        other_tmp = self.root / 'competing-run-tmp'
        other_tmp.mkdir()
        command = [sys.executable, '-B', '-c', '''
import sys
from unittest.mock import patch
sys.path.insert(0, sys.argv[1])
from publication_product import fixture_listener_port
with patch('publication_product.secrets.SystemRandom') as chooser:
    chooser.return_value.sample.return_value = [int(sys.argv[2])]
    try:
        lease, port = fixture_listener_port()
        lease.close()
        print('available')
    except RuntimeError as error:
        assert str(error) == 'no unoccupied fixture listener address available', str(error)
        print('leased')
''', str(REPO/'crates/daemon/tests/support'), str(product.port)]
        environment = dict(os.environ, TMPDIR=str(other_tmp))
        process = None
        try:
            # Exercise the actual nonempty stop branch with a bounded local process
            # that exits on the same shutdown pipe EOF as the real daemon.
            product.shutdown_r, product.shutdown_w = os.pipe()
            product.cap_r, product.cap_w = os.pipe()
            product.cap_ack_r, product.cap_ack_w = os.pipe()
            process = product.process = subprocess.Popen([sys.executable, '-c',
                'import os,sys; os.read(int(sys.argv[1]),1)', str(product.shutdown_r)],
                pass_fds=(product.shutdown_r,), stdout=subprocess.PIPE, stderr=subprocess.PIPE)
            product.stop()
            self.assertEqual(subprocess.check_output(command, text=True, env=environment).strip(), 'leased')
        finally:
            product.close()
            if process is not None:
                process.stdout.close()
                process.stderr.close()
        self.assertEqual(subprocess.check_output(command, text=True, env=environment).strip(), 'available')

    def context(self, harness):
        root = self.root / harness
        home, project = root / 'home', root / 'project'
        home.mkdir(parents=True)
        project.mkdir()
        config = home / ('.codex' if harness == 'codex' else '.claude')
        return fixture.prepare(home, config, project, harness)

    def body(self, value, results=None, prompt='Use the named native skills'):
        text = prompt + ' ' + ' '.join(skill['discovery'] for skill in value['skills'])
        results = results or {}
        if value['harness'] == 'codex':
            return {'model': 'gpt-5.4', 'tools': [{'name': 'exec_command'}], 'input': [
                {'role': 'user', 'content': text},
                *[{'type': 'function_call_output', 'call_id': key, 'output': output}
                  for key, output in results.items()]]}
        return {'model': 'gpt-5.4', 'tools': [{'name': 'Skill'}, {'name': 'Bash'}], 'messages': [
            {'role': 'user', 'content': text},
            {'role': 'user', 'content': [{'type': 'tool_result', 'tool_use_id': key, 'content': output}
                                       for key, output in results.items()]}]}

    def receipt(self, value):
        return ' '.join(skill[key] for skill in value['skills'] for key in ('contents', 'executed'))

    def test_old_private_context_fails_without_native_discovery(self):
        for harness in ('codex', 'claude'):
            value = self.context(harness)
            body = self.body(value)
            if harness == 'codex':
                body['input'][0]['content'] = 'Use native-context-user and native-context-project'
            else:
                body['messages'][0]['content'] = 'Use native-context-user and native-context-project'
            with self.assertRaisesRegex(AssertionError, 'native skill discovery missing'):
                fixture.decision(value, body)

    def test_discovery_alone_is_not_skill_execution(self):
        value = self.context('codex')
        action = fixture.decision(value, self.body(value))
        self.assertEqual(action['kind'], 'tool')
        self.assertEqual(action['id'], 'native_context_execute')
        self.assertNotIn(value['receipt'], json.dumps(action))

    def test_actual_fixture_scripts_produce_the_independent_receipts(self):
        value = self.context('codex')
        action = fixture.decision(value, self.body(value))
        # Only our two synthetic read-only scripts run; no Agent or product binary.
        result = subprocess.run(['/bin/sh', '-c', action['arguments']['cmd']],
                                check=True, capture_output=True, text=True)
        for skill in value['skills']:
            self.assertIn(skill['contents'], result.stdout)
            self.assertIn(skill['executed'], result.stdout)
        answer = fixture.decision(value, self.body(value, {'native_context_execute': result.stdout}))
        self.assertEqual(answer['text'], value['receipt'])
        fixture.assert_preserved(value)

    def test_wrong_tool_id_or_prompt_echo_cannot_prove_execution(self):
        value = self.context('codex')
        action = fixture.decision(value, self.body(value, {'wrong': self.receipt(value)}, self.receipt(value)))
        self.assertEqual(action['kind'], 'tool')
        with self.assertRaisesRegex(AssertionError, 'receipt mismatch'):
            fixture.decision(value, self.body(value, {'native_context_execute': 'done'}))

    def test_continue_requires_prior_correlated_tool_history(self):
        for harness in ('codex', 'claude'):
            value = self.context(harness)
            for result in ({}, {'wrong-id': self.receipt(value)}):
                with self.assertRaisesRegex(AssertionError, 'prior tool result'):
                    fixture.decision(value, self.body(value, result, fixture.CONTINUE_PROMPT + self.receipt(value)))
            action = fixture.decision(value, self.body(
                value, {'native_context_execute': self.receipt(value)}, fixture.CONTINUE_PROMPT))
            self.assertTrue(action['continued'])

    def test_claude_invokes_both_native_skills_before_shell(self):
        value = self.context('claude')
        results = {}
        for skill in value['skills']:
            action = fixture.decision(value, self.body(value, results))
            self.assertEqual(action['name'], 'Skill')
            self.assertEqual(action['arguments'], {'skill': skill['name']})
            results[action['id']] = skill['contents']
        action = fixture.decision(value, self.body(value, results))
        self.assertEqual(action['name'], 'Bash')

    def test_claude_missing_skill_tool_fails_closed(self):
        value = self.context('claude')
        body = self.body(value)
        body['tools'] = [{'name': 'Bash'}]
        with self.assertRaisesRegex(AssertionError, 'Skill tool unavailable'):
            fixture.decision(value, body)

    def test_failed_claude_tool_cannot_satisfy_continue(self):
        value = self.context('claude')
        body = self.body(value, {'native_context_execute': self.receipt(value)}, fixture.CONTINUE_PROMPT)
        body['messages'][-1]['content'][0]['is_error'] = True
        with self.assertRaisesRegex(AssertionError, 'prior tool result'):
            fixture.decision(value, body)

    def test_setup_refuses_existing_skill_and_preserves_neighbor(self):
        value = self.context('codex')
        with self.assertRaises(FileExistsError):
            fixture.prepare(value['home'], value['config'], value['project'], 'codex')
        fixture.assert_preserved(value)
        Path(value['skills'][0]['skill']).write_text('changed')
        with self.assertRaisesRegex(AssertionError, 'changed native user material'):
            fixture.assert_preserved(value)

    def test_native_session_identity_is_independent_of_task_identity(self):
        value = self.context('codex')
        root = Path(value['config']) / 'sessions'
        root.mkdir()
        history = root / 'rollout.jsonl'
        history.write_text(json.dumps({'type': 'session_meta', 'payload': {'id': 'original-native-session'}})
                           + '\n' + json.dumps({'type': 'assistant', 'text': value['receipt']}) + '\n')
        self.assertEqual(exact_history(value), (str(history), 'original-native-session'))
        (root / 'new-session.jsonl').write_text(history.read_text())
        with self.assertRaisesRegex(AssertionError, 'exactly the task native transcript'):
            exact_history(value)

    def test_protocol_events_contain_correlated_tool_and_terminal_frames(self):
        for harness, protocol in (('codex', 'responses'), ('claude', 'messages')):
            value = self.context(harness)
            body = self.body(value)
            action = fixture.decision(value, body)
            frames = fixture.events(body, action, protocol)
            self.assertIn(action['id'], json.dumps(frames))
            self.assertEqual(frames[-1][0], 'response.completed' if protocol == 'responses' else 'message_stop')

    def assert_native_wire(self, harness, protocol):
        value = self.context(harness)
        controls = self.root / harness
        (controls / 'native-context.json').write_text(json.dumps(value))
        server = fixture.NativeContextUpstream(controls)
        self.addCleanup(server.close)
        connection = http.client.HTTPConnection(*server.server.server_address, timeout=3)
        self.addCleanup(connection.close)
        for results in ({}, {'native_context_execute': self.receipt(value)}):
            connection.request('POST', '/v1/' + protocol, json.dumps(self.body(value, results)),
                               {'Authorization': 'Bearer ' + server.token})
            response = connection.getresponse()
            wire = response.read().decode()
            self.assertEqual(response.status, 200)
            self.assertEqual(response.getheader('Content-Type'), 'text/event-stream')
            frames = []
            for frame in wire.strip().split('\n\n'):
                fields = dict(line.split(': ', 1) for line in frame.splitlines())
                event, payload = fields['event'], json.loads(fields['data'])
                self.assertEqual(payload.get('type'), event, 'native SSE JSON lost its event discriminator')
                if protocol == 'responses':
                    self.assertEqual(payload.get('sequence_number'), len(frames))
                frames.append((event, payload))
            self.assertGreater(len(frames), 2)
            if protocol == 'responses':
                self.assertEqual(frames[-1][0], 'response.completed')
                self.assertEqual(frames[-1][1]['response']['status'], 'completed')
                terminal = frames[-1][1]['response']['output'][0]
                self.assertEqual(terminal['type'], 'message' if results else 'function_call')
                if results:
                    self.assertEqual(terminal['content'][0]['text'], value['receipt'])
            else:
                self.assertEqual(frames[-1][0], 'message_stop')
                self.assertEqual(frames[-2][1]['delta']['stop_reason'], 'end_turn' if results else 'tool_use')

    def test_responses_native_wire_has_typed_ordered_terminal_frames(self):
        self.assert_native_wire('codex', 'responses')

    def test_messages_native_wire_has_typed_terminal_frames(self):
        self.assert_native_wire('claude', 'messages')

    def test_length_terminal_waits_for_the_stream_prefix_witness(self):
        (self.root / 'native-context.json').write_text('{}')
        server = fixture.NativeContextUpstream(self.root)
        connection = http.client.HTTPConnection(*server.server.server_address, timeout=3)
        entered, release = threading.Event(), threading.Event()
        server.reply = lambda *_: dict(kind='text', text='incomplete attempt',
                                      recoverable_length=True, input_tokens=10000)

        def before_incomplete():
            entered.set()
            assert release.wait(3), 'stream prefix witness was never released'

        server.before_incomplete = before_incomplete
        try:
            connection.request('POST', '/v1/responses', json.dumps({'model': server.model}),
                               {'Authorization': 'Bearer ' + server.token})
            response = connection.getresponse()
            prefix = []
            while True:
                line = response.readline().decode()
                self.assertTrue(line, 'stream ended before the text prefix')
                prefix.append(line)
                if line.startswith('data: ') and 'response.output_text.delta' in line:
                    break
            self.assertIn('incomplete attempt', ''.join(prefix))
            self.assertNotIn('response.incomplete', ''.join(prefix))
            self.assertTrue(entered.wait(1), 'length terminal did not wait for its witness')
            release.set()
            self.assertIn('response.incomplete', response.read().decode())
        finally:
            release.set()
            connection.close()
            server.close()

    def test_loopback_server_rejects_wrong_route_and_records_old_context_red(self):
        value = self.context('codex')
        (self.root / 'native-context.json').write_text(json.dumps(value))
        server = fixture.NativeContextUpstream(self.root)
        self.addCleanup(server.close)
        connection = http.client.HTTPConnection(*server.server.server_address, timeout=3)
        self.addCleanup(connection.close)
        body = {'model': server.model, 'input': 'old private HOME', 'tools': []}
        connection.request('POST', '/v1/responses', json.dumps(body), {'Authorization': 'Bearer wrong'})
        response = connection.getresponse()
        self.assertEqual(response.status, 401)
        response.read()
        connection.request('POST', '/v1/responses', json.dumps(body), {'Authorization': 'Bearer ' + server.token})
        response = connection.getresponse()
        self.assertEqual(response.status, 400)
        response.read()
        recorded = json.loads((self.root / 'native-context-events.jsonl').read_text())
        self.assertEqual(recorded['state'], 'red')
        self.assertIn('discovery missing', recorded['reason'])

    def test_product_native_roots_do_not_escape_to_parent_configuration(self):
        with patch.dict(os.environ, {'CODEX_HOME': '/daily/codex', 'CLAUDE_CONFIG_DIR': '/daily/claude',
                                    'CLAUDE_CODE_OAUTH_TOKEN': 'synthetic-parent-token',
                                    'CODEX_CONFIG': 'synthetic-parent-config', 'AWS_PROFILE': 'daily',
                                    'QODER_CONFIG_DIR': '/daily/qoder',
                                    'PI_CODING_AGENT_DIR': '/daily/pi',
                                    'DEEPSEEK_API_KEY': 'synthetic-deepseek-secret',
                                    'GROQ_API_KEY': 'synthetic-groq-secret',
                                    'MISTRAL_API_KEY': 'synthetic-mistral-secret',
                                    'XAI_API_KEY': 'synthetic-xai-secret',
                                    'CEREBRAS_API_KEY': 'synthetic-cerebras-secret',
                                    'HIROUTE_WORKER_RECEIPT_DIR': '/daily/worker-receipts',
                                    'QODER_PERSONAL_ACCESS_TOKEN': 'synthetic-qoder-secret'}):
            product = Product(REPO, root=self.root / 'product')
        self.addCleanup(product.close)
        home = Path(product.env['HOME'])
        self.assertEqual(product.env['CODEX_HOME'], str(home / '.codex'))
        self.assertEqual(product.env['CLAUDE_CONFIG_DIR'], str(home / '.claude'))
        self.assertEqual(product.env['QODER_CONFIG_DIR'], str(home / '.qoder'))
        self.assertEqual(product.env['PI_CODING_AGENT_DIR'], str(home / '.pi/agent'))
        self.assertNotIn('HIROUTE_WORKER_RECEIPT_DIR', product.env)
        for key in ('CLAUDE_CODE_OAUTH_TOKEN', 'CODEX_CONFIG', 'AWS_PROFILE', 'QODER_PERSONAL_ACCESS_TOKEN',
                    'DEEPSEEK_API_KEY', 'GROQ_API_KEY', 'MISTRAL_API_KEY', 'XAI_API_KEY', 'CEREBRAS_API_KEY'):
            self.assertNotIn(key, product.env)

    def test_proxy_trap_records_any_method_without_request_content(self):
        trap = fixture.NativeProxyTrap(self.root / 'proxy-attempts.log')
        self.addCleanup(trap.close)
        connection = http.client.HTTPConnection(*trap.server.server_address, timeout=3)
        self.addCleanup(connection.close)
        for method in ('CONNECT', 'POST', 'CUSTOM_METHOD'):
            connection.request(method, '/synthetic-private-path', 'synthetic-private-body',
                               {'Proxy-Authorization': 'synthetic-private-token'})
            response = connection.getresponse()
            self.assertEqual(response.status, 502)
            response.read()
        self.assertEqual(trap.path.read_text(), 'proxy-request\n' * 3)

    def test_claude_proxy_conflict_is_live_and_part_of_preservation_verdict(self):
        value = self.context('claude')
        upstream = fixture.NativeContextUpstream(self.root)
        self.addCleanup(upstream.close)
        environment = fixture.install_proxy_conflict(value, upstream)
        self.assertEqual({environment[name] for name in ('HTTP_PROXY', 'HTTPS_PROXY', 'ALL_PROXY',
                                                         'http_proxy', 'https_proxy', 'all_proxy')},
                         {upstream.proxy_trap.url})
        self.assertEqual(environment['NO_PROXY'], environment['no_proxy'])
        self.assertNotIn('127.0.0.1', environment['NO_PROXY'])
        fixture.assert_preserved(value)
        connection = http.client.HTTPConnection(*upstream.proxy_trap.server.server_address, timeout=3)
        self.addCleanup(connection.close)
        connection.request('CONNECT', 'synthetic.invalid:443')
        response = connection.getresponse()
        response.read()
        with self.assertRaisesRegex(AssertionError, 'user-configured proxy'):
            fixture.assert_preserved(value)

    def test_native_sources_declare_a_budget_the_selected_client_can_admit(self):
        upstream = Mock(token='synthetic-token', model='synthetic-model')
        for harness, protocol, context_tokens in (('codex_cli', 'responses', 32768),
                ('claude_code', 'messages', 200000), ('qoder_cli', 'responses', 100000)):
            product = Mock(worker_work={'harness': harness, 'protocol': protocol})
            with patch('native_context_product.save_native_source', return_value={'binding_id': 'saved'}) as save:
                self.assertEqual(save_context_source(product, upstream, 'neighbor'), {'binding_id': 'saved'})
            self.assertEqual(save.call_args.kwargs['context_tokens'], context_tokens)
            self.assertEqual(save.call_args.kwargs['protocol'], protocol)
            self.assertEqual(save.call_args.kwargs['variant'], 'neighbor')

    def test_plan_replacement_changes_source_and_both_protocols_for_multi_protocol_agents(self):
        for index, (harness, worker, protocol) in enumerate((('codex','codex_cli','responses'),
                ('qoder','qoder_cli','responses'), ('qoder','qoder_cli','messages'),
                ('pi','pi','responses'), ('pi','pi','messages'))):
            root = self.root / str(index)
            root.mkdir()
            work = {'protocol':protocol, 'harness':worker}
            product = Mock(root=root, worker_work=work)
            product.preview.return_value = {'preview_id': 'new-route'}
            upstream = Mock(controls=root)
            with patch('native_context_product.NativeContextUpstream', return_value=upstream), \
                    patch('native_context_product.save_native_source', return_value={'binding_id': 'new-binding'}) as save, \
                    patch('native_context_product.plan_change', return_value={'change': 'new-route'}) as change:
                self.assertIs(publish_replacement_route(product, {'harness':harness}), upstream)
            expected = protocol if harness == 'codex' else ('messages' if protocol == 'responses' else 'responses')
            self.assertEqual(save.call_args.kwargs['protocol'], expected)
            self.assertEqual(change.call_args.kwargs['work']['protocol'], expected)
            self.assertEqual(product.worker_work, work)
            self.assertEqual(product.worker_work['protocol'], protocol)
            self.assertEqual(upstream.model, 'gpt-5.5')
            self.assertEqual(save.call_args.kwargs['upstream_model_id'], 'gpt-5.5')
            self.assertEqual(change.call_args.kwargs['candidates'], [{'binding_id': 'new-binding'}])
            product.apply.assert_called_once()

    def test_frozen_route_requires_old_source_traffic_and_rejects_new_route_traffic(self):
        replacement = Mock(controls=self.root)
        replacement.request_count.return_value = 0
        continued = {'state': 'green', 'continued': True}
        with self.assertRaisesRegex(AssertionError, 'original source'):
            assert_frozen_route([continued], 1, replacement)
        assert_frozen_route([continued], 0, replacement)
        with self.assertRaisesRegex(AssertionError, 'frozen protocol'):
            assert_frozen_route([dict(continued, protocol='messages')], 0, replacement, 'responses')
        assert_frozen_route([dict(continued, protocol='responses')], 0, replacement, 'responses')
        (self.root / 'native-context-events.jsonl').write_text(json.dumps(continued) + '\n')
        with self.assertRaisesRegex(AssertionError, 'newly published route'):
            assert_frozen_route([continued], 0, replacement)

    def test_frozen_route_rejects_attempts_even_when_the_new_source_rejects_them(self):
        continued = {'state': 'green', 'continued': True}
        for protocol in ('responses', 'messages'):
            for rejection, status in (('credential', 401), ('endpoint', 404), ('model', 400)):
                with self.subTest(protocol=protocol, rejection=rejection):
                    source = fixture.NativeContextUpstream(self.root)
                    connection = http.client.HTTPConnection(*source.server.server_address, timeout=3)
                    try:
                        assert_frozen_route([continued], 0, source)
                        connection.request('POST', '/v1/' + ('wrong' if rejection == 'endpoint' else protocol),
                            json.dumps({'model': 'wrong' if rejection == 'model' else source.model}),
                            {'Authorization': 'Bearer ' + ('wrong' if rejection == 'credential' else source.token)})
                        response = connection.getresponse()
                        response.read()
                        self.assertEqual(response.status, status)
                        self.assertEqual(source.request_count(), 1)
                        self.assertFalse((self.root / 'native-context-events.jsonl').exists())
                        with self.assertRaisesRegex(AssertionError, 'newly published route'):
                            assert_frozen_route([continued], 0, source)
                    finally:
                        connection.close()
                        source.close()

    def test_failed_journey_preserves_diagnostics_even_if_stop_fails(self):
        product = Mock(repo=self.root)
        product.stop.side_effect = RuntimeError('stop failure')
        product.preserve_diagnostics.return_value = {'state': 'complete', 'current_boot': 'this-boot'}
        report = {'scenario': 'native-case', 'worker_harness': 'codex'}
        with patch('sys.stdout', new_callable=io.StringIO) as output:
            report_failure(product, report, 'actual-failure-stage')
        emitted = json.loads(output.getvalue())
        self.assertEqual(emitted['stage'], 'actual-failure-stage')
        self.assertEqual(emitted['state'], 'red')
        self.assertEqual(emitted['daemon_stop_state'], 'failed')
        self.assertEqual(emitted['diagnostics']['current_boot'], 'this-boot')
        product.preserve_diagnostics.assert_called_once()

    def test_diagnostics_copy_error_preserves_red_stage_and_primary_exception(self):
        product = Mock(repo=self.root)
        product.preserve_diagnostics.side_effect = OSError('sensitive exception detail')
        report = {'scenario': 'native-case', 'worker_harness': 'claude'}
        with patch('sys.stdout', new_callable=io.StringIO) as output:
            with self.assertRaisesRegex(ValueError, 'primary failure'):
                try:
                    raise ValueError('primary failure')
                except ValueError:
                    report_failure(product, report, 'native-history')
                    raise
        emitted = json.loads(output.getvalue())
        self.assertEqual(emitted['state'], 'red')
        self.assertEqual(emitted['stage'], 'native-history')
        self.assertEqual(emitted['diagnostics'], {'state': 'unavailable', 'reason': 'diagnostics_io'})
        self.assertNotIn('sensitive', output.getvalue())

    def test_native_history_waits_for_public_cleanup_and_resume_eligibility(self):
        ready = {'task_id': 'task', 'latest_run_id': 'run',
                 'run': {'state': 'succeeded', 'cleanup': 'complete'}, 'resumable_until_ms': 2000}
        responses = [(0, {'data': {'tasks': [dict(ready, resumable_until_ms=None)]}}),
                     (0, {'data': {'tasks': [ready]}})]
        with patch('native_context_product.worker_cli', side_effect=responses) as read, \
                patch('native_context_product.time.sleep'), patch('native_context_product.time.time', return_value=1):
            self.assertEqual(wait_for_resumable_task(object(), 'task', 'run'), ready)
        self.assertEqual(read.call_count, 2)

    def test_missing_resume_eligibility_cannot_pass_just_because_history_exists(self):
        task = {'task_id': 'task', 'latest_run_id': 'run',
                'run': {'state': 'succeeded', 'cleanup': 'complete'}, 'resumable_until_ms': None}
        with patch('native_context_product.worker_cli', return_value=(0, {'data': {'tasks': [task]}})):
            with self.assertRaisesRegex(AssertionError, 'continuation did not become ready'):
                wait_for_resumable_task(object(), 'task', 'run', timeout=0)

    def test_fixture_new_skill_ancestors_are_private_under_group_writable_umask(self):
        previous = os.umask(0o002)
        try:
            value = self.context('codex')
        finally:
            os.umask(previous)
        for base in (Path(value['home']), Path(value['project'])):
            for relative in ('.agents', '.agents/skills'):
                self.assertEqual((base / relative).stat().st_mode & 0o777, 0o700)

    def test_fixture_never_chmods_an_existing_native_parent(self):
        parent = self.root / 'existing-native-root'
        parent.mkdir(mode=0o755)
        original_mode = parent.stat().st_mode
        fixture.write_new(parent / 'owned/subdirectory/file', 'owned')
        self.assertEqual(parent.stat().st_mode, original_mode)
        self.assertEqual((parent / 'owned').stat().st_mode & 0o777, 0o700)

    def test_user_skill_uses_the_selected_claude_root(self):
        home, project = self.root / 'home', self.root / 'workspace'
        home.mkdir()
        project.mkdir()
        selected = home / 'custom-native-configuration'
        value = fixture.prepare(home, selected, project, 'claude')
        self.assertEqual(Path(value['skills'][0]['skill']).parent.parent, (selected / 'skills').resolve())
        self.assertFalse((home / '.claude').exists())


class NativeProtocolWitnessTests(unittest.TestCase):
    def test_correlated_tool_results_follow_wire_protocol_not_agent_name(self):
        responses = {'input':[{'type':'function_call_output','call_id':'actual','output':'receipt'},
            {'role':'user','content':'prompt echo receipt'}]}
        messages = {'system':'not a tool result', 'messages':[
            {'role':'user','content':[{'type':'tool_result','tool_use_id':'actual','content':'receipt'},
                {'type':'tool_result','tool_use_id':'failed','content':'spoofed','is_error':True}]},
            {'role':'assistant','content':[{'type':'tool_result','tool_use_id':'spoof','content':'spoofed'}]}]}
        for harness in ('qoder','pi'):
            for body in (responses, messages):
                with self.subTest(harness=harness, body=body):
                    self.assertEqual(fixture.tool_results(body, harness), {'actual':'receipt'})

    def test_messages_text_and_skill_expansion_keep_content_and_exact_directory_guards(self):
        directory = Path('/fixture/skill')
        body = {'system':'system marker','messages':[
            {'role':'assistant','content':'Base directory for this skill: /fixture/skill\n\nwrong role'},
            {'role':'user','content':[{'type':'text','text':'Base directory for this skill: /fixture/skill-other\n\nwrong directory'}]},
            {'role':'user','content':[{'type':'text','text':'Base directory for this skill: /fixture/skill\n\nactual contents'}]}],
            'metadata':{'text':'not content'}}
        self.assertIn('system marker', fixture.native_text(body))
        self.assertIn('actual contents', fixture.native_text(body))
        self.assertNotIn('not content', fixture.native_text(body))
        self.assertEqual(list(fixture.qoder_skill_expansions(body, directory)), ['actual contents'])

    def test_messages_budget_keeps_the_same_frozen_limit_assertion(self):
        value = {'harness':'qoder','expected_max_output_tokens':4096,'skills':[], 'receipt':'done'}
        body = {'max_tokens':4096,'messages':[{'role':'user','content':[
            {'type':'tool_result','tool_use_id':'native_context_execute','content':'done'}]}]}
        self.assertEqual(fixture.decision(value, body)['text'], 'done')
        body['max_tokens'] = 8192
        with self.assertRaisesRegex(AssertionError, 'frozen source output budget'):
            fixture.decision(value, body)


if __name__ == '__main__':
    unittest.main()