| """Released environment operations and snapshot validation.""" |
| from __future__ import annotations |
| from copy import deepcopy as ext_deepcopy |
| from pathlib import Path as ext_Path |
| from rescopebench.raw_module_isolation import load_isolated_modules as ext_load_isolated_modules |
| from typing import Any as ext_Any |
| import hashlib as mod_hashlib |
| import json as mod_json |
| from .spec import CASE_DIR, DATA_AUDIT_PROFILES, DATA_POLICY_MATRIX, DATA_RECORD_SPECS, DATA_TOOL_BY_NAME, DATA_TOOL_COSTS, DATA_DRIFT_OVERRIDES, DATA_VISITS, DATA_PUBLIC_TOOLS, DATA_CORRECTION_CLASSES, DATA_RESOURCE_KEYS, DATA_PRESERVED_RETESTS, DATA_SCHEDULE_2, DATA_LATE_CLASSES, DATA_STREAM_TARGETS |
|
|
| def fn_targets(task_id): |
| rows = fn_targets_2(task_id) |
| if task_id == 'T01': |
| return rows |
| offset = (int(task_id[1:]) - 1) % len(DATA_VISITS) |
| order = DATA_VISITS[offset:] + DATA_VISITS[:offset] |
| return sorted(rows, key=lambda row: order.index(row['visit_type'])) |
|
|
| def fn_expectations(task_id): |
| return [{key: row[key] for key in ('record_ref', 'correction_class', 'corrected_value')} for row in fn_targets(task_id)] |
|
|
| def fn__canonical(value): |
| return mod_json.dumps(value, sort_keys=True, separators=(',', ':'), ensure_ascii=True) |
|
|
| def fn_verify_source_lock(case_dir=CASE_DIR, source_lock=CASE_DIR / 'data/source-manifest.json', source_root=None): |
| """Verify the frozen raw closure without incorporating successor files.""" |
| lock = mod_json.loads(ext_Path(source_lock).read_text(encoding='utf-8')) |
| prefix = f'cases/{ext_Path(case_dir).name}/' |
| mismatches = [] |
| closure = mod_hashlib.sha256() |
| checked = 0 |
| for (locked_name, expected) in sorted(lock['files'].items()): |
| if not locked_name.startswith(prefix): |
| mismatches.append({'path': locked_name, 'error': 'outside_case_prefix'}) |
| continue |
| relative = locked_name[len(prefix):] |
| if source_root is not None and relative.startswith('raw/'): |
| path = ext_Path(source_root) / relative.removeprefix('raw/') |
| else: |
| path = ext_Path(case_dir) / relative |
| if not path.is_file(): |
| mismatches.append({'path': relative, 'error': 'missing'}) |
| continue |
| actual = fn__sha256(path) |
| checked += 1 |
| if actual != expected: |
| mismatches.append({'path': relative, 'expected_sha256': expected, 'actual_sha256': actual}) |
| closure.update(relative.encode('utf-8')) |
| closure.update(b'\x00') |
| closure.update(actual.encode('ascii')) |
| closure.update(b'\n') |
| return {'matched': checked == lock['file_count'] and (not mismatches), 'checked_file_count': checked, 'locked_file_count': lock['file_count'], 'closure_sha256': closure.hexdigest(), 'mismatches': mismatches, 'snapshot_identity_sha256': lock['snapshot_identity_sha256']} |
|
|
| def fn__empty_resources(): |
| return {key: 0 for key in DATA_RESOURCE_KEYS} |
|
|
| def fn__validate(arguments, schema): |
| if not isinstance(arguments, dict): |
| return 'arguments must be an object' |
| properties = schema['properties'] |
| if set(arguments) - set(properties): |
| return 'arguments contain unsupported fields' |
| if any((name not in arguments for name in schema['required'])): |
| return 'arguments are missing required fields' |
| for (name, value) in arguments.items(): |
| spec = properties[name] |
| if spec.get('type') == 'string' and (not isinstance(value, str)): |
| return f'{name} must be a string' |
| if 'enum' in spec and value not in spec['enum']: |
| return f'{name} is outside the declared enum' |
| return None |
|
|
| def fn_targets_2(task_id): |
| rows = fn_targets_3(task_id) |
| for row in rows: |
| correction = DATA_PRESERVED_RETESTS.get(task_id, {}).get(row['visit_type']) |
| if correction is not None: |
| row['correction_class'] = correction |
| material = f"{'oracle-clinical-one-form-correction-v9.3'}|{task_id}|{row['record_ref']}|{correction}" |
| row['corrected_value'] = 'cv-' + mod_hashlib.sha256(material.encode()).hexdigest()[:16] |
| return rows |
|
|
| def fn__sha256(path): |
| digest = mod_hashlib.sha256() |
| with path.open('rb') as handle: |
| for chunk in iter(lambda : handle.read(1024 * 1024), b''): |
| digest.update(chunk) |
| return digest.hexdigest() |
|
|
| def fn_targets_3(task_id): |
| rows = fn_stream_targets(task_id) |
| for row in rows: |
| correction = DATA_LATE_CLASSES.get(task_id, {}).get(row['visit_type']) |
| if correction is not None: |
| row['correction_class'] = correction |
| material = f"{'oracle-clinical-one-form-correction-v9.1'}|{task_id}|{row['record_ref']}|{correction}" |
| row['corrected_value'] = 'cv-' + mod_hashlib.sha256(material.encode()).hexdigest()[:16] |
| return rows |
|
|
| def fn_stream_targets(task_id): |
| if task_id not in DATA_STREAM_TARGETS: |
| raise ValueError(f'unknown task id: {task_id}') |
| return ext_deepcopy(DATA_STREAM_TARGETS[task_id]) |
|
|
| class World: |
|
|
| def public_tool_schemas(self, role='clinical_data_corrector'): |
| tools = self._oracle_clinical_one_correction_public_tool_schemas(role) |
| for tool in tools: |
| if tool['name'] == 'apply_form_correction': |
| tool['description'] = tool['description'].replace('Requests are enforced in listed order and rejected writes are charged.', 'Independent requests may be corrected in any order; rejected writes are charged.') |
| return tools |
|
|
| def _apply(self, arguments): |
| record = self.records_by_handle.get(arguments['correction_handle']) |
| if record is None or record['record_ref'] not in self.active_requests: |
| return self._oracle_clinical_one_correction_apply(arguments) |
| original = self.active_order |
| self.active_order = [record['record_ref']] + [r for r in original if r != record['record_ref']] |
| try: |
| return self._oracle_clinical_one_correction_apply(arguments) |
| finally: |
| self.active_order = original |
|
|
| def snapshot(self): |
| value = self._oracle_priority_world_snapshot() |
| value['independent_correction_contract'] = 'oracle-independent-corrections-evolution-v3' |
| return value |
|
|
| def restore(self, snapshot): |
| value = ext_deepcopy(snapshot) |
| if value.pop('independent_correction_contract', None) != 'oracle-independent-corrections-evolution-v3': |
| raise ValueError('Oracle independent snapshot version differs') |
| self._oracle_priority_world_restore(value) |
| if self.snapshot() != snapshot: |
| raise ValueError('Oracle independent snapshot did not round trip') |
|
|
| def grade(self, expected): |
| baseline = self._oracle_clinical_one_correction_grade(expected) |
| if baseline['errors'] == ['malformed or duplicate expected artifact']: |
| return baseline |
| transactions = [] |
| for row in expected: |
| record = self.records[row['record_ref']] |
| form = next((f for f in self.episode_entry_raw['database']['form'] if f.get('form_id') == record['form_id'])) |
| previous = next((a['value'] for a in form['answers'] if a.get('question_id') == record['question_id'])) |
| profile = self.policy_matrix[record['visit_type'], row['correction_class']] |
| transactions.append({'record_type': 'FormAnswerChange', 'visit_id': record['visit_id'], 'question_id': record['question_id'], 'previous_value': previous, 'new_value': row['corrected_value'], 'reason_for_change': DATA_AUDIT_PROFILES[profile]}) |
| actual = self.manager.transactions[self.episode_transaction_start:] |
| indices = [] |
| lineage_exact = True |
| for transaction in actual: |
| matches = [i for (i, candidate) in enumerate(transactions) if candidate == transaction] |
| if len(matches) != 1 or matches[0] in indices: |
| lineage_exact = False |
| break |
| indices.append(matches[0]) |
| reconstructed = ext_deepcopy(self.episode_entry_raw) |
| for index in indices: |
| row = expected[index] |
| record = self.records[row['record_ref']] |
| form = next((f for f in reconstructed['database']['form'] if f.get('form_id') == record['form_id'])) |
| answer = next((a for a in form['answers'] if a.get('question_id') == record['question_id'])) |
| answer['value'] = row['corrected_value'] |
| reconstructed['transactions'].extend(actual) |
| valid = lineage_exact and self.manager.snapshot() == reconstructed |
| artifacts = [] |
| for (index, (row, transaction)) in enumerate(zip(expected, transactions, strict=True)): |
| record = self.records[row['record_ref']] |
| form = self.manager.database.get('form', record['form_id']) or {} |
| count = actual.count(transaction) |
| saved = form.get('status') == 'complete' and form.get('save_state') == 'saved' |
| value_matches = self._record_value(record) == row['corrected_value'] |
| artifacts.append({'record_ref': row['record_ref'], 'complete': bool(valid and index in indices and saved and value_matches and (count == 1)), 'terminal_value_matches': value_matches, 'completed_saved': saved, 'audit_lineage_count': count}) |
| completed = sum((r['complete'] for r in artifacts)) |
| return {'task_id': self.active_task_id, 'score': 100.0 * completed / len(artifacts), 'completed_artifacts': completed, 'valid': valid, 'artifacts': artifacts, 'errors': [] if valid else ['raw terminal state or current-episode FormAnswerChange lineage differs from the objective artifact']} |
|
|
| def _get_policy(self, arguments): |
| cell = (arguments['visit_type'], arguments['correction_class']) |
| profiles = {DATA_POLICY_MATRIX[cell], self.policy_matrix[cell]} |
| evidence = [{'evidence_id': 'APE-' + mod_hashlib.sha256(fn__canonical({'visit_type': cell[0], 'correction_class': cell[1], 'audit_profile_id': profile}).encode('utf-8')).hexdigest()[:12].upper(), 'audit_profile_id': profile, 'reason_for_change': DATA_AUDIT_PROFILES[profile]} for profile in profiles] |
| evidence.sort(key=lambda row: row['evidence_id']) |
| if self.rule_revalidation.get(cell) in {'awaiting_current_policy', 'awaiting_exact_stale'}: |
| self.rule_revalidation[cell] = 'ready_current' |
| return (self._result('get_correction_policy', 'success', {'visit_type': cell[0], 'correction_class': cell[1], 'evidence': evidence}), {'policy_requests': 1, 'policy_records_read': len(evidence)}) |
|
|
| def activate_task(self, task_id, requests, allowance=17): |
| return self._oracle_clinical_one_correction_activate_task(task_id, requests, allowance=allowance) |
|
|
| def _get_context(self, arguments): |
| (result, delta) = self._oracle_clinical_one_correction_get_context(arguments) |
| if result['content']['status'] == 'success': |
| result['content']['data'].update({'binding_scope': 'environment_instance', 'correction_handle_reusable_across_episodes': True}) |
| return (result, delta) |
|
|
| def __init__(self, source=CASE_DIR / 'raw', snapshot=None): |
| self.source = ext_Path(source).resolve() |
| self.source_lock = fn_verify_source_lock(source_root=self.source) |
| if not self.source_lock['matched']: |
| raise RuntimeError('raw source lock mismatch') |
| (modules, manager) = ext_load_isolated_modules(self.source, ('mcp_servers.tools.update_completed_form_value', 'mcp_servers.state.state_manager'), initialize=lambda imported: imported[1].StateManager(self.source)) |
| self.raw_update = modules[0].update_completed_form_value |
| self.manager = manager |
| self.records = {row['record_ref']: ext_deepcopy(row) for row in DATA_RECORD_SPECS} |
| self.handles = {record_ref: self._opaque_handle(record) for (record_ref, record) in self.records.items()} |
| self.records_by_handle = {handle: self.records[record_ref] for (record_ref, handle) in self.handles.items()} |
| self.active_task_id: str | None = None |
| self.active_requests: dict[str, dict[str, str]] = {} |
| self.active_order: list[str] = [] |
| self.policy_matrix = ext_deepcopy(DATA_POLICY_MATRIX) |
| self.applied_boundary_events: set[str] = set() |
| self.rule_revalidation: dict[tuple[str, str], str] = {} |
| self.episode_entry_raw: dict[str, ext_Any] | None = None |
| self.episode_transaction_start = 0 |
| self.resources = fn__empty_resources() |
| self.allowance = 18 |
| self.remaining = 18 |
| self.receipts: list[dict[str, ext_Any]] = [] |
| self.committed: dict[str, dict[str, str]] = {} |
| self._validate_seed_records() |
| if snapshot is not None: |
| self.restore(snapshot) |
|
|
| @staticmethod |
| def _opaque_handle(record): |
| material = '|'.join(('oracle-correction-v7', record['record_ref'], record['form_id'], record['visit_id'], record['question_id'])) |
| return 'ch-' + mod_hashlib.sha256(material.encode('utf-8')).hexdigest()[:20] |
|
|
| def _validate_seed_records(self): |
| for record in self.records.values(): |
| form = self.manager.database.get('form', record['form_id']) |
| visit = self.manager.database.get('visit', record['visit_id']) |
| question = self.manager.database.get('question', record['question_id']) |
| if form is None or visit is None or question is None: |
| raise RuntimeError('declared correction record is missing from raw seed') |
| answers = [answer for answer in form.get('answers', []) if answer.get('question_id') == record['question_id']] |
| if form.get('visit_id') != record['visit_id'] or visit.get('visit_type') != record['visit_type'] or form.get('status') != 'complete' or (form.get('save_state') != 'saved') or (len(answers) != 1): |
| raise RuntimeError('declared correction record is not a completed saved form') |
|
|
| def close(self): |
| runtime_directory = getattr(self.manager, '_runtime_directory', None) |
| if runtime_directory is not None: |
| runtime_directory.cleanup() |
|
|
| def _result(self, tool, status, data=None, *, code=None, message=''): |
| return {'type': 'tool_result', 'tool': tool, 'content': {'status': status, 'data': ext_deepcopy(data or {}), 'error_code': code, 'message': message}} |
|
|
| def _record(self, tool, actor, arguments, before_hash, result, delta=None): |
| resource_delta = fn__empty_resources() |
| resource_delta.update(delta or {}) |
| for (key, value) in resource_delta.items(): |
| self.resources[key] += value |
| receipt = {'index': len(self.receipts) + 1, 'tool': tool, 'actor': actor, 'arguments': ext_deepcopy(arguments), 'status': result['content']['status'], 'error_code': result['content'].get('error_code'), 'observed': ext_deepcopy(result['content'].get('data', {})), 'resource_delta': resource_delta, 'resource_totals': ext_deepcopy(self.resources), 'before_business_hash': before_hash, 'after_business_hash': self.business_hash()} |
| self.receipts.append(receipt) |
| result['resource'] = {'delta': ext_deepcopy(resource_delta), 'totals': ext_deepcopy(self.resources)} |
| result['budget'] = {'charged': resource_delta['work_units_charged'], 'remaining': self.remaining, 'allowance': self.allowance} |
| result['receipt_index'] = receipt['index'] |
| return ext_deepcopy(result) |
|
|
| def _active_record(self, record_ref): |
| if record_ref not in self.active_requests: |
| return None |
| return self.records.get(record_ref) |
|
|
| def _record_value(self, record): |
| form = self.manager.database.get('form', record['form_id']) |
| if form is None: |
| return None |
| values = [answer.get('value') for answer in form.get('answers', []) if answer.get('question_id') == record['question_id']] |
| return values[0] if len(values) == 1 else None |
|
|
| def _correctable_state(self, record): |
| form = self.manager.database.get('form', record['form_id']) |
| visit = self.manager.database.get('visit', record['visit_id']) |
| if form is None or visit is None: |
| return None |
| answer_count = sum((answer.get('question_id') == record['question_id'] for answer in form.get('answers', []))) |
| raw_resolution = next((candidate.get('form_id') for candidate in sorted((row for row in self.manager.database.all('form') if row.get('visit_id') == record['visit_id']), key=lambda row: row['form_id']) if any((answer.get('question_id') == record['question_id'] for answer in candidate.get('answers', [])))), None) |
| if form.get('visit_id') != record['visit_id'] or visit.get('visit_type') != record['visit_type'] or form.get('status') != 'complete' or (form.get('save_state') != 'saved') or (answer_count != 1) or (raw_resolution != record['form_id']): |
| return None |
| return (form, visit) |
|
|
| def _expected_raw_after(self, before, record, corrected_value, reason): |
| expected = ext_deepcopy(before) |
| previous_value = None |
| for form in expected['database']['form']: |
| if form.get('form_id') != record['form_id']: |
| continue |
| for answer in form.get('answers', []): |
| if answer.get('question_id') == record['question_id']: |
| previous_value = answer['value'] |
| answer['value'] = corrected_value |
| expected['transactions'].append({'record_type': 'FormAnswerChange', 'visit_id': record['visit_id'], 'question_id': record['question_id'], 'previous_value': previous_value, 'new_value': corrected_value, 'reason_for_change': reason}) |
| return expected |
|
|
| def dispatch(self, tool, arguments, actor='clinical_data_corrector'): |
| before_hash = self.business_hash() |
| if actor != 'clinical_data_corrector': |
| return self._result(tool, 'error', code='ROLE_FORBIDDEN', message='actor is not authorized for clinical data correction') |
| spec = DATA_TOOL_BY_NAME.get(tool) |
| if spec is None: |
| return self._result(tool, 'error', code='TOOL_FORBIDDEN', message='tool is outside the clinical data correction slice') |
| if self.active_task_id is None: |
| return self._result(tool, 'error', code='TASK_NOT_ACTIVE', message='activate a task before using correction tools') |
| validation_error = fn__validate(arguments, spec['input_schema']) |
| if validation_error is not None: |
| return self._record(tool, actor, arguments, before_hash, self._result(tool, 'error', code='INVALID_ARGUMENTS', message=validation_error)) |
| cost = DATA_TOOL_COSTS[tool] |
| if self.remaining < cost: |
| return self._record(tool, actor, arguments, before_hash, self._result(tool, 'error', code='WORK_BUDGET_EXHAUSTED', message='remaining backend work units cannot fund this request')) |
| self.remaining -= cost |
| if tool == 'get_correction_context': |
| (result, delta) = self._get_context(arguments) |
| elif tool == 'get_correction_policy': |
| (result, delta) = self._get_policy(arguments) |
| else: |
| (result, delta) = self._apply(arguments) |
| delta['work_units_charged'] = cost |
| return self._record(tool, actor, arguments, before_hash, result, delta) |
|
|
| def apply_policy_drift(self, event_id='correction-audit-revision-v2'): |
| """Apply the private candidate revision without announcing it to the learner.""" |
| if event_id != 'correction-audit-revision-v2': |
| raise ValueError('unknown correction policy drift event') |
| if event_id in self.applied_boundary_events: |
| return {'status': 'success', 'event_id': event_id, 'idempotent': True, 'changed_cell_count': 0} |
| before_business_hash = self.business_hash() |
| for (cell, profile_id) in DATA_DRIFT_OVERRIDES.items(): |
| if profile_id == self.policy_matrix[cell]: |
| raise RuntimeError('drift candidate must change every declared cell') |
| self.policy_matrix[cell] = profile_id |
| self.rule_revalidation[cell] = 'awaiting_exact_stale' |
| self.applied_boundary_events.add(event_id) |
| return {'status': 'success', 'event_id': event_id, 'idempotent': False, 'changed_cell_count': len(DATA_DRIFT_OVERRIDES), 'business_state_unchanged': self.business_hash() == before_business_hash} |
|
|
| def business_hash(self): |
| return mod_hashlib.sha256(fn__canonical(self.manager.snapshot()).encode('utf-8')).hexdigest() |
|
|
| def semantic_hash(self): |
| return mod_hashlib.sha256(fn__canonical(self.snapshot()).encode('utf-8')).hexdigest() |
|
|
| def business_events(self, since=0): |
| if not isinstance(since, int) or isinstance(since, bool) or since < 0: |
| raise ValueError('since must be a non-negative integer') |
| return ext_deepcopy(self.manager.transactions[since:]) |
|
|
| def _oracle_clinical_one_correction_public_tool_schemas(self, role='clinical_data_corrector'): |
| return ext_deepcopy(list(DATA_PUBLIC_TOOLS)) if role == 'clinical_data_corrector' else [] |
|
|
| def _oracle_clinical_one_correction_apply(self, arguments): |
| (result, delta) = self._oracle_clinical_one_correction_apply_2(arguments) |
| if result['content']['status'] == 'success': |
| result['content']['data']['terminal_verification'] = {'authoritative': True, 'additional_read_required': False} |
| return (result, delta) |
|
|
| def _oracle_priority_world_snapshot(self): |
| snapshot = self._oracle_evolution_snapshot() |
| snapshot['priority_contract'] = 'oracle-priority-lifecycle-evolution-v2' |
| return snapshot |
|
|
| def _oracle_priority_world_restore(self, snapshot): |
| snapshot = ext_deepcopy(snapshot) |
| if snapshot.pop('priority_contract', None) != 'oracle-priority-lifecycle-evolution-v2': |
| raise ValueError('Oracle priority snapshot belongs to a different version') |
| self._oracle_evolution_restore(snapshot) |
|
|
| def _oracle_clinical_one_correction_grade(self, expected): |
| """Grade only raw terminal state and current-episode audit lineage.""" |
| if self.episode_entry_raw is None: |
| raise RuntimeError('activate a task before grading') |
| if not isinstance(expected, list) or not expected: |
| raise ValueError('expected artifacts must be a non-empty list') |
| refs = [row.get('record_ref') for row in expected if isinstance(row, dict)] |
| malformed = len(refs) != len(expected) or len(set(refs)) != len(refs) |
| malformed = malformed or refs != self.active_order |
| malformed = malformed or any((set(row) != {'record_ref', 'correction_class', 'corrected_value'} or row['record_ref'] not in self.active_requests or row['correction_class'] != self.active_requests[row['record_ref']]['correction_class'] or (not isinstance(row['corrected_value'], str)) for row in expected if isinstance(row, dict))) |
| if malformed: |
| return {'task_id': self.active_task_id, 'score': 0.0, 'completed_artifacts': 0, 'valid': False, 'errors': ['malformed or duplicate expected artifact'], 'artifacts': []} |
| expected_transactions = [] |
| artifacts = [] |
| for row in expected: |
| record = self.records[row['record_ref']] |
| profile_id = self.policy_matrix[record['visit_type'], row['correction_class']] |
| entry_form = next((form for form in self.episode_entry_raw['database']['form'] if form.get('form_id') == record['form_id'])) |
| previous_value = next((answer['value'] for answer in entry_form.get('answers', []) if answer.get('question_id') == record['question_id'])) |
| transaction = {'record_type': 'FormAnswerChange', 'visit_id': record['visit_id'], 'question_id': record['question_id'], 'previous_value': previous_value, 'new_value': row['corrected_value'], 'reason_for_change': DATA_AUDIT_PROFILES[profile_id]} |
| expected_transactions.append(transaction) |
| current_transactions = self.manager.transactions[self.episode_transaction_start:] |
| completed_prefix = len(current_transactions) |
| lineage_exact = completed_prefix <= len(expected_transactions) and current_transactions == expected_transactions[:completed_prefix] |
| expected_raw = ext_deepcopy(self.episode_entry_raw) |
| for row in expected[:completed_prefix]: |
| record = self.records[row['record_ref']] |
| for form in expected_raw['database']['form']: |
| if form.get('form_id') != record['form_id']: |
| continue |
| for answer in form.get('answers', []): |
| if answer.get('question_id') == record['question_id']: |
| answer['value'] = row['corrected_value'] |
| expected_raw['transactions'].extend(expected_transactions[:completed_prefix]) |
| raw_exact = self.manager.snapshot() == expected_raw |
| valid = raw_exact and lineage_exact |
| for (index, (row, transaction)) in enumerate(zip(expected, expected_transactions)): |
| record = self.records[row['record_ref']] |
| form = self.manager.database.get('form', record['form_id']) or {} |
| transaction_count = current_transactions.count(transaction) |
| answer_value = self._record_value(record) |
| complete = bool(valid and index < completed_prefix and (form.get('status') == 'complete') and (form.get('save_state') == 'saved') and (answer_value == row['corrected_value']) and (transaction_count == 1)) |
| artifacts.append({'record_ref': row['record_ref'], 'complete': complete, 'terminal_value_matches': answer_value == row['corrected_value'], 'completed_saved': form.get('status') == 'complete' and form.get('save_state') == 'saved', 'audit_lineage_count': transaction_count}) |
| completed = sum((row['complete'] for row in artifacts)) |
| return {'task_id': self.active_task_id, 'score': 100.0 * completed / len(artifacts), 'completed_artifacts': completed, 'valid': valid, 'errors': [] if valid else ['raw terminal state or current-episode FormAnswerChange lineage differs from the objective artifact'], 'artifacts': artifacts} |
|
|
| def _oracle_clinical_one_correction_activate_task(self, task_id, requests, allowance=18): |
| if not isinstance(task_id, str) or not task_id: |
| raise ValueError('task_id must be a non-empty string') |
| if not isinstance(requests, list) or not requests: |
| raise ValueError('requests must be a non-empty list') |
| if not isinstance(allowance, int) or isinstance(allowance, bool) or allowance <= 0: |
| raise ValueError('allowance must be a positive integer') |
| active: dict[str, dict[str, str]] = {} |
| for request in requests: |
| if not isinstance(request, dict) or set(request) != {'record_ref', 'correction_class'}: |
| raise ValueError('each request must contain record_ref and correction_class') |
| record_ref = request['record_ref'] |
| correction_class = request['correction_class'] |
| if record_ref not in self.records or correction_class not in DATA_CORRECTION_CLASSES: |
| raise ValueError('task request is outside the correction slice') |
| if record_ref in active: |
| raise ValueError('task requests must not repeat a correction record') |
| active[record_ref] = ext_deepcopy(request) |
| self.active_task_id = task_id |
| self.active_requests = active |
| self.active_order = list(active) |
| self.episode_entry_raw = self.manager.snapshot() |
| self.episode_transaction_start = len(self.manager.transactions) |
| self.resources = fn__empty_resources() |
| self.allowance = allowance |
| self.remaining = allowance |
| self.receipts = [] |
| self.committed = {} |
| return {'status': 'success', 'task_id': task_id, 'active_record_count': len(active), 'allowance': allowance, 'entry_business_hash': self.business_hash()} |
|
|
| def _oracle_clinical_one_correction_get_context(self, arguments): |
| record = self._active_record(arguments['record_ref']) |
| delta = {'context_requests': 1} |
| if record is None: |
| return (self._result('get_correction_context', 'error', code='CORRECTION_RECORD_NOT_ACTIVE', message='no active correction dossier matches this reference'), delta) |
| state = self._correctable_state(record) |
| if state is None: |
| return (self._result('get_correction_context', 'error', code='FORM_NOT_CORRECTABLE', message='the active dossier is not a completed saved form'), delta) |
| (form, visit) = state |
| delta['context_rows_read'] = 1 |
| return (self._result('get_correction_context', 'success', {'record_ref': record['record_ref'], 'correction_handle': self.handles[record['record_ref']], 'visit_type': visit['visit_type'], 'current_value': self._record_value(record), 'completion_evidence': {'form_status': form['status'], 'save_state': form['save_state']}}), delta) |
|
|
| def _oracle_clinical_one_correction_apply_2(self, arguments): |
| delta = {'write_requests': 1} |
| record = self.records_by_handle.get(arguments['correction_handle']) |
| if record is None or record['record_ref'] not in self.active_requests: |
| delta['failed_write_requests'] = 1 |
| return (self._result('apply_form_correction', 'error', code='CORRECTION_HANDLE_NOT_ACTIVE', message='the correction handle is not active'), delta) |
| active = self.active_requests[record['record_ref']] |
| if arguments['correction_class'] != active['correction_class']: |
| delta['failed_write_requests'] = 1 |
| return (self._result('apply_form_correction', 'error', code='CORRECTION_CLASS_MISMATCH', message='the correction class does not match the active request'), delta) |
| record_index = self.active_order.index(record['record_ref']) |
| pending = [record_ref for record_ref in self.active_order[:record_index] if record_ref not in self.committed] |
| if pending: |
| delta['failed_write_requests'] = 1 |
| return (self._result('apply_form_correction', 'error', code='PRIORITY_REQUEST_PENDING', message='an earlier correction request must be completed first'), delta) |
| cell = (record['visit_type'], arguments['correction_class']) |
| expected_profile = self.policy_matrix[cell] |
| if arguments['audit_profile_id'] != expected_profile: |
| if self.rule_revalidation.get(cell) == 'awaiting_exact_stale' and arguments['audit_profile_id'] == DATA_POLICY_MATRIX[cell]: |
| self.rule_revalidation[cell] = 'awaiting_current_policy' |
| delta['failed_write_requests'] = 1 |
| return (self._result('apply_form_correction', 'error', code='CORRECTION_POLICY_MISMATCH', message='the audit profile does not satisfy the current correction policy'), delta) |
| committed = self.committed.get(record['record_ref']) |
| if committed is not None: |
| if committed == {'corrected_value': arguments['corrected_value'], 'correction_class': arguments['correction_class'], 'audit_profile_id': arguments['audit_profile_id']}: |
| delta['idempotent_replays'] = 1 |
| return (self._result('apply_form_correction', 'success', {'record_ref': record['record_ref'], 'correction_handle': arguments['correction_handle'], 'corrected_value': arguments['corrected_value'], 'audit_profile_id': arguments['audit_profile_id'], 'form_status': 'complete', 'save_state': 'saved', 'audit_recorded': True, 'idempotent': True}), delta) |
| delta['failed_write_requests'] = 1 |
| return (self._result('apply_form_correction', 'error', code='CORRECTION_ALREADY_APPLIED', message='this dossier already has a committed correction in the current task'), delta) |
| if self._record_value(record) == arguments['corrected_value']: |
| delta['failed_write_requests'] = 1 |
| return (self._result('apply_form_correction', 'error', code='NO_VALUE_CHANGE', message='the replacement value must differ from the current value'), delta) |
| if self._correctable_state(record) is None: |
| delta['failed_write_requests'] = 1 |
| return (self._result('apply_form_correction', 'error', code='FORM_NOT_CORRECTABLE', message='the active dossier is not a completed saved form'), delta) |
| before = self.manager.snapshot() |
| reason = DATA_AUDIT_PROFILES[expected_profile] |
| expected_after = self._expected_raw_after(before, record, arguments['corrected_value'], reason) |
| delta['raw_calls'] = 1 |
| try: |
| raw_result = self.raw_update(self.manager, visit_id=record['visit_id'], question_id=record['question_id'], new_value=arguments['corrected_value'], reason_for_change=reason, ui_selection=arguments['correction_handle']) |
| except Exception: |
| self.manager.restore(before) |
| delta['failed_write_requests'] = 1 |
| return (self._result('apply_form_correction', 'error', code='RAW_CORRECTION_FAILED', message='the raw correction failed without committing clinical state'), delta) |
| if raw_result.get('status') != 'succeeded' or raw_result.get('error_code') is not None or self.manager.snapshot() != expected_after: |
| self.manager.restore(before) |
| delta['failed_write_requests'] = 1 |
| return (self._result('apply_form_correction', 'error', code='RAW_POSTCONDITION_FAILED', message='the raw correction did not produce the declared atomic artifact'), delta) |
| self.committed[record['record_ref']] = {'corrected_value': arguments['corrected_value'], 'correction_class': arguments['correction_class'], 'audit_profile_id': arguments['audit_profile_id']} |
| if self.rule_revalidation.get(cell) in {'awaiting_exact_stale', 'awaiting_current_policy'}: |
| self.rule_revalidation[cell] = 'ready_current' |
| delta['raw_writes_committed'] = 1 |
| delta['transactions_appended'] = 1 |
| return (self._result('apply_form_correction', 'success', {'record_ref': record['record_ref'], 'correction_handle': arguments['correction_handle'], 'corrected_value': arguments['corrected_value'], 'audit_profile_id': arguments['audit_profile_id'], 'form_status': 'complete', 'save_state': 'saved', 'audit_recorded': True, 'idempotent': False}), delta) |
|
|
| def _oracle_evolution_snapshot(self): |
| value = self._oracle_clinical_one_correction_snapshot() |
| value['evolution_contract'] = {'case_version': 'oracle-correction-lifecycle-evolution-v1', 'schedule': ext_deepcopy(DATA_SCHEDULE_2)} |
| return value |
|
|
| def _oracle_evolution_restore(self, snapshot): |
| value = ext_deepcopy(snapshot) |
| if value.pop('evolution_contract', None) != {'case_version': 'oracle-correction-lifecycle-evolution-v1', 'schedule': DATA_SCHEDULE_2}: |
| raise ValueError('Oracle evolution contract differs') |
| self._oracle_clinical_one_correction_restore(value) |
|
|
| def _oracle_clinical_one_correction_snapshot(self): |
| return {'schema': 'oracle-clinical-one-form-correction/v7', 'source_lock_closure_sha256': self.source_lock['snapshot_identity_sha256'], 'raw_state': self.manager.snapshot(), 'active_task_id': self.active_task_id, 'active_requests': ext_deepcopy(self.active_requests), 'active_order': ext_deepcopy(self.active_order), 'policy_matrix': {f'{visit_type}|{correction_class}': profile_id for ((visit_type, correction_class), profile_id) in self.policy_matrix.items()}, 'applied_boundary_events': sorted(self.applied_boundary_events), 'rule_revalidation': {f'{visit_type}|{correction_class}': state for ((visit_type, correction_class), state) in self.rule_revalidation.items()}, 'episode_entry_raw': ext_deepcopy(self.episode_entry_raw), 'episode_transaction_start': self.episode_transaction_start, 'resources': ext_deepcopy(self.resources), 'allowance': self.allowance, 'remaining': self.remaining, 'receipts': ext_deepcopy(self.receipts), 'committed': ext_deepcopy(self.committed)} |
|
|
| def _oracle_clinical_one_correction_restore(self, snapshot): |
| if snapshot.get('schema') != 'oracle-clinical-one-form-correction/v7': |
| raise ValueError('unsupported Oracle correction snapshot') |
| if snapshot.get('source_lock_closure_sha256') != self.source_lock['snapshot_identity_sha256']: |
| raise ValueError('snapshot raw source closure does not match') |
| self.manager.restore(ext_deepcopy(snapshot['raw_state'])) |
| self.active_task_id = snapshot.get('active_task_id') |
| self.active_requests = ext_deepcopy(snapshot.get('active_requests', {})) |
| self.active_order = ext_deepcopy(snapshot.get('active_order', list(self.active_requests))) |
| self.policy_matrix = {tuple(key.split('|', 1)): profile_id for (key, profile_id) in snapshot.get('policy_matrix', {}).items()} |
| if set(self.policy_matrix) != set(DATA_POLICY_MATRIX): |
| raise ValueError('snapshot correction policy matrix is incomplete') |
| self.applied_boundary_events = set(snapshot.get('applied_boundary_events', [])) |
| self.rule_revalidation = {tuple(key.split('|', 1)): state for (key, state) in snapshot.get('rule_revalidation', {}).items()} |
| self.episode_entry_raw = ext_deepcopy(snapshot.get('episode_entry_raw')) |
| self.episode_transaction_start = int(snapshot.get('episode_transaction_start', 0)) |
| self.resources = ext_deepcopy(snapshot.get('resources', fn__empty_resources())) |
| self.allowance = int(snapshot.get('allowance', 18)) |
| self.remaining = int(snapshot.get('remaining', self.allowance)) |
| self.receipts = ext_deepcopy(snapshot.get('receipts', [])) |
| self.committed = ext_deepcopy(snapshot.get('committed', {})) |
|
|
