diff --git a/docs/releases/2026-11-02-issue-2-startup-recovery.md b/docs/releases/2026-11-02-issue-2-startup-recovery.md index cbe4620..67b5ffd 100644 --- a/docs/releases/2026-11-02-issue-2-startup-recovery.md +++ b/docs/releases/2026-11-02-issue-2-startup-recovery.md @@ -100,7 +100,11 @@ cooperative close only after a terminal native error, an enabled exact-project main window, no other windows/prompts and no target database address. The worker then waits for normal process exit. Unknown/custom prompts and incomplete native operations receive no close action. A failure classification can coexist with -unreleased state; that state always stops the queue. A busy-project message in +unreleased state; that state always stops the queue. Terminal `DATABASE_BUSY` +errors also retain the native tool without close, reopen or queue continuation. +Unreadable, absent, hung or truncated initial Output waits within the deadline +and retains the tool without requesting Repair; a readable empty string is a +valid invocation baseline. A busy-project message in this fresh native process's initial loading Output prevents Repair invocation entirely; it is not hidden by the later invocation baseline. @@ -112,10 +116,17 @@ Only a conclusively failed, released, independently revalidated project-local target may allow the next CBB. Shared or unknown scope, busy owners, timeouts, unknown prompts and historical restores stop for review. +Before accepting native success, the parent validates native process identity +and true exit, exact project/database, empty address state, confirmed backup/ +repair evidence and absence of restore/failure/unknown-prompt contradictions. +Missing or wrong-typed fields fail closed. Independent process, address and +database-handle probes remain additional requirements. + Native `REPAIRED` is retained as `native_status`; summaries count a repair only after the same request reopens, completes Verify and returns authoritative `PASS/GREEN` with confirmed release. A failed reopen becomes -`REPAIR_VALIDATION_FAILED`; an unconfirmed native release prevents reopening. +`REPAIR_VALIDATION_FAILED`; incomplete or contradictory native success/release +becomes `UNCONFIRMED` and prevents reopening. Historical restoration remains `RESTORED_REVIEW_REQUIRED`. The original error, stage and evidence references, a `pre-repair-result.json` snapshot, native evidence and validation evidence remain attached even if the retry raises. @@ -139,3 +150,8 @@ Task 1 checks: full suite once, 532 passed with the existing pywinauto COM warni after the final initial-busy gate regression, the related final suite passed all 234 tests. Compileall and `git diff --check` passed. The coordinator will run candidate/frozen validation against the final implementation. + +Task 1 review fix round: 259 related tests passed (17.86s); compileall and +`git diff --check` passed. These checks include busy retention, real readback +failure branches, 30 malformed-success variants at both release and reopen/ +counting boundaries, and a complete actual worker-result replay control. diff --git a/src/cbb_refresh_verify/native_repair.py b/src/cbb_refresh_verify/native_repair.py index ee5b90e..9390c8d 100644 --- a/src/cbb_refresh_verify/native_repair.py +++ b/src/cbb_refresh_verify/native_repair.py @@ -140,7 +140,11 @@ def attempt_recovery(request, diagnosis, evidence_root, *, progress=None): callback = (lambda event: progress({'block': request.block_name, **event})) if progress else None record = run_native_repair(target, root, mentor_bin=request.mentor_bin, timeout_seconds=max(60, request.timeout_seconds), progress=callback) + native_status = record.get('status') record['release'] = repair_release_state(request, target, record) + if native_status == 'REPAIRED' and record['release']['safe_to_continue'] is not True: + record.update(status='UNCONFIRMED', native_status=native_status, + detail='NATIVE_REPAIR_EVIDENCE_UNCONFIRMED: 原生成功或释放证据不完整') record['evidence_path'] = str(root) except Exception as error: record['detail'] = str(error) @@ -148,14 +152,64 @@ def attempt_recovery(request, diagnosis, evidence_root, *, progress=None): return record +def _native_identity_and_exit_confirmed(target, record): + if not isinstance(record, dict): + return False + release = record.get('release') + if (not isinstance(release, dict) or release.get('safe_to_continue') is not True + or release.get('native_exited') is not True + or not isinstance(release.get('addresses'), list) or release['addresses'] + or type(record.get('native_pid')) is not int or record['native_pid'] <= 0 + or not isinstance(record.get('unknown_dialogs', []), list) + or record.get('unknown_dialogs')): + return False + try: + for name, expected in (('project', target.project), ('database', target.database)): + path = record.get(name) + if (not isinstance(path, str) or not Path(path).is_absolute() + or Path(path).resolve(strict=True) != expected.resolve(strict=True)): + return False + except (OSError, ValueError): + return False + return True + + +def native_success_confirmed(target, record): + """Validate the worker's complete, consistent success before any reopening.""" + if not _native_identity_and_exit_confirmed(target, record) or record.get('status') != 'REPAIRED': + return False + evidence = record.get('evidence') + if (not isinstance(evidence, dict) or evidence.get('confirmed') is not True + or evidence.get('native_backup') is not True + or evidence.get('outcome') != 'UNCONFIRMED' + or evidence.get('failure_complete') is not False + or evidence.get('restore_complete') is not False + or evidence.get('restored_from_backup') != ''): + return False + fields = ('diagnostic_tail', 'database_tail', 'restore_tail', 'output_tail') + if any(not isinstance(evidence.get(field), str) for field in fields): + return False + if not evidence['diagnostic_tail'] or not evidence['database_tail']: + return False + from .native_repair_ui import classify_repair_evidence + return (classify_repair_evidence(*(evidence[field] for field in fields))['outcome'] == 'UNCONFIRMED' + and 'iCDB database restored from backup:' not in evidence['restore_tail']) + + def repair_release_state(request, target, native_result): """Require normal exit, owner/address absence and exclusive database access.""" from .mentor_adapter import pcb_processes, _process_details from .icdb_ownership import database_directories, unreleased_addresses from .verify_runner import preflight - result = {**native_result.get('release', {}), 'safe_to_continue': False, + release = native_result.get('release') if isinstance(native_result, dict) else None + result = {**(release if isinstance(release, dict) else {}), 'safe_to_continue': False, 'database_exclusive': False} try: + if (not _native_identity_and_exit_confirmed(target, native_result) + or (native_result.get('status') == 'REPAIRED' + and not native_success_confirmed(target, native_result))): + result['error'] = 'NATIVE_REPAIR_EVIDENCE_UNCONFIRMED' + return result project, pcb = preflight(request) owners = [int(r[0]) for r in pcb_processes()] for name in ('LibraryManager.exe', 'iCDBProjectBackup.exe', 'ReuseBlockImporter.exe'): diff --git a/src/cbb_refresh_verify/native_repair_ui.py b/src/cbb_refresh_verify/native_repair_ui.py index 8f14966..1b4339d 100644 --- a/src/cbb_refresh_verify/native_repair_ui.py +++ b/src/cbb_refresh_verify/native_repair_ui.py @@ -237,7 +237,8 @@ def repair_worker_main(job_path): if busy_before_start: output = current_output result.update(status='DATABASE_BUSY', detail='原生工具加载工程时报告占用;未请求 Repair') - if not invoked and not busy_before_start and main and not dialogs and not unknown and main['enabled']: + if (not invoked and isinstance(current_output, str) and not busy_before_start + and main and not dialogs and not unknown and main['enabled']): if Path(job['cancel_signal']).exists(): raise ValueError('REPAIR_CANCELLED_BEFORE_START') output_baseline = current_output @@ -275,7 +276,8 @@ def repair_worker_main(job_path): if result['status'] == 'UNKNOWN_DIALOG' or busy_before_start: break if confirmed and not closing and main and not dialogs and main['enabled']: - if (not (database/'cdbsvr/sAddress.adr').exists() and ( + if (evidence['outcome'] != 'DATABASE_BUSY' + and not (database/'cdbsvr/sAddress.adr').exists() and ( evidence['failure_complete'] or evidence['confirmed'] or (evidence.get('restore_complete') and evidence['native_backup'] and evidence['outcome'] == 'UNCONFIRMED'))): diff --git a/src/cbb_refresh_verify/verify_runner.py b/src/cbb_refresh_verify/verify_runner.py index 74a838e..6b370bc 100644 --- a/src/cbb_refresh_verify/verify_runner.py +++ b/src/cbb_refresh_verify/verify_runner.py @@ -533,7 +533,19 @@ def run_verify(request, *, progress=None, flag_reader=None, process_runner=None, 'original_evidence': str(original.evidence_path), 'original_result_snapshot': str(snapshot), 'original_stage': original.error_stage, - 'native_status': recovery.get('status'), 'validation_passed': False} + 'native_status': recovery.get('native_status', recovery.get('status')), + 'validation_passed': False} + if recovery.get('status') == 'REPAIRED': + from .native_repair import native_success_confirmed, select_repair_target + try: + confirmed = native_success_confirmed(select_repair_target(request, diagnosis), recovery) + except (ValueError, OSError): + confirmed = False + if not confirmed: + release = recovery.get('release') + recovery.update(status='UNCONFIRMED', + release={**(release if isinstance(release, dict) else {}), 'safe_to_continue': False}, + detail='NATIVE_REPAIR_EVIDENCE_UNCONFIRMED: 原生成功记录不完整或矛盾,未重试校验') if (recovery.get('status') == 'REPAIRED' and recovery.get('release', {}).get('safe_to_continue') is True): result = replace(original, recovery_attempts=(recovery,)) @@ -552,9 +564,6 @@ def run_verify(request, *, progress=None, flag_reader=None, process_runner=None, stderr=(result.stderr+'\nREPAIR_VALIDATION_UNCONFIRMED: 未取得校验 GREEN').strip()) else: recovery['status'] = 'REPAIRED' - elif recovery.get('status') == 'REPAIRED': - recovery['status'] = 'REPAIR_RELEASE_UNCONFIRMED' - result = replace(result, safe_to_continue=False) else: # A failed local database must not block unrelated CBBs once # every owner is released. Re-check target ownership here so diff --git a/tests/test_native_repair.py b/tests/test_native_repair.py index bfad7bd..5485477 100644 --- a/tests/test_native_repair.py +++ b/tests/test_native_repair.py @@ -16,6 +16,19 @@ def target_fixture(tmp_path): return request(tmp_path), diagnosis, select_repair_target(request(tmp_path), diagnosis) +def complete_native_success(target): + """A complete successful worker result, with no contradictory native state.""" + return {'status': 'REPAIRED', 'project': str(target.project), 'database': str(target.database), + 'native_pid': 777, + 'release': {'native_exited': True, 'safe_to_continue': True, 'addresses': []}, + 'evidence': {'confirmed': True, 'native_backup': True, 'outcome': 'UNCONFIRMED', + 'failure_complete': False, 'restore_complete': False, 'restored_from_backup': '', + 'diagnostic_tail': 'Diagnostic: START\nDiagnostic: FINISH', + 'database_tail': f'{target.database}\niCDBProjectBackupRepair\nIC: Closing project', + 'restore_tail': '', 'output_tail': '', 'backup_log_tail': '', + 'log_paths': []}} + + def test_repair_target_matches_actual_database_not_guessed_cbb_name(tmp_path): request, record, target = target_fixture(tmp_path) assert target.project.name == 'CBB1.prj' @@ -135,8 +148,7 @@ def test_automatic_repair_retries_only_once_and_preserves_original_failure(tmp_p calls.append(req) return original monkeypatch.setattr(runner, '_run_verify_serialized', verify) - monkeypatch.setattr(native_repair, 'attempt_recovery', lambda *a, **kw: - {'status':'REPAIRED', 'release': {'safe_to_continue': True}}) + monkeypatch.setattr(native_repair, 'attempt_recovery', lambda *a, **kw: complete_native_success(target)) outcome = runner.run_verify(request) assert len(calls) == 2 assert outcome.status == 'FAIL' @@ -379,7 +391,7 @@ def repair_worker_fixture(tmp_path, monkeypatch, scenario): @pytest.mark.parametrize('scenario,expected,closed', [ - ('failed', 'MISSING_HEALTHY_BACKUP', True), ('busy', 'DATABASE_BUSY', True), + ('failed', 'MISSING_HEALTHY_BACKUP', True), ('busy', 'DATABASE_BUSY', False), ('unknown', 'UNKNOWN_DIALOG', False), ('custom_prompt', 'UNKNOWN_DIALOG', False), ('active', 'TIMEOUT_UNRELEASED', False), ('stale', 'TIMEOUT_UNRELEASED', False), ('address', 'MISSING_HEALTHY_BACKUP', False), @@ -399,6 +411,7 @@ def test_native_worker_closes_only_conclusively_failed_idle_tool(tmp_path, monke @pytest.mark.parametrize('scenario,expected', [('success', 'REPAIRED'), ('restore', 'RESTORED_REVIEW_REQUIRED')]) def test_native_worker_preserves_success_and_historical_restore_distinction(tmp_path, monkeypatch, scenario, expected): + from cbb_refresh_verify.native_repair import RepairTarget, native_success_confirmed ui, root, job, actions = repair_worker_fixture(tmp_path, monkeypatch, scenario) assert ui.repair_worker_main(job) == (0 if scenario == 'success' else 1) result = json.loads((root/'repair-result.json').read_text('utf-8')) @@ -407,6 +420,9 @@ def test_native_worker_preserves_success_and_historical_restore_distinction(tmp_ assert result['evidence']['native_backup'] is True assert result['evidence']['confirmed'] is (scenario == 'success') assert (root/'native-logs/dbcheck/new-777/log.txt').exists() + request = json.loads(job.read_text('utf-8')) + target = RepairTarget(Path(request['project']), Path(request['database'])) + assert native_success_confirmed(target, result) is (scenario == 'success') def test_native_busy_project_on_load_never_invokes_repair(tmp_path, monkeypatch): @@ -418,6 +434,80 @@ def test_native_busy_project_on_load_never_invokes_repair(tmp_path, monkeypatch) assert not result['release']['safe_to_continue'] +@pytest.mark.parametrize('readback', ['missing', 'timeout', 'truncated']) +def test_unavailable_initial_output_never_requests_or_confirms_repair(tmp_path, monkeypatch, readback): + from types import SimpleNamespace + from cbb_refresh_verify import native_repair_ui as module + actual_read = module._native_output + ui, root, job, actions = repair_worker_fixture(tmp_path, monkeypatch, 'active') + windows = ui._windows + def observe(pid): + result = windows(pid) + if readback != 'missing': + result[0]['children'].append({'hwnd': 400, 'class': 'RichEdit20A'}) + return result + monkeypatch.setattr(ui, '_windows', observe) + class Readback: + def __call__(self, hwnd, message, length, buffer, flags, timeout, copied): + if readback == 'timeout': return 0 + copied._obj.value = length-1 + return 1 + monkeypatch.setattr(ui.ctypes, 'WinDLL', lambda *a, **kw: SimpleNamespace(SendMessageTimeoutW=Readback())) + monkeypatch.setattr(ui, '_native_output', actual_read) + assert ui.repair_worker_main(job) == 1 + result = json.loads((root/'repair-result.json').read_text('utf-8')) + assert actions == [] + assert result['status'] == 'TIMEOUT_UNRELEASED' + assert result['release']['safe_to_continue'] is False + assert json.loads((root/'native-output.json').read_text('utf-8'))['baseline'] is None + + +def test_initial_output_waits_until_readable_and_accepts_empty_baseline(tmp_path, monkeypatch): + import win32con + ui, root, job, actions = repair_worker_fixture(tmp_path, monkeypatch, 'active') + reads = [] + def output(_): + reads.append(len(reads)) + if len(reads) <= 2: + assert not actions + return None + return '' + monkeypatch.setattr(ui, '_native_output', output) + assert ui.repair_worker_main(job) == 1 + assert actions == [(100, win32con.WM_COMMAND), (201, win32con.BM_CLICK)] + assert json.loads((root/'native-output.json').read_text('utf-8'))['baseline'] == '' + + +def test_invoked_busy_native_result_never_reopens_or_continues_queue(tmp_path, monkeypatch): + import win32con + from test_verify_runner import request + from cbb_refresh_verify import verify_runner as runner, native_repair + ui, root, job, actions = repair_worker_fixture(tmp_path, monkeypatch, 'busy') + assert ui.repair_worker_main(job) == 1 + busy = json.loads((root/'repair-result.json').read_text('utf-8')) + assert (100, win32con.WM_CLOSE) not in actions + assert busy['status'] == 'DATABASE_BUSY' and busy['release']['native_exited'] is False + req = request(tmp_path) + target = json.loads(job.read_text('utf-8')) + evidence = tmp_path/'first/result.json' + evidence.parent.mkdir() + (evidence.parent/'diagnostics').mkdir() + (evidence.parent/'diagnostics/icdb-recovery.json').write_text(json.dumps({ + 'error_code': 'ICDB_REPAIR_REQUIRED', 'scope': 'project', + 'session': 'original-session', 'database_path': target['database']})) + opens = [] + def verify(*a, **kw): + opens.append('open') + return runner.VerifyResult('FAIL', error_category='ICDB_REPAIR_REQUIRED', + safe_to_continue=False, evidence_path=evidence) + monkeypatch.setattr(runner, '_run_verify_serialized', verify) + monkeypatch.setattr(native_repair, 'attempt_recovery', lambda *a, **kw: busy) + results = runner.run_batch([req, req], verifier=runner.run_verify) + assert opens == ['open'] + assert results[0].recovery_attempts[0]['status'] == 'DATABASE_BUSY' + assert results[0].safe_to_continue is False and results[1].status == 'SKIPPED' + + @pytest.mark.parametrize('status,released,scope,expected', [ ('MISSING_HEALTHY_BACKUP', True, 'project', True), ('NATIVE_REPAIR_FAILED', True, 'project', True), @@ -425,6 +515,7 @@ def test_native_busy_project_on_load_never_invokes_repair(tmp_path, monkeypatch) ('MISSING_HEALTHY_BACKUP', True, 'central_library', False), ('MISSING_HEALTHY_BACKUP', True, 'unknown', False), ('UNKNOWN_DIALOG', True, 'project', False), ('TIMEOUT_UNRELEASED', True, 'project', False), + ('DATABASE_BUSY', True, 'project', False), ]) def test_failed_repair_continues_only_released_project_local_items( tmp_path, monkeypatch, status, released, scope, expected): @@ -473,8 +564,7 @@ def test_maintenance_counts_require_native_success_then_verify_green( calls.append(req) return original if len(calls) == 1 else validated monkeypatch.setattr(runner, '_run_verify_serialized', verify) - monkeypatch.setattr(native_repair, 'attempt_recovery', lambda *a, **kw: - {'status': 'REPAIRED', 'release': {'safe_to_continue': True}}) + monkeypatch.setattr(native_repair, 'attempt_recovery', lambda *a, **kw: complete_native_success(target)) result = runner.run_verify(request) assert len(calls) == 2 and calls[1].auto_repair is False assert result.recovery_attempts[0]['validation_passed'] is expected @@ -500,7 +590,7 @@ def test_native_success_without_release_does_not_reopen(tmp_path, monkeypatch): result = runner.run_verify(request) assert calls == ['open'] assert not result.safe_to_continue - assert result.recovery_attempts[0]['status'] == 'REPAIR_RELEASE_UNCONFIRMED' + assert result.recovery_attempts[0]['status'] == 'UNCONFIRMED' @pytest.mark.parametrize('obstacle', ['none', 'launcher', 'repair_tool', 'importer', 'address', 'handle', 'shared_handle', 'probe']) @@ -531,8 +621,7 @@ def test_repair_release_requires_process_address_and_database_handle_release(tmp database_file.touch() handle = win32file.CreateFile(str(database_file), win32con.GENERIC_READ, 0, None, win32con.OPEN_EXISTING, 0, None) - result = native_repair.repair_release_state(request, target, - {'release': {'safe_to_continue': True}}) + result = native_repair.repair_release_state(request, target, complete_native_success(target)) assert result['safe_to_continue'] is (obstacle == 'none') finally: if handle: handle.Close() @@ -547,7 +636,8 @@ def test_attempt_persists_distinct_native_failure_and_release_result(tmp_path, m monkeypatch.setattr(mentor_adapter, '_process_details', lambda *_: []) monkeypatch.setattr(native_repair, 'run_native_repair', lambda *a, **kw: { 'status': 'MISSING_HEALTHY_BACKUP', 'project': str(target.project), - 'database': str(target.database), 'release': {'safe_to_continue': True}, + 'database': str(target.database), 'native_pid': 777, + 'release': {'safe_to_continue': True, 'native_exited': True, 'addresses': []}, 'evidence': {'failure_complete': True, 'output_tail': 'no backup'}}) result = native_repair.attempt_recovery(request, diagnosis, evidence) assert result['status'] == 'MISSING_HEALTHY_BACKUP' @@ -572,14 +662,14 @@ def test_retry_exception_keeps_original_error_and_native_repair_evidence(tmp_pat return runner.VerifyResult('FAIL', stderr='original native error', safe_to_continue=False, error_category='ICDB_REPAIR_REQUIRED', evidence_path=evidence) monkeypatch.setattr(runner, '_run_verify_serialized', verify) - monkeypatch.setattr(native_repair, 'attempt_recovery', lambda *a, **kw: { - 'status': 'REPAIRED', 'release': {'safe_to_continue': True}, - 'evidence': {'confirmed': True, 'diagnostic_tail': 'original repair evidence'}}) + native_result = complete_native_success(target) + native_result['evidence']['diagnostic_tail'] += '\noriginal repair evidence' + monkeypatch.setattr(native_repair, 'attempt_recovery', lambda *a, **kw: native_result) result = runner.run_verify(request) assert not result.safe_to_continue assert 'original native error' in result.stderr assert 'retry infrastructure failure' in result.stderr - assert result.recovery_attempts[0]['evidence']['diagnostic_tail'] == 'original repair evidence' + assert 'original repair evidence' in result.recovery_attempts[0]['evidence']['diagnostic_tail'] assert result.recovery_attempts[0]['status'] == 'REPAIR_VALIDATION_FAILED' assert json.loads(evidence.read_text('utf-8'))['recovery_attempts'] @@ -637,8 +727,7 @@ def test_sanitized_field_open_failure_replay_closes_launcher_then_repairs_once(t assert trace[-1] == 'launcher_exited' assert not records and launcher.poll() == 0 trace.append('native_repair') - return {'status': 'REPAIRED', 'project': str(actual.project), 'database': str(actual.database), - 'release': {'safe_to_continue': True}, 'evidence': {'confirmed': True}} + return complete_native_success(actual) monkeypatch.setattr(runner, '_run_verify_serialized', verify) monkeypatch.setattr(native_repair, 'run_native_repair', repair) result = runner.run_verify(request) @@ -649,3 +738,76 @@ def test_sanitized_field_open_failure_replay_closes_launcher_then_repairs_once(t assert result.recovery_attempts[0]['status'] == 'REPAIR_VALIDATION_FAILED' assert result.recovery_attempts[0]['original_error'] == replay['native_error'] assert json.loads((tmp_path/'pre-repair-result.json').read_text('utf-8'))['stderr'] == replay['native_error'] + + +MALFORMED_SUCCESS = [ + ('minimal', None), + ('native_pid', None), ('native_pid', True), + ('project', None), ('project', '/CBB.prj'), ('project', []), + ('database', None), ('database', '/database'), + ('release', []), ('release', 'released'), + ('release.native_exited', None), ('release.native_exited', False), + ('release.native_exited', 1), ('release.native_exited', 'true'), + ('release.safe_to_continue', 1), ('release.addresses', ['owner']), ('release.addresses', ''), + ('evidence', None), ('evidence', []), ('evidence', 'confirmed'), + ('evidence.confirmed', None), ('evidence.confirmed', False), + ('evidence.confirmed', 1), ('evidence.confirmed', 'true'), + ('evidence.native_backup', False), ('evidence.failure_complete', True), + ('evidence.outcome', 'DATABASE_BUSY'), ('evidence.restore_complete', True), + ('evidence.restored_from_backup', 'old.zip'), ('unknown_dialogs', [{'title': 'Unknown'}]), +] + + +def malformed_native_success(target, key, value): + result = complete_native_success(target) + if key == 'minimal': return {'status': 'REPAIRED', 'release': {'safe_to_continue': True}} + if key in {'project', 'database'} and isinstance(value, str) and value.startswith(''): + other = target.project.parent.parent.parent/'other-target' + other.mkdir(exist_ok=True) + if key == 'project': + other = other/'other.prj' + other.touch() + value = str(other.resolve()) + if '.' in key: + parent, field = key.split('.') + result[parent][field] = value + else: + result[key] = value + return result + + +@pytest.mark.parametrize('key,value', MALFORMED_SUCCESS) +def test_malformed_native_success_never_authorizes_release(tmp_path, monkeypatch, key, value): + from cbb_refresh_verify import native_repair, mentor_adapter + request, diagnosis, target = target_fixture(tmp_path) + monkeypatch.setattr(mentor_adapter, 'pcb_processes', lambda: []) + monkeypatch.setattr(mentor_adapter, '_process_details', lambda *_: []) + result = native_repair.repair_release_state(request, target, malformed_native_success(target, key, value)) + assert result['safe_to_continue'] is False + + +@pytest.mark.parametrize('key,value', MALFORMED_SUCCESS) +def test_malformed_native_success_never_reopens_or_counts_repaired(tmp_path, monkeypatch, key, value): + from cbb_refresh_verify import verify_runner as runner, native_repair + from cbb_refresh_verify.icdb_maintenance import maintenance_counts + request, diagnosis, target = target_fixture(tmp_path) + evidence = tmp_path/'first/result.json' + evidence.parent.mkdir() + (evidence.parent/'diagnostics').mkdir() + (evidence.parent/'diagnostics/icdb-recovery.json').write_text(json.dumps(diagnosis)) + calls = [] + def verify(*a, **kw): + calls.append('open') + if len(calls) == 1: + return runner.VerifyResult('FAIL', stderr='original error', error_category='ICDB_REPAIR_REQUIRED', + safe_to_continue=False, evidence_path=evidence) + return runner.VerifyResult('PASS', library_flag='GREEN', evidence_path=evidence) + monkeypatch.setattr(runner, '_run_verify_serialized', verify) + monkeypatch.setattr(native_repair, 'attempt_recovery', lambda *a, **kw: + malformed_native_success(target, key, value)) + result = runner.run_verify(request) + assert calls == ['open'] + assert result.status == 'FAIL' and result.safe_to_continue is False + assert result.recovery_attempts[0]['status'] == 'UNCONFIRMED' + assert result.recovery_attempts[0]['release']['safe_to_continue'] is False + assert maintenance_counts([result])['repaired'] == 0