from __future__ import annotations import json import os from pathlib import Path import sqlite3 import pytest from dx_productivity.trial_task_center.errors import TaskCenterError from dx_productivity.trial_task_center.logging_setup import configure_logging from dx_productivity.trial_task_center.models import ProjectStatus, TaskStatus import dx_productivity.trial_task_center.runner as runner_module from dx_productivity.trial_task_center.runner import TrialRunner from dx_productivity.trial_task_center.store import TaskStore FIXTURES = Path(__file__).parents[1] / "fixtures" / "trial_task_center" def _write_profile(name: str, destination: Path, project: Path) -> None: profile = json.loads((FIXTURES / name).read_text(encoding="utf-8")) profile["project"]["identity"] = str(project) destination.write_text(json.dumps(profile), encoding="utf-8") def _runner_with_selected_projects(tmp_path: Path, count: int = 1) -> tuple[TrialRunner, TaskStore, str, tuple[str, ...]]: store = TaskStore(tmp_path / "task-center.db") task = store.create_task("Trial") store.add_rule(task.task_id, "OLD-1", "NEW-1") root = tmp_path / "projects" root.mkdir() paths = [] for number in range(count): path = root / f"project-{number + 1}.prj" path.write_text("project", encoding="utf-8") paths.append(path) projects = store.sync_projects(task.task_id, root, paths) for project in projects: store.set_project_selected(project.project_id, True) probe_source = tmp_path / "menu-probe-default.json" probe_source.write_text("baseline", encoding="utf-8") return ( TrialRunner( store, configure_logging(tmp_path / "logs"), probe_source_resolver=lambda _task, _project: probe_source, ), store, task.task_id, tuple(project.project_id for project in projects), ) def _runner_with_probe_source( tmp_path: Path, count: int = 1 ) -> tuple[TrialRunner, TaskStore, str, tuple[str, ...], Path]: runner, store, task_id, project_ids = _runner_with_selected_projects(tmp_path, count) probe_source = tmp_path / "menu-probe.json" probe_source.write_text("baseline", encoding="utf-8") return ( TrialRunner( store, configure_logging(tmp_path / "logs"), probe_source_resolver=lambda _task, _project: probe_source, ), store, task_id, project_ids, probe_source, ) def test_start_requires_disposable_confirmation_and_activates_exact_first_selected_project(tmp_path: Path) -> None: """Removing the confirmation or choosing an unselected project must block the trial.""" runner, store, task_id, project_ids = _runner_with_selected_projects(tmp_path, count=2) store.set_project_selected(project_ids[0], False) with pytest.raises(TaskCenterError) as raised: runner.start_task(task_id, disposable_copy_confirmed=False) assert raised.value.code == "disposable_copy_required" snapshot = runner.start_task(task_id, disposable_copy_confirmed=True) assert snapshot.task.status is TaskStatus.RUNNING assert snapshot.active_project is not None assert snapshot.active_project.project_id == project_ids[1] assert snapshot.active_project.status is ProjectStatus.CAPTURING_BEFORE def test_before_capture_supplies_project_and_matching_rules_to_operator(tmp_path: Path) -> None: """A before profile must be captured before native replacement guidance is shown.""" runner, store, task_id, (project_id,) = _runner_with_selected_projects(tmp_path) project = store.list_projects(task_id)[0] probe = tmp_path / "before.json" _write_profile("profile-before.json", probe, project.path) runner.start_task(task_id, disposable_copy_confirmed=True) snapshot = runner.capture_before(task_id, project_id, probe) assert snapshot.active_project is not None assert snapshot.active_project.status is ProjectStatus.AWAITING_OPERATOR assert snapshot.instruction is not None assert snapshot.instruction.project_path == project.path assert [(rule.old_part_number, rule.new_part_number, rule.match_count) for rule in snapshot.instruction.rules] == [ ("OLD-1", "NEW-1", 1) ] assert snapshot.evidence_directory.joinpath("before.json").exists() def test_operator_confirmation_does_not_mark_project_successful(tmp_path: Path) -> None: """Changing confirmation into completion would let an assertion bypass machine verification.""" runner, store, task_id, (project_id,) = _runner_with_selected_projects(tmp_path) project = store.list_projects(task_id)[0] before = tmp_path / "before.json" _write_profile("profile-before.json", before, project.path) runner.start_task(task_id, disposable_copy_confirmed=True) runner.capture_before(task_id, project_id, before) snapshot = runner.confirm_native_attempt(task_id, project_id) assert snapshot.task.status is TaskStatus.RUNNING assert snapshot.active_project is not None assert snapshot.active_project.status is ProjectStatus.AWAITING_OPERATOR assert store.get_task(task_id).status is not TaskStatus.COMPLETED def test_fresh_after_capture_that_passes_completes_project_and_advances_queue(tmp_path: Path) -> None: """Skipping comparison or next-project activation would leave verified work unsafe or stranded.""" runner, store, task_id, project_ids = _runner_with_selected_projects(tmp_path, count=2) first, second = (store.list_projects(task_id)[index] for index in range(2)) before = tmp_path / "before.json" after = tmp_path / "after.json" _write_profile("profile-before.json", before, first.path) _write_profile("profile-after-valid.json", after, first.path) runner.start_task(task_id, disposable_copy_confirmed=True) runner.capture_before(task_id, project_ids[0], before) runner.confirm_native_attempt(task_id, project_ids[0]) snapshot = runner.capture_after(task_id, project_ids[0], after) assert store.list_projects(task_id)[0].status is ProjectStatus.COMPLETED assert snapshot.task.status is TaskStatus.RUNNING assert snapshot.active_project is not None assert snapshot.active_project.project_id == second.project_id assert snapshot.active_project.status is ProjectStatus.CAPTURING_BEFORE def test_hard_comparison_failure_keeps_project_failed_and_task_failed(tmp_path: Path) -> None: """Treating a hard profile mismatch as success would violate the trial safety gate.""" runner, store, task_id, (project_id,) = _runner_with_selected_projects(tmp_path) project = store.list_projects(task_id)[0] before = tmp_path / "before.json" after = tmp_path / "after.json" _write_profile("profile-before.json", before, project.path) _write_profile("profile-after-invalid.json", after, project.path) runner.start_task(task_id, disposable_copy_confirmed=True) runner.capture_before(task_id, project_id, before) with pytest.raises(TaskCenterError) as raised: runner.capture_after(task_id, project_id, after) assert raised.value.code == "comparison_failed" assert store.list_projects(task_id)[0].status is ProjectStatus.FAILED assert store.get_task(task_id).status is TaskStatus.FAILED def test_paused_commit_still_records_a_failed_comparison_as_task_failure(tmp_path: Path) -> None: """Leaving a paused task nonfailed after a rejected commit would hide a hard safety failure.""" runner, store, task_id, (project_id,) = _runner_with_selected_projects(tmp_path) project = store.list_projects(task_id)[0] before = tmp_path / "before.json" after = tmp_path / "after.json" _write_profile("profile-before.json", before, project.path) _write_profile("profile-after-invalid.json", after, project.path) runner.start_task(task_id, disposable_copy_confirmed=True) runner.capture_before(task_id, project_id, before) runner.pause_task(task_id) with pytest.raises(TaskCenterError, match="comparison_failed"): runner.capture_after(task_id, project_id, after) assert store.list_projects(task_id)[0].status is ProjectStatus.FAILED assert store.get_task(task_id).status is TaskStatus.FAILED def test_pause_prevents_next_project_then_resume_reactivates_it(tmp_path: Path) -> None: """Starting another project while paused would defeat the operator's pause request.""" runner, store, task_id, project_ids = _runner_with_selected_projects(tmp_path, count=2) first = store.list_projects(task_id)[0] before = tmp_path / "before.json" after = tmp_path / "after.json" _write_profile("profile-before.json", before, first.path) _write_profile("profile-after-valid.json", after, first.path) runner.start_task(task_id, disposable_copy_confirmed=True) runner.capture_before(task_id, project_ids[0], before) runner.pause_task(task_id) paused = runner.capture_after(task_id, project_ids[0], after) assert paused.task.status is TaskStatus.PAUSED assert paused.active_project is None assert store.list_projects(task_id)[1].status is ProjectStatus.PENDING resumed = runner.resume_task(task_id) assert resumed.task.status is TaskStatus.RUNNING assert resumed.active_project is not None assert resumed.active_project.project_id == project_ids[1] def test_retry_uses_new_attempt_directory_and_skip_finishes_queue(tmp_path: Path) -> None: """Reusing a failed attempt's evidence or failing to finish skipped work loses auditability.""" runner, store, task_id, (project_id,) = _runner_with_selected_projects(tmp_path) project = store.list_projects(task_id)[0] before = tmp_path / "before.json" after = tmp_path / "after.json" _write_profile("profile-before.json", before, project.path) _write_profile("profile-after-invalid.json", after, project.path) runner.start_task(task_id, disposable_copy_confirmed=True) runner.capture_before(task_id, project_id, before) with pytest.raises(TaskCenterError): runner.capture_after(task_id, project_id, after) failed_directory = runner.snapshot(task_id).evidence_directory retried = runner.retry_project(task_id, project_id) assert retried.active_project is not None assert retried.evidence_directory != failed_directory assert retried.evidence_directory.name == "attempt-2" completed = runner.skip_project(task_id, project_id) assert store.list_projects(task_id)[0].status is ProjectStatus.SKIPPED assert completed.task.status is TaskStatus.COMPLETED def test_passing_final_project_completes_the_task(tmp_path: Path) -> None: """Omitting terminal task completion would strand a verified one-project trial.""" runner, store, task_id, (project_id,) = _runner_with_selected_projects(tmp_path) project = store.list_projects(task_id)[0] before = tmp_path / "before.json" after = tmp_path / "after.json" _write_profile("profile-before.json", before, project.path) _write_profile("profile-after-valid.json", after, project.path) runner.start_task(task_id, disposable_copy_confirmed=True) runner.capture_before(task_id, project_id, before) completed = runner.capture_after(task_id, project_id, after) assert completed.task.status is TaskStatus.COMPLETED assert completed.active_project is None def test_restart_recovery_uses_store_state_and_records_transition_events(tmp_path: Path) -> None: """A restarted process must recover durable work instead of trusting a stale runner instance.""" runner, store, task_id, (project_id,) = _runner_with_selected_projects(tmp_path) runner.start_task(task_id, disposable_copy_confirmed=True) restarted = TrialRunner(store, configure_logging(tmp_path / "logs")) snapshot = restarted.snapshot(task_id) events = [ json.loads(line) for line in (tmp_path / "logs" / "tasks" / task_id / "events.jsonl").read_text(encoding="utf-8").splitlines() ] assert snapshot.task.status is TaskStatus.PAUSED assert snapshot.active_project is None assert store.list_projects(task_id)[0].status is ProjectStatus.FAILED recovery_events = [ event for event in events if event["operation"] == "recover_interrupted_work" and event["project_id"] == project_id ] assert [event["details"]["phase"] for event in recovery_events] == ["before", "after"] assert [event["state_before"] for event in recovery_events] == [ ProjectStatus.CAPTURING_BEFORE.value, ProjectStatus.CAPTURING_BEFORE.value, ] def test_restart_awaiting_operator_uses_persisted_before_stamp_and_instruction(tmp_path: Path) -> None: """Dropping an attempt context on restart must fail closed instead of accepting the old probe as after evidence.""" runner, store, task_id, (project_id,), probe_source = _runner_with_probe_source(tmp_path) project = store.list_projects(task_id)[0] before = tmp_path / "before.json" _write_profile("profile-after-valid.json", probe_source, project.path) _write_profile("profile-after-valid.json", before, project.path) before_profile = json.loads(before.read_text(encoding="utf-8")) before_profile["capture"] = "new-before-probe" before.write_text(json.dumps(before_profile), encoding="utf-8") runner.start_task(task_id, disposable_copy_confirmed=True) runner.capture_before(task_id, project_id, before) restarted = TrialRunner( store, configure_logging(tmp_path / "logs"), probe_source_resolver=lambda _task, _project: probe_source, ) recovered = restarted.snapshot(task_id) assert recovered.instruction is not None with pytest.raises(TaskCenterError) as raised: restarted.capture_after(task_id, project_id, before) assert raised.value.code == "profile_unchanged" assert store.get_task(task_id).status is TaskStatus.FAILED def test_restart_without_persisted_before_stamp_fails_closed(tmp_path: Path) -> None: """A damaged attempt record cannot safely advance from operator state to verification.""" runner, store, task_id, (project_id,), probe_source = _runner_with_probe_source(tmp_path) project = store.list_projects(task_id)[0] after = tmp_path / "after.json" _write_profile("profile-before.json", probe_source, project.path) _write_profile("profile-after-valid.json", after, project.path) runner.start_task(task_id, disposable_copy_confirmed=True) store.set_project_status(project_id, ProjectStatus.AWAITING_OPERATOR) restarted = TrialRunner( store, configure_logging(tmp_path / "logs"), probe_source_resolver=lambda _task, _project: probe_source, ) with pytest.raises(TaskCenterError) as raised: restarted.capture_after(task_id, project_id, after) assert raised.value.code == "attempt_before_missing" assert store.list_projects(task_id)[0].status is ProjectStatus.FAILED def test_capture_after_rechecks_persisted_before_content_hash(tmp_path: Path) -> None: runner, store, task_id, (project_id,), probe_source = _runner_with_probe_source(tmp_path) project = store.list_projects(task_id)[0] _write_profile("profile-before.json", probe_source, project.path) runner.start_task(task_id, disposable_copy_confirmed=True) before = json.loads(probe_source.read_text(encoding="utf-8")) before["capture"] = "fresh-before" probe_source.write_text(json.dumps(before), encoding="utf-8") runner.capture_before(task_id, project_id, probe_source) context = store.current_attempt(project_id) assert context is not None and context.before_path is not None altered = json.loads(context.before_path.read_text(encoding="utf-8")) altered["components"][0]["pins"][0]["x"] = 999 context.before_path.write_text(json.dumps(altered), encoding="utf-8") _write_profile("profile-after-valid.json", probe_source, project.path) with pytest.raises(TaskCenterError) as raised: runner.capture_after(task_id, project_id, probe_source) assert raised.value.code == "evidence_integrity" assert store.list_projects(task_id)[0].status is ProjectStatus.FAILED def test_attempt_freezes_rules_for_instruction_and_comparison(tmp_path: Path) -> None: """Comparing with an edited mapping rather than the attempt mapping must reject the UI edit race.""" runner, store, task_id, (project_id,), probe_source = _runner_with_probe_source(tmp_path) project = store.list_projects(task_id)[0] before = tmp_path / "before.json" after = tmp_path / "after.json" _write_profile("profile-before.json", probe_source, project.path) _write_profile("profile-before.json", before, project.path) before_profile = json.loads(before.read_text(encoding="utf-8")) before_profile["capture"] = "new-before-probe" before.write_text(json.dumps(before_profile), encoding="utf-8") _write_profile("profile-after-valid.json", after, project.path) runner.start_task(task_id, disposable_copy_confirmed=True) runner.capture_before(task_id, project_id, before) rule = store.list_rules(task_id)[0] store.update_rule(rule.rule_id, old_part_number="OLD-1", new_part_number="OTHER-1", enabled=True) completed = runner.capture_after(task_id, project_id, after) assert completed.task.status is TaskStatus.COMPLETED def test_start_baseline_rejects_unchanged_before_probe(tmp_path: Path) -> None: """Capturing the probe present at Start as a before profile would permit stale evidence.""" runner, store, task_id, (project_id,), probe_source = _runner_with_probe_source(tmp_path) project = store.list_projects(task_id)[0] _write_profile("profile-before.json", probe_source, project.path) runner.start_task(task_id, disposable_copy_confirmed=True) with pytest.raises(TaskCenterError) as raised: runner.capture_before(task_id, project_id, probe_source) assert raised.value.code == "profile_unchanged" def test_global_active_project_gate_blocks_second_task(tmp_path: Path) -> None: """Selecting one active project per task still permits dangerous concurrent native work.""" first, store, first_task_id, _, probe_source = _runner_with_probe_source(tmp_path) second_task = store.create_task("Second") store.add_rule(second_task.task_id, "OLD-1", "NEW-1") second_path = tmp_path / "second.prj" second_path.write_text("project", encoding="utf-8") second_project = store.sync_projects(second_task.task_id, tmp_path, (second_path,))[0] store.set_project_selected(second_project.project_id, True) second = TrialRunner(store, configure_logging(tmp_path / "logs"), probe_source_resolver=lambda _task, _project: probe_source) first.start_task(first_task_id, disposable_copy_confirmed=True) with pytest.raises(TaskCenterError) as raised: second.start_task(second_task.task_id, disposable_copy_confirmed=True) assert raised.value.code == "active_project_exists" assert store.get_task(second_task.task_id).status is TaskStatus.DRAFT def test_retry_slot_conflict_leaves_failed_task_and_project_unchanged(tmp_path: Path) -> None: """A rejected retry claim must not first persist a runnable task or pending project.""" blocker, store, blocker_task_id, _, probe_source = _runner_with_probe_source(tmp_path) blocked_task = store.create_task("Blocked retry") store.add_rule(blocked_task.task_id, "OLD-1", "NEW-1") path = tmp_path / "blocked-retry.prj" path.write_text("project", encoding="utf-8") blocked_project = store.sync_projects(blocked_task.task_id, tmp_path, (path,))[0] store.set_project_selected(blocked_project.project_id, True) store.set_task_status(blocked_task.task_id, TaskStatus.RUNNING) store.set_project_status(blocked_project.project_id, ProjectStatus.CAPTURING_BEFORE) store.set_project_status(blocked_project.project_id, ProjectStatus.FAILED) store.set_task_status(blocked_task.task_id, TaskStatus.FAILED) blocker.start_task(blocker_task_id, disposable_copy_confirmed=True) events_path = tmp_path / "logs" / "tasks" / blocked_task.task_id / "events.jsonl" with pytest.raises(TaskCenterError) as raised: blocker.retry_project(blocked_task.task_id, blocked_project.project_id) assert raised.value.code == "active_project_exists" assert store.get_task(blocked_task.task_id).status is TaskStatus.FAILED assert store.list_projects(blocked_task.task_id)[0].status is ProjectStatus.FAILED assert not events_path.exists() or "retry started" not in events_path.read_text(encoding="utf-8") def test_resume_slot_conflict_leaves_paused_task_and_pending_project_unchanged(tmp_path: Path) -> None: """A rejected resume claim must not advertise success after another task owns the slot.""" blocker, store, blocker_task_id, _, probe_source = _runner_with_probe_source(tmp_path) blocked_task = store.create_task("Blocked resume") store.add_rule(blocked_task.task_id, "OLD-1", "NEW-1") path = tmp_path / "blocked-resume.prj" path.write_text("project", encoding="utf-8") blocked_project = store.sync_projects(blocked_task.task_id, tmp_path, (path,))[0] store.set_project_selected(blocked_project.project_id, True) store.set_task_status(blocked_task.task_id, TaskStatus.RUNNING) store.set_task_status(blocked_task.task_id, TaskStatus.PAUSED) blocker.start_task(blocker_task_id, disposable_copy_confirmed=True) events_path = tmp_path / "logs" / "tasks" / blocked_task.task_id / "events.jsonl" with pytest.raises(TaskCenterError) as raised: blocker.resume_task(blocked_task.task_id) assert raised.value.code == "active_project_exists" assert store.get_task(blocked_task.task_id).status is TaskStatus.PAUSED assert store.list_projects(blocked_task.task_id)[0].status is ProjectStatus.PENDING assert not events_path.exists() or "trial resumed" not in events_path.read_text(encoding="utf-8") def test_resume_completes_terminal_task_while_another_task_owns_the_active_slot(tmp_path: Path) -> None: """A finished queue needs no native-work slot, so resuming it must be allowed to complete.""" blocker, store, blocker_task_id, _, _ = _runner_with_probe_source(tmp_path) completed_task = store.create_task("Completed queue") path = tmp_path / "completed-queue.prj" path.write_text("project", encoding="utf-8") completed_project = store.sync_projects(completed_task.task_id, tmp_path, (path,))[0] store.set_project_selected(completed_project.project_id, True) store.set_task_status(completed_task.task_id, TaskStatus.RUNNING) for status in ( ProjectStatus.CAPTURING_BEFORE, ProjectStatus.AWAITING_OPERATOR, ProjectStatus.CAPTURING_AFTER, ProjectStatus.VERIFYING, ProjectStatus.COMPLETED, ): store.set_project_status(completed_project.project_id, status) store.set_task_status(completed_task.task_id, TaskStatus.PAUSED) blocker.start_task(blocker_task_id, disposable_copy_confirmed=True) resumed = blocker.resume_task(completed_task.task_id) assert resumed.task.status is TaskStatus.COMPLETED assert resumed.active_project is None def test_v1_migration_recovery_emits_before_and_after_events(tmp_path: Path) -> None: """Fail-closed v1 migration must retain enough durable context for recovery audit events.""" database = tmp_path / "task-center.db" first = TaskStore(database) task = first.create_task("Trial") path = tmp_path / "one.prj" path.touch() project = first.sync_projects(task.task_id, tmp_path, (path,))[0] first.set_task_status(task.task_id, TaskStatus.RUNNING) first.set_project_status(project.project_id, ProjectStatus.CAPTURING_BEFORE) first.close() with sqlite3.connect(database) as connection: connection.execute("DROP TABLE attempts") connection.execute("UPDATE metadata SET value = '1' WHERE key = 'schema_version'") migrated = TaskStore(database) TrialRunner(migrated, configure_logging(tmp_path / "logs")) events = [ json.loads(line) for line in (tmp_path / "logs" / "tasks" / task.task_id / "events.jsonl").read_text(encoding="utf-8").splitlines() ] project_events = [ event for event in events if event["operation"] == "recover_v1_attemptless_work" and event["project_id"] == project.project_id ] task_events = [ event for event in events if event["operation"] == "recover_v1_attemptless_work" and event["project_id"] is None ] assert [event["details"]["phase"] for event in project_events] == ["before", "after"] assert [event["state_before"] for event in project_events] == [ProjectStatus.CAPTURING_BEFORE.value] * 2 assert [event["state_after"] for event in project_events] == [ProjectStatus.FAILED.value] * 2 assert [event["details"]["phase"] for event in task_events] == ["before", "after"] assert [event["state_before"] for event in task_events] == [TaskStatus.RUNNING.value] * 2 assert [event["state_after"] for event in task_events] == [TaskStatus.PAUSED.value] * 2 @pytest.mark.parametrize("failure_point", ("append_after_write", "acknowledge_before_delete")) def test_v1_migration_recovery_events_are_idempotent_across_restart( tmp_path: Path, monkeypatch: pytest.MonkeyPatch, failure_point: str ) -> None: """Restarting after a partial recovery must not duplicate an event that is already durable.""" database = tmp_path / "task-center.db" first = TaskStore(database) task = first.create_task("Trial") path = tmp_path / "one.prj" path.touch() project = first.sync_projects(task.task_id, tmp_path, (path,))[0] first.set_task_status(task.task_id, TaskStatus.RUNNING) first.set_project_status(project.project_id, ProjectStatus.CAPTURING_BEFORE) first.close() with sqlite3.connect(database) as connection: connection.execute("DROP TABLE attempts") connection.execute("UPDATE metadata SET value = '1' WHERE key = 'schema_version'") migrated = TaskStore(database) logging_context = configure_logging(tmp_path / "logs") original_append = runner_module.append_task_event original_acknowledge = TaskStore.acknowledge_migration_recoveries append_count = 0 if failure_point == "append_after_write": def append_then_fail(*args: object, **kwargs: object) -> dict[str, object]: nonlocal append_count event = original_append(*args, **kwargs) append_count += 1 if append_count == 2: raise TaskCenterError("event_write_failed", "simulated crash after durable append") return event monkeypatch.setattr(runner_module, "append_task_event", append_then_fail) else: def fail_acknowledge(_store: TaskStore, _project_ids: object) -> None: raise TaskCenterError("recovery_ack_failed", "simulated crash before recovery acknowledgement") monkeypatch.setattr(TaskStore, "acknowledge_migration_recoveries", fail_acknowledge) with pytest.raises(TaskCenterError): TrialRunner(migrated, logging_context) migrated.close() monkeypatch.setattr(runner_module, "append_task_event", original_append) monkeypatch.setattr(TaskStore, "acknowledge_migration_recoveries", original_acknowledge) restarted_store = TaskStore(database) TrialRunner(restarted_store, configure_logging(tmp_path / "logs")) events = [ json.loads(line) for line in (tmp_path / "logs" / "tasks" / task.task_id / "events.jsonl").read_text(encoding="utf-8").splitlines() ] recovery_events = [event for event in events if event["operation"] == "recover_v1_attemptless_work"] assert len(recovery_events) == 4 assert len({event["details"]["recovery_event_id"] for event in recovery_events}) == 4 assert restarted_store.pending_migration_recoveries() == () def test_completed_project_event_failure_reconciles_task_without_illegal_failure( tmp_path: Path, monkeypatch: pytest.MonkeyPatch ) -> None: """An event-write failure after completion must not attempt an illegal completed-to-failed transition.""" runner, store, task_id, (project_id,), probe_source = _runner_with_probe_source(tmp_path) project = store.list_projects(task_id)[0] before = tmp_path / "before.json" after = tmp_path / "after.json" _write_profile("profile-before.json", probe_source, project.path) _write_profile("profile-before.json", before, project.path) os.utime(probe_source, ns=(1_700_000_000_000_000_000, 1_700_000_000_000_000_000)) os.utime(before, ns=(1_700_000_001_000_000_000, 1_700_000_001_000_000_000)) _write_profile("profile-after-valid.json", after, project.path) runner.start_task(task_id, disposable_copy_confirmed=True) runner.capture_before(task_id, project_id, before) original_append = runner_module.append_task_event def fail_terminal_event(*args: object, **kwargs: object) -> dict[str, object]: if kwargs.get("operation") == "compare_profiles" and kwargs.get("details") == {"phase": "after"}: raise TaskCenterError("event_write_failed", "cannot append task event") return original_append(*args, **kwargs) monkeypatch.setattr(runner_module, "append_task_event", fail_terminal_event) with pytest.raises(TaskCenterError, match="event_write_failed"): runner.capture_after(task_id, project_id, after) assert store.list_projects(task_id)[0].status is ProjectStatus.COMPLETED assert store.get_task(task_id).status is TaskStatus.COMPLETED def test_restart_reconciles_completed_project_when_task_completion_was_interrupted(tmp_path: Path) -> None: """A crash after project completion must not leave a restartable trial permanently running.""" runner, store, task_id, (project_id,), _ = _runner_with_probe_source(tmp_path) runner.start_task(task_id, disposable_copy_confirmed=True) store.set_project_status(project_id, ProjectStatus.FAILED) store.set_project_status(project_id, ProjectStatus.PENDING) store.set_project_status(project_id, ProjectStatus.CAPTURING_BEFORE) store.set_project_status(project_id, ProjectStatus.AWAITING_OPERATOR) store.set_project_status(project_id, ProjectStatus.CAPTURING_AFTER) store.set_project_status(project_id, ProjectStatus.VERIFYING) store.set_project_status(project_id, ProjectStatus.COMPLETED) restarted = TrialRunner(store, configure_logging(tmp_path / "logs")) assert restarted.snapshot(task_id).task.status is TaskStatus.COMPLETED def test_retry_uses_blank_current_instruction_without_mutating_prior_attempt_evidence(tmp_path: Path) -> None: """Reusing a previous attempt instruction can direct the operator with stale match evidence.""" runner, store, task_id, (project_id,), probe_source = _runner_with_probe_source(tmp_path) project = store.list_projects(task_id)[0] before = tmp_path / "before.json" after = tmp_path / "after.json" _write_profile("profile-before.json", probe_source, project.path) _write_profile("profile-before.json", before, project.path) before_profile = json.loads(before.read_text(encoding="utf-8")) before_profile["capture"] = "new-before-probe" before.write_text(json.dumps(before_profile), encoding="utf-8") _write_profile("profile-after-invalid.json", after, project.path) runner.start_task(task_id, disposable_copy_confirmed=True) first_attempt = runner.capture_before(task_id, project_id, before) original_before = (first_attempt.evidence_directory / "before.json").read_bytes() with pytest.raises(TaskCenterError): runner.capture_after(task_id, project_id, after) retried = runner.retry_project(task_id, project_id) assert retried.instruction is None assert (first_attempt.evidence_directory / "before.json").read_bytes() == original_before def test_before_capture_rejects_duplicate_logical_identity(tmp_path: Path) -> None: """Ignoring malformed components before operator action creates unverified replacement guidance.""" runner, store, task_id, (project_id,), probe_source = _runner_with_probe_source(tmp_path) project = store.list_projects(task_id)[0] before = tmp_path / "before.json" _write_profile("profile-before.json", probe_source, project.path) profile = json.loads((FIXTURES / "profile-before.json").read_text(encoding="utf-8")) profile["project"]["identity"] = str(project.path) profile["components"].append(dict(profile["components"][0])) before.write_text(json.dumps(profile), encoding="utf-8") runner.start_task(task_id, disposable_copy_confirmed=True) with pytest.raises(TaskCenterError) as raised: runner.capture_before(task_id, project_id, before) assert raised.value.code == "before_profile_invalid" assert store.list_projects(task_id)[0].status is ProjectStatus.FAILED def test_failed_project_can_be_deselected_and_reconciles_task(tmp_path: Path) -> None: """A failed deselected project must not keep an otherwise empty queue in failed state forever.""" runner, store, task_id, (project_id,), probe_source = _runner_with_probe_source(tmp_path) project = store.list_projects(task_id)[0] before = tmp_path / "before.json" after = tmp_path / "after.json" _write_profile("profile-before.json", probe_source, project.path) _write_profile("profile-before.json", before, project.path) before_profile = json.loads(before.read_text(encoding="utf-8")) before_profile["capture"] = "before-evidence" before.write_text(json.dumps(before_profile), encoding="utf-8") _write_profile("profile-after-invalid.json", after, project.path) runner.start_task(task_id, disposable_copy_confirmed=True) runner.capture_before(task_id, project_id, before) with pytest.raises(TaskCenterError): runner.capture_after(task_id, project_id, after) snapshot = runner.set_project_selected(task_id, project_id, False) assert not store.list_projects(task_id)[0].selected assert snapshot.task.status is TaskStatus.PAUSED