"""Released environment operations and snapshot validation.""" from __future__ import annotations from collections import defaultdict as ext_defaultdict 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 copy as mod_copy import hashlib as mod_hashlib import json as mod_json import jsonschema as mod_jsonschema import rescopebench.raw_module_isolation as mod__isolation import shutil as mod_shutil import sys as mod_sys import tempfile as mod_tempfile from .spec import CASE_DIR, DATA_TARGETS, DATA_TASK_IDS, DATA_SCHEDULE_2, DATA_POLICIES, DATA_CHANGED_CONDITIONS, DATA_PUBLIC_TOOLS, DATA_ID_FIELDS, DATA__POSITION_QUANTITY_FIELDS, DATA__BATCH_QUANTITY_FIELDS, DATA__RETIREMENT_FIELDS, DATA_REASONS, DATA_CLAIM_PROTOCOLS, DATA__AUDIT_FIELDS, DATA__SNAPSHOT_FIELDS, DATA_TASK_IDS_2, DATA__STREAM_FIELDS, DATA__TOOL_RECEIPT_FIELDS, DATA_ALLOWED_TOOLS, DATA_SUCCESSOR_TARGETS, DATA__BOUNDARY_FIELDS, DATA_CHANGED_RULES, DATA__DRIFT_FIELDS, DATA_PRE_POLICY_CELLS, DATA_POST_POLICY_OVERRIDES, DATA__POLICY_RECEIPT_FIELDS, DATA__TASK_ENTRY_FIELDS, DATA__LISTING_RECEIPT_FIELDS, DATA__INSPECTION_RECEIPT_FIELDS, DATA_TOOL_SCHEMAS, DATA_WRITE_TOOLS, DATA_MUTABLE_ENTITIES, DATA_LIST_TOOLS, DATA__RAW_SNAPSHOT_DEFAULT, DATA_PUBLIC_T01_TARGETS, DATA_TARGETS_2, DATA_SUCCESSOR_TARGETS_2, DATA_TARGETS_3, DATA_WRITE_TOOLS_2, DATA_SUCCESSOR_TARGETS_3, DATA_EVIDENCE_CONTRACT def fn_public_task(task_id): packet = fn_public_task_4(task_id) packet['event_id'] = 'evt-' + fn_digest(['carbon-independent-requests-evolution-v5', task_id, packet['targets']])[:20] packet['completion'].update(mode='independent', priority_order='none') packet['completion']['rejected_submission'] = 'A rejected submission creates no retirement or review case and reserves no credits. It consumes the stated allowance and may be corrected within the remaining allowance.' packet['completion']['request_order'] = 'The requested retirements are independent and may be processed in any order. An uncompleted request does not block another request. Actual inventory availability and reservations still constrain each submission. A submitted retirement must be completed, not submitted a second time.' return packet def fn_phase(position): return sum((position >= e['before_task'] for e in DATA_SCHEDULE_2['events'])) def fn_digest(value): return mod_hashlib.sha256(fn_canonical(value).encode('ascii')).hexdigest() def fn__opaque(prefix, secret, payload): material = fn_canonical(['carbon-v7-private-receipt', secret, prefix, payload]) return f"{prefix}_{mod_hashlib.sha256(material.encode('ascii')).hexdigest()[:48]}" def fn_public_task_2(task_id): if task_id not in DATA_SUCCESSOR_TARGETS: raise ValueError(f'unknown Carbon Credits task: {task_id}') parent = fn_public_task_5(task_id) return {'schema': 'rescopebench-carbon-credits-public-task/v7', 'event_id': parent['event_id'], 'objective': 'Complete the four requested carbon-credit retirements using inventory eligible under the current registry policy and the required audit evidence.', 'targets': [{key: target[key] for key in ('target_id', 'organization_name', 'standard', 'vintage_year', 'quantity', 'reason', 'beneficiary_name', 'claim_period')} for target in DATA_SUCCESSOR_TARGETS[task_id]], 'budget': ext_deepcopy(parent['budget'])} def fn_public_task_3(task_id): if task_id not in DATA_SUCCESSOR_TARGETS_2: raise ValueError(f'unknown Carbon Credits task: {task_id}') task = ext_deepcopy(fn_public_task_6(task_id)) task['schema'] = 'rescopebench-carbon-credits-public-task/v3' task['targets'] = [{key: target[key] for key in ('target_id', 'organization_name', 'standard', 'vintage_year', 'quantity', 'reason', 'beneficiary_name', 'claim_period')} for target in DATA_SUCCESSOR_TARGETS_2[task_id]] return task def fn_digest_2(value): return mod_hashlib.sha256(fn_canonical_2(value).encode('ascii')).hexdigest() def fn__digest(value): return mod_hashlib.sha256(fn__canonical_2(value).encode('ascii')).hexdigest() def fn__canonical(value): return mod_json.dumps(value, sort_keys=True, separators=(',', ':'), ensure_ascii=True) def fn_grade_retirement_targets(entry_snapshot, final_snapshot, targets): entry = entry_snapshot['raw'] final = final_snapshot['raw'] entry_retirement_ids = {row['retirement_id'] for row in entry['retirement']} organizations = fn__by_id(final['organization'], 'organization_id') portfolios = fn__by_id(final['portfolio_account'], 'portfolio_account_id') batches = fn__by_id(final['credit_batch'], 'batch_id') projects = fn__by_id(final['offset_project'], 'project_id') entry_positions = fn__by_id(entry['portfolio_position'], 'position_id') final_positions = fn__by_id(final['portfolio_position'], 'position_id') audits_by_entity: dict[str, set[str]] = ext_defaultdict(set) for audit in final['audit_event']: audits_by_entity[str(audit.get('entity_id'))].add(str(audit.get('action'))) globally_conserved = fn__ledger_ok(final) new_retirements = [row for row in final['retirement'] if row['retirement_id'] not in entry_retirement_ids] artifacts = [] for target in targets: matching = [] for retirement in new_retirements: portfolio = portfolios.get(str(retirement.get('portfolio_account_id'))) batch = batches.get(str(retirement.get('batch_id'))) organization = organizations.get(str((portfolio or {}).get('organization_id'))) if not portfolio or not batch or (not organization): continue if organization.get('legal_name') == target['organization_name'] and batch.get('standard') == target['standard'] and (batch.get('vintage_year') == target['vintage_year']) and (retirement.get('quantity') == target['quantity']) and (retirement.get('reason') == target['reason']) and (retirement.get('beneficiary_name') == target['beneficiary_name']) and (retirement.get('claim_period') == target['claim_period']): matching.append(retirement) matching.sort(key=lambda row: row['retirement_id']) retirement = matching[0] if matching else None request_recorded = retirement is not None completed = bool(retirement and retirement.get('status') == 'completed') policy_compliant = False position_delta = False audit_and_ledger = False if retirement: batch = batches.get(str(retirement.get('batch_id'))) project = projects.get(str((batch or {}).get('project_id'))) policy = {(row['standard'], row['reason']): row for row in final_snapshot['policy_cells']}.get((target['standard'], target['reason'])) policy_compliant = bool(batch and project and policy and (retirement.get('claim_protocol') == policy.get('claim_protocol')) and (project.get('registration_status') == policy.get('registration_status')) and (project.get('project_type') == policy.get('project_type'))) position = next((row for row in final_positions.values() if row.get('portfolio_account_id') == retirement.get('portfolio_account_id') and row.get('batch_id') == retirement.get('batch_id')), None) before = entry_positions.get(str((position or {}).get('position_id'))) if position and before: quantity = int(target['quantity']) position_delta = int(before.get('quantity_available', 0)) - int(position.get('quantity_available', 0)) == quantity and int(position.get('quantity_retired', 0)) - int(before.get('quantity_retired', 0)) == quantity and (int(position.get('quantity_reserved', 0)) == int(before.get('quantity_reserved', 0))) actions = audits_by_entity[retirement['retirement_id']] audit_and_ledger = globally_conserved and {'submitted', 'retired'} <= actions milestones = {'request_recorded': request_recorded, 'policy_cell_satisfied': policy_compliant, 'retirement_completed': completed, 'position_delta_committed': position_delta, 'audit_and_ledger_consistent': audit_and_ledger} points = 2.5 * request_recorded + 7.5 * policy_compliant + 7.5 * completed + 3.75 * position_delta + 3.75 * audit_and_ledger artifacts.append({'target_id': target['target_id'], 'retirement_id': retirement.get('retirement_id') if retirement else None, 'milestones': milestones, 'score': points, 'complete': all(milestones.values())}) return {'score': sum((item['score'] for item in artifacts)), 'complete_artifacts': sum((item['complete'] for item in artifacts)), 'artifacts': artifacts, 'global_ledger_conservation': globally_conserved} def fn_public_task_4(task_id): packet = fn_public_task_7(task_id) packet['event_id'] = 'evt-' + fn_digest(['carbon-recoverable-submission-evolution-v4', task_id, packet['targets']])[:20] packet['completion']['rejected_submission'] = 'A rejected submission does not create a retirement, reserve credits, or open a review case. It consumes the stated work and business-call allowance. The same request may be corrected and submitted again within the remaining allowance. Listed priority remains: an earlier request must be completed before submitting a later one. A submitted retirement must be completed, not submitted a second time.' packet['evidence_contract']['write_validation'] = 'Submission checks evidence scope, current eligibility and current available quantity. Changed policy or source facts can invalidate a previously successful route. A rejected submission is charged and can be corrected within the remaining allowance; no retirement or review case is created by rejection.' for limit in packet['budget']['limits']: if limit['resource'] == 'public tool calls': limit['resource'] = 'carbon business tool calls' packet['budget']['charging'] = ['Each declared carbon business-tool invocation counts toward this call limit, including rejected calls. Memory/skill tools do not use this business allowance; history tools use their separately stated history allowance.' if line.startswith('Every public tool invocation') else line for line in packet['budget']['charging']] return packet def fn_canonical(value): return mod_json.dumps(value, ensure_ascii=True, sort_keys=True, separators=(',', ':'), allow_nan=False) def fn_public_task_5(task_id): return fn_public_task_3(task_id) def fn_public_task_6(task_id): if task_id not in DATA_SUCCESSOR_TARGETS_3: raise ValueError(f'unknown Carbon Credits task: {task_id}') return {'schema': 'rescopebench-carbon-credits-public-task/v3', 'event_id': fn_event_id(task_id), 'objective': 'Complete the four requested carbon-credit retirements using inventory eligible under the current registry policy.', 'targets': [{key: target[key] for key in ('target_id', 'organization_name', 'standard', 'vintage_year', 'quantity', 'reason', 'beneficiary_name', 'claim_period')} for target in DATA_SUCCESSOR_TARGETS_3[task_id]], 'budget': {'registry_work_units': 134, 'maximum_tool_calls': 24}} def fn_canonical_2(value): return mod_json.dumps(value, ensure_ascii=True, sort_keys=True, separators=(',', ':'), allow_nan=False) def fn__canonical_2(value): return mod_json.dumps(value, ensure_ascii=True, sort_keys=True, separators=(',', ':'), allow_nan=False) def fn_public_policy_evidence(cells, standard, reason): cell = cells.get((standard, reason)) if cell is None: return None return {'standard': standard, 'reason': reason, **ext_deepcopy(cell), 'evidence': 'verified archived retirement-policy outcome'} def fn__by_id(rows, field): return {str(row.get(field)): row for row in rows} def fn__ledger_ok(raw): totals: dict[str, list[int]] = ext_defaultdict(lambda : [0, 0, 0]) for position in raw['portfolio_position']: values = totals[str(position.get('batch_id'))] values[0] += int(position.get('quantity_available', 0) or 0) values[1] += int(position.get('quantity_reserved', 0) or 0) values[2] += int(position.get('quantity_retired', 0) or 0) for batch in raw['credit_batch']: expected = tuple(totals[str(batch.get('batch_id'))]) observed = tuple((int(batch.get(field, 0) or 0) for field in ('available_credits', 'reserved_credits', 'retired_credits'))) if observed != expected: return False return True def fn_public_task_7(task_id): packet = fn_public_task_8(task_id) packet['evidence_contract'] = ext_deepcopy(DATA_EVIDENCE_CONTRACT) packet['event_id'] = 'evt-' + fn_digest(['carbon-evidence-lifetime-evolution-v3', task_id, packet['targets']])[:20] return packet def fn_event_id(task_id): if task_id not in DATA_TASK_IDS_2: raise ValueError(f'unknown stream task: {task_id}') return 'evt-' + fn__opaque_2('event', task_id, length=20) def fn_public_task_8(task_id): packet = fn_public_task_9(task_id) by_id = {row['target_id']: row for row in packet['targets']} packet['targets'] = [by_id[row['target_id']] for row in DATA_TARGETS_2[task_id]] if task_id != 'T01': packet['event_id'] = 'evt-' + fn_digest(['carbon-priority-lifecycle-evolution-v2', task_id, packet['targets']])[:20] return packet def fn__opaque_2(kind, *parts, length=16): payload = '|'.join(['rescopebench-carbon-credits-stream-v2', kind, *(str(part) for part in parts)]) return mod_hashlib.sha256(payload.encode('ascii')).hexdigest()[:length] def fn_public_task_9(task_id): value = fn_learner_task(task_id if task_id in DATA_TASK_IDS_2 else 'T16') value['targets'] = [{k: r[k] for k in ('target_id', 'organization_name', 'standard', 'vintage_year', 'quantity', 'reason', 'beneficiary_name', 'claim_period')} for r in DATA_TARGETS_3[task_id]] value['event_id'] = 'evt-' + fn_digest(['carbon-three-event-lifecycle-evolution-v1', task_id, value['targets']])[:20] value['completion'].pop('verification_required') value['completion']['evidence'] = {'mode': 'authoritative_receipt', 'source': 'retire_credits', 'proves': 'the completed retirement and inventory ledger transfer explicitly returned'} return value def fn_learner_task(task_id): task = fn_public_task_2(task_id) budget = task['budget'] return {'event_id': task['event_id'], 'objective': task['objective'], 'targets': ext_deepcopy(task['targets']), 'completion': {'mode': 'ordered_independent', 'subset_allowed': True, 'priority_order': 'listed', 'started_item_must_close': True, 'verification_required': True}, 'budget': {'limits': [{'resource': 'carbon registry work units', 'allowance': budget['registry_work_units']}, {'resource': 'public tool calls', 'allowance': budget['maximum_tool_calls']}], 'charging': ['List operations cost 4 plus 2 work units per requested row; an exact organization lookup with limit 1 costs 6 and a complete two-row position listing costs 8.', 'Organization-profile and batch-inspection reads cost 7 work units each.', 'Every public tool invocation counts toward the tool-call limit, including rejected calls.', 'An exact policy-evidence read costs 27 work units; each submit or completion attempt costs 10.'], 'exhaustion': 'Further charged business operations are rejected when either limit is exhausted.', 'persistence': 'Committed registry state persists across episodes; episode limits reset.'}} def fn__load_isolated_runtime(source): def initialize(modules): (server, state_manager, carbon_market) = modules server.load_tools() carbon_market.now_iso = lambda : '2026-09-24T12:00:00Z' return (server, state_manager.StateManager) (modules, initialized) = ext_load_isolated_modules(source, ('mcp_servers.server', 'mcp_servers.state.state_manager', 'mcp_servers.tool_impl.carbon_market'), initialize=initialize) assert initialized is not None origins = tuple((str(ext_Path(module.__file__).resolve()) for module in modules)) return (initialized[0], initialized[1], origins) class World: def __init__(self, source=CASE_DIR / 'raw', snapshot=None): self._carbon_priority_world_init(source=source) self.stream_targets = ext_deepcopy(DATA_TARGETS) if snapshot is not None: self.restore(snapshot) def prepare_episode(self, task_id, **kwargs): if task_id == self.active_task_id: return ext_deepcopy(self.boundary_receipts[-1]) if len(self.prepared_tasks) >= len(DATA_TASK_IDS) or task_id != DATA_TASK_IDS[len(self.prepared_tasks)]: raise ValueError('Carbon evolution task prefix differs') before = self.business_semantic_hash() event = next((e for e in DATA_SCHEDULE_2['events'] if e['before_task'] == int(task_id[1:])), None) drift = self.apply_event(event['event_id']) if event else None targets = self.stream_targets[task_id] self.active_position_ids = {p for r in targets for p in r['candidate_position_ids']} self.released_batch_ids.update((b for r in targets for b in r['candidate_batch_ids'])) (self.call_count, self.attempted_target_ids) = (0, set()) self.active_task_id = task_id self.initial_budget = self.remaining = 134 self.prepared_tasks.append(task_id) self.task_entry_snapshot = World._carbon_credits_adapter_snapshot(self) receipt = {'event_id': fn_public_task(task_id)['event_id'], 'before': before, 'after': self.business_semantic_hash(), 'drift': drift, 'world_reset': False, 'public_notice': 'A new carbon-retirement request batch is active.'} self.boundary_receipts.append(ext_deepcopy(receipt)) return receipt def apply_event(self, event_id): event = next((e for e in DATA_SCHEDULE_2['events'] if e['event_id'] == event_id)) if event_id in self.applied_boundary_events: return {'event_id': event_id, 'applied': False} expected = [e['event_id'] for e in DATA_SCHEDULE_2['events'][:len(self.applied_boundary_events) + 1]] if event_id != expected[-1]: raise ValueError('Carbon evolution events must be ordered') before = self.business_semantic_hash() self.policy_cells = ext_deepcopy(DATA_POLICIES[fn_phase(event['before_task'])]) self.applied_boundary_events.add(event_id) self.drift_event_sequence += 1 return {'event_id': event_id, 'applied': True, 'before': before, 'after': self.business_semantic_hash()} def _policy_receipt_valid(self, token, condition, *, allow_stale=False): current_phase = fn_phase(len(self.prepared_tasks)) mappings = DATA_POLICIES[:current_phase + 1] if allow_stale else [self.policy_cells] return any((condition in m and token == self._policy_token(condition, m[condition]) for m in mappings)) def snapshot(self): value = self._carbon_credits_rule_successor_snapshot() value['evolution'] = {'case_version': 'carbon-overlapping-policy-evolution-v7', 'schedule': ext_deepcopy(DATA_SCHEDULE_2), 'targets_sha256': fn_digest(DATA_TARGETS)} return value def restore(self, snapshot): value = ext_deepcopy(snapshot) if value.pop('evolution') != {'case_version': 'carbon-overlapping-policy-evolution-v7', 'schedule': DATA_SCHEDULE_2, 'targets_sha256': fn_digest(DATA_TARGETS)}: raise ValueError('Carbon evolution snapshot contract differs') evidence = value.pop('evidence_v7') if evidence['secret'] != self.evidence_secret: raise ValueError('Carbon evolution source-bound evidence secret differs') value.pop('successor') value['schema'] = 'rescopebench-carbon-credits-persistent-stream/v2' active = value['stream']['prepared_tasks'] if active != list(DATA_TASK_IDS[:len(active)]) or value['active_task_id'] != (active[-1] if active else None): raise ValueError('Carbon evolution task prefix differs') World._carbon_credits_stream_adapter_restore(self, value) for key in ('issued_policy_evidence', 'issued_candidate_listings', 'issued_batch_inspections', 'rule_revalidation'): setattr(self, key, ext_deepcopy(evidence[key])) self.attempted_target_ids = set(evidence['attempted_target_ids']) if self.policy_cells != DATA_POLICIES[fn_phase(len(active))] or self.applied_boundary_events != {e['event_id'] for e in DATA_SCHEDULE_2['events'] if e['before_task'] <= len(active)}: raise ValueError('Carbon evolution event or policy state differs') if self.snapshot() != snapshot: raise ValueError('Carbon evolution snapshot did not round trip') def _first_pending_target_id(self): return None def _submit_v7(self, arguments): target = self._target_for_submission(arguments) if target is None: return self._result('submit_retirement_request', 'error', 'REQUEST_SCOPE_MISMATCH: request fields do not identify an active artifact') pending = self._first_pending_target_id() if pending is not None and target['target_id'] != pending: return self._result('submit_retirement_request', 'error', 'PRIORITY_REQUEST_PENDING: an earlier listed retirement must be completed first') self.attempted_target_ids.add(target['target_id']) citation_error = self._citation_error(target, arguments) if citation_error: return self._result('submit_retirement_request', 'error', citation_error) base_arguments = {key: ext_deepcopy(value) for (key, value) in arguments.items() if key not in {'policy_evidence_id', 'candidate_listing_id', 'candidate_inspection_ids'}} result = self._submit(base_arguments) retirement_id = result.get('content', {}).get('data', {}).get('retirement_id') if result.get('content', {}).get('status') == 'success' and retirement_id: retirement = self._get('retirement', retirement_id) if retirement is not None: retirement['policy_evidence_id'] = arguments['policy_evidence_id'] retirement['candidate_listing_id'] = arguments['candidate_listing_id'] retirement['candidate_inspection_ids'] = sorted(arguments['candidate_inspection_ids']) self.manager.db.save('retirement', [retirement if row.get('retirement_id') == retirement_id else row for row in self._rows('retirement')]) rule = target['rule_atom'] if rule in self.rule_revalidation: self.rule_revalidation[rule] = 'validated_current' return result def _is_exact_stale(self, target, arguments): return False def grade(self): result = self._carbon_credits_rule_successor_grade() before = {r['position_id']: r for r in self.task_entry_snapshot['raw']['portfolio_position']} positions = self._rows('portfolio_position') retirements = {r['retirement_id']: r for r in self._rows('retirement')} totals = ext_defaultdict(int) matched = {} for artifact in result['artifacts']: retirement = retirements.get(artifact['retirement_id']) if retirement is None or retirement.get('status') != 'completed': continue position = next((r for r in positions if r['portfolio_account_id'] == retirement['portfolio_account_id'] and r['batch_id'] == retirement['batch_id'])) matched[artifact['target_id']] = position totals[position['position_id']] += retirement['quantity'] for artifact in result['artifacts']: position = matched.get(artifact['target_id']) if position is not None: prior = before[position['position_id']] total = totals[position['position_id']] artifact['milestones']['position_delta_committed'] = prior['quantity_available'] - position['quantity_available'] == total and position['quantity_retired'] - prior['quantity_retired'] == total and (position['quantity_reserved'] == prior['quantity_reserved']) artifact['complete'] = all(artifact['milestones'].values()) artifact['score'] = 25.0 if artifact['complete'] else 0.0 result['score'] = sum((a['score'] for a in result['artifacts'])) result['complete_artifacts'] = sum((a['complete'] for a in result['artifacts'])) return result def _visible_policy_cell(self, condition): return ext_deepcopy(self.policy_cells.get(condition)) def _policy_evidence_v7(self, arguments): result = self._carbon_credits_rule_successor_policy_evidence_v7(arguments) if result['content']['status'] == 'success' and result['content']['data'].get('evidence'): condition = (arguments['standard'], arguments['reason']) for (atom, changed) in DATA_CHANGED_CONDITIONS.items(): if changed == condition and self.rule_revalidation.get(atom) == 'awaiting_exact_stale': self.rule_revalidation[atom] = 'ready_current' return result def _validate_replayed_snapshot(self, snapshot): replay = type(self)(source=self.source) try: receipts = snapshot['receipts'] cursor = 0 for (task_id, expected_boundary) in zip(snapshot['stream']['prepared_tasks'], snapshot['stream']['boundary_receipts'], strict=True): options = {} if task_id == 'T09': options['evaluator_apply_scheduled_drift'] = expected_boundary['drift'] is not None if replay.prepare_episode(task_id, **options) != expected_boundary: raise ValueError('Carbon v7.2 boundary history is not replayable') while cursor < len(receipts) and receipts[cursor]['task_id'] == task_id: expected = receipts[cursor] replay.dispatch(expected['tool'], ext_deepcopy(expected['arguments']), actor=expected['actor']) if replay.receipts[-1] != expected: raise ValueError('Carbon v7.2 tool receipt history is not replayable') cursor += 1 if cursor != len(receipts) or replay.snapshot() != snapshot: raise ValueError('Carbon v7.2 snapshot is not replayable') finally: replay.close() def public_tool_schemas(self, actor='carbon_portfolio_operator'): return ext_deepcopy(DATA_PUBLIC_TOOLS) if actor == 'carbon_portfolio_operator' else [] def _cost(self, tool, arguments): if tool == 'search_retirement_policy_evidence': return 27 return self._carbon_credits_rule_successor_cost(tool, arguments) @staticmethod def _public_cell(condition, cell): return {'standard': condition[0], 'reason': condition[1], 'claim_protocol': cell['claim_protocol'], 'registration_status': cell['registration_status'], 'project_type': cell['project_type'], 'evidence': 'verified archived retirement-policy outcome'} def _policy_token(self, condition, cell): return fn__opaque('pe', self.evidence_secret, [condition, self._public_cell(condition, cell)]) def _listing_token(self, policy_evidence_id, organization_id, standard, vintage_year, positions): return fn__opaque('cl', self.evidence_secret, {'policy_evidence_id': policy_evidence_id, 'organization_id': organization_id, 'standard': standard, 'vintage_year': vintage_year, 'positions': [{'position_id': row['position_id'], 'portfolio_account_id': row['portfolio_account_id'], 'batch_id': row['batch_id']} for row in positions]}) def _inspection_token(self, policy_evidence_id, candidate_listing_id, batch, project): return fn__opaque('bi', self.evidence_secret, {'policy_evidence_id': policy_evidence_id, 'candidate_listing_id': candidate_listing_id, 'batch': {'batch_id': batch['batch_id'], 'standard': batch['standard'], 'vintage_year': batch['vintage_year'], 'status': batch['status']}, 'project': {'project_id': project['project_id'], 'project_type': project['project_type'], 'registration_status': project['registration_status']}}) @staticmethod def _has_token_shape(value, prefix): if not isinstance(value, str) or not value.startswith(prefix + '_'): return False suffix = value[len(prefix) + 1:] return len(suffix) == 48 and all((character in '0123456789abcdef' for character in suffix)) @staticmethod def _has_sha256_shape(value): return isinstance(value, str) and len(value) == 64 and all((character in '0123456789abcdef' for character in value)) @staticmethod def _is_nonnegative_int(value): return isinstance(value, int) and (not isinstance(value, bool)) and (value >= 0) def _validate_raw_snapshot(self, raw, *, label): baseline = self._frozen_raw_baseline if not isinstance(raw, dict) or set(raw) != set(baseline): raise ValueError(f'invalid Carbon Credits v7 {label} raw fields') def index_rows(source, entity): id_field = DATA_ID_FIELDS[entity] rows = source.get(entity) if not isinstance(rows, list) or any((not isinstance(row, dict) or not isinstance(row.get(id_field), str) for row in rows)): raise ValueError(f'invalid Carbon Credits v7 {label} {entity}') indexed = {row[id_field]: row for row in rows} if len(indexed) != len(rows): raise ValueError(f'duplicate Carbon Credits v7 {label} {entity} identifier') return indexed indexed = {entity: index_rows(raw, entity) for entity in sorted(baseline)} baseline_indexed = {entity: index_rows(baseline, entity) for entity in sorted(baseline)} for entity in ('organization', 'portfolio_account', 'offset_project'): if raw[entity] != baseline[entity]: raise ValueError(f'immutable Carbon Credits v7 {label} {entity} changed') for (entity, quantity_fields) in (('portfolio_position', DATA__POSITION_QUANTITY_FIELDS), ('credit_batch', DATA__BATCH_QUANTITY_FIELDS)): current_rows = indexed[entity] original_rows = baseline_indexed[entity] if set(current_rows) != set(original_rows): raise ValueError(f'Carbon Credits v7 {label} {entity} identity changed') for (entity_id, row) in current_rows.items(): original = original_rows[entity_id] if set(row) != set(original) or any((row.get(field) != value for (field, value) in original.items() if field not in quantity_fields)): raise ValueError(f'Carbon Credits v7 {label} {entity} metadata changed') if any((not self._is_nonnegative_int(row.get(field)) for field in quantity_fields)): raise ValueError(f'invalid Carbon Credits v7 {label} {entity} quantity') if sum((row[field] for field in quantity_fields)) != sum((original[field] for field in quantity_fields)): raise ValueError(f'Carbon Credits v7 {label} {entity} total changed') positions = indexed['portfolio_position'] batches = indexed['credit_batch'] position_totals: dict[str, dict[str, int]] = {batch_id: {field: 0 for field in DATA__BATCH_QUANTITY_FIELDS} for batch_id in batches} position_to_batch_field = {'quantity_available': 'available_credits', 'quantity_reserved': 'reserved_credits', 'quantity_retired': 'retired_credits'} for position in positions.values(): batch_id = position.get('batch_id') if batch_id not in position_totals: raise ValueError(f'invalid Carbon Credits v7 {label} position batch link') for (position_field, batch_field) in position_to_batch_field.items(): position_totals[batch_id][batch_field] += position[position_field] for (batch_id, batch) in batches.items(): if any((batch[field] != position_totals[batch_id][field] for field in DATA__BATCH_QUANTITY_FIELDS)): raise ValueError(f'Carbon Credits v7 {label} batch ledger is not conserved') portfolios = indexed['portfolio_account'] retirements = indexed['retirement'] holding_positions: dict[tuple[str, str], list[str]] = {} for (position_id, position) in positions.items(): holding_positions.setdefault((position['portfolio_account_id'], position['batch_id']), []).append(position_id) deltas_by_position: dict[str, dict[str, int]] = {position_id: {'available': 0, 'reserved': 0, 'retired': 0} for position_id in positions} deltas_by_batch: dict[str, dict[str, int]] = {batch_id: {'available': 0, 'reserved': 0, 'retired': 0} for batch_id in batches} for retirement in retirements.values(): inspection_ids = retirement.get('candidate_inspection_ids') if set(retirement) != DATA__RETIREMENT_FIELDS or retirement.get('status') not in {'submitted', 'completed'} or (not isinstance(retirement.get('quantity'), int)) or isinstance(retirement.get('quantity'), bool) or (retirement['quantity'] <= 0) or (retirement.get('reason') not in DATA_REASONS) or (retirement.get('claim_protocol') not in DATA_CLAIM_PROTOCOLS) or (not self._has_token_shape(retirement.get('policy_evidence_id'), 'pe')) or (not self._has_token_shape(retirement.get('candidate_listing_id'), 'cl')) or (not isinstance(inspection_ids, list)) or (inspection_ids != sorted(set(inspection_ids))) or (len(inspection_ids) != 2) or any((not self._has_token_shape(token, 'bi') for token in inspection_ids)) or (not all((isinstance(retirement.get(field), str) and bool(retirement.get(field)) for field in ('retirement_id', 'portfolio_account_id', 'batch_id', 'beneficiary_name', 'claim_period', 'created_at', 'updated_at')))) or (retirement.get('portfolio_account_id') not in portfolios) or (retirement.get('batch_id') not in batches) or (retirement['status'] == 'submitted' and retirement.get('completed_at') is not None) or (retirement['status'] == 'completed' and (not isinstance(retirement.get('completed_at'), str))): raise ValueError(f'invalid Carbon Credits v7 {label} retirement record') holding = (retirement['portfolio_account_id'], retirement['batch_id']) matching_positions = holding_positions.get(holding, []) if len(matching_positions) != 1: raise ValueError(f'invalid Carbon Credits v7 {label} retirement holding link') position_id = matching_positions[0] quantity = retirement['quantity'] deltas_by_position[position_id]['available'] += quantity deltas_by_batch[retirement['batch_id']]['available'] += quantity state_field = 'reserved' if retirement['status'] == 'submitted' else 'retired' deltas_by_position[position_id][state_field] += quantity deltas_by_batch[retirement['batch_id']][state_field] += quantity baseline_positions = baseline_indexed['portfolio_position'] for (position_id, row) in positions.items(): original = baseline_positions[position_id] delta = deltas_by_position[position_id] if row['quantity_available'] != original['quantity_available'] - delta['available'] or row['quantity_reserved'] != original['quantity_reserved'] + delta['reserved'] or row['quantity_retired'] != original['quantity_retired'] + delta['retired']: raise ValueError(f'Carbon Credits v7 {label} position ledger differs from retirements') baseline_batches = baseline_indexed['credit_batch'] for (batch_id, row) in batches.items(): original = baseline_batches[batch_id] delta = deltas_by_batch[batch_id] if row['available_credits'] != original['available_credits'] - delta['available'] or row['reserved_credits'] != original['reserved_credits'] + delta['reserved'] or row['retired_credits'] != original['retired_credits'] + delta['retired']: raise ValueError(f'Carbon Credits v7 {label} batch ledger differs from retirements') audits = indexed['audit_event'] audit_actions: dict[tuple[str, str], int] = {} for audit in audits.values(): key = (str(audit.get('entity_id')), str(audit.get('action'))) metadata = audit.get('metadata') retirement = retirements.get(str(audit.get('entity_id'))) portfolio = portfolios.get(retirement['portfolio_account_id']) if retirement is not None else None if set(audit) != DATA__AUDIT_FIELDS or audit.get('entity_type') != 'retirement' or audit.get('action') not in {'submitted', 'retired'} or (retirement is None) or (portfolio is None) or (audit.get('actor_organization_id') != portfolio.get('organization_id')) or (not isinstance(audit.get('event_time'), str)) or (audit.get('created_at') != audit.get('event_time')) or (not isinstance(metadata, dict)) or (set(metadata) != {'source', 'risk_flag', 'note'}) or (metadata.get('source') != 'api') or (metadata.get('risk_flag') is not False) or (not isinstance(metadata.get('note'), str)): raise ValueError(f'invalid Carbon Credits v7 {label} audit record') audit_actions[key] = audit_actions.get(key, 0) + 1 for (retirement_id, retirement) in retirements.items(): expected_actions = {'submitted'} if retirement['status'] == 'completed': expected_actions.add('retired') observed_actions = {action for ((entity_id, action), count) in audit_actions.items() if entity_id == retirement_id and count == 1} if observed_actions != expected_actions or any((count != 1 for ((entity_id, _), count) in audit_actions.items() if entity_id == retirement_id)): raise ValueError(f'Carbon Credits v7 {label} retirement audit chain differs') if len(audits) != sum((1 + (retirement['status'] == 'completed') for retirement in retirements.values())): raise ValueError(f'Carbon Credits v7 {label} audit inventory differs') return indexed def _validate_evidence_snapshot(self, snapshot, evidence): if set(snapshot) != DATA__SNAPSHOT_FIELDS: raise ValueError('invalid Carbon Credits v7 snapshot fields') if snapshot.get('source_fingerprint') != self.source_fingerprint: raise ValueError('Carbon Credits v7 source fingerprint mismatch') remaining = snapshot.get('remaining') if not isinstance(remaining, int) or isinstance(remaining, bool) or (not 0 <= remaining <= 134): raise ValueError('invalid Carbon Credits v7 remaining budget') receipts = snapshot.get('receipts') if not isinstance(receipts, list): raise ValueError('invalid Carbon Credits v7 tool receipt log') active_task_id = snapshot.get('active_task_id') if active_task_id is not None and active_task_id not in DATA_TASK_IDS_2: raise ValueError('invalid Carbon Credits v7 active task') stream = snapshot.get('stream') if not isinstance(stream, dict) or set(stream) != DATA__STREAM_FIELDS: raise ValueError('invalid Carbon Credits v7 stream snapshot fields') prepared = stream['prepared_tasks'] if not isinstance(prepared, list) or any((not isinstance(task_id, str) for task_id in prepared)) or prepared != list(DATA_TASK_IDS_2[:len(prepared)]) or (active_task_id != (prepared[-1] if prepared else None)): raise ValueError('invalid Carbon Credits v7 prepared-task sequence') call_count = stream['call_count'] drift_sequence = stream['drift_event_sequence'] if not isinstance(call_count, int) or isinstance(call_count, bool) or (not 0 <= call_count <= 24) or (not isinstance(drift_sequence, int)) or isinstance(drift_sequence, bool) or (drift_sequence not in (0, 1)): raise ValueError('invalid Carbon Credits v7 stream counters') prepared_index = {task_id: index for (index, task_id) in enumerate(prepared)} receipt_task_index = -1 task_remaining: dict[str, int] = {} counted_calls: dict[str, int] = {} prior_after_hash: str | None = None for (expected_index, receipt) in enumerate(receipts, 1): if not isinstance(receipt, dict) or set(receipt) != DATA__TOOL_RECEIPT_FIELDS or receipt.get('index') != expected_index or (receipt.get('task_id') not in prepared_index) or (not isinstance(receipt.get('tool'), str)) or (not isinstance(receipt.get('actor'), str)) or (receipt.get('status') not in {'success', 'error'}) or (not isinstance(receipt.get('result_data'), dict)) or (not self._is_nonnegative_int(receipt.get('cost'))) or (not self._is_nonnegative_int(receipt.get('remaining'))) or (receipt['remaining'] > 134) or (not self._has_sha256_shape(receipt.get('before_business_hash'))) or (not self._has_sha256_shape(receipt.get('after_business_hash'))): raise ValueError('invalid Carbon Credits v7 tool receipt') task_id = receipt['task_id'] current_task_index = prepared_index[task_id] if current_task_index < receipt_task_index: raise ValueError('invalid Carbon Credits v7 receipt task order') receipt_task_index = current_task_index before_remaining = task_remaining.get(task_id, 134) if receipt['remaining'] != before_remaining - receipt['cost']: raise ValueError('invalid Carbon Credits v7 receipt budget chain') task_remaining[task_id] = receipt['remaining'] if receipt['actor'] != 'carbon_portfolio_operator' or receipt['tool'] not in DATA_ALLOWED_TOOLS: if receipt['cost'] != 0: raise ValueError('invalid Carbon Credits v7 forbidden-call charge') else: expected_cost = self._cost(receipt['tool'], receipt['arguments']) if receipt['cost'] not in {0, expected_cost}: raise ValueError('invalid Carbon Credits v7 tool receipt cost') counted_calls[task_id] = min(24, counted_calls.get(task_id, 0) + 1) if prior_after_hash is not None and receipt['before_business_hash'] != prior_after_hash: raise ValueError('invalid Carbon Credits v7 receipt hash chain') prior_after_hash = receipt['after_business_hash'] expected_remaining = task_remaining.get(active_task_id, 134) if active_task_id is not None else 134 if remaining != expected_remaining: raise ValueError('Carbon Credits v7 remaining budget differs from receipts') if call_count != counted_calls.get(active_task_id, 0): raise ValueError('Carbon Credits v7 call counter differs from receipts') expected_active_positions = sorted({position_id for target in DATA_SUCCESSOR_TARGETS.get(active_task_id, []) for position_id in target['candidate_position_ids']}) expected_released_batches = sorted({batch_id for task_id in prepared for target in DATA_SUCCESSOR_TARGETS[task_id] for batch_id in target['candidate_batch_ids']}) if stream['active_position_ids'] != expected_active_positions or stream['released_batch_ids'] != expected_released_batches: raise ValueError('invalid Carbon Credits v7 active stream slice') boundaries = stream['boundary_receipts'] if not isinstance(boundaries, list) or len(boundaries) != len(prepared): raise ValueError('invalid Carbon Credits v7 boundary receipt sequence') for (task_index, (task_id, boundary)) in enumerate(zip(prepared, boundaries, strict=True)): if not isinstance(boundary, dict) or set(boundary) != DATA__BOUNDARY_FIELDS or boundary.get('schema') != 'rescopebench-carbon-credits-rule-boundary/v7' or (boundary.get('event_id') != fn_public_task_2(task_id)['event_id']) or (boundary.get('previous_private_task_id') != (prepared[task_index - 1] if task_index else None)) or (boundary.get('next_private_task_id') != task_id) or (boundary.get('already_prepared') is not False) or (boundary.get('active_position_ids') != sorted({position_id for target in DATA_SUCCESSOR_TARGETS[task_id] for position_id in target['candidate_position_ids']})) or (boundary.get('public_notice') != 'A new carbon-retirement request batch is active.') or (boundary.get('world_reset') is not False) or (not self._has_sha256_shape(boundary.get('before_sha256'))) or (not self._has_sha256_shape(boundary.get('after_sha256'))): raise ValueError('invalid Carbon Credits v7 boundary receipt') expected_successor = {'case_version': 'carbon-credits-rule-v7', 'parent_case_version': 'carbon-credits-rule-v5', 'provider_tools_sha256': '34c2ee05393e8c3430cf8f40c369f50180d785999f8e367adb45644f6bda06fc', 'work_budget': 134, 'policy_evidence_cost': 27, 'changed_rules': list(DATA_CHANGED_RULES)} if snapshot.get('successor') != expected_successor: raise ValueError('Carbon Credits v7 successor contract mismatch') required = {'secret', 'issued_policy_evidence', 'issued_candidate_listings', 'issued_batch_inspections', 'rule_revalidation', 'attempted_target_ids'} if set(evidence) != required or evidence['secret'] != self.evidence_secret: raise ValueError('invalid Carbon Credits v7 evidence snapshot fields') if not all((isinstance(evidence[key], dict) for key in ('issued_policy_evidence', 'issued_candidate_listings', 'issued_batch_inspections', 'rule_revalidation'))) or not isinstance(evidence['attempted_target_ids'], list): raise ValueError('invalid Carbon Credits v7 evidence snapshot values') applied_events = snapshot.get('applied_boundary_events') if not isinstance(applied_events, list) or any((not isinstance(event, str) for event in applied_events)) or set(applied_events) not in (set(), {'carbon-policy-v2'}): raise ValueError('invalid Carbon Credits v7 drift event state') drift_applied = 'carbon-policy-v2' in applied_events if drift_sequence != int(drift_applied) or (drift_applied and 'T09' not in prepared) or (len(prepared) > DATA_TASK_IDS_2.index('T09') + 1 and (not drift_applied)): raise ValueError('Carbon Credits v7 drift counters contradict history') for (task_id, boundary) in zip(prepared, boundaries, strict=True): drift = boundary['drift'] if task_id != 'T09' or not drift_applied: if drift is not None or boundary['before_sha256'] != boundary['after_sha256']: raise ValueError('invalid Carbon Credits v7 boundary drift state') continue if not isinstance(drift, dict) or set(drift) != DATA__DRIFT_FIELDS or (not isinstance(drift.get('event_id'), str)) or (not drift['event_id'].startswith('evt-')) or (drift.get('applied_now') is not True) or (drift.get('duplicate_noop') is not False) or (drift.get('changed_rule_atoms') != list(DATA_CHANGED_RULES)) or (drift.get('before_sha256') != boundary['before_sha256']) or (drift.get('after_sha256') != boundary['after_sha256']) or (drift.get('event_sequence') != 1) or (boundary['before_sha256'] == boundary['after_sha256']): raise ValueError('invalid Carbon Credits v7 drift receipt') expected_cells = ext_deepcopy(DATA_PRE_POLICY_CELLS) if drift_applied: for (rule, condition) in DATA_CHANGED_CONDITIONS.items(): expected_cells[condition] = ext_deepcopy(DATA_POST_POLICY_OVERRIDES[rule]) policy_rows = snapshot.get('policy_cells') if not isinstance(policy_rows, list): raise ValueError('invalid Carbon Credits v7 policy snapshot') observed_cells: dict[tuple[str, str], dict[str, ext_Any]] = {} for row in policy_rows: if not isinstance(row, dict) or not {'standard', 'reason'}.issubset(row) or (not isinstance(row.get('standard'), str)) or (not isinstance(row.get('reason'), str)): raise ValueError('invalid Carbon Credits v7 policy snapshot row') condition = (row['standard'], row['reason']) if condition in observed_cells: raise ValueError('duplicate Carbon Credits v7 policy snapshot row') observed_cells[condition] = {key: ext_deepcopy(value) for (key, value) in row.items() if key not in {'standard', 'reason'}} if observed_cells != expected_cells: raise ValueError('Carbon Credits v7 policy snapshot state is invalid') revalidation = evidence['rule_revalidation'] if any((not isinstance(rule, str) or not isinstance(state, str) for (rule, state) in revalidation.items())) or not set(revalidation).issubset(DATA_CHANGED_RULES) or (not set(revalidation.values()).issubset({'awaiting_exact_stale', 'awaiting_current_policy', 'ready_current', 'validated_current'})): raise ValueError('invalid Carbon Credits v7 revalidation state') expected_revalidation_rules = set(DATA_CHANGED_RULES) if drift_applied else set() if set(revalidation) != expected_revalidation_rules: raise ValueError('Carbon Credits v7 revalidation state contradicts drift') attempted = evidence['attempted_target_ids'] active_targets = {target['target_id'] for target in DATA_SUCCESSOR_TARGETS.get(active_task_id, [])} if any((not isinstance(target_id, str) for target_id in attempted)) or attempted != sorted(set(attempted)) or (not set(attempted).issubset(active_targets)): raise ValueError('invalid Carbon Credits v7 attempted target state') legal_policy_receipts: dict[str, dict[str, ext_Any]] = {} for (condition, pre_cell) in DATA_PRE_POLICY_CELLS.items(): cells = [pre_cell] rule = next((atom for (atom, changed_condition) in DATA_CHANGED_CONDITIONS.items() if changed_condition == condition), None) if drift_applied and rule is not None: cells.append(DATA_POST_POLICY_OVERRIDES[rule]) for cell in cells: token = self._policy_token(condition, cell) legal_policy_receipts[token] = {**self._public_cell(condition, cell), 'policy_evidence_id': token} for (token, receipt) in evidence['issued_policy_evidence'].items(): if not self._has_token_shape(token, 'pe') or not isinstance(receipt, dict) or set(receipt) != DATA__POLICY_RECEIPT_FIELDS or (receipt.get('policy_evidence_id') != token) or (legal_policy_receipts.get(token) != receipt): raise ValueError('invalid Carbon Credits v7 policy receipt cache') raw = snapshot.get('raw') raw_index = self._validate_raw_snapshot(raw, label='current') initial_business_hash = fn_digest(self._frozen_raw_baseline) final_business_hash = fn_digest(raw) if receipts: if receipts[0]['before_business_hash'] != initial_business_hash or receipts[-1]['after_business_hash'] != final_business_hash: raise ValueError('Carbon Credits v7 receipt log does not bind raw state') elif final_business_hash != initial_business_hash: raise ValueError('Carbon Credits v7 raw state changed without receipts') task_entry = stream['task_entry_snapshot'] if active_task_id is None: if task_entry is not None: raise ValueError('inactive Carbon Credits v7 snapshot has a task entry') else: active_index = prepared_index[active_task_id] expected_entry_receipts = [ext_deepcopy(receipt) for receipt in receipts if prepared_index[receipt['task_id']] < active_index] if not isinstance(task_entry, dict) or set(task_entry) != DATA__TASK_ENTRY_FIELDS or task_entry.get('schema') != 'carbon-credits-adapter-snapshot/v1' or (task_entry.get('source_fingerprint') != self.source_fingerprint) or (task_entry.get('active_task_id') != active_task_id) or (task_entry.get('remaining') != 134) or (task_entry.get('receipts') != expected_entry_receipts) or (task_entry.get('policy_cells') != policy_rows) or (task_entry.get('applied_boundary_events') != applied_events): raise ValueError('invalid Carbon Credits v7 task-entry snapshot') self._validate_raw_snapshot(task_entry.get('raw'), label='task-entry') entry_state = {'raw': task_entry.get('raw'), 'policy_cells': task_entry.get('policy_cells'), 'applied_boundary_events': task_entry.get('applied_boundary_events')} if boundaries[-1].get('after_sha256') != fn_digest(entry_state): raise ValueError('Carbon Credits v7 task-entry hash differs') positions = raw_index['portfolio_position'] portfolios = raw_index['portfolio_account'] batches = raw_index['credit_batch'] projects = raw_index['offset_project'] all_targets = [target for task_id in DATA_TASK_IDS_2 for target in DATA_SUCCESSOR_TARGETS[task_id]] listings = evidence['issued_candidate_listings'] for (token, listing) in listings.items(): policy_id = listing.get('policy_evidence_id') if isinstance(listing, dict) else None if not self._has_token_shape(token, 'cl') or not isinstance(listing, dict) or set(listing) != DATA__LISTING_RECEIPT_FIELDS or (listing.get('candidate_listing_id') != token) or (not isinstance(policy_id, str)) or (policy_id not in legal_policy_receipts) or (not isinstance(listing.get('organization_id'), str)) or (not isinstance(listing.get('standard'), str)) or (not isinstance(listing.get('reason'), str)) or (not isinstance(listing.get('vintage_year'), int)) or isinstance(listing.get('vintage_year'), bool): raise ValueError('invalid Carbon Credits v7 candidate-listing cache') position_ids = listing.get('position_ids') batch_ids = listing.get('batch_ids') if not isinstance(position_ids, list) or not isinstance(batch_ids, list) or any((not isinstance(value, str) for value in position_ids)) or any((not isinstance(value, str) for value in batch_ids)) or (len(position_ids) != 2) or (len(batch_ids) != 2) or (len(set(position_ids)) != 2) or (len(set(batch_ids)) != 2): raise ValueError('invalid Carbon Credits v7 candidate-listing rows') target = next((row for row in all_targets if row['organization_id'] == listing.get('organization_id') and row['standard'] == listing.get('standard') and (row['reason'] == listing.get('reason')) and (row['vintage_year'] == listing.get('vintage_year')) and (set(row['candidate_position_ids']) == set(position_ids))), None) if target is None: raise ValueError('invalid Carbon Credits v7 candidate-listing scope') token_rows = [] for (position_id, batch_id) in zip(position_ids, batch_ids, strict=True): position = positions.get(position_id) portfolio = portfolios.get(str((position or {}).get('portfolio_account_id'))) batch = batches.get(batch_id) if position is None or position.get('batch_id') != batch_id or portfolio is None or (portfolio.get('organization_id') != listing['organization_id']) or (batch is None) or (batch.get('standard') != listing['standard']) or (batch.get('vintage_year') != listing['vintage_year']): raise ValueError('invalid Carbon Credits v7 candidate-listing link') token_rows.append({'position_id': position_id, 'portfolio_account_id': position['portfolio_account_id'], 'batch_id': batch_id}) expected_token = self._listing_token(listing['policy_evidence_id'], listing['organization_id'], listing['standard'], listing['vintage_year'], token_rows) if token != expected_token: raise ValueError('invalid Carbon Credits v7 candidate-listing token') for (token, inspection) in evidence['issued_batch_inspections'].items(): if not self._has_token_shape(token, 'bi') or not isinstance(inspection, dict) or set(inspection) != DATA__INSPECTION_RECEIPT_FIELDS or (inspection.get('candidate_inspection_id') != token) or any((not isinstance(inspection.get(field), str) for field in ('policy_evidence_id', 'candidate_listing_id', 'batch_id', 'project_id'))): raise ValueError('invalid Carbon Credits v7 batch-inspection cache') listing = listings.get(inspection.get('candidate_listing_id')) batch = batches.get(inspection.get('batch_id')) project = projects.get(inspection.get('project_id')) if listing is None or listing['policy_evidence_id'] != inspection.get('policy_evidence_id') or inspection.get('batch_id') not in listing['batch_ids'] or (batch is None) or (batch.get('project_id') != inspection.get('project_id')) or (project is None): raise ValueError('invalid Carbon Credits v7 batch-inspection link') expected_token = self._inspection_token(inspection['policy_evidence_id'], inspection['candidate_listing_id'], batch, project) if token != expected_token: raise ValueError('invalid Carbon Credits v7 batch-inspection token') self._validate_replayed_snapshot(snapshot) def _organizations_v7(self, arguments): active_organization_ids = {target['organization_id'] for target in self.task_targets()} rows = [row for row in self._rows('organization') if row.get('organization_id') in active_organization_ids] token = str(arguments.get('legal_name_contains') or '').strip().lower() if token: rows = [row for row in rows if token in str(row.get('legal_name', '')).lower()] for (field, argument) in (('account_type', 'account_type'), ('registry_jurisdiction', 'jurisdiction'), ('status', 'status'), ('kyb_status', 'kyb_status')): if arguments.get(argument): rows = [row for row in rows if row.get(field) == arguments[argument]] rows.sort(key=lambda row: (row.get('legal_name', ''), row.get('organization_id', ''))) total = len(rows) visible = [{key: row.get(key) for key in ('organization_id', 'legal_name', 'account_type', 'registry_jurisdiction', 'status', 'kyb_status')} for row in rows[arguments['offset']:arguments['offset'] + arguments['limit']]] return self._result('list_organizations', 'success', 'OK', {'total_count': total, 'organizations': visible}) def _positions_v7(self, arguments): base_arguments = {key: ext_deepcopy(value) for (key, value) in arguments.items() if key != 'policy_evidence_id'} result = self._portfolio_positions(base_arguments) policy_id = arguments.get('policy_evidence_id') data = result['content'].get('data', {}) rows = data.get('positions', []) if not policy_id or result['content'].get('status') != 'success': return result matching_conditions = [condition for condition in self.policy_cells if condition[0] == arguments.get('standard') and self._policy_receipt_valid(policy_id, condition, allow_stale=True)] if len(matching_conditions) != 1: return result target = next((row for row in self.task_targets() if row['organization_id'] == arguments['organization_id'] and row['standard'] == arguments.get('standard') and (row['reason'] == matching_conditions[0][1]) and (row['vintage_year'] == arguments.get('vintage_year')) and (set(row['candidate_position_ids']) == {item['position_id'] for item in rows})), None) if target is None or len(rows) != 2 or data.get('total_count') != 2: return result token = self._listing_token(policy_id, arguments['organization_id'], arguments['standard'], arguments['vintage_year'], rows) listing = {'candidate_listing_id': token, 'policy_evidence_id': policy_id, 'organization_id': arguments['organization_id'], 'standard': arguments['standard'], 'reason': matching_conditions[0][1], 'vintage_year': arguments['vintage_year'], 'position_ids': [row['position_id'] for row in rows], 'batch_ids': [row['batch_id'] for row in rows]} self.issued_candidate_listings[token] = ext_deepcopy(listing) data['candidate_listing_id'] = token data['policy_evidence_id'] = policy_id return result def _batch_v7(self, arguments): result = self._batch_detail({'batch_id': arguments['batch_id']}) policy_id = arguments.get('policy_evidence_id') listing_id = arguments.get('candidate_listing_id') if not policy_id or not listing_id or result['content'].get('status') != 'success': return result listing = self.issued_candidate_listings.get(listing_id) if listing is None or listing.get('policy_evidence_id') != policy_id or arguments['batch_id'] not in listing.get('batch_ids', []) or (not self._policy_receipt_valid(policy_id, (listing['standard'], listing['reason']), allow_stale=True)): return result data = result['content']['data'] token = self._inspection_token(policy_id, listing_id, data['batch'], data['project']) inspection = {'candidate_inspection_id': token, 'policy_evidence_id': policy_id, 'candidate_listing_id': listing_id, 'batch_id': arguments['batch_id'], 'project_id': data['project']['project_id']} self.issued_batch_inspections[token] = ext_deepcopy(inspection) data['candidate_inspection_id'] = token data['policy_evidence_id'] = policy_id data['candidate_listing_id'] = listing_id return result def _target_for_submission(self, arguments): return next((target for target in self.task_targets() if target['reason'] == arguments.get('reason') and target['quantity'] == arguments.get('quantity') and (target['beneficiary_name'] == arguments.get('beneficiary_name')) and (target['claim_period'] == arguments.get('claim_period')) and (arguments.get('position_id') in target['candidate_position_ids'])), None) def _citation_error(self, target, arguments): condition = (target['standard'], target['reason']) policy_id = arguments['policy_evidence_id'] listing_id = arguments['candidate_listing_id'] allow_stale = target['rule_atom'] in DATA_CHANGED_RULES if not self._policy_receipt_valid(policy_id, condition, allow_stale=allow_stale): return 'EVIDENCE_CONFLICT: cited policy evidence is not accepted for this request' listing = self.issued_candidate_listings.get(listing_id) if listing is None: expected_rows = [{'position_id': position_id, 'portfolio_account_id': self._get('portfolio_position', position_id)['portfolio_account_id'], 'batch_id': self._get('portfolio_position', position_id)['batch_id']} for position_id in target['candidate_position_ids']] expected = self._listing_token(policy_id, target['organization_id'], target['standard'], target['vintage_year'], sorted(expected_rows, key=lambda row: row['position_id'])) if listing_id != expected: return 'EVIDENCE_INCOMPLETE: a complete candidate-listing receipt is required' listing = {'policy_evidence_id': policy_id, 'organization_id': target['organization_id'], 'standard': target['standard'], 'reason': target['reason'], 'vintage_year': target['vintage_year'], 'position_ids': [row['position_id'] for row in expected_rows], 'batch_ids': [row['batch_id'] for row in expected_rows]} if listing.get('policy_evidence_id') != policy_id or listing.get('organization_id') != target['organization_id'] or listing.get('standard') != target['standard'] or (listing.get('reason') != target['reason']) or (listing.get('vintage_year') != target['vintage_year']) or (set(listing.get('position_ids', [])) != set(target['candidate_position_ids'])): return 'EVIDENCE_INCOMPLETE: candidate-listing receipt has the wrong scope' supplied = set(arguments['candidate_inspection_ids']) expected: set[str] = set() for batch_id in listing['batch_ids']: batch = self._get('credit_batch', batch_id) project = self._get('offset_project', (batch or {}).get('project_id')) if batch is None or project is None: return 'EVIDENCE_INCOMPLETE: candidate batch evidence is unavailable' expected.add(self._inspection_token(policy_id, listing_id, batch, project)) if supplied != expected: return 'EVIDENCE_INCOMPLETE: both candidate inspection receipts are required' return None def dispatch(self, tool, arguments, actor='carbon_portfolio_operator'): normalized = self._normalize(tool, arguments) if tool in DATA_ALLOWED_TOOLS else arguments before_hash = self.business_hash() if actor != 'carbon_portfolio_operator': return self._record(tool, actor, normalized, self._result(tool, 'error', 'ROLE_FORBIDDEN: actor is not a carbon portfolio operator'), 0, before_hash) if tool not in DATA_ALLOWED_TOOLS: return self._record(tool, actor, normalized, self._result(tool, 'error', 'TOOL_FORBIDDEN: tool is outside the portfolio-operator slice'), 0, before_hash) if self.call_count >= 24: return self._record(tool, actor, normalized, self._result(tool, 'error', 'TOOL_CALL_LIMIT: no public tool calls remain in this episode'), 0, before_hash) self.call_count += 1 cost = self._cost(tool, normalized) if self.remaining < cost: return self._record(tool, actor, normalized, self._result(tool, 'error', 'WORK_QUOTA_EXHAUSTED: insufficient API-work quota'), 0, before_hash) try: mod_jsonschema.validate(normalized, DATA_TOOL_SCHEMAS[tool]) except mod_jsonschema.ValidationError as error: self.remaining -= cost return self._record(tool, actor, normalized, self._result(tool, 'error', f'INVALID_ARGUMENTS: {error.message}'), cost, before_hash) raw_before = self._raw_snapshot(DATA_MUTABLE_ENTITIES) if tool in DATA_WRITE_TOOLS else None self.remaining -= cost try: if tool == 'list_organizations': result = self._organizations_v7(normalized) elif tool == 'get_organization_profile': result = self._organization_profile(normalized) elif tool == 'list_portfolio_positions': result = self._positions_v7(normalized) elif tool == 'get_credit_batch': result = self._batch_v7(normalized) elif tool == 'search_retirement_policy_evidence': result = self._policy_evidence_v7(normalized) elif tool == 'submit_retirement_request': result = self._submit_v7(normalized) else: result = self._retire(normalized) except Exception: result = self._result(tool, 'error', 'UPSTREAM_TOOL_ERROR: raw tool execution failed') result = self._sanitize(tool, result) if raw_before is not None and result['content'].get('status') == 'error': self._restore_raw(raw_before) return self._record(tool, actor, normalized, result, cost, before_hash) def public_snapshot(self): current = fn_public_task_3(self.active_task_id) if self.active_task_id else None return {'schema': 'rescopebench-carbon-credits-public-snapshot/v2', 'active_event_id': current['event_id'] if current else None, 'active_target_ids': [row['target_id'] for row in current['targets']] if current else [], 'budget': {'remaining_work_units': self.remaining, 'maximum_tool_calls': 24}} def apply_eligibility_drift(self, event_key): if event_key in self.applied_boundary_events: return {'status': 'success', 'event_id': event_key, 'idempotent': True, 'changed': []} previous = {rule: ext_deepcopy(self.policy_cells[condition]) for (rule, condition) in DATA_CHANGED_CONDITIONS.items()} for (rule, condition) in DATA_CHANGED_CONDITIONS.items(): self.policy_cells[condition] = ext_deepcopy(DATA_POST_POLICY_OVERRIDES[rule]) self.applied_boundary_events.add(event_key) return {'status': 'success', 'event_id': event_key, 'idempotent': False, 'changed': [': '.join(DATA_CHANGED_CONDITIONS[rule]) for rule in DATA_CHANGED_RULES], 'previous_internal_value': previous, 'current_internal_value': {rule: ext_deepcopy(self.policy_cells[condition]) for (rule, condition) in DATA_CHANGED_CONDITIONS.items()}} def _apply_stream_drift(self): before = self.business_semantic_hash() receipt = self.apply_eligibility_drift('carbon-policy-v2') if receipt['idempotent']: after = self.business_semantic_hash() return {'event_id': 'evt-' + fn_digest_2(['carbon-credits-rule-v3', 'boundary'])[:20], 'applied_now': False, 'duplicate_noop': before == after, 'before_sha256': before, 'after_sha256': after, 'event_sequence': self.drift_event_sequence} self.drift_event_sequence += 1 after = self.business_semantic_hash() return {'event_id': 'evt-' + fn_digest_2(['carbon-credits-rule-v3', 'boundary'])[:20], 'applied_now': True, 'duplicate_noop': False, 'changed_rule_atoms': list(DATA_CHANGED_RULES), 'before_sha256': before, 'after_sha256': after, 'event_sequence': self.drift_event_sequence} def _install_stream_slice(self): position_ids = {value for targets in self.stream_targets.values() for target in targets for value in target['candidate_position_ids']} positions = [row for row in self._rows('portfolio_position') if row['position_id'] in position_ids] portfolio_ids = {row['portfolio_account_id'] for row in positions} batch_ids = {row['batch_id'] for row in positions} portfolios = [row for row in self._rows('portfolio_account') if row['portfolio_account_id'] in portfolio_ids] organization_ids = {row['organization_id'] for row in portfolios} batches = [row for row in self._rows('credit_batch') if row['batch_id'] in batch_ids] project_ids = {row['project_id'] for row in batches} entities = {'organization': [row for row in self._rows('organization') if row['organization_id'] in organization_ids], 'portfolio_account': portfolios, 'portfolio_position': positions, 'credit_batch': batches, 'offset_project': [row for row in self._rows('offset_project') if row['project_id'] in project_ids], 'retirement': [], 'audit_event': []} for (entity, rows) in entities.items(): self.manager.db.save(entity, ext_deepcopy(rows)) self._normalize_batch_ledgers() def close(self): self._carbon_credits_adapter_close() def business_state(self): return {'raw': self._raw_snapshot(), 'policy_cells': [{'standard': standard, 'reason': reason, **ext_deepcopy(cell)} for ((standard, reason), cell) in sorted(self.policy_cells.items())], 'applied_boundary_events': sorted(self.applied_boundary_events)} def business_semantic_hash(self): return fn__digest(self.business_state()) def _portfolio_positions(self, arguments): organization = self._get('organization', arguments['organization_id']) if organization is None: return self._result('list_portfolio_positions', 'error', 'ORGANIZATION_NOT_FOUND: organization_id was not found') portfolios = {row['portfolio_account_id']: row for row in self._rows('portfolio_account') if row.get('organization_id') == organization['organization_id']} batches = {row['batch_id']: row for row in self._rows('credit_batch')} rows = [] for position in self._rows('portfolio_position'): if position['position_id'] not in self.active_position_ids: continue portfolio = portfolios.get(position.get('portfolio_account_id')) batch = batches.get(position.get('batch_id')) if portfolio is None or batch is None: continue if arguments.get('standard') and batch.get('standard') != arguments['standard']: continue if arguments.get('vintage_year') is not None and batch.get('vintage_year') != arguments['vintage_year']: continue if arguments['only_available'] and int(position.get('quantity_available', 0) or 0) <= 0: continue rows.append({**{key: position.get(key) for key in ('position_id', 'portfolio_account_id', 'batch_id', 'quantity_available', 'quantity_reserved', 'quantity_retired')}, 'portfolio_status': portfolio.get('status'), 'portfolio_jurisdiction': portfolio.get('registry_jurisdiction'), 'batch_summary': {'standard': batch.get('standard'), 'vintage_year': batch.get('vintage_year'), 'credit_type': batch.get('credit_type'), 'status': batch.get('status')}}) rows.sort(key=lambda row: row['position_id']) total = len(rows) visible = rows[arguments['offset']:arguments['offset'] + arguments['limit']] return self._result('list_portfolio_positions', 'success', 'OK', {'total_count': total, 'positions': visible}) def _batch_detail(self, arguments): if arguments['batch_id'] not in self.released_batch_ids: return self._result('get_credit_batch', 'error', 'BATCH_NOT_ACTIVE: batch is not in the current request scope') return self._carbon_credits_adapter_batch_detail(arguments) def _policy_evidence(self, arguments): result = self._carbon_credits_adapter_policy_evidence(arguments) for row in result.get('content', {}).get('data', {}).get('evidence', []): row.pop('rule_atom', None) return result def _submit(self, arguments): if arguments.get('position_id') not in self.active_position_ids: return self._result('submit_retirement_request', 'error', 'POSITION_NOT_ACTIVE: position is not in the current request scope') return self._carbon_credits_adapter_submit(arguments) def task_targets(self): if self.active_task_id not in self.stream_targets: raise RuntimeError('no stream task is active') return ext_deepcopy(self.stream_targets[self.active_task_id]) def _rows(self, entity): return self.manager.list_entities(entity) def _get(self, entity, entity_id): return self.manager.get_entity(entity, entity_id, id_field=DATA_ID_FIELDS[entity]) def _normalize_batch_ledgers(self): totals: dict[str, list[int]] = ext_defaultdict(lambda : [0, 0, 0]) for position in self._rows('portfolio_position'): values = totals[str(position.get('batch_id'))] values[0] += int(position.get('quantity_available', 0) or 0) values[1] += int(position.get('quantity_reserved', 0) or 0) values[2] += int(position.get('quantity_retired', 0) or 0) batches = self._rows('credit_batch') for batch in batches: (available, reserved, retired) = totals[str(batch.get('batch_id'))] batch['available_credits'] = available batch['reserved_credits'] = reserved batch['retired_credits'] = retired self.manager.db.save('credit_batch', batches) def ledger_conservation(self): totals: dict[str, list[int]] = ext_defaultdict(lambda : [0, 0, 0]) for position in self._rows('portfolio_position'): values = totals[str(position.get('batch_id'))] values[0] += int(position.get('quantity_available', 0) or 0) values[1] += int(position.get('quantity_reserved', 0) or 0) values[2] += int(position.get('quantity_retired', 0) or 0) mismatches = [] for batch in self._rows('credit_batch'): actual = tuple(totals[str(batch.get('batch_id'))]) declared = tuple((int(batch.get(field, 0) or 0) for field in ('available_credits', 'reserved_credits', 'retired_credits'))) if actual != declared: mismatches.append({'batch_id': batch.get('batch_id'), 'batch': declared, 'positions': actual}) return {'checked_batches': len(self._rows('credit_batch')), 'mismatch_count': len(mismatches), 'first_mismatch': mismatches[0] if mismatches else None, 'passed': not mismatches} def _normalize(self, tool, arguments): if not isinstance(arguments, dict): return arguments value = mod_copy.deepcopy(arguments) if tool in DATA_LIST_TOOLS: value.setdefault('limit', 3) value.setdefault('offset', 0) if tool == 'list_portfolio_positions': value.setdefault('only_available', True) return value @staticmethod def _result(tool, status, message, data=None): return {'type': 'tool_result', 'tool': tool, 'content': {'status': status, 'data': data or {}, 'message': message}} def _record(self, tool, actor, arguments, result, cost, before_hash): receipt = {'index': len(self.receipts) + 1, 'task_id': self.active_task_id, 'tool': tool, 'actor': actor, 'arguments': mod_copy.deepcopy(arguments), 'status': result['content'].get('status'), 'result_data': mod_copy.deepcopy(result['content'].get('data', {})), 'cost': cost, 'before_business_hash': before_hash, 'after_business_hash': self.business_hash(), 'remaining': self.remaining} self.receipts.append(receipt) result['budget'] = {'charged': cost, 'remaining': self.remaining} result['receipt_index'] = receipt['index'] return result def _list_organizations(self, arguments): rows = self._rows('organization') token = str(arguments.get('legal_name_contains') or '').strip().lower() if token: rows = [row for row in rows if token in str(row.get('legal_name', '')).lower()] for (field, argument) in (('account_type', 'account_type'), ('registry_jurisdiction', 'jurisdiction'), ('status', 'status'), ('kyb_status', 'kyb_status')): if arguments.get(argument): rows = [row for row in rows if row.get(field) == arguments[argument]] rows.sort(key=lambda row: (row.get('legal_name', ''), row.get('organization_id', ''))) total = len(rows) visible = [{key: row.get(key) for key in ('organization_id', 'legal_name', 'account_type', 'registry_jurisdiction', 'status', 'kyb_status')} for row in rows[arguments['offset']:arguments['offset'] + arguments['limit']]] return self._result('list_organizations', 'success', 'OK', {'total_count': total, 'organizations': visible}) def _organization_profile(self, arguments): organization = self._get('organization', arguments['organization_id']) if organization is None: return self._result('get_organization_profile', 'error', 'ORGANIZATION_NOT_FOUND: organization_id was not found') portfolios = [{key: row.get(key) for key in ('portfolio_account_id', 'account_name', 'registry_jurisdiction', 'status')} for row in self._rows('portfolio_account') if row.get('organization_id') == organization['organization_id']] portfolios.sort(key=lambda row: row['portfolio_account_id']) public_org = {key: organization.get(key) for key in ('organization_id', 'legal_name', 'account_type', 'registry_jurisdiction', 'status', 'kyb_status')} return self._result('get_organization_profile', 'success', 'OK', {'organization': public_org, 'portfolios': portfolios}) def _eligibility_error(self, position_id, reason, claim_protocol): position = self._get('portfolio_position', position_id) if position is None: return None portfolio = self._get('portfolio_account', position.get('portfolio_account_id')) organization = self._get('organization', portfolio.get('organization_id')) if portfolio else None batch = self._get('credit_batch', position.get('batch_id')) project = self._get('offset_project', batch.get('project_id')) if batch else None if organization is None or organization.get('status') != 'active' or organization.get('kyb_status') != 'verified': return 'ORGANIZATION_NOT_ELIGIBLE: the owning organization is not currently eligible' if portfolio is None or portfolio.get('status') != 'active': return 'PORTFOLIO_NOT_ACTIVE: the position is not held in an active portfolio' if batch is None or batch.get('status') != 'issued': return 'BATCH_NOT_RETIRABLE: the linked credit batch is not currently usable' policy = self.policy_cells.get((str(batch.get('standard')), reason)) if batch else None if policy is None: return 'RETIREMENT_POLICY_NOT_FOUND: no policy cell covers this condition' if claim_protocol is not None and claim_protocol != policy['claim_protocol']: return 'CLAIM_PROTOCOL_MISMATCH: claim protocol does not match the current policy' if project is None or project.get('registration_status') != policy['registration_status'] or project.get('project_type') != policy['project_type']: return 'PROJECT_NOT_ELIGIBLE: the linked project does not satisfy the current retirement policy' return None def _retire(self, arguments): retirement = self._get('retirement', arguments['retirement_id']) if retirement: position = next((row for row in self._rows('portfolio_position') if row.get('portfolio_account_id') == retirement.get('portfolio_account_id') and row.get('batch_id') == retirement.get('batch_id')), None) if position: error = self._eligibility_error(position['position_id'], str(retirement.get('reason')), retirement.get('claim_protocol')) if error: return self._result('retire_credits', 'error', error) return self.server.call_tool('retire_credits', state_manager=self.manager, completion_time='2026-09-24T12:00:00Z', **arguments) def _sanitize(self, tool, result): if not isinstance(result, dict) or not isinstance(result.get('content'), dict): return self._result(tool, 'error', 'UPSTREAM_TOOL_ERROR: invalid raw response') if result['content'].get('status') == 'error': message = str(result['content'].get('message') or 'UPSTREAM_TOOL_ERROR') if message.startswith('INTERNAL_ERROR') or 'traceback' in message.lower(): return self._result(tool, 'error', 'UPSTREAM_TOOL_ERROR: raw tool execution failed') return result def _raw_snapshot(self, entities=DATA__RAW_SNAPSHOT_DEFAULT): return {entity: mod_copy.deepcopy(self._rows(entity)) for entity in entities} def _restore_raw(self, snapshot): for (entity, rows) in snapshot.items(): self.manager.db.save(entity, mod_copy.deepcopy(rows)) def business_hash(self): return mod_hashlib.sha256(fn__canonical({entity: self._rows(entity) for entity in DATA__RAW_SNAPSHOT_DEFAULT}).encode()).hexdigest() def semantic_hash(self): return mod_hashlib.sha256(fn__canonical(self.snapshot()).encode()).hexdigest() def activate_task(self, task_id, allowance=100): if not isinstance(task_id, str) or not task_id: raise ValueError('task_id must be non-empty') self.active_task_id = task_id self.initial_budget = int(allowance) self.remaining = int(allowance) self.task_entry_snapshot = self.snapshot() return {'task_id': task_id, 'allowance': self.remaining, 'world_reset': False} def business_events(self, since_receipt=0): return mod_copy.deepcopy([row for row in self.receipts if row['index'] > since_receipt]) def grade_targets(self, targets=None): if self.task_entry_snapshot is None: raise RuntimeError('activate_task must be called before grading') try: PUBLIC_T01_TARGETS = DATA_PUBLIC_T01_TARGETS grade_retirement_targets = fn_grade_retirement_targets except ImportError: from diagnostic import PUBLIC_T01_TARGETS, grade_retirement_targets return grade_retirement_targets(self.task_entry_snapshot, self.snapshot(), targets or PUBLIC_T01_TARGETS) def _carbon_priority_world_init(self, source=CASE_DIR / 'raw', snapshot=None): self._carbon_evolution_init(source=source) self.stream_targets = ext_deepcopy(DATA_TARGETS_2) if snapshot is not None: self.restore(snapshot) def _carbon_credits_adapter_snapshot(self): return {'schema': 'carbon-credits-adapter-snapshot/v1', 'source_fingerprint': self.source_fingerprint, 'raw': self._raw_snapshot(), 'remaining': self.remaining, 'receipts': mod_copy.deepcopy(self.receipts), 'policy_cells': [{'standard': standard, 'reason': reason, **mod_copy.deepcopy(cell)} for ((standard, reason), cell) in sorted(self.policy_cells.items())], 'applied_boundary_events': sorted(self.applied_boundary_events), 'active_task_id': self.active_task_id} def _carbon_credits_rule_successor_snapshot(self): value = self._carbon_credits_rule_successor_snapshot_2() value['schema'] = 'rescopebench-carbon-credits-rule-stream/v7' value['evidence_v7'] = {'secret': self.evidence_secret, 'issued_policy_evidence': ext_deepcopy(self.issued_policy_evidence), 'issued_candidate_listings': ext_deepcopy(self.issued_candidate_listings), 'issued_batch_inspections': ext_deepcopy(self.issued_batch_inspections), 'rule_revalidation': ext_deepcopy(self.rule_revalidation), 'attempted_target_ids': sorted(self.attempted_target_ids)} value['successor'] = {'case_version': 'carbon-credits-rule-v7', 'parent_case_version': 'carbon-credits-rule-v5', 'provider_tools_sha256': '34c2ee05393e8c3430cf8f40c369f50180d785999f8e367adb45644f6bda06fc', 'work_budget': 134, 'policy_evidence_cost': 27, 'changed_rules': list(DATA_CHANGED_RULES)} return value def _carbon_credits_stream_adapter_restore(self, snapshot): if snapshot.get('schema') != 'rescopebench-carbon-credits-persistent-stream/v2': raise ValueError('unsupported Carbon Credits stream snapshot') self._carbon_credits_adapter_restore(snapshot) stream = snapshot.get('stream') or {} self.prepared_tasks = list(stream.get('prepared_tasks') or []) self.boundary_receipts = ext_deepcopy(stream.get('boundary_receipts') or []) self.active_position_ids = set(stream.get('active_position_ids') or []) self.released_batch_ids = set(stream.get('released_batch_ids') or []) self.call_count = int(stream.get('call_count', 0)) self.drift_event_sequence = int(stream.get('drift_event_sequence', 0)) self.task_entry_snapshot = ext_deepcopy(stream.get('task_entry_snapshot')) def _carbon_credits_rule_successor_grade(self): grade = self._carbon_credits_stream_adapter_grade() for artifact in grade['artifacts']: artifact['score'] = 25.0 if artifact.get('complete') else 0.0 grade['score'] = sum((artifact['score'] for artifact in grade['artifacts'])) grade['complete_artifacts'] = sum((bool(artifact.get('complete')) for artifact in grade['artifacts'])) return grade def _carbon_credits_rule_successor_policy_evidence_v7(self, arguments): condition = (arguments['standard'], arguments['reason']) cell = self._visible_policy_cell(condition) if cell is None: return self._result('search_retirement_policy_evidence', 'success', 'OK', {'total_count': 0, 'evidence': []}) token = self._policy_token(condition, cell) evidence = {**self._public_cell(condition, cell), 'policy_evidence_id': token} self.issued_policy_evidence[token] = ext_deepcopy(evidence) rule = next((atom for (atom, value) in DATA_CHANGED_CONDITIONS.items() if value == condition), None) if rule and self.rule_revalidation.get(rule) == 'awaiting_current_policy': self.rule_revalidation[rule] = 'ready_current' return self._result('search_retirement_policy_evidence', 'success', 'OK', {'total_count': 1, 'evidence': [evidence]}) def _carbon_credits_rule_successor_cost(self, tool, arguments): if tool == 'search_retirement_policy_evidence': return 26 return self._carbon_credits_adapter_cost(tool, arguments) def _carbon_credits_adapter_close(self): mod_shutil.rmtree(self.runtime_root, ignore_errors=True) def _carbon_credits_adapter_batch_detail(self, arguments): batch = self._get('credit_batch', arguments['batch_id']) if batch is None: return self._result('get_credit_batch', 'error', 'BATCH_NOT_FOUND: batch_id was not found') project = self._get('offset_project', batch.get('project_id')) public_batch = {key: batch.get(key) for key in ('batch_id', 'project_id', 'standard', 'vintage_year', 'credit_type', 'status', 'available_credits', 'reserved_credits', 'retired_credits', 'expiry_date')} public_project = None if project: public_project = {key: project.get(key) for key in ('project_id', 'project_name', 'standard', 'project_type', 'host_country', 'registration_status', 'methodology_code')} return self._result('get_credit_batch', 'success', 'OK', {'batch': public_batch, 'project': public_project}) def _carbon_credits_adapter_policy_evidence(self, arguments): evidence = fn_public_policy_evidence(self.policy_cells, arguments['standard'], arguments['reason']) if evidence is None: return self._result('search_retirement_policy_evidence', 'success', 'OK', {'total_count': 0, 'evidence': []}) return self._result('search_retirement_policy_evidence', 'success', 'OK', {'total_count': 1, 'evidence': [evidence]}) def _carbon_credits_adapter_submit(self, arguments): error = self._eligibility_error(arguments['position_id'], arguments['reason'], arguments['claim_protocol']) if error: return self._result('submit_retirement_request', 'error', error) raw_arguments = {key: value for (key, value) in arguments.items() if key != 'claim_protocol'} result = self.server.call_tool('submit_retirement_request', state_manager=self.manager, **raw_arguments) retirement_id = result.get('content', {}).get('data', {}).get('retirement_id') if result.get('content', {}).get('status') == 'success' and retirement_id: retirement = self._get('retirement', retirement_id) if retirement is not None: retirement['claim_protocol'] = arguments['claim_protocol'] self.manager.db.save('retirement', [retirement if row.get('retirement_id') == retirement_id else row for row in self._rows('retirement')]) return result def _carbon_evolution_init(self, source=CASE_DIR / 'raw', snapshot=None): self._carbon_credits_rule_successor_init(source=source) self.stream_targets = ext_deepcopy(DATA_TARGETS_3) positions = self._rows('portfolio_position') for row in positions: row['quantity_available'] *= 2 self.manager.db.save('portfolio_position', positions) self._normalize_batch_ledgers() self._frozen_raw_baseline = self._raw_snapshot() self.evidence_secret = fn_digest(['carbon-three-event-lifecycle-evolution-v1', self.source_fingerprint]) if snapshot is not None: self.restore(snapshot) def _carbon_credits_rule_successor_snapshot_2(self): value = self._carbon_credits_rule_successor_snapshot_3() value['schema'] = 'rescopebench-carbon-credits-rule-stream/v5' value['successor'] = {'case_version': 'carbon-credits-rule-v5', 'parent_case_version': 'carbon-credits-rule-v4', 'provider_tools_sha256': '6c0fc8c3ea2349a5503a82ec4318d097b51ee6bcfa7f5f9ce98064a63e10d445', 'work_budget': 134, 'policy_evidence_cost': 26, 'changed_rules': list(DATA_CHANGED_RULES)} return value def _carbon_credits_adapter_restore(self, snapshot): if snapshot.get('source_fingerprint') != self.source_fingerprint: raise ValueError('snapshot source fingerprint does not match this adapter') self._restore_raw(mod_copy.deepcopy(snapshot['raw'])) self.remaining = int(snapshot['remaining']) self.receipts = mod_copy.deepcopy(snapshot['receipts']) self.policy_cells = {(row['standard'], row['reason']): {key: value for (key, value) in row.items() if key not in {'standard', 'reason'}} for row in snapshot['policy_cells']} self.applied_boundary_events = set(snapshot.get('applied_boundary_events', [])) self.active_task_id = snapshot.get('active_task_id') def _carbon_credits_stream_adapter_grade(self): return self.grade_targets(self.task_targets()) def _carbon_credits_adapter_cost(self, tool, arguments): if tool in DATA_LIST_TOOLS: limit = arguments.get('limit', 3) if isinstance(arguments, dict) else 3 if not isinstance(limit, int) or isinstance(limit, bool) or (not 1 <= limit <= 10): limit = 3 return 4 + 2 * limit if tool in {'get_organization_profile', 'get_credit_batch'}: return 7 if tool == 'search_retirement_policy_evidence': return 16 if tool in DATA_WRITE_TOOLS_2: return 10 return 0 def _carbon_credits_rule_successor_init(self, source=CASE_DIR / 'raw', snapshot=None): self.evidence_secret = '' self.issued_policy_evidence: dict[str, dict[str, ext_Any]] = {} self.issued_candidate_listings: dict[str, dict[str, ext_Any]] = {} self.issued_batch_inspections: dict[str, dict[str, ext_Any]] = {} self.rule_revalidation: dict[str, str] = {} self.attempted_target_ids: set[str] = set() self._frozen_raw_baseline: dict[str, ext_Any] = {} self._carbon_credits_rule_successor_init_2(source=source) self.stream_targets = ext_deepcopy(DATA_SUCCESSOR_TARGETS) self._frozen_raw_baseline = self._raw_snapshot() self.evidence_secret = fn_digest(['carbon-v7-evidence-secret', self.source_fingerprint]) if snapshot is not None: self.restore(snapshot) def _carbon_credits_rule_successor_snapshot_3(self): value = self._carbon_credits_rule_successor_snapshot_4() value['schema'] = 'rescopebench-carbon-credits-rule-stream/v4' value['successor'] = {'case_version': 'carbon-credits-rule-v4', 'provider_tools_sha256': '6c0fc8c3ea2349a5503a82ec4318d097b51ee6bcfa7f5f9ce98064a63e10d445', 'work_budget': 134, 'changed_rules': list(DATA_CHANGED_RULES)} return value def _carbon_credits_rule_successor_init_2(self, source=CASE_DIR / 'raw', snapshot=None): self._carbon_credits_rule_successor_init_3(source=source) if snapshot is not None: self.restore(snapshot) def _carbon_credits_rule_successor_snapshot_4(self): value = World._carbon_credits_stream_adapter_snapshot(self) value['schema'] = 'rescopebench-carbon-credits-rule-stream/v3' value['successor'] = {'case_version': 'carbon-credits-rule-v3', 'provider_tools_sha256': '6c0fc8c3ea2349a5503a82ec4318d097b51ee6bcfa7f5f9ce98064a63e10d445', 'work_budget': 134} return value def _carbon_credits_rule_successor_init_3(self, source=CASE_DIR / 'raw', snapshot=None): with mod__isolation._IMPORT_LOCK: previous = mod_sys.dont_write_bytecode mod_sys.dont_write_bytecode = True try: self._carbon_credits_rule_successor_init_4(source=source) finally: mod_sys.dont_write_bytecode = previous self.stream_targets = ext_deepcopy(DATA_SUCCESSOR_TARGETS_2) if snapshot is not None: self.restore(snapshot) def _carbon_credits_stream_adapter_snapshot(self): value = self._carbon_credits_adapter_snapshot() value['schema'] = 'rescopebench-carbon-credits-persistent-stream/v2' value['stream'] = {'prepared_tasks': list(self.prepared_tasks), 'boundary_receipts': ext_deepcopy(self.boundary_receipts), 'active_position_ids': sorted(self.active_position_ids), 'released_batch_ids': sorted(self.released_batch_ids), 'call_count': self.call_count, 'drift_event_sequence': self.drift_event_sequence, 'task_entry_snapshot': ext_deepcopy(self.task_entry_snapshot)} return value def _carbon_credits_rule_successor_init_4(self, source=CASE_DIR / 'raw', snapshot=None): self.source = ext_Path(source).resolve() if not self.source.is_dir(): raise FileNotFoundError(self.source) (self.server, StateManager, self.raw_module_origins) = fn__load_isolated_runtime(self.source) self.runtime_root = ext_Path(mod_tempfile.mkdtemp(prefix='rescope_carbon_rule_v3_')) mod_shutil.copytree(self.source / 'data/database', self.runtime_root / 'database') self.manager = StateManager(str(self.runtime_root / 'database')) self._normalize_batch_ledgers() self.source_fingerprint = fn_digest_2({entity: self._rows(entity) for entity in DATA__RAW_SNAPSHOT_DEFAULT}) self.initial_budget = 134 self.remaining = 134 self.receipts: list[dict[str, ext_Any]] = [] self.policy_cells = ext_deepcopy(DATA_PRE_POLICY_CELLS) self.applied_boundary_events: set[str] = set() self.active_task_id: str | None = None self.task_entry_snapshot: dict[str, ext_Any] | None = None self.stream_targets = ext_deepcopy(DATA_SUCCESSOR_TARGETS_3) self.prepared_tasks: list[str] = [] self.boundary_receipts: list[dict[str, ext_Any]] = [] self.active_position_ids: set[str] = set() self.released_batch_ids: set[str] = set() self.call_count = 0 self.drift_event_sequence = 0 self._install_stream_slice() if snapshot is not None: self.restore(snapshot)